Deep Learning Cluster with AWS for CPU

 

한국 지역 설정하기

sudo locale-gen ko_KR.UTF-8

tzselect

sudo apt-get install language-pack-ko

 

docker CE올리기

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -

sudo apt-key fingerprint 0EBFCD88
sudo add-apt-repository \
  "deb [arch=amd64] https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) \
  stable"


sudo apt-get update
sudo apt-get install docker-ce

도커를 ubuntu계정에서 실행하게 변경(리붓해야지 반영됨)

sudo groupadd docker
sudo gpasswd -a ubuntu docker

 

우리 도커를 다운 받는다.

docker pull hoyai/hoyai_dev_docker:squashed

 

1번 서버는 nfs server를 올린다.

sudo apt-get install nfs-kernel-server

 

nfs 마운트 포인트를 만든다

sudo mkdir /var/nfs/hoya_src_root -p
sudo mkdir /var/nfs/hoya_model_root -p
sudo mkdir /var/nfs/hoya_str_root -p
sudo mkdir /var/nfs/hoyai_playground -p


sudo chown nobody:nogroup /var/nfs/hoya_src_root
sudo chown nobody:nogroup /var/nfs/hoya_model_root 
sudo chown nobody:nogroup /var/nfs/hoya_str_root

nfs conf

vi /etc/exports


/var/nfs/hoya_src_root   xx.xx.xx.xx(rw,sync,no_subtree_check)   xx.xx.xx.xx(rw,sync,no_subtree_check)
/var/nfs/hoya_model_root  xx.xx.xx.xx(rw,sync,no_subtree_check)   xx.xx.xx.xx(rw,sync,no_subtree_check)
/var/nfs/hoya_str_root   xx.xx.xx.xx(rw,sync,no_subtree_check)   xx.xx.xx.xx(rw,sync,no_subtree_check)

nfs reload 한다

service nfs-kernel-server reload

 

AWS에서 nfs용 Security group을 설정한다.

 

TCPPort (Service) Source 111 0.0.0.0/0  2049 0.0.0.0/0  32768 0.0.0.0/0  44182 0.0.0.0/0  54508 0.0.0.0/0

UDPPort (Service) Source 111 0.0.0.0/0  2049 0.0.0.0/0  32768 0.0.0.0/0  32770-32800 0.0.0.0/0

 

  • gpu에서 ap1번으로 붙는지 테스트 해봄

 

Hoya Docker cluster용(AP용) seciruty group 설정

Port (Service) Source Port (Service) Source 4369 0.0.0.0/0  25672 0.0.0.0/0  5672 0.0.0.0/0  2266 0.0.0.0/0  5432 0.0.0.0/0  8000 0.0.0.0/0  6006 0.0.0.0/0  8888 0.0.0.0/0  5901 0.0.0.0/0  5555 0.0.0.0/0

도커를 실행하면서, nfs 포인트로 올리고, 부팅시 자동으로 올라가게 하고, vnc확인하고, host도 확인하고,

도커를 재부팅시 자동으로 올라가게 설정 도커 이름은 hoyai_dev로 설정한다

docker run -itd --env="VNC_RESOLUTION=1920x1080" --env="DISPLAY" --env="QT_X11_NO_MITSHM=1" --volume="/tmp/.X11-unix:/tmp/.X11-unix:rw" --volume="/var/nfs/hoya_src_root:/hoya_src_root" --volume="/var/nfs/hoya_model_root:/hoya_model_root" --volume="/var/nfs/hoya_str_root:/hoya_str_root" --name hoyai_dev -p 4369:4369 -p 25672:25672 -p 5672:5672 -p 2266:2266 -p 5432:5432 -p 8000:8000 -p 6006:6006 -p 8888:8888 -p 5901:5901 -p 5555:5555 hoyai/hoyai_dev_docker:squashed

 

도커가 자동으로 올라가게 설정한다.

cd /etc/systemd/system/
 vi docker_hoyai.service
[Unit]
Description=hoyai container
Requires=docker.service
After=docker.service

[Service]
Restart=always
ExecStart=/usr/bin/docker start -a hoyai_dev
ExecStop=/usr/bin/docker stop -t 2 hoyai_dev

[Install]
WantedBy=default.target

도커 스타트업 스크립트

sudo systemctl enable docker_hoyai.service
   
   sudo systemctl start docker_hoyai.service

도커 서비스 삭제 스크립트

sudo systemctl disable docker_hoyai.service
  
  sudo systemctl stop docker_hoyai.service
sudo apt-get install nfs-common

 

도커 속에서 cluster 설정하기

hoyai/settings.py에서 DB를 AP1번을 보도록 설정

git에서 settings.py 추적 안하게 변경

git update-index --assume-unchanged hoyai/settings.py

 

각서버별로 장고가 뜨는지 확인

hosts파일을 만들어서 ap1, ap2, gpu1, gpu2에 배포

ssh를 활용해서 각각 서버에 붙는지 확인한다.

 

rabitmq cluster 연결을 위한 erlang cookie 맞추기

 

master에서 cooker를 보고, slave에 복사해준다

vi /var/lib/rabbitmq/.erlang.cookie

 

slave는 끄고

service rabbitmq-server stop

erlang cookie 복사하고

다시 스타트

service rabbitmq-server start

 

 

rabbitmq cluster를 확인한다.

rabbitmqctl cluster_status

 

hoya settings.py의 celery 설정 부분을 변경한다.

host는 master의 Docker id로 변경

CELERY_BROKER_URL = 'amqp://tensormsa:tensormsa@'+host+'//'

result_backend = 'db+postgresql://xxxxxxxxxxxxx'

 

entrypoint에 hosts파일 add하는것을 추가

echo "xxx.xxx.xxx" >> /etc/hosts

 

gpu1번을 ap1에 조인

rabbitmqctl stop_app

rabbitmqctl join_cluster --ram rabbit@16224139bcee


rabbitmqctl start_app

gpt2번을 ap1에 조인

rabbitmqctl stop_app

rabbitmqctl join_cluster --ram rabbit@16224139bcee

rabbitmqctl start_app

 

클러스터에서 빠지기

rabbitmqctl reset

 

 

 

 

 

 

 

client nfs 설치한다

sudo apt-get install nfs-common

 

부팅했을때 nfs가 자동으로 붙도록 설정

hoya_src_root, hoya_model_root, hoya_str_root 3개 디렉토리 설정

sudo mkdir /hoya_src_root -p
sudo mkdir /hoya_model_root -p
sudo mkdir /hoya_str_root -p

 

vi /etc/fstab
xx.xx.xx.xx:/var/nfs/hoya_src_root /hoya_src_root nfs hard 0 0
xx.xx.xx.xx:/var/nfs/hoya_model_root /hoya_model_root nfs hard 0 0
xx.xx.xx.xx:/var/nfs/hoya_str_root /hoya_str_root nfs hard 0 0

 

reboot 해서 df -h로 nfs가 잘 붙는지 확인한다

df -h

 

gpu Tensormsa Docker를 받는다

docker pull docker pull hoyai/hoyai_gpu_dev_docker:v1.0

 

gpu docker 를 실행한다.

nvidia-docker run -itd --env="VNC_RESOLUTION=1920x1080" --volume="/hoya_src_root:/hoya_src_root" --volume="/hoya_model_root:/hoya_model_root" --volume="/hoya_str_root:/hoya_str_root" --name hoyai_dev -p 4369:4369 -p 25672:25672 -p 5672:5672 -p 2266:2266 -p 5432:5432 -p 8000:8000 -p 6006:6006 -p 8888:8888 -p 5901:5901 -p 5555:5555 hoyai/hoyai_gpu_dev_docker:v1.0

docker 서비스를 올린다.

sudo gpasswd -a ubuntu docker

 

 

cd /etc/systemd/system/
 vi docker_hoyai.service

 

[Unit]
Description=hoyai container
Requires=docker.service
After=docker.service

[Service]
Restart=always
ExecStart=/usr/bin/nvidia-docker start -a hoyai_dev
ExecStop=/usr/bin/nvidia-docker stop -t 2 hoyai_dev

[Install]
WantedBy=default.target

 

sudo systemctl enable docker_hoyai.service

sudo systemctl start docker_hoyai.service

 

sudo systemctl disable docker_hoyai.service

sudo systemctl stop docker_hoyai.service

 

AP1, GPU2, GPU2의 docker id와 IP를 찾는다.

Neural Net 활용

AI 의 대표적인 방법론인 Neural Net 의 활용 방안에 대한 아이디어를 찾기 위해서는 기존에 어떤 분야에 활용되는지를 알 필요가 있다.

http://www.alyuda.com/products/forecaster/neural-network-applications.htm

가) Financial
(1) 주식시장 예측 : 오픈, 최고, 최저, 마감, 가격 등으로 주식 시장 예측
(2) 신용도 예측 : 개인 데이터, 수입, 지출, 신용 History 등 활용
(3) 회사 신용도 : 회사의 재무적인 지표 등으로 신용도 예측
(4) 부도 예측
(5) 자산관리/증식
(6) 거짓말 탐지
(7) 가격 예측
(8) 경제 지표 예측

나) Medical
(1) 의학적 진료 : 환자개인 정보, 증상 패턴, 맥박, 혈압으로 병명진단
(2) 의학적 현상 감지 : 간질발생 예측, 신체 이상 기관 사이즈 등 수치 예측
(3) 생존일 예측
(4) 치료비용 예측

다) Industrial
(1) Process Control : 최적의 컨트롤 세팅, 과거의 이력을 신경망을 통해 수식화
(2) Quality Control : 원재료의 품질 예측, 결함 예측, 디젤 테스트, 타이어 테스트 등
(3) Temperature and force prediction in mills and factories

라) Science
(1) 패턴인식
(2) 재료와 화학식 최적화
(3) 화학 혼합물 식별
(4) 물리 시스템 모델링
(5) 환경시스템 평가
(6) 고분자 화합물 식별
(7) 유전자 인식
(8) 식물 분류
(9) 신호 프로세싱
(10) 생물학적 시스템 분석
(11) 심층 OZone 예측
(12) 향기 식별

마) Educational
(1) 학생 성취도 예측

바) Data Mining
(1) 예측 : 다양한 데이터 셋으로 미래의 일의 예측
(2) 분류 : 데이터를 특징으로 분류
(3) 변화와 편차 검출
(4) 지식 탐색 : 기존에 정의되지 않은 데이터간의 관계 도출
(5) Response Modeling
(6) Time Series Analysis

사) Sales and Marketing
(1) 판매 예측 : 마케팅 비용, 광고수, 할인행사 등이 세일에 주는 영향
(2) 타겟 마케팅 : 고객 맞춤형 마케팅
(3) 서비스 수요 예측 : 식당 이용자 수, 서버접속자 등을 예측 적절하게 대응 할 수 있도록
(4) 판매 마진 예측 :  제품 가격, 마케팅 비용, 시장 상황 등이 마진에 주는 영향

마) Operational Analysis
(1) 판매 목록 최적화 : 소비자를 만족시키는 최적의 판매 목록 구성
(2) 스케줄 최적화 :  비행기, 버스, 비행기 스케줄 최적화
(3) 경영 의사 결정
(4) 현금흐름 예측 : 자원의 활용 극대화, 현급 희름의 정확한 예측

바) HR Management
(1) 직원 고용
(2) 직원 근무 기간 : 직원이 회사에 머무를 것으로 예상되는 기간 예측
(3) 필요 직원 수 예측 : 식당, 은행 등에 필요할 것으로 예상되는 인원 예측
(4) 개인 프로파일링 : 트레이닝의 효과, 직원의 업무 적합성
(5) 직원 기여도 : 직원이 회사에 기여하는 정도 평가

사) Energy
(1) 에너지 저장 예측
(2) 에너지 소요 예측
(3) 원유/가스 가격 예측
(4) 수력발전소 모니터링
(5) 발전 컨트롤 시스템
(6) Short and Long-Term Load Estimation

아) Other
(1) 도박
(2) 경마 등
(3) 기상 예측
(4) 게임 개발
(5) 문제 최적화
(6) 농업 생산 평가

 

[예제]

this is a good example of reinforcement algorithm

 

[DL4J] Complex Network

[목차]

(0) 환경 설정 : DL4J 개발 환경 설정 및 예제 설명 (完)

(1) Data Iterator : 사용하고자 하는 데이터를 DL4J 에서 사용가능한 형태로 변환하는 작업 개발 필요

• Canova: The Rosetta Stone of Vectorization

• Spark

• Hadoop

• JDBC

Text ,CSV (完)

• Image (完)

• Sound

• Video

(2) Net : 사용할 신경망의 형태가 어떤 것이 있는지 이해하고 선택, 활용 할 수 있어야 함
• Restricted Boltzmann machines (完)
• Convolutional nets (完)
• Recursive autoencoders (完)
• Recurrent nets: Long Short-Term Memory (LSTM) (including bi-directional LSTMs)
• Deep-belief networks
• Denoising and Stacked Denoising autoencoders
• Deep autoencoders

(3) Activation : Weight + Bias 결과 다음 적용할 함수 결정 (예 : SigMoid : Chap1 에서 설명한 것)

• ReLU (完)
• Leaky ReLU
• Tanh
• Sigmoid
• Hard Tanh
• Softmax
• Identity
• ELU: Exponential Linear Units
• Softsign
• Softplus

(4) Loss&Objective Functions : 일부 데이터를 누락함으로써 더 Robust 한 모델을 만들 수 있다.
• Reconstruction entropy
• Squared loss
• Mean squared error
• Multi-class cross entropy for classification
• Negative log likelihood
• RMSE_XENT

(5) Hyperparameters : 모든 Layer 에 공통적으로 적용되는 파라메터로 숙지 필요

• Dropout (random ommission of feature detectors to prevent overfitting)
• Sparsity (force activations of sparse/rare inputs)
• Adagrad (feature-specific learning-rate optimization)
• L1 and L2 regularization (weight decay)
• Weight transforms (useful for deep autoencoders)
• Probability distribution manipulation for initial weight generation
• Gradient normalization and clipping

(6) Event Listener & Result Anal : 분석 중간 발생하는 이벤트를 받아서 처리 및 결과에 대한 검증 및 비지니스 연동 등

(7) 모델 저장 및 로딩

• 매번 모든 데이터를 로딩하여 학습 시키는 것이 아니라, 모델 자체를 저장하고, 새로 발생하는 데이터만 학습 시킴으로써,

모델의 즉각적인 학습효과와 대량 데이터 처리에 따른 Performacne 문제를 해결 할수 있을 것으로 보임

http://deeplearning4j.org/modelpersistence

(8) Grapth 의 종류

MultiLayerNetwork

ComputationGraph

1. DL4J 제공 Grapth 의 종류와 차이

(1) MultiLayerNetwork : 지금까지의 예제에서 일반적으로 사용했던 형태로 어느정도 정해진 틀을 손쉽게 사용할 수 있도록 제공하는 형태

(2) ComputationGraph : 더 자유롭게 변형이 가능한 형태로 저금 더 정의가 복잡하지만 (1) 에서 제공하는 기능 전체 수용가능하며, 추가적인 변형 가능

– Multiple network input arrays : 복수의 Input 을 받는 node 설계

– Multiple network outputs (including mixed classification/regression architectures) : Out put 값을 그 다음 Layer 의 복수의 Node 로 전송

– Layers connected to other layers using a directed acyclic graph connection structure (instead of just a stack of layers) : 별도의 직접 연결 경로 지정

※ 위 3가지 Case 를 구현하는 방법은 아래서 다루도록 함

2. ComputationGrapth 의 기본 구성

(1) LayerVertex

MultiLayerNetwork를 사용할때 layer(1, DenseLayer.Builder() …. 와 같이 정의했던 것과 같은 맥락으로 LayerVertex 에서는 아래와 같은 두 가지 방법으로 정의

.addLayer(레이어명,레이어 클래스,인풋값 Label)

.addLayer(레이어명,레이어 클래스,전처리 클래스, 인풋값 Label)

EX) .addLayer(“L1”, new GravesLSTM.Builder().nIn(5).nOut(5).build(), “input”)

※ 결국 MultiLayerNetwork 와 동일한 형태이지만, Layer 와 Layer 간의 관계를 좀더 자유롭게 정의할 수 있게 되겠다~

아래 예제는 .addLayer(“L2”,new RnnOutputLayer.Builder().nIn(5+5).nOut(5).build(), “input”, “L1”) 와 같이 정의하여

OUTPUT 을 두군데로 연결하도록 하는 것이다.

K-052

[예제]

ComputationGraphConfiguration conf = new NeuralNetConfiguration.Builder()
.learningRate(0.01)
.graphBuilder()
.addInputs("input") //can use any label for this
.addLayer("L1", new GravesLSTM.Builder().nIn(5).nOut(5).build(), "input")
.addLayer("L2",new RnnOutputLayer.Builder().nIn(5+5).nOut(5).build(), "input", "L1")
.setOutputs("L2")//We need to specify the network outputs and their order
.build();

ComputationGraph net = new ComputationGraph(conf);
net.init();

 

(2) InputVertex

MultiLayerNetwork에서는 INDArrays 에 정의된 형태 그대로 신경망의 데이터로 사용한다

반면에 ComputationGraph 에서는 원하는 데이터 항목명 및 순서를 정의할 수 있다

.addInputs(String…) 형태로 사용 INDArrays 에서 사용하는 Label 명을 넣으면 됨

(3) ElementWiseVertex

MultiLayerNetwork에서는 불가능 했던 행위들로 한개 이상의 Activation 을 받아서 누락시키거나, 더하거나 하는 행위를 하는 Vertex

인풋에 사용되는 Activation들의 사이즈는 모두 같아야 하며, 인풋과 아웃풋의 사이즈도 같아야 한다.

[예제]

 public void testBasicIrisWithElementWiseNode(){

ElementWiseVertex.Op[] ops = new ElementWiseVertex.Op[]{ElementWiseVertex.Op.Add, ElementWiseVertex.Op.Subtract};

for( ElementWiseVertex.Op op : ops ) {

Nd4j.getRandom().setSeed(12345);
ComputationGraphConfiguration conf = new NeuralNetConfiguration.Builder()
.seed(12345)
.optimizationAlgo(OptimizationAlgorithm.STOCHASTIC_GRADIENT_DESCENT)
.weightInit(WeightInit.DISTRIBUTION).dist(new NormalDistribution(0, 1))
.updater(Updater.NONE).learningRate(1.0)
.graphBuilder()
.addInputs("input")
.addLayer("l1", new DenseLayer.Builder().nIn(4).nOut(5).activation("tanh").build(), "input")
.addLayer("l2", new DenseLayer.Builder().nIn(4).nOut(5).activation("sigmoid").build(), "input")
.addVertex("elementwise", new ElementWiseVertex(op), "l1", "l2")
.addLayer("outputLayer", new OutputLayer.Builder().lossFunction(LossFunctions.LossFunction.MCXENT)
.activation("softmax").nIn(5).nOut(3).build(), "elementwise")
.setOutputs("outputLayer")
.pretrain(false).backprop(true)
.build();

ComputationGraph graph = new ComputationGraph(conf);
graph.init();

int numParams = (4 * 5 + 5) + (4 * 5 + 5) + (5 * 3 + 3);
assertEquals(numParams, graph.numParams());

Nd4j.getRandom().setSeed(12345);
int nParams = graph.numParams();
INDArray newParams = Nd4j.rand(1, nParams);
graph.setParams(newParams);

DataSet ds = new IrisDataSetIterator(150, 150).next();
INDArray min = ds.getFeatureMatrix().min(0);
INDArray max = ds.getFeatureMatrix().max(0);
ds.getFeatureMatrix().subiRowVector(min).diviRowVector(max.sub(min));
INDArray input = ds.getFeatureMatrix();
INDArray labels = ds.getLabels();

if (PRINT_RESULTS) {
System.out.println("testBasicIrisWithElementWiseVertex(op=" + op + ")");
for (int j = 0; j < graph.getNumLayers(); j++)
System.out.println("Layer " + j + " # params: " + graph.getLayer(j).numParams());
}

boolean gradOK = GradientCheckUtil.checkGradients(graph, DEFAULT_EPS, DEFAULT_MAX_REL_ERROR,
PRINT_RESULTS, RETURN_ON_FIRST_FAILURE, new INDArray[]{input}, new INDArray[]{labels});

String msg = "testBasicIrisWithElementWiseVertex(op=" + op + ")";
assertTrue(msg, gradOK);
}
}

 

(4) MergeVertex

MultiLayerNetwork에서는 불가능 했던 행위들로 복수개의 Activation 을 Merging 하는 행위를 수행한다.

예를 들어 두개의 Activation 이 각각 IN(3) , OUT(5) 라고 하면 MergeVertex 는 IN(10) , OUT(3) 이 된다.

K-051

[예제]

ComputationGraphConfiguration conf = new NeuralNetConfiguration.Builder()
.learningRate(0.01)
.graphBuilder()
.addInputs("input1", "input2")
.addLayer("L1", new DenseLayer.Builder().nIn(3).nOut(4).build(), "input1")
.addLayer("L2", new DenseLayer.Builder().nIn(3).nOut(4).build(), "input2")
.addVertex("merge", new MergeVertex(), "L1", "L2")
.addLayer("out", new OutputLayer.Builder().nIn(4+4).nOut(3).build(), "merge")
.setOutputs("out")
.build();

 

(5) SubsetVertex

MultiLayerNetwork에서는 불가능 했던 행위들로 다른 Layer 의 일부를 추출하여 별도의 Layer 로 만들 수 있다.

.addVertex("subset1", new SubsetVertex(0,4), "layer1")

 

(6) Multi-Task Learning

MultiLayerNetwork에서와 같이 최종적인 Output Layer 에서는 복수개의 결과를 갖을 수 있다. 그 예제는 아래와 같다.

K-053

[예제]

ComputationGraphConfiguration conf = new NeuralNetConfiguration.Builder()
.learningRate(0.01)
.graphBuilder()
.addInputs("input")
.addLayer("L1", new DenseLayer.Builder().nIn(3).nOut(4).build(), "input")
.addLayer("out1", new OutputLayer.Builder()
.lossFunction(LossFunctions.LossFunction.NEGATIVELOGLIKELIHOOD)
.nIn(4).nOut(3).build(), "L1")
.addLayer("out2", new OutputLayer.Builder()
.lossFunction(LossFunctions.LossFunction.MSE)
.nIn(4).nOut(2).build(), "L1")
.setOutputs("out1","out2")
.build();

 

(7) 데이터의 학습

학습용 데이터 구성시 하나의 Input 과 하나의 Output 값을 갖는 Activation 을 정의하는 것이라면 MultiLayerNetwork에서 사용한

데이터셋을 그대로 사용할 수 있다. 그러나, 복수의 인폿, 아웃풋을 갖는 Activation 을 설계하고자 한다면 별도의 과정이 필요하다.

int numLinesToSkip = 0;
String fileDelimiter = ",";
RecordReader rr = new CSVRecordReader(numLinesToSkip,fileDelimiter);
String csvPath = "/path/to/my/file.csv";
rr.initialize(new FileSplit(new File(csvPath)));

int batchSize = 4;
MultiDataSetIterator iterator = new RecordReaderMultiDataSetIterator.Builder(batchSize)
.addReader("myReader",rr)
.addInput("myReader",0,2) //Input: columns 0 to 2 inclusive
.addOutput("myReader",3,4) //Output: columns 3 to 4 inclusive
.build();

 

[DL4J] 실무적용 계획

1. Business Target

현재는 근무자가 유선상으로 수집한 정보와 감에 의존하여 수행하고 있는 제품 창고 만고 예측과 이에 대한 후속 조치로 이루어 지는

이송조치 업무를 시스템화 하는 것을 그 대상으로 선정하였다.

단, 과제 수행원의 운영, 프로젝트 및 복수 개선 과제 수행에 따른 업무 부하를 고려하여 , 현실적인 수준에서 만고 여부를 Neural Net 을

이용 학습 및 예측 현재 근무자가 만고 판단을 위해 사용하고 있는 단순 기준보다 높은 정합성을 확보하는 것까지를 목표로 설정하였다.

본 과제의 예상되는 효과는 아래와 같다.

– Neural Net 기법을 실무 환경에 적용하는 Know How 를 확보

. Architecture 적인 접목, 데이터 연동, 비지니스 활용 등

– Java 기반 Deep Learning Open Source 인 DL4J 에 대한 Know How 확보

– 제한된 범위의 Neural Net 적용을 통해 그 효용성(정확성)을 검증하여 향후 사업에 참고 자료로 사용

– JDK1.7 기반의 새로운 서비스 아이템으로서의 Neural Net 기법의 가능성 검토

2. Neural Net 구성 방안

현재 기준 Neural Net 을 업무에 적용하고자 하는 방안은 아래와 같이 현 적치상황, 입고 예측, 출고 예측 크게 3가지 Factor 를 Input 으로

사용자가 나름의 판단으로 이송지시를 내린 시점을 Output 으로 데이터를 구성하고 네트워크를 설계하고자 한다.

– 적치 상황 : 적치 상황을 Matrix 형태의 데이터르 변환하여 Input Layer 로 사용한다.

. 전체 야드를 대상으로 할 경우 배열의 크기가 너무 커져 Single Server 에서는 Memory 문제를 야기할 수 있어 특정 동하나만 대상으로 진행

– 입고 추이 : 입고 추이를 실제적으로 예측하기 위해서는 이전 프로세스의 정보들이 다수 필요한바, 본 과제에서는 시계열을 이용하여 대략적 정보 유추

– 출고 추이 : 출고 정보의 경우 선적계획 , 하역기 운영계획 및 선이송 예측 3가지 팩터가 고려 되어야 하며, 여기서는 마찬가지로 최소화 하여 진행

※ 더 자세한 내용은 별도의 문서로 작성 중

K-049 K-048

 

3. System 개발 대상

DL4J 및 Neural Network 에 대한 모든 지식을 습득한 후 개발에 착수하면 좋겠지만, 여건상 이론 학습과 개발을 병행하고자 함

아래는 개발하고자 하는 대상과 기능 Flow 로 크게 학습, 검증, 예측 3가지로 구분하였으며 현재 업무 체인의 자원과 머징하여

개발할 수 있도록 로컬 개발환경 및 빌드 환경을 구성하여 일부 대상 개발중에 있음

– 모델 학습을 위한 적치 정보 추출, 신경망 학습, 저장, 로드, 예측 화면 연결 View 까지 뼈대만 Test 수준으로 개발되어 있는 상황

K-050

(1) DL 학습 공통 Class

– 학습을 요청하는 클래스로 화면, CM 등 다양한 경로에서 요청시 복잡한 시스템 구조를 이해하지 않고도 실행 할 수 있는 Interface 제공

Case 별로 수집 데이터, 모델 구조 등 모든 것이 다른 관계로 여러가지 모델을 포괄적으로 수용할 수 있는 설계가 필요

(2) DL 예측 공통 Class

– 위와 동일한 의미의 Interface Classs 로 개발 예정이며, (1)과는 달리 학습이 아닌 예측을 위해 사용

(3) 입고/출고 예측

– 과제 수행 규모 조정을 위해 SQL 을 통해 CSV 파일 추출, CSV 으로 모델을 만들고 실행하는 Rjava 기반 Class를 간단하게 개발 예정

(4) 적치 현황 추출

– 동, 열, 스판, 순서로 구성되어 있는 데이터를 DB 에서 추출하고 이미지와 같이 Matrix 기반의 데이터로 변환하는 작업 수행

. 특정 동 기반으로 개발되어 있으나, 범용성있게 사용할 수 있도록 개선 필요

(5) 신경망 학습

– RBM 기반 3Level 신경망을 설계하였으며, 모델 학습 후 그 결과를 서버에 파일 형태로 저장하도록 개발됨

(6) 신경망 예측

– 파일로 저장된 학습된 결과 값으로 신경망으르 재 생성하여 입력되된 값으로 예측 실행하도록 개발됨

(7) 스케줄 가이던스

– HTML5 기반 Rich UI 로 학습, 예측 기동 및 그 결과를 화면에 출력하도록 개발 진행중

(8) 신경망 검증

– 현재 DB 구조로는 복수의 CASE 를 저장하고 관리 할 수 없음

입고, 출고, 적치 현황을 이벤트 시점별로 관리 할 수 있도록 개발 필요 (Hadoop 환경 제공 여부에 따라 진행 방향 변경)

※ 과제원 두분은 어떤 내용을 개발해야 할지 확인하시기를 바라며,추가적으로 관심있으시면 과제원 모집합니다.

감사합니다.

[DL4J] Image

[목차]

(0) 환경 설정 : DL4J 개발 환경 설정 및 예제 설명 (完)

(1) Data Iterator : 사용하고자 하는 데이터를 DL4J 에서 사용가능한 형태로 변환하는 작업 개발 필요

• Canova: The Rosetta Stone of Vectorization

• Spark

• Hadoop

• JDBC

Text ,CSV (完)

• Image

• Sound

• Video

(2) Net : 사용할 신경망의 형태가 어떤 것이 있는지 이해하고 선택, 활용 할 수 있어야 함
• Restricted Boltzmann machines (完)
• Convolutional nets (完)
• Recursive autoencoders (完)
• Recurrent nets: Long Short-Term Memory (LSTM) (including bi-directional LSTMs)
• Deep-belief networks
• Denoising and Stacked Denoising autoencoders
• Deep autoencoders

(3) Activation : Weight + Bias 결과 다음 적용할 함수 결정 (예 : SigMoid : Chap1 에서 설명한 것)

• ReLU (完)
• Leaky ReLU
• Tanh
• Sigmoid
• Hard Tanh
• Softmax
• Identity
• ELU: Exponential Linear Units
• Softsign
• Softplus

(4) Loss&Objective Functions : 일부 데이터를 누락함으로써 더 Robust 한 모델을 만들 수 있다.
• Reconstruction entropy
• Squared loss
• Mean squared error
• Multi-class cross entropy for classification
• Negative log likelihood
• RMSE_XENT

(5) Hyperparameters : 모든 Layer 에 공통적으로 적용되는 파라메터로 숙지 필요

• Dropout (random ommission of feature detectors to prevent overfitting)
• Sparsity (force activations of sparse/rare inputs)
• Adagrad (feature-specific learning-rate optimization)
• L1 and L2 regularization (weight decay)
• Weight transforms (useful for deep autoencoders)
• Probability distribution manipulation for initial weight generation
• Gradient normalization and clipping

(6) Event Listener & Result Anal : 분석 중간 발생하는 이벤트를 받아서 처리 및 결과에 대한 검증 및 비지니스 연동 등

(7) 모델 저장 및 로딩

• 매번 모든 데이터를 로딩하여 학습 시키는 것이 아니라, 모델 자체를 저장하고, 새로 발생하는 데이터만 학습 시킴으로써,

모델의 즉각적인 학습효과와 대량 데이터 처리에 따른 Performacne 문제를 해결 할수 있을 것으로 보임

http://deeplearning4j.org/modelpersistence

0.개요

Canova Lib 는 다양한 입출력 데이터를 지원한다. DL4J 사이트에서 정리된 자료를 찾고자 하였으나 찾지 못하여,

ND4J 사이트에서 Canova 관련 카테고리에서 유사한 내용을 찾아 정리하고자 한다.

(ND4J 는다양한 수학함수를 제공하는 라이브러리로 Nuppy 보다 4배정도 빠른 연산속도를 보여준다고 함)

http://nd4j.org/get-data-into-canova

○ FileRecordReader (Raw Text as Input)

– Input Format : org.canova.cli.formats.input.TextInputFormat

. FileRecordReader 를 상속받음 한나의 라인을 하나의 Record 로 생각함

– output Format : { csvLineString, dirLabelString }

. 폴더 이름이나, 고유한 ID 로 Label 를 자동으로 생성함

CSVRecordReader (CSV Records as Input)

– Input Format : org.canova.api.formats.input.impl.LineInputFormat

. CSV 는 이미 정형화된 구조임으로 nomalize, binarize, skip, label 만 정의하면 됨

– output Format : { string }

. 라벨 값은 CSV 데이터 안에 포함되어 있음

ImageRecordReader (Image Data as Input)

– Input Format : org.canova.api.formats.input.impl.ImageInputFormat

– output Format : { [array of doubles], directoryLabelID }

. 이미지 데이터와 라벨 값

MNISTRecordReader (Custom Binary Format Data)

– Input Format : org.canova.image.format.MNISTInputFormat

– output Format : { [array of doubles], classIndexID}

1. ImageRecordReader

(1) Loading Labels

이미지에 라벨을 붙이는 과정 , 서브 폴더명을 라벨로 사용하는 예

※ 아래와 같은 과정이라면 폴더명이 아닌 다른 기준으로 라벨링 가능하다고 보여짐

// Set path to the labeled images
String labeledPath = System.getProperty("user.home")+"/lfw";

//create array of strings called labels
List<String> labels = new ArrayList<>();

//traverse dataset to get each label
for(File f : new File(labeledPath).list Files()) {
labels.add(f.getName());
}

 

(2) Reading Records, Iterating Over Data

28 X 28 사이즈로 이미지를 Input Data 로 변환함 이 사이즈는 변경 가능함

true 파라메터는 라벨 값을 append 하는 것에 대한 허용

// Instantiating RecordReader. Specify height and width of images.
RecordReader recordReader = new ImageRecordReader(28, 28, true, labels);

// Point to data path.
recordReader.initialize(new FileSplit(new File(labeledPath)));

 

(3) Canova to DL4J

Canova 데이터 형을 최종적으로DL4J 데이터 형으로 변환한다.

DataSetIterator iter = new RecordReaderDataSetIterator(recordReader, 784, labels.size());

 

※ 위와 같이 실제 이미지에 라벨을 붙이고 DL4J 분석을 위한 Iterator 로 변환하는 과정을 거친다고 하면,

Location 2 Image 형태의 분석 아이디어를 서버에 구축하기 위한 아키택쳐를 어떻게 구성해야 할지 고민이 된다.

DB -> Image 생성 -> Canova -> DL4J 라고 하면 전처리 과정이 너무 많아 지는 것이 아닌지 고민됨

직접 DB 에서 DL4J 로 학습시키는 것과 차이가 있는지 고민 필요

[DL4J] Save&Load

[목차]

(0) 환경 설정 : DL4J 개발 환경 설정 및 예제 설명 (完)

(1) Data Iterator : 사용하고자 하는 데이터를 DL4J 에서 사용가능한 형태로 변환하는 작업 개발 필요

• Canova: The Rosetta Stone of Vectorization

• Spark

• Hadoop

• JDBC

Text ,CSV (完)

• Image

• Sound

• Video

(2) Net : 사용할 신경망의 형태가 어떤 것이 있는지 이해하고 선택, 활용 할 수 있어야 함
• Restricted Boltzmann machines (完)
• Convolutional nets (完)
• Recursive autoencoders (完)
• Recurrent nets: Long Short-Term Memory (LSTM) (including bi-directional LSTMs)
• Deep-belief networks
• Denoising and Stacked Denoising autoencoders
• Deep autoencoders

(3) Activation : Weight + Bias 결과 다음 적용할 함수 결정 (예 : SigMoid : Chap1 에서 설명한 것)

• ReLU (完)
• Leaky ReLU
• Tanh
• Sigmoid
• Hard Tanh
• Softmax
• Identity
• ELU: Exponential Linear Units
• Softsign
• Softplus

(4) Loss&Objective Functions : 일부 데이터를 누락함으로써 더 Robust 한 모델을 만들 수 있다.
• Reconstruction entropy
• Squared loss
• Mean squared error
• Multi-class cross entropy for classification
• Negative log likelihood
• RMSE_XENT

(5) Hyperparameters : 모든 Layer 에 공통적으로 적용되는 파라메터로 숙지 필요

• Dropout (random ommission of feature detectors to prevent overfitting)
• Sparsity (force activations of sparse/rare inputs)
• Adagrad (feature-specific learning-rate optimization)
• L1 and L2 regularization (weight decay)
• Weight transforms (useful for deep autoencoders)
• Probability distribution manipulation for initial weight generation
• Gradient normalization and clipping

(6) Event Listener & Result Anal : 분석 중간 발생하는 이벤트를 받아서 처리 및 결과에 대한 검증 및 비지니스 연동 등

(7) 모델 저장 및 로딩

• 매번 모든 데이터를 로딩하여 학습 시키는 것이 아니라, 모델 자체를 저장하고, 새로 발생하는 데이터만 학습 시킴으로써,

모델의 즉각적인 학습효과와 대량 데이터 처리에 따른 Performacne 문제를 해결 할수 있을 것으로 보임

http://deeplearning4j.org/modelpersistence

1. Save an Interoperable Vector of All Weights

– Neural Network 의 Cofiguration 값을 JSON 형태로 저장

– Neuron 의 모든 Weight 값과 Bias 값 등을 Binary 형태로 저장

– 아래는 모델을 저장하고 로딩하는 Sample 코드 이다, Code 상에는 File 로 되어 있지만,

Binary 형태로 변환하여 DB 에 Save & Load 를 하는 것도 가능할 것으로 보인다.

[Sample Code]

// 네트워크 파라메터 저장

try(DataOutputStream dos = new DataOutputStream(Files.newOutputStream(Paths.get("coefficients.bin")))){
Nd4j.write(net.params(),dos);
}

//네트워크 Configuration 저장
FileUtils.write(new File("conf.json"), net.getLayerWiseConfigurations().toJson());

//네트워크 Configuration 로딩
MultiLayerConfiguration confFromJson = MultiLayerConfiguration.fromJson(FileUtils.readFileToString(new File("conf.json")));

//네트워크 파라메터 로딩
INDArray newParams;
try(DataInputStream dis = new DataInputStream(new FileInputStream("coefficients.bin"))){
newParams = Nd4j.read(dis);
}

//저장된 정보로 네트워크 생성
MultiLayerNetwork savedNetwork = new MultiLayerNetwork(confFromJson);
savedNetwork.init();
savedNetwork.setParameters(newParams);

 

2. A Note on Updaters

데이터를 로딩한 후에 계속해서 Training 을 진행하고 싶다면, 네트워크의 부분만 저장하는 방법을 사용한다.

더 이상 Training 이 필요 없는 경우 더 이상 Save & Load 를 할 필요가 없다.

데이터 트레이닝에 momentum, AdaGrad and RMSProp와 같은 기법을 사용하는데, 이러한 기법들은

Trainging 의 이력을 남긴다. 이러한 이력 값 없이 그냥 파라메터를 저장하고 로딩할 경우 이후에 발생하는

Training 에서 데이터가 외곡될 가능성이 크다. 이러한 것을 방지하기 위해서 Update 를 저장하는 방법은

아래와 같다.

[Code Sample]

// Update 를 저장

try(ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("updater.bin"))){
oos.writeObject(model.getUpdater());
}

//Update 를 로드
org.deeplearning4j.nn.api.Updater updater;
try(ObjectInputStream ois = new ObjectInputStream(new FileInputStream("updater.bin"))){
updater = (org.deeplearning4j.nn.api.Updater) ois.readObject();
}

//Update 값을 모델에 사용
model.setUpdater(updater);

 

3. Model Utils

– Model Util을 사용해서 모델을 업데이트하고 로드하는 예제

– 모델의 Save & Load 를 사용하여 한번에 대량의 데이터를 로딩하지 않음으로써,

서버의 부하를 줄이고, 지속적으로 발생하는 데이터를 학습시켜 모델의 정합성을

올리는 방식으로 사용할 수 있지 않을까 기대 함

/**
* Project utility class to save and load models and parameters.
*/
@Deprecated
public class ModelUtils {

private static final Logger log = LoggerFactory.getLogger(ModelUtils.class);

private ModelUtils(){}

public static void saveModelAndParameters(MultiLayerNetwork net, String basePath) {
String confPath = FilenameUtils.concat(basePath, net.toString()+"-conf.json");
String paramPath = FilenameUtils.concat(basePath, net.toString() + ".bin");
log.info("Saving model and parameters to {} and {} ...", confPath, paramPath);

// save parameters
try {
DataOutputStream dos = new DataOutputStream(new FileOutputStream(paramPath));
Nd4j.write(net.params(), dos);
dos.flush();
dos.close();

// save model configuration
FileUtils.write(new File(confPath), net.conf().toJson());
} catch (IOException e) {
e.printStackTrace();
}
}

public static MultiLayerNetwork loadModelAndParameters(File confPath, String paramPath) {
log.info("Loading saved model and parameters...");
MultiLayerNetwork savedNetwork = null;
// load parameters
try {
MultiLayerConfiguration confFromJson = MultiLayerConfiguration.fromJson(FileUtils.readFileToString(confPath));
DataInputStream dis = new DataInputStream(new FileInputStream(paramPath));
INDArray newParams = Nd4j.read(dis);
dis.close();

// load model configuration
savedNetwork = new MultiLayerNetwork(confFromJson);
savedNetwork.init();
savedNetwork.setParams(newParams);
} catch (IOException e) {
e.printStackTrace();
}
return savedNetwork;
}

public static void saveLayerParameters(INDArray param, String paramPath) {
// save parameters for each layer
log.info("Saving parameters to {} ...", paramPath);

try {
DataOutputStream dos = new DataOutputStream(new FileOutputStream(paramPath));
Nd4j.write(param, dos);
dos.flush();
dos.close();
} catch(IOException e) {
e.printStackTrace();
}
}

public static Layer loadLayerParameters(Layer layer, String paramPath) {
// load parameters for each layer
String name = layer.conf().getLayer().getLayerName();
log.info("Loading saved parameters for layer {} ...", name);

try{
DataInputStream dis = new DataInputStream(new FileInputStream(paramPath));
INDArray param = Nd4j.read(dis);
dis.close();
layer.setParams(param);
} catch(IOException e) {
e.printStackTrace();
}

return layer;
}

public static void saveParameters(MultiLayerNetwork model, int[] layerIds, Map<Integer, String> paramPaths) {
Layer layer;
for(int layerId: layerIds) {
layer = model.getLayer(layerId);
if (!layer.paramTable().isEmpty()) {
ModelUtils.saveLayerParameters(layer.params(), paramPaths.get(layerId));
}
}
}

public static void saveParameters(MultiLayerNetwork model, String[] layerIds, Map<String, String> paramPaths) {
Layer layer;
for(String layerId: layerIds) {
layer = model.getLayer(layerId);
if (!layer.paramTable().isEmpty()) {
ModelUtils.saveLayerParameters(layer.params(), paramPaths.get(layerId));
}
}
}
public static MultiLayerNetwork loadParameters(MultiLayerNetwork model, int[] layerIds, Map<Integer, String> paramPaths) {
Layer layer;
for(int layerId: layerIds) {
layer = model.getLayer(layerId);
loadLayerParameters(layer, paramPaths.get(layerId));
}
return model;
}

public static MultiLayerNetwork loadParameters(MultiLayerNetwork model, String[] layerIds, Map<String, String> paramPaths) {
Layer layer;
for(String layerId: layerIds) {
layer = model.getLayer(layerId);
loadLayerParameters(layer, paramPaths.get(layerId));
}
return model;
}

public static Map<Integer, String> getIdParamPaths(MultiLayerNetwork model, String basePath, int[] layerIds){
Map<Integer, String> paramPaths = new HashMap<>();
for (int id : layerIds) {
paramPaths.put(id, FilenameUtils.concat(basePath, id + ".bin"));
}

return paramPaths;
}

public static Map<String, String> getStringParamPaths(MultiLayerNetwork model, String basePath, String[] layerIds){
Map<String, String> paramPaths = new HashMap<>();

for (String name : layerIds) {
paramPaths.put(name, FilenameUtils.concat(basePath, name + ".bin"));
}

return paramPaths;
}

public static String defineOutputDir(String modelType){
String tmpDir = System.getProperty("java.io.tmpdir");
String outputPath = File.separator + modelType + File.separator + "output";
File dataDir = new File(tmpDir,outputPath);
if (!dataDir.getParentFile().exists())
dataDir.mkdirs();
return dataDir.toString();

}

}

 

[DL4J] CSV

[목차]

(0) 환경 설정 : DL4J 개발 환경 설정 및 예제 설명 (完)

(1) Data Iterator : 사용하고자 하는 데이터를 DL4J 에서 사용가능한 형태로 변환하는 작업 개발 필요

• Canova: The Rosetta Stone of Vectorization

• Spark

• Hadoop

• JDBC

Text ,CSV

• Image

• Sound

• Video

(2) Net : 사용할 신경망의 형태가 어떤 것이 있는지 이해하고 선택, 활용 할 수 있어야 함
• Restricted Boltzmann machines (完)
• Convolutional nets (完)
• Recursive autoencoders (完)
• Recurrent nets: Long Short-Term Memory (LSTM) (including bi-directional LSTMs)
• Deep-belief networks
• Denoising and Stacked Denoising autoencoders
• Deep autoencoders

(3) Activation : Weight + Bias 결과 다음 적용할 함수 결정 (예 : SigMoid : Chap1 에서 설명한 것)

• ReLU (完)
• Leaky ReLU
• Tanh
• Sigmoid
• Hard Tanh
• Softmax
• Identity
• ELU: Exponential Linear Units
• Softsign
• Softplus

(4) Loss&Objective Functions : 일부 데이터를 누락함으로써 더 Robust 한 모델을 만들 수 있다.
• Reconstruction entropy
• Squared loss
• Mean squared error
• Multi-class cross entropy for classification
• Negative log likelihood
• RMSE_XENT

(5) Hyperparameters : 모든 Layer 에 공통적으로 적용되는 파라메터로 숙지 필요

• Dropout (random ommission of feature detectors to prevent overfitting)
• Sparsity (force activations of sparse/rare inputs)
• Adagrad (feature-specific learning-rate optimization)
• L1 and L2 regularization (weight decay)
• Weight transforms (useful for deep autoencoders)
• Probability distribution manipulation for initial weight generation
• Gradient normalization and clipping

(6) Event Listener & Result Anal : 분석 중간 발생하는 이벤트를 받아서 처리 및 결과에 대한 검증 및 비지니스 연동 등

(7) 모델 저장 및 로딩

• 매번 모든 데이터를 로딩하여 학습 시키는 것이 아니라, 모델 자체를 저장하고, 새로 발생하는 데이터만 학습 시킴으로써,

모델의 즉각적인 학습효과와 대량 데이터 처리에 따른 Performacne 문제를 해결 할수 있을 것으로 보임

http://deeplearning4j.org/modelpersistence

1. 참고 사이트

Data Load 관련하여서는 종합적으로 잘 정리된 사이트가 없어 이런저런 사이트나 소스코드를 참조

http://deeplearning4j.org/canova

http://deeplearning4j.org/image-data-pipeline.html

https://github.com/deeplearning4j/dl4j-0.4-examples/blob/master/src/main/java/org/deeplearning4j/examples/misc/csv/CSVExample.java

https://github.com/deeplearning4j/Canova/blob/master/canova-api/src/main/java/org/canova/api/records/reader/impl/CSVRecordReader.java

https://github.com/deeplearning4j/deeplearning4j/blob/3e5c6a942864ced574c7715ae548d5e3cb22982c/deeplearning4j-core/src/main/java/org/deeplearning4j/datasets/canova/RecordReaderDataSetIterator.java

https://github.com/deeplearning4j/Canova/tree/master/canova-api/src/main/java/org/canova/api/records/reader/impl

https://github.com/deeplearning4j/Canova/blob/master/canova-nd4j/canova-nd4j-image/src/main/java/org/canova/image/recordreader/ImageRecordReader.java

http://javadox.com/org.nd4j/canova-api/0.0.0.12/org/canova/api/records/reader/class-use/RecordReader.html

https://github.com/deeplearning4j/Canova

http://idosi.com/javadoc/DL4J/index.html?org/nd4j/jdbc/mysql/class-use/MysqlLoaderTest.html

2. Canova 개요

Canova 는 아래와 같은 특징을 갖는다.

– text, CSV, Image, Video, Sound 등을 DL4J 에서 사용하는 데이터 포맷 타입으로 변환하는 기능을 수행한다.

– 신경망 분석에 적합한 ARFF, SVMLight 등 포맷으로 변경한다

– Command Line으로도 실행할 수 있다.

– 특이한 데이터를 위하여 Custom 으로 Input Format 을 만들 수 있다.

Spark ,Hadoop, JDBC 연동 및 text, CSV, Image, Video, Sound 데이터 로딩 등 다양한 데이터 연동 방법이 있는데

각각의 케이스가 사용법이 달라서 따로 정리가 필요하다고 보여진다.

3. CSV Example

csv 파일을 신경망 분석에 적합한 포맷으로 변경하는 부분 예제

public class CSVExample {

private static Logger log = LoggerFactory.getLogger(CSVExample.class);

public static void main(String[] args) throws Exception {

//First: get the dataset using the record reader. CSVRecordReader handles loading/parsing
int numLinesToSkip = 0;
String delimiter = “,”;

/* 1. 데이터 Reader 정의

numLinesToSkip : 0으로 지정 보통 CSV 파일의 첫라인은 해더 명 등이 들어 있어서 SKIP

delimiter : 구분자 지정 여기서는 “,” */
RecordReader recordReader = new CSVRecordReader(numLinesToSkip,delimiter);
recordReader.initialize(new FileSplit(new ClassPathResource(“iris.txt”).getFile()));

//Second: the RecordReaderDataSetIterator handles conversion to DataSet objects, ready for use in neural network

/* 2. Data Set 변환

CSV 파일이라면, CSVRecordReader 와 RecordReaderDataSetIterator 별도의 개발 없이 두개 클레스를 활용하여

뉴런에 적합한 형태의 데이터로 충분히 변환 가능하다.

labelIndex : 몇개의 컬럼 데이터로 이루어져 있는지

numClasses : 가이드하고자 하는 구분자가 몇가지 종류인지

BatchSize : 몇개의 데이터를 로딩할 것인지 (Row 수)

*/

int labelIndex = 4; //5 values in each row of the iris.txt CSV: 4 input features followed by an integer label (class) index. Labels are the 5th value (index 4) in each row
int numClasses = 3; //3 classes (types of iris flowers) in the iris data set. Classes have integer values 0, 1 or 2
int batchSize = 150; //Iris data set: 150 examples total. We are loading all of them into one DataSet (not recommended for large data sets)
DataSetIterator iterator = new RecordReaderDataSetIterator(recordReader,batchSize,labelIndex,numClasses);

DataSet next = iterator.next();

final int numInputs = 4;
int outputNum = 3;
int iterations = 1000;
long seed = 6;

log.info("Build model....");
MultiLayerConfiguration conf = new NeuralNetConfiguration.Builder()
.seed(seed)
.iterations(iterations)
.learningRate(0.1)
.regularization(true).l2(1e-4)
.list(3)
.layer(0, new DenseLayer.Builder().nIn(numInputs).nOut(3)
.activation("tanh")
.weightInit(WeightInit.XAVIER)
.build())
.layer(1, new DenseLayer.Builder().nIn(3).nOut(3)
.activation("tanh")
.weightInit(WeightInit.XAVIER)
.build())
.layer(2, new OutputLayer.Builder(LossFunctions.LossFunction.NEGATIVELOGLIKELIHOOD)
.weightInit(WeightInit.XAVIER)
.activation("softmax")
.nIn(3).nOut(outputNum).build())
.backprop(true).pretrain(false)
.build();

//run the model
MultiLayerNetwork model = new MultiLayerNetwork(conf);
model.init();
model.setListeners(new ScoreIterationListener(100));

 

/* 3. Data 훈련

DataSet 은 정규화, Shuffle 및 훈련용 데이터와 검증용 데이터를 분리하는 등 Util 성 기능도 제공하며

위에서 정의한 뉴런에 model.fit (Data) 와 같은 형태로 사용하여 모델을 훈련 시킬 수 있다.

*/

next.normalizeZeroMeanZeroUnitVariance();
next.shuffle();
split test and train
SplitTestAndTrain testAndTrain = next.splitTestAndTrain(0.65); //Use 65% of data for training

DataSet trainingData = testAndTrain.getTrain();
model.fit(trainingData);

 

/* 4. 모델 평가

테스트 데이터 Set 으로 모델 예측 결과와 원래 알고 있는 결과를 비교하여 모델의 정확도를 평가한다.

*/

//evaluate the model on the test set
Evaluation eval = new Evaluation(3);
DataSet test = testAndTrain.getTest();
INDArray output = model.output(test.getFeatureMatrix());
eval.eval(test.getLabels(), output);
log.info(eval.stats());
}

}

 

[DL4J] ReLu

[목차]

(0) 환경 설정 : DL4J 개발 환경 설정 및 예제 설명 (完)

(1) Data Iterator : 사용하고자 하는 데이터를 DL4J 에서 사용가능한 형태로 변환하는 작업 개발 필요

• Canova: The Rosetta Stone of Vectorization

(2) Net : 사용할 신경망의 형태가 어떤 것이 있는지 이해하고 선택, 활용 할 수 있어야 함
• Restricted Boltzmann machines (完)
• Convolutional nets (完)
• Recursive autoencoders (完)
• Recurrent nets: Long Short-Term Memory (LSTM) (including bi-directional LSTMs)
• Deep-belief networks
• Denoising and Stacked Denoising autoencoders
• Deep autoencoders

(3) Activation : Weight + Bias 결과 다음 적용할 함수 결정 (예 : SigMoid : Chap1 에서 설명한 것)

• ReLU <—
• Leaky ReLU
• Tanh
• Sigmoid
• Hard Tanh
• Softmax
• Identity
• ELU: Exponential Linear Units
• Softsign
• Softplus

(4) Loss&Objective Functions : 일부 데이터를 누락함으로써 더 Robust 한 모델을 만들 수 있다.
• Reconstruction entropy
• Squared loss
• Mean squared error
• Multi-class cross entropy for classification
• Negative log likelihood
• RMSE_XENT

(5) Hyperparameters : 모든 Layer 에 공통적으로 적용되는 파라메터로 숙지 필요

• Dropout (random ommission of feature detectors to prevent overfitting)
• Sparsity (force activations of sparse/rare inputs)
• Adagrad (feature-specific learning-rate optimization)
• L1 and L2 regularization (weight decay)
• Weight transforms (useful for deep autoencoders)
• Probability distribution manipulation for initial weight generation
• Gradient normalization and clipping

(6) Event Listener & Result Anal : 분석 중간 발생하는 이벤트를 받아서 처리 및 결과에 대한 검증 및 비지니스 연동 등

1. ReLu (Rectifier Linear Unit)

– 다른 Activator 인 Sigmoid 에 대해서 설명한 것 처럼 ReLu 는 Weight, Bias, Input 으로 이루어진 결과를 보정하는 역할을 하는

또 다른 종류의 알고리즘이다. 아래의 그래프에서 파란선은 원래 값, 빨간선은 ReLu 로 보정한 결과 값이다.

K-043 K-044

 

– ReLu를 어떤 경우에 사용할지 판단하려면 ReLu 의 특성을 알아야 한다. 그럼 ReLu 과 Sigmoid 등과 어떤 차이와 장단점이 있는가.

결국 확률로 표시하고자 할 경우는 Sigmoid 가 유용할 듯하고 다음 Hidden Layer 에 Real Number 를 넘겨야 하는 경우에는 ReLu 가

더 효과적인 그런 것인듯 하다..

(1) 차이점

– Sigmoid 는 0 ~ 1 사이의 값을 갖는 반면 ReLu는 0 ~ Infinite 의 값을 갖는다. 그 말인 즉슨 Sigmoid 는 확률적인 표현만 가능한 반면

ReLu는 다음 Hidden Layer에 실제 값에 가까운 값을 전달할 수 있다는 것이다. (굉장히 큰 차이군..)

– Sigmoid 등은 탐색 과정에서 사라지는 경우가 있는데 ReLu는 그렇지 않다 (??)

(2) 장점

– Hidden Layer 의 Sparsity 를 증가 시킨다.. 결국 Density 가 출어서 Perfomance 가 올라간다는 말 같은데 어떻게 인지 모르겠음..

– 위에 말한 것처럼 Sigmoid 나 tanh 처럼 탐색중 사라지는 문제가 없다.

– 사전 트레이닝 과정 없이도 효과적으로 Net 에 트레이닝이 된다

– RBM 에 실제 데이터를 적용할 수 있다.. (위에 말한거다..)

[참조]

DL4J 공식 문서에서도 아래와 같은 예를 들어 설명하고 있는데, 결국 위에 설명된 내용중 실수 값을 전달할 수 있다가 핵심이다.

아래 그림을 그리면서 설명한 예제는 집값에 영향을 주는 요소를 Input , 예상 집값을 Ouput 으로 NN 은 설계한 예를 들은 것

결국 Hidden Layer 에서 Activator 로 Sigmoid 를 사용했다면 예상 집값은 0 ~ 1 값의 SUM 이 되어 얼토 당토 않은 결과가 나왔겠지만

하지만 ReLu 를 써서 실수 값을 예상할 수 있다. 뭐 이런 내용이다.

K-045

[DL4J]Auto Encoder

[목차]

(0) 환경 설정 : DL4J 개발 환경 설정 및 예제 설명

(1) Data Iterator : 사용하고자 하는 데이터를 DL4J 에서 사용가능한 형태로 변환하는 작업 개발 필요

• Canova: The Rosetta Stone of Vectorization

(2) Net : 사용할 신경망의 형태가 어떤 것이 있는지 이해하고 선택, 활용 할 수 있어야 함
• Restricted Boltzmann machines
• Convolutional nets
• Recursive autoencoders
• Recurrent nets: Long Short-Term Memory (LSTM) (including bi-directional LSTMs)
• Deep-belief networks
• Denoising and Stacked Denoising autoencoders
• Deep autoencoders

(3) Activation : Weight + Bias 결과 다음 적용할 함수 결정 (예 : SigMoid : Chap1 에서 설명한 것)

• ReLU
• Leaky ReLU
• Tanh
• Sigmoid
• Hard Tanh
• Softmax
• Identity
• ELU: Exponential Linear Units
• Softsign
• Softplus

(4) Loss&Objective Functions : 일부 데이터를 누락함으로써 더 Robust 한 모델을 만들 수 있다.
• Reconstruction entropy
• Squared loss
• Mean squared error
• Multi-class cross entropy for classification
• Negative log likelihood
• RMSE_XENT

(5) Hyperparameters : 모든 Layer 에 공통적으로 적용되는 파라메터로 숙지 필요

• Dropout (random ommission of feature detectors to prevent overfitting)
• Sparsity (force activations of sparse/rare inputs)
• Adagrad (feature-specific learning-rate optimization)
• L1 and L2 regularization (weight decay)
• Weight transforms (useful for deep autoencoders)
• Probability distribution manipulation for initial weight generation
• Gradient normalization and clipping

(6) Event Listener & Result Anal : 분석 중간 발생하는 이벤트를 받아서 처리 및 결과에 대한 검증 및 비지니스 연동 등

1. Supervissed Learning & Unsupervised Learning

앞에서 마치 Deep Learning 은 비지도 학습인 것처럼 이야기 하였는데, 조금 혼란스럽게도 Recursive autoencoders는 비지도 학습 알고리즘이라고 한다.

DL 의 정의는 다시 생각해 보고도록하고, 우선 비지도 학습이라함은 데이터 관점으로 정담을 사람이 가이드 해주지 않는 것을 말한다.

IRIS 데이터의 경우 1,2,3,4 Factor 와 5의 종류가 가이드 되어 있다. 요런 데이터를 분석하여 결로적으로 Output Layer 에 어떤 꽃이다~ 혹은 손글씨

인식이라고 하면 0~9 중에 하나다. 사람 고양이 인식이라고 하면 사람 혹은 고양이다. 이런식으로 답을 알려주고 Training 을 시키는 것을 지도 학습

답도 없이 그냥 마구 학습 시키는?? 것을 비지도 학습이라고 한다.

K-030

그래서 위의 그림을 보면 Input 과 Ouput 이 같음을 볼수 있다. 이게 바로 비지도 학습이기 때문에 나타나는 모양인데, 주어진 Input 예를 들면 78X78 이미지라고

하면 해당 이미지가 고양이인지, 사람인지 뭔가 학습시키고 싶은 내용이 없기 때문에 전반부에서는 Encoding 을 통해서 30 node 까지 압축을 시키고 후반부에서는

다시 원래 노드수 (78 X78) 로 Decoing 을 시킨다. 그리고 물론 Input 과 OutPut 이 얼마나 일치하는가가 Compressed Feature Vector 의 신뢰도를 나타낼 것이라고 생각된다.

[Encoding]
784 (input) —-> 1000 —-> 500 —-> 250 —-> 100 —–> 30

[Decoding]

784 (output) <—- 1000 <—- 500 <—- 250 <—- 30

785 는 78 X 78 이미지의 Pixel 수이고 1000으로 처음에 증가 시키는 것은 Overfitting 을 위함니다. 그럼 이런식의 비지도 학습 모델은 어디가가 써먹는가?

2. 활용

세 가지 정도 예가 있을 수 있는데,

하나는 이미지 서칭이다. 이미지들을 위와 같이 학습을 시켰다가 검색시에는 유사한 이미지들은 검색해서 보여주는 식으로 사용

두번째는 semantic Hashing 이라고 하는데 잘 이해는 못하겠으니.. 추가적으로 검색 해보시길..

세번째는 문서에서 주제 찾기라고 하는데 이해하기로는 문서를 Deep Autoencoder 를 사용해서 압축하고 압축된 Conpresse Feature Vector 에 가이드 테크글 달아서

데이터 셋을 다시 구성한 후에 해당 데이터를 다시 RBM 모델에 학습을 시킨다는 말 같다. 이렇게 되면 최종적인 RBM 모델에 글을 넣으면 주제는 XXX 입니다.

이런식으로 예측을 할 수 있을 것 같다.

3. Code Sample

코드를 많이 보다보니 딱보면 척 하고 느낌이 오는 것 같다. 아래의 코드는 위의 그림과 동일하게 이미지를 받아서 100부터 30가지 RBM 모델을 이용해서 Encoding 하고

다시 역으로 이미지 픽셀수 만큼의 아웃풋 노드를 Decoding 하는 신경망 설계이며 이미지 Iterator 는 MnistDataSetIterator 를 사용하는데 데이터 추출 부분에 대해선는

따로 정의하도록 하겠다. 이와 유사한 것으로 Denoising and Stacked Denoising autoencoders 라는 것이 있는데 이는 AutoEncoder 로 학습시 발행하는 쓰레기 값을 보정하는

Process 를 추가한 신경망이라고 보면 된다. (이 내용도 나중에 정리)

 DataSetIterator iter = new MnistDataSetIterator(batchSize,numSamples,true);

log.info("Build model....");
MultiLayerConfiguration conf = new NeuralNetConfiguration.Builder()
.seed(seed)
.iterations(iterations)
.optimizationAlgo(OptimizationAlgorithm.STOCHASTIC_GRADIENT_DESCENT)
.list(10)
.layer(0, new RBM.Builder().nIn(numRows * numColumns).nOut(1000).lossFunction(LossFunctions.LossFunction.RMSE_XENT).build())
.layer(1, new RBM.Builder().nIn(1000).nOut(500).lossFunction(LossFunctions.LossFunction.RMSE_XENT).build())
.layer(2, new RBM.Builder().nIn(500).nOut(250).lossFunction(LossFunctions.LossFunction.RMSE_XENT).build())
.layer(3, new RBM.Builder().nIn(250).nOut(100).lossFunction(LossFunctions.LossFunction.RMSE_XENT).build())
.layer(4, new RBM.Builder().nIn(100).nOut(30).lossFunction(LossFunctions.LossFunction.RMSE_XENT).build())

//encoding stops
.layer(5, new RBM.Builder().nIn(30).nOut(100).lossFunction(LossFunctions.LossFunction.RMSE_XENT).build())

//decoding starts
.layer(6, new RBM.Builder().nIn(100).nOut(250).lossFunction(LossFunctions.LossFunction.RMSE_XENT).build())
.layer(7, new RBM.Builder().nIn(250).nOut(500).lossFunction(LossFunctions.LossFunction.RMSE_XENT).build())
.layer(8, new RBM.Builder().nIn(500).nOut(1000).lossFunction(LossFunctions.LossFunction.RMSE_XENT).build())
.layer(9, new OutputLayer.Builder(LossFunctions.LossFunction.RMSE_XENT).nIn(1000).nOut(numRows*numColumns).build())
.pretrain(true).backprop(true)
.build();

MultiLayerNetwork model = new MultiLayerNetwork(conf);
model.init();

model.setListeners(Arrays.asList((IterationListener) new ScoreIterationListener(listenerFreq)));

log.info("Train model....");
while(iter.hasNext()) {
DataSet next = iter.next();
model.fit(new DataSet(next.getFeatureMatrix(),next.getFeatureMatrix()));

 

[DL4J]Boltzmann Machines

K-029[목차]

(0) 환경 설정 : DL4J 개발 환경 설정 및 예제 설명

(1) Data Iterator : 사용하고자 하는 데이터를 DL4J 에서 사용가능한 형태로 변환하는 작업 개발 필요

• Canova: The Rosetta Stone of Vectorization

(2) Net : 사용할 신경망의 형태가 어떤 것이 있는지 이해하고 선택, 활용 할 수 있어야 함
• Restricted Boltzmann machines
• Convolutional nets
• Recursive autoencoders
• Recurrent nets: Long Short-Term Memory (LSTM) (including bi-directional LSTMs)
• Deep-belief networks
• Denoising and Stacked Denoising autoencoders
• Deep autoencoders

(3) Activation : Weight + Bias 결과 다음 적용할 함수 결정 (예 : SigMoid : Chap1 에서 설명한 것)

• ReLU
• Leaky ReLU
• Tanh
• Sigmoid
• Hard Tanh
• Softmax
• Identity
• ELU: Exponential Linear Units
• Softsign
• Softplus

(4) Loss&Objective Functions : 일부 데이터를 누락함으로써 더 Robust 한 모델을 만들 수 있다.
• Reconstruction entropy
• Squared loss
• Mean squared error
• Multi-class cross entropy for classification
• Negative log likelihood
• RMSE_XENT

(5) Hyperparameters : 모든 Layer 에 공통적으로 적용되는 파라메터로 숙지 필요

• Dropout (random ommission of feature detectors to prevent overfitting)
• Sparsity (force activations of sparse/rare inputs)
• Adagrad (feature-specific learning-rate optimization)
• L1 and L2 regularization (weight decay)
• Weight transforms (useful for deep autoencoders)
• Probability distribution manipulation for initial weight generation
• Gradient normalization and clipping

(6) Event Listener & Result Anal : 분석 중간 발생하는 이벤트를 받아서 처리 및 결과에 대한 검증 및 비지니스 연동 등

1. Restricted Boltzmann machines
Restricted Boltzmann machines 을 한 문장으로 표현하면 제한된 반복적인 확률 기반 신경망 알고리즘 정도 될 것이다.

여기서 제한되었다라는 것은 Chap1 에서의 도식화된 신경망을 보면 Layer 가 나누어진것을 볼 수 있는데 여기에서

동일한 Layer 간에는 연결관계를 표시하지 않겠다는 이야기로 신경망을 조금더 간단화 할 수 있을 것이다.

반복적인 확률기반 신경망 알고리즘이라 함은 Backword Propagation 을 이야기 할 수 있을 듯한데 이는 초기에 세팅한

Weight 값과 Bias 값을 실제 데이터 값과 비교하여 Error 수치를 추출하고 이를 다시 Wegight 와 Bias 에 반영하는 과정을

말함이다.

2. 신경망 기본 개념

K-023

K-029

Chap1 에서도 설명했던 것과 유사한 개념으로 각 뉴런은 Weight , Bias, Input 값과 output 값으로 구성된

Activation 이라고 볼 수 있다. 보라색은 Input Layer , 분홍색은 Hidden Layer , 표시되지는 않았지만

결과값은 output Layer인데.. 여기서는 표시가 안된 것으로 보인다. 실제 예제 코드에서도 사이즈가 2로

지정한 것이 input, Hidden , output 각 1개 인 것으로 보아 output Layer 는 카운팅에서 빼는 것인가 싶기도하다.

K-026

위의 그림은 layer1의 결과 값이 Layer2 의 input 값으로 활용되는 Multi Layer를 도식화 하고 있다.

위와 같은 방법으로 Layer 의 Depth는 계속 깊어 질 수 있다. 물론 Depth 가 깊어 질수록 퍼포먼스는

떨어 지겠지만 말이다. .

멀티 Layer 를 구성하고 각 뉴런을 커스터마이징하는 개발 방법은 추후에 정리 하도록 한다.

3. 학습 Process (RECONSTRUCTION)

하지만 위와 같이 정방향으로 진행되는 Process 만 있다면 이것을 Deep Learning 이라고 부를 이유가 없다.

 K-027
K-029

실제로 RBM 은 위와 같은 형태로 적정 Weight 값과 Bias 값을 훈련신다. 대략적으로 말로 설명하자면 아래와 같을 것이다.

(1) 초기 값을 지정한다.

(2) 실제 데이터로 초기 값과의 오차를 구한다.

. 위의 식을 거꾸로 연산하면 a 가 인풋이되고 x 가 아웃 풋이 되는 형태라고 생각하면 된다.

(3) 오차와 초기값이 적어지는 방향으로 weight 값과 bias 값을 조금식 수정을하는데 그 변화 정도가 코드에서 보면

학습 정도라고 되어있는 파라메터이다. 아래 그림에서 보는 것과 같이 점점 데이터와의 오차를 줄이는 방향으로

변경되어 간다.

K-028

(4) 실제로 모델을 활용할때는 정방향으로 데이터를 진행시켜서 OUTPUT 데이터를 도출하면 결과 값은 확률로 나온다.

각 OutPut 노드 별로 확률이 얼마다 이런식으로~

※ 이렇게 하고 보니.. R의 RNN Package 와의 차이도 애매하고.. DL쪽은 더 많은 학습이 필요할 듯하다..

Two Depth 이상의 신경망의 구성이라던지, 뉴런을 논리회로 식으로 구성하는 방법이라던지.. 적극적으로

프로그래머가 신경망 형태에 개입할 수 있는 방법을 찾아 봐야 할 듯하다…