[ 딥러닝 기초 입문 ] 2. 통계적이 아니라 시행착오적 회귀분석 by Tensorflow - Tensorflow를 사용하는 이유, 신경망 구조 - youngdocseo@gmail.com.

Slides:



Advertisements
Similar presentations
학교 자체평가의 실제 신 동 한. 목 차  표지 제목  학교 소개  평가위원회 구성  지표별 평가의 실제  학교 자체평가의 향후 반영 계획  설문지 처리.
Advertisements

Python RaspberryPi Sejin Oh. Raspberry Pi Python  참과 거짓  Python 자료형의 참과 거짓을 구분 짓는 기준은 다음과 같다. 2 참과 거짓 자료형참 or 거짓 “” 가 아닌 문자열 ( 예 : “python”) 참 “” 거짓.
김수연 Capstone Design Realization Cost Reduction through Deep Artificial Neural Network Analysis.
Ch.4 수요관리와 수요예측 Ch.2 수요예측생산 ∙ 운영관리 1. 제 1 절 수요관리의 개념과 중요성 1. 수요관리의 필요성 정확한 수요예측은 사업의 성과를 좌우하는 매우 중요한 과제이다. – 수요는 판매량과 다르다. – 하지만 온갖 불확실성 요소가 난무하는 사업환경에서.
Introduction of Deep Learning
Training Neural Networks
Machine Learning to Deep Learning_2
Lec 4 Backpropagation & Neural Network
Neural Network - Perceptron
IT Application Development Dept. Financial Team May 24, 2005
14주차 1교시 강화계획 [학습목표] 1. 강화계획의 정의를 안다 [학습내용] 1. 단순한 강화계획 2. 간헐적 강화 3. 복합 계획 4. 선택과 대응법칙 [사전학습] 강화계획이 일어날 수 있는 사례를 생각해본다.
연장근로와 야간·휴일근로 김영호 노무사 나눔 노사관계연구소 소장 연세대 일반대학원 박사 수료 고려사이버대 법학과 외래교수
REC 가격예측 분석 발표자: 김주철.
Chapter 5. Q-LEARNING & DEEP SARSA
의료의 질 평가 분석 기법 김 민 경.
Toad for Oracle 설치 방법.
제 7장 회귀분석 회귀분석의 목적 여러변수사이의 관계를 알아본기 위함 단순회귀모형과 다항회귀모형
 13장. 배시쉘 프로그래밍.
Multimedia Programming 06: Point Processing3
9.확률 분포 정규 분포 형태 : 평균을 중심으로 좌우대칭의 종 모양을 가진 분포이다.
Medical Instrumentation
Word2Vec Tutorial 박 영택 숭실대학교.
Progress Seminar 선석규.
Genetic Algorithm 신희성.
Technological Forecasting & social change(2014)
Chapter 05. 클래스 완성. chapter 05. 클래스 완성 01. 복사 생성자 복사 생성(Copy Construction) 생성될 때 자신과 같은 타입의 객체를 변수로 받아, 이 객체와 같은 값을 갖는 새로운 객체를 생성하는 것 명시적인 생성 과정뿐만.
제 3 장 신경회로망 (Neural Networks)
Communication and Information Systems Lab. 최정훈
Machine Learning to Deep Learning
MINITAB for Six Sigma.
-제어문, 함수, 클래스- IS lab. 김건영 Python -제어문, 함수, 클래스- IS lab. 김건영
Medical Instrumentation
Parallel software Lab. 박 창 규
Lab Assignment 3 Deep Learning 1 1.
Multimedia Programming 10: Unsharp Masking/ Histogram Equalization
Data Mining Final Project
Modeling one measurement variable against another Regression analysis (회귀분석) Chapter 12.
Tensorboard Lecture 데이터 마이닝 최 현영 컴퓨터학부.
Introduction to Programming Language
Association between two measurement variables Correlation
딥러닝의 개념들.
Ch06_인공 신경망.
[CPA340] Algorithms and Practice Youn-Hee Han
Chaper 02 코드설계.
Apache Spark Tutorial 빅데이터 분산 컴퓨팅 박영택.
좋은징조 담당교수 : 조성제 김도엽 김현일 이상훈.
Progress Seminar 신희안.
Statistical inference I (통계적 추론)
문자열 처리하기 working with Strings
Apache Spark Tutorial 빅데이터 분산 컴퓨팅 박영택.
nauten Compiler – Report Ver.3 Mini-C (주간)
장애인단체 간담회 마스터 제목 스타일 편집 마스터 제목 스타일 편집 장애인 단체 간담회 마스터 부제목 스타일 편집
Chapter 4: 통계적 추정과 검정 Pilsung Kang
제2장 통계학의 기초 1절 확률 기본정의 확률의 기본 공리와 법칙 2절 확률변수와 확률분포 3절 정규분포와 관련 분포 정규분포
인공신경망 실제 적용사례 및 가상사례 조사.
Modeling one measurement variable against another Regression analysis (회귀분석) Chapter 12.
Neural Networks & Deep Learning
K Nearest Neighbor.
9장. 프로그램 평가.
다층 퍼셉트론의 학습과 최적화 알고리즘 부산대학교 전자전기컴퓨터공학과 김민호.
C.
Progress Seminar 선석규.
Spring, 2019 School of CSE Pusan National University
Python 기본.
List, ArrayList, Vector, LinkedList 가 있습니다
제2기 지역사회복지계획 수립, 추진 및 평가 사 례 발 표
Progress Seminar 선석규.
Python 라이브러리 딥러닝 강의소개 정성훈 연락처 : 이메일 :
Deep Learning Basics Junghwan Goh (Kyung Hee University)
Model representation Linear regression with one variable
Presentation transcript:

[ 딥러닝 기초 입문 ] 2. 통계적이 아니라 시행착오적 회귀분석 by Tensorflow - Tensorflow를 사용하는 이유, 신경망 구조 - youngdocseo@gmail.com

백讀이 불여일打 : revisited import random xdata = list() ydata = list() for num in range( 500 ) : temp = random.random() xdata.append( temp ) ydata.append( 10 + 3 * temp ) import tensorflow myB = tensorflow.Variable( 0.5 ) myW = tensorflow.Variable( 0.5 ) myY = myB + myW * xdata myLoss = tensorflow.reduce_mean( ( myY – ydata )**2 ) myTrain = tensorflow.train.GradientDescentOptimizer( 0.1 ).minimize( myLoss ) myInit = tensorflow.global_variables_initializer() mySess = tensorflow.Session() mySess.run( myInit ) for step in range( 100 ) : mySess.run( myTrain ) print( mySess.run( myB ), mySess.run( myW ), mySess.run( myLoss ) )

백讀이 불여일打 : revisited ① ② ③ ④ ⑤ ⑥ ⑦ ⑧ ⑨ ⑩ import random xdata = list() ydata = list() for num in range( 500 ) : temp = random.random() xdata.append( temp ) ydata.append( 10 + 3 * temp ) import tensorflow myB = tensorflow.Variable( 0.5 ) myW = tensorflow.Variable( 0.5 ) myY = myB + myW * xdata myLoss = tensorflow.reduce_mean( ( myY – ydata )**2 ) myTrain = tensorflow.train.GradientDescentOptimizer( 0.1 ).minimize( myLoss ) myInit = tensorflow.global_variables_initializer() mySess = tensorflow.Session() mySess.run( myInit ) for step in range( 100 ) : mySess.run( myTrain ) print( mySess.run( myB ), mySess.run( myW ), mySess.run( myLoss ) ) On your mark cf) tensorflow.zeros( [1] ) cf) tensorflow.random_uniform( [1], -1.0, 1.0 ). 단, 0은 안됨. *시작값 cf) tensorflow.square( myY – ydata ) Get Set *학습률 cf) 이 코드의 위치는 myW, myB 뒤쪽이기만 하면 됨 Go 여기에도 print(mySess.run( myB ), mySess.run( myW ), mySess.run( myLoss ) ) 를 넣고 실행해보면? *학습횟수

Python Tensorflow ① ③ myY = myB + myW * xdata xdata myY myB ② 변수 Tensorflow 함수 ① ③ myY = myB + myW * xdata xdata [ 500 ] myY [ 500 ] myB 찾고 싶은 값 ② Variable() On your mark myW ydata [ 500 ] 배열의 요소 값들의 평균 ④ myLoss reduce_mean() 결국 이 기능때문에 Tensorflow 사용 ⑩ run train.GradientDescentOptimizer(). minimize() 옵티마이저 ⑤ myTrain ⑨ run *여러 번(학습과정) initialize global_variables_initializer() ⑥ myInit Go ⑧ run *한번만 (초기값 실행) Get Set ⑦ mySess Session() run()

xdata ydata Mean Squared Error myB + myW * xdata myY myB myW 상수 변수 함수 독립변수 입력 데이터 (神이 만든 세계) “어떤” 관계 종속변수 xdata ydata 손실/오차/비용 함수 실제값(target/label) vs 회귀모형에 의한 값 Mean Squared Error 회귀모형=선형 (인간의 추정) myB + myW * xdata myY 분류 문제일 경우에는 Cross Entropy를 많이 사용 bias(편향, 절편) weight(가중치) 모형이 계산한 값 myB myW parameter(그냥 가중치라고도 함) (기계의 계산/학습) 손실/오차/비용 점수 옵티마이저 parameter / kernel / filter GradientDescent Optimizer cf) hyper-parameter: 학습률, 학습횟수 등 손실/오차/비용 점수를 최소화하도록 parameter(가중치+편향)를 업데이트함 = 학습/지능 (parameter는 학습/지능의 저장소) *여기서의 간단한 회귀모형의 경우 모형 자체가 인간의 추정이지만, 향후 딥러닝에서 “선형의 비선형적 결합에 따른 복잡한 모형”은 기계가 학습을 통해 찾음.

𝑦=10+2 𝑥 1 3 (즉, 3을 찾는 것) [ 실습 체크 ] □ “다중” 회귀분석도 가능 𝑦=10+3 𝑥 1 +8 𝑥 2 𝑦=10+3 𝑥 1 +8 𝑥 2 □ “비선형” 회귀분석도 가능 𝑦=10+3 𝑥 1 2 −6 𝑥 1 +8 𝑥 2 단, 코드③에서 리스트 값의 제곱(square) 처리는 아래와 같이 myY = myW * [ i**2 for i in xdata ] + myW2 * xdata + myW3 * x2_data + myB □ “조절효과” 회귀분석도 가능 𝑦=10+3 𝑥 1 𝑥 2 −6 𝑥 1 +8 𝑥 2 □ “승수 찾기”도 가능? 𝑦=10+2 𝑥 1 3 (즉, 3을 찾는 것)

[ 주의사항 ] □ 가중치를 업데이트하는 경사하강법(gradient descent)의 특성에 의해 효과적인 학습을 위해 - 입출력값은 정규화(normalize: 0~1) 혹은 표준화(standardize: 95%로 -2~2)할 것 *xdata값 생성을 temp = random.random()*5로 해보자. (Overshooting문제 – 통계적 회귀분석에는 없는 현상) - 초기 가중치의 값을 가급적 -1~1 사이로 하되 0으로 하거나 모든 가중치의 값이 동일한 값으로는 설정하지 말 것 (참고로 가중치의 수가 많으면 많을수록 작은 값으로 시작할 것 그래서 가중치의 초기값을 𝑁(0, 1 노드 수 )로 설정하기도 함.) [참고] 데이터 전처리 고급버전 백색화(whitening)∼주성분분석(PCA) : 독립변수 간 상관성 제거

신경망 구조

회귀분석 with “hidden layer” and “activation function(AF)” <이전: No hidden layer> <이번: “One hidden layer(with two units/nodes)” and “Activation Function(AF)”> “선형분리가능문제”만 해결 “선형분리불가능문제”는 해결 안됨. 선형분리불가능문제 일명 “XOR 문제”도 해결 가능. xdata xdata ① Input Input xdata * myW1to2 + myB1to2 xdata * myW1to3 + myB1to3 kernel to hidden myH2 ② myH3 ③ kernel xdata * myW + myB Hidden Layer AF AF 은닉층의 AF는 주로 relu, sigmoid, tanh사용. “분류” 문제에서는 출력층에도 AF 적용 (주로 sigmoid, softmax). 입력층에는 AF 미적용. myH2 ② myH3 ③ kernel to output myH2 * myW2to4 + myH3 * myW3to4 + myB23to4 myY ydata myY ④ ydata Output Label Output Label

import random xdata = list() ydata = list() for num in range( 500 ) : temp = random.random() xdata.append(temp) ydata.append( -3 * ( temp – 0.5 )** 2 + 10 ) import tensorflow as tf myW1to2 = tf.Variable( tf.random.normal ( [1] , 0 , 1 ) ) myB1to2 = tf.Variable( 0.0 ) myW1to3 = tf.Variable( tf.random.normal ( [1] , 0 , 1 ) ) myB1to3 = tf.Variable( 0.0 ) myW2to4 = tf.Variable( tf.random.normal ( [1] , 0 , 1 ) ) myW3to4 = tf.Variable( tf.random.normal ( [1] , 0 , 1 ) ) myB23to4 = tf.Variable( 0.0 ) myH2 = xdata * myW1to2 + myB1to2 # 회귀식H2 myH2 = tf.nn.sigmoid( myH2 ) # 활성화함수(Activation Function) myH3 = xdata * myW1to3 + myB1to3 # 회귀식H3 myH3 = tf.nn.sigmoid( myH3 ) # 활성화함수(Activation Function) myY = myH2 * myW2to4 + myH3 * myW3to4 + myB23to4 myLoss = tf.reduce_mean( (myY - ydata) ** 2 ) # 손실함수 myTrain = tf.train.GradientDescentOptimizer( 0.1 ).minimize( myLoss ) # 옵티마이저 myInit = tf.global_variables_initializer() mySess = tf.Session() mySess.run( myInit ) for step in range( 20000 ) : mySess.run( myTrain ) print( mySess.run(myLoss) ) import matplotlib.pyplot as plt plt.plot( xdata, ydata, 'ro' ) plt.plot( xdata, mySess.run(myY), 'bo' ) plt.show() cf) 선형들의 선형 결합은 선형일 뿐이다. AF를 모두 주석처리해보자. AF를 모두 sigmoid -> relu로 변경해보자. *학습률 0.01로 수정 후 여러 번 실행 1) 0.01에 따른 직선 도출은 local trap에 빠진것? 2) 가중치 초기값의 중요성!! ⇒ 적합한 초기값을 찾는 ML도 발전하고 있음 ex) 사전학습(비지도) with e.g. AutoEncoder or RBM(생성모델) cf) vanishing gradient 문제도 해결해 줌

[고급] 앞의 예제 with AutoEncoder(사전학습) 지금은 그냥 PASS! <주의> 사전학습의 개념적 이해를 위한 코드일 뿐임. [고급] 앞의 예제 with AutoEncoder(사전학습) import random xdata = list() ydata = list() for num in range( 500 ) : temp = random.random() xdata.append(temp) ydata.append( -3 * (temp - 0.5)**2 + 10 ) import tensorflow as tf # AutoEncoder를 통한 사전학습 myW1to2 = tf.Variable( tf.random.normal( [1], 0, 1 ) ) myB1to2 = tf.Variable( 0.0) myW1to3 = tf.Variable( tf.random.normal( [1], 0, 1 ) ) myB1to3 = tf.Variable( 0.0 ) myW2to4 = tf.Variable( tf.random.normal( [1], 0, 1 ) ) myW3to4 = tf.Variable( tf.random.normal( [1], 0, 1 ) ) myB23to4 = tf.Variable( 0.0 ) myH2 = xdata * myW1to2 + myB1to2 myH2 = tf.nn.sigmoid( myH2 ) myH3 = xdata * myW1to3 + myB1to3 myH3 = tf.nn.sigmoid( myH3 ) myY = myH2 * myW2to4 + myH3 * myW3to4 + myB23to4 myLoss = tf.reduce_mean((myY - xdata) ** 2) # 정답이 xdata 그 자체 myTrain = tf.train.GradientDescentOptimizer( 0.01 ).minimize( myLoss ) myInit = tf.global_variables_initializer() mySess = tf.Session() mySess.run( myInit ) for step in range( 10000 ) : mySess.run( myTrain ) # 본 학습 # 사전학습된 지식(가중치) 초기값 설정 myW1to2 = tf.Variable( mySess.run(myW1to2) ) myB1to2 = tf.Variable( mySess.run(myB1to2) ) myW1to3 = tf.Variable( mySess.run(myW1to3) ) myB1to3 = tf.Variable( mySess.run(myB1to3) ) myW2to4 = tf.Variable( mySess.run(myW2to4) ) myW3to4 = tf.Variable( mySess.run(myW3to4) ) myB23to4 = tf.Variable( mySess.run(myB23to4) ) myH2 = xdata * myW1to2 + myB1to2 myH2 = tf.nn.sigmoid( myH2 ) myH3 = xdata * myW1to3 + myB1to3 myH3 = tf.nn.sigmoid( myH3 ) myY = myH2 * myW2to4 + myH3 * myW3to4 + myB23to4 myLoss = tf.reduce_mean((myY - ydata) ** 2) # 정답이 ydata myTrain = tf.train.GradientDescentOptimizer( 0.01 ).minimize( myLoss ) myInit = tf.global_variables_initializer() mySess = tf.Session() mySess.run( myInit ) for step in range( 20000 ) : mySess.run( myTrain ) print( mySess.run(myLoss) ) import matplotlib.pyplot as plt plt.plot(xdata, ydata, 'ro') plt.plot(xdata, mySess.run(myY), 'bo') plt.show()

신경망 구조 ∙ ∙ ∙ ∙ ∙ ∙ ∙ ∙ ∙ ∙ ∙ ∙ ∙ ∙ ∙ ∙ ∙ ∙ Input Data 𝑥 1 𝑥 2 𝑥 𝑖 Kernel(가중치, 편향) ℎ 1 ℎ 2 ∙ ∙ ∙ ℎ 𝑚 Hidden Layer Activation Function (relu, sigmoid etc.) ℎ 1 ℎ 2 ∙ ∙ ∙ ℎ 𝑚 Optimizer Kernel(가중치, 편향) 𝑧 1 𝑧 2 ∙ ∙ ∙ 𝑧 𝑗 Output Layer Activation Function (sigmoid, softmax etc.) 𝑧 1 𝑧 2 ∙ ∙ ∙ 𝑧 𝑗 Loss Function (MSE, CrossEntropy etc.) Label Data 𝑦 1 𝑦 2 ∙ ∙ ∙ 𝑦 𝑗

myH2 * myW2to5 + myH3 * myW3to5 + myH4* myW4to5 + myB234to5 Y = (X – 0.3)* (X – 0.6)* (X – 0.9) + 5 *일단 앞의 2 units의 경우로 해볼 것. < 응용1 > One hidden layer with 3 units/nodes and Activation Function xdata ① Input xdata * myW1to3 + myB1to3 xdata * myW1to2 + myB1to2 xdata * myW1to4 + myB1to4 kernel to hidden myH2 ② myH3 ③ myH4 ④ Hidden Layer AF AF AF myH2 ② myH3 ③ myH4 ④ kernel to output myH2 * myW2to5 + myH3 * myW3to5 + myH4* myW4to5 + myB234to5 myY ⑤ ydata Output Label

import random xdata = list() ydata = list() for num in range( 500 ) : temp = random.random() xdata.append(temp) ydata.append( (temp - 0.3)*(temp - 0.6)*(temp - 0.9) + 5 ) import tensorflow as tf myW1to2 = tf.Variable( tf.random.normal ( [1] , 0 , 1 ) ) myB1to2 = tf.Variable( 0.0 ) myW1to3 = tf.Variable( tf.random.normal ( [1] , 0 , 1 ) ) myB1to3 = tf.Variable( 0.0 ) myW1to4 = tf.Variable( tf.random.normal ( [1] , 0 , 1 ) ) myB1to4 = tf.Variable( 0.0 ) myW2to5 = tf.Variable( tf.random.normal ( [1] , 0 , 1 ) ) myW3to5 = tf.Variable( tf.random.normal ( [1] , 0 , 1 ) ) myW4to5 = tf.Variable( tf.random.normal ( [1] , 0 , 1 ) ) myB234to5 = tf.Variable( 0.0 ) myH2 = xdata * myW1to2 + myB1to2 # 회귀식H2 myH2 = tf.nn.sigmoid( myH2 ) # 활성화함수(Activation Function) myH3 = xdata * myW1to3 + myB1to3 # 회귀식H3 myH3 = tf.nn.sigmoid( myH3 ) # 활성화함수(Activation Function) myH4 = xdata * myW1to4 + myB1to4 # 회귀식H3 myH4 = tf.nn.sigmoid( myH4 ) # 활성화함수(Activation Function) myY = myH2 * myW2to5 + myH3 * myW3to5 + myH4 * myW4to5 + myB234to5 myLoss = tf.reduce_mean( (myY - ydata) ** 2 ) # 손실함수 myTrain = tf.train.GradientDescentOptimizer( 0.1 ).minimize( myLoss ) # 옵티마이저 myInit = tf.global_variables_initializer() mySess = tf.Session() mySess.run( myInit ) for step in range( 50000 ) : mySess.run( myTrain ) print( mySess.run(myLoss) ) import matplotlib.pyplot as plt plt.plot( xdata, ydata, 'ro' ) plt.plot( xdata, mySess.run(myY), 'bo' ) plt.show()

kernel to SECOND hidden Y = (X – 0.3)* (X – 0.6)* (X – 0.9) + 5 < 응용2 > 2 hidden layer with 2 units/nodes for each layer xdata Input kernel to FIRST hidden myH2 myH3 FIRST Hidden AF AF myH2 myH3 kernel to SECOND hidden myH4 myH5 SECOND Hidden AF AF myH4 myH5 kernel to output myY ydata Output Label

import random xdata = list() ydata = list() for num in range( 500 ) : temp = random.random() xdata.append(temp) ydata.append( (temp - 0.3)*(temp - 0.6)*(temp - 0.9) + 5 ) import tensorflow as tf myW1to2 = tf.Variable( tf.random.normal( [1], 0, 1 ) ) myB1to2 = tf.Variable( 0.0) myW1to3 = tf.Variable( tf.random.normal( [1], 0, 1 ) ) myB1to3 = tf.Variable( 0.0 ) myW2to4 = tf.Variable( tf.random.normal( [1], 0, 1 ) ) myW3to4 = tf.Variable( tf.random.normal( [1], 0, 1 ) ) myB23to4 = tf.Variable( 0.0 ) myW2to5 = tf.Variable( tf.random.normal( [1], 0, 1 ) ) myW3to5 = tf.Variable( tf.random.normal( [1], 0, 1 ) ) myB23to5 = tf.Variable( 0.0 ) myW4to6 = tf.Variable( tf.random.normal( [1], 0, 1 ) ) myW5to6 = tf.Variable( tf.random.normal( [1], 0, 1 ) ) myB45to6 = tf.Variable( 0.0 ) myH2 = xdata * myW1to2 + myB1to2 myH2 = tf.nn.sigmoid( myH2 ) myH3 = xdata * myW1to3 + myB1to3 myH3 = tf.nn.sigmoid( myH3 ) myH4 = myH2 * myW2to4 + myH3 * myW3to4 + myB23to4 myH4 = tf.nn.sigmoid( myH4 ) myH5 = myH2 * myW2to5 + myH3 * myW3to5 + myB23to5 myH5 = tf.nn.sigmoid( myH5 ) myY = myH4 * myW4to6 + myH5 * myW5to6 + myB45to6 myLoss = tf.reduce_mean( (myY - ydata) ** 2 ) # 손실함수 myTrain = tf.train.GradientDescentOptimizer( 0.1 ).minimize( myLoss ) # 옵티마이저 myInit = tf.global_variables_initializer() mySess = tf.Session() mySess.run( myInit ) for step in range( 100000 ) : mySess.run( myTrain ) print( mySess.run(myLoss) ) import matplotlib.pyplot as plt plt.plot( xdata, ydata, 'ro' ) plt.plot( xdata, mySess.run(myY), 'bo' ) plt.show()

① ② ③ myH4 ④ myH5 ⑤ myH4 ④ myH5 ⑤ ⑥ < 실습 > 독립변수 3개, 은닉층(with 2 units)의 code를 작성해보시오. 이처럼 독립변수가 3개 이상일 경우 성능 결과를 간단한 그래프로 확인할 수조차 없게 됨[왜?]. 우리가 기계의 학습 과정 과정을 분석/파악하기가 어려워 짐. 즉, 머신러닝 과정은 우리에게 “블랙박스”가 되어 버림. X1 data ① X2 data ② X3 data ③ Input kernel to hidden myH4 ④ myH5 ⑤ Hidden AF AF myH4 ④ myH5 ⑤ kernel to output myY ⑥ ydata Output Label

import random x1data = list() x2data = list() x3data = list() ydata = list() for num in range( 500 ) : temp1 = random.random() temp2 = random.random() temp3 = random.random() x1data.append( temp1 ) x2data.append( temp2 ) x3data.append( temp3 ) ydata.append( 10 + 3 * temp1 - 4 * temp2 + 2 * temp3 ) import tensorflow as tf myW1to4 = tf.Variable( tf.random.normal( [1], 0, 1 ) ) myW2to4 = tf.Variable( tf.random.normal( [1], 0, 1 ) ) myW3to4 = tf.Variable( tf.random.normal( [1], 0, 1 ) ) myB123to4 = tf.Variable( 0.0) myW1to5 = tf.Variable( tf.random.normal( [1], 0, 1 ) ) myW2to5 = tf.Variable( tf.random.normal( [1], 0, 1 ) ) myW3to5 = tf.Variable( tf.random.normal( [1], 0, 1 ) ) myB123to5 = tf.Variable( 0.0) myW4to6 = tf.Variable( tf.random.normal( [1], 0, 1 ) ) myW5to6 = tf.Variable( tf.random.normal( [1], 0, 1 ) ) myB45to6 = tf.Variable( 0.0 ) myH4 = x1data * myW1to4 + x2data * myW2to4 + x3data * myW3to4 + myB123to4 myH4 = tf.nn.sigmoid( myH4 ) myH5 = x1data * myW1to5 + x2data * myW2to5 + x3data * myW3to5 + myB123to5 myH5 = tf.nn.sigmoid( myH5 ) myY = myH4 * myW4to6 + myH5 * myW5to6 + myB45to6 myLoss = tf.reduce_mean( (myY - ydata) ** 2 ) # 손실함수 myTrain = tf.train.GradientDescentOptimizer( 0.1 ).minimize( myLoss ) # 옵티마이저 myInit = tf.global_variables_initializer() mySess = tf.Session() mySess.run( myInit ) for step in range( 20000 ) : mySess.run( myTrain ) print( mySess.run(myLoss) )

< 문제 > 독립변수 3개, 2개의 은닉층(with 4 and 5 units for each) < 문제 > 독립변수 3개, 2개의 은닉층(with 4 and 5 units for each). 생성해야 할 Variable 및 세워야 할 식은 모두 몇 개? X1 Data X2 data X3 data Input my4 my5 my6 my7 FIRST Hidden AF AF AF AF my4 my5 my6 my7 my8 my9 myA my11 my12 SECOND Hidden AF AF AF AF AF my8 my9 my10 my11 my12 myY ydata Output Label

<답> 66개 □ 생성해야 할 Variable 개수 = 37 + 10 = 47 ○ 가중치(myW)의 개수 = kernel의 모든 연결 선 개수 3x4(input → first hidden) + 4x5(first hidden → second hidden) + 5x1(second hidden → output) = 37개 ○ 편향(myB)의 개수 = kernel의 output 개수 4(input → first) + 5(first → second) + 1(second → output) = 10개 □ 세워야 할 식 개수 = 10 + 9 = 19 ○ kernel의 output 개수 = 10개 ○ activation function 개수 = output을 제외한 9개

with Many inputs/outputs 회귀분석 with Many inputs/outputs by using Matrix

입력값 및 가중치의 행렬표기방법 : tf.matmul for ONE case < 수학적 방정식 > 𝑤 1 𝑥 1 + 𝑤 2 𝑥 2 + 𝑤 3 𝑥 3 +𝑏=𝑦 < 행렬 표기법 1> 𝑤 1 𝑤 2 𝑤 3 𝑥 1 𝑥 2 𝑥 3 +𝑏= 𝑦 matmul( 𝑊 1∙3 , 𝑋 1∙3 ) + b = y matmul( 𝑊 1∙3 , 𝑋 3∙1 ) + b = y Why 𝑏 instead of [𝑏]? < 행렬 표기법 2: 더 권장> 𝑥 1 𝑥 2 𝑥 3 𝑤 1 𝑤 2 𝑤 3 +𝑏= 𝑦 matmul( 𝑋 1∙3 , 𝑊 1∙3 ) + b = y matmul( 𝑋 1∙3 , 𝑊 3∙1 ) + b = y import numpy as np a = np.array( [ 1, 2, 3 ] ) b = np.array( [ 4, 5, 6 ] ) c = np.array( [ [4], [5], [6]] ) print(np.matmul(a, b)) print(np.matmul(b, a)) print(np.matmul(a, c)) print(np.matmul(c, a)) # 오류

입력값 및 가중치의 행렬표기방법 : tf.matmul for MANY cases < 수학적 방정식 > 𝑤 1 𝑥 1 1 + 𝑤 2 𝑥 2 1 + 𝑤 3 𝑥 3 1 +𝑏= 𝑦 1 𝑤 1 𝑥 1 2 + 𝑤 2 𝑥 2 2 + 𝑤 3 𝑥 3 2 +𝑏= 𝑦 2 < 행렬 표기법 1> 𝑤 1 𝑤 2 𝑤 3 𝑥 1 1 𝑥 1 2 𝑥 2 1 𝑥 2 2 𝑥 3 1 𝑥 3 2 +𝑏= 𝑦 1 𝑦 2 matmul( 𝑊 1∙3 , 𝑋 3∙2 ) + b = 𝑌 1∙2 Why 𝑏 instead of [𝑏, 𝑏]? < 행렬 표기법 2: 더 권장> 𝑥 1 1 𝑥 2 1 𝑥 3 1 𝑥 1 2 𝑥 2 2 𝑥 3 2 𝑤 1 𝑤 2 𝑤 3 +𝑏= 𝑦 1 𝑦 2 matmul( 𝑋 2∙3 , 𝑊 3∙1 ) + 𝑏 = 𝑌 2∙1 𝑏 instead of 𝑏 𝑏 𝑖.𝑒. [ [𝑏], [𝑏] ] import numpy as np w1 = np.array( [ 1, 2, 3 ] ) x1 = np.array( [ [ 1, 4 ], [ 2, 5 ], [3, 6] ] ) print(np.matmul(w1, x1)) x2 = np.array( [ [ 1, 2, 3 ], [ 4, 5, 6] ] ) w2 = np.array( [ [ 1 ], [ 2 ], [ 3 ] ] ) print(np.matmul(x2, w2))

입력값 및 가중치의 행렬표기방법 : tf.matmul for MANY OUTPUTs < 수학적 방정식: many inputs과 many outputs 구분 및 W, B 형태 이해 중요 > 𝑤 1←1 𝑥 1 1 + 𝑤 1←2 𝑥 2 1 + 𝑤 1←3 𝑥 3 1 + 𝑏 1 = 𝑦 1 1 𝑤 2←1 𝑥 1 1 + 𝑤 2←2 𝑥 2 1 + 𝑤 2←3 𝑥 3 1 + 𝑏 2 = 𝑦 2 1 𝑤 1←1 𝑥 1 2 + 𝑤 1←2 𝑥 2 2 + 𝑤 1←3 𝑥 3 2 + 𝑏 1 = 𝑦 1 2 𝑤 2←1 𝑥 1 2 + 𝑤 2←2 𝑥 2 2 + 𝑤 2←3 𝑥 3 2 + 𝑏 2 = 𝑦 2 2 < 행렬 표기법2: 더 권장> 𝑥 1 1 𝑥 2 1 𝑥 3 1 𝑥 1 2 𝑥 2 2 𝑥 3 2 𝑤 1←1 𝑤 2←1 𝑤 1←2 𝑤 2←2 𝑤 1←3 𝑤 2←3 + 𝑏 1 𝑏 2 = 𝑦 1 1 𝑦 2 1 𝑦 1 2 𝑦 2 2 case input 종류 output 종류 input 연결 output 연결 𝑏 1 𝑏 2 instead of 𝑏 1 𝑏 2 𝑏 1 𝑏 2 𝑋 𝑏∙𝑚 ∙ 𝑊 𝑚∙𝑛 + 𝐵 1∙𝑛 = 𝑌 𝑏∙𝑛 𝑏 : case/sample/batch 개수 𝑚 : input 종류(독립변수) 개수 𝑛 : output 종류 개수 matmul( 𝑋 2∙3 , 𝑊 3∙2 ) + 𝐵 1∙2 = 𝑌 2∙2 import numpy as np x = np.array( [ [ 1, 2, 3 ], [ 4, 5, 6] ] ) w = np.array( [ [ 1, 2 ], [ 3, 4 ], [ 5, 6 ] ] ) b = np.array( [10, 20] ) b2 = np.array( [ [10, 20], [10, 20] ] ) print( np.matmul(x, w) ) print( np.matmul(x, w) + b ) print( np.matmul(x, w) + b2 ) 참고 < 행렬 표기법1> 𝑤 1←1 𝑤 1←2 𝑤 1←3 𝑤 2←1 𝑤 2←2 𝑤 2←3 𝑥 1 1 𝑥 1 2 𝑥 2 1 𝑥 2 2 𝑥 3 1 𝑥 3 2 + 𝑏 1 𝑏 2 = 𝑦 1 1 𝑦 1 2 𝑦 2 1 𝑦 2 2

*case/sample/batch의 값들은 동일한 parameter(가중치, 편향)를 공유함. < 수학적 방정식: many inputs과 many outputs 구분 및 W, B 형태 이해 중요 > 𝑤 1←1 𝑥 1 1 + 𝑤 1←2 𝑥 2 1 + 𝑤 1←3 𝑥 3 1 + 𝑏 1 = 𝑦 1 1 𝑤 2←1 𝑥 1 1 + 𝑤 2←2 𝑥 2 1 + 𝑤 2←3 𝑥 3 1 + 𝑏 2 = 𝑦 2 1 𝑤 1←1 𝑥 1 2 + 𝑤 1←2 𝑥 2 2 + 𝑤 1←3 𝑥 3 2 + 𝑏 1 = 𝑦 1 2 𝑤 2←1 𝑥 1 2 + 𝑤 2←2 𝑥 2 2 + 𝑤 2←3 𝑥 3 2 + 𝑏 2 = 𝑦 2 2 < 행렬 표기법2: 더 권장> 𝑥 1 1 𝑥 2 1 𝑥 3 1 𝑥 1 2 𝑥 2 2 𝑥 3 2 𝑤 1←1 𝑤 2←1 𝑤 1←2 𝑤 2←2 𝑤 1←3 𝑤 2←3 + 𝑏 1 𝑏 2 = 𝑦 1 1 𝑦 2 1 𝑦 1 2 𝑦 2 2 case input 종류 output 종류 input 연결 output 연결 𝑥 1 𝑥 2 𝑥 3 Input 𝑤 1←2 𝑤 2←2 𝑤 2←1 𝑤 1←3 𝑤 1←1 𝑤 2←3 case/sample/batch의 묶음은 각 선으로 함께 흐름. 𝑦 1 𝑦 2 Output 𝑤 1←1 𝑥 1 + 𝑤 1←2 𝑥 2 + 𝑤 1←3 𝑥 3 + 𝑏 1 = 𝑦 1 𝑤 2←1 𝑥 1 + 𝑤 2←2 𝑥 2 + 𝑤 2←3 𝑥 3 + 𝑏 2 = 𝑦 2

신경망 구조 ∙ ∙ ∙ ∙ ∙ ∙ ∙ ∙ ∙ ∙ ∙ ∙ ∙ ∙ ∙ ∙ ∙ ∙ Input Data 𝑥 1 𝑥 2 𝑥 𝑖 Kernel : 𝑯 𝒃𝒎 = 𝑿 𝒃𝒊 𝑾 𝒊𝒎 + 𝑩 𝟏𝒎 * 𝑏 for batch size * 𝒊 is given, 𝒎 is decision * 𝟏 is possible for 𝑏 ℎ 1 ℎ 2 ∙ ∙ ∙ ℎ 𝑚 Hidden Layer Activation Function (relu, sigmoid etc.) ℎ 1 ℎ 2 ∙ ∙ ∙ ℎ 𝑚 Optimizer Kernel : 𝒁 𝒃𝒋 = 𝑯 𝒃𝒎 𝑾 𝒎𝒋 + 𝑩 𝟏𝒋 * 𝑏 for batch size * 𝒋 is given * 𝟏 is possible for 𝑏 𝑧 1 𝑧 2 ∙ ∙ ∙ 𝑧 𝑗 Output Layer Activation Function (sigmoid, softmax etc.) 𝑧 1 𝑧 2 ∙ ∙ ∙ 𝑧 𝑗 Loss Function (MSE, CrossEntropy etc.) Label Data 𝑦 1 𝑦 2 ∙ ∙ ∙ 𝑦 𝑗

X1 X2 X3 myY # 데이터 생성 import random xdata = list() ydata = list() for num in range( 500 ) : temp1 = random.random() temp2 = random.random() temp3 = random.random() xdata.append( [ temp1, temp2, temp3 ] ) # [구조 주의] ydata.append( [ 10 + 3 * temp1 – 4 * temp2 + 2 * temp3 ] ) # [구조 주의] # tensorflow로 모델링 import tensorflow as tf myB = tf.Variable( 0.0 ) myW = tf.Variable( tf.random.normal( [3, 1] , 0, 1 ) ) # 3x1행렬 : (input node 3개) x (output의 node 1개) myY = tf.matmul( xdata, myW ) + myB # 회귀식 : 행렬 연산 사용 matmul(input data, 가중치) + 편향 myLoss = tf.reduce_mean( (myY - ydata)**2 ) # 손실함수 myTrain = tf.train.GradientDescentOptimizer( 0.1 ).minimize( myLoss ) # 옵티마이저 myInit = tf.global_variables_initializer() mySess = tf.Session() mySess.run( myInit ) for step in range( 1000 ) : mySess.run( myTrain ) print( mySess.run(myB), mySess.run(myW) ) X1 X2 X3 myY

VS X1 X2 X3 myH4 myH5 AF AF myH4 myH5 myY import random x1data = list() x2data = list() x3data = list() ydata = list() for num in range( 500 ) : temp1 = random.random() temp2 = random.random() temp3 = random.random() x1data.append( temp1 ) x2data.append( temp2 ) x3data.append( temp3 ) ydata.append( 10 + 3 * temp1 - 4 * temp2 + 2 * temp3 ) import tensorflow as tf myW1to4 = tf.Variable( tf.random.normal( [1], 0, 1 ) ) myW2to4 = tf.Variable( tf.random.normal( [1], 0, 1 ) ) myW3to4 = tf.Variable( tf.random.normal( [1], 0, 1 ) ) myB123to4 = tf.Variable( 0.0) myW1to5 = tf.Variable( tf.random.normal( [1], 0, 1 ) ) myW2to5 = tf.Variable( tf.random.normal( [1], 0, 1 ) ) myW3to5 = tf.Variable( tf.random.normal( [1], 0, 1 ) ) myB123to5 = tf.Variable( 0.0) myW4to6 = tf.Variable( tf.random.normal( [1], 0, 1 ) ) myW5to6 = tf.Variable( tf.random.normal( [1], 0, 1 ) ) myB45to6 = tf.Variable( 0.0 ) myH4 = x1data * myW1to4 + x2data * myW2to4 + x3data * myW3to4 + myB123to4 myH4 = tf.nn.sigmoid( myH4 ) myH5 = x1data * myW1to5 + x2data * myW2to5 + x3data * myW3to5 + myB123to5 myH5 = tf.nn.sigmoid( myH5 ) myY = myH4 * myW4to6 + myH5 * myW5to6 + myB45to6 X1 X2 X3 myH4 myH5 import random xdata = list() ydata = list() for num in range( 500 ) : temp1 = random.random() temp2 = random.random() temp3 = random.random() xdata.append( [ temp1, temp2, temp3 ] ) ydata.append( [ 10 + 3 * temp1 - 4 * temp2 + 2 * temp3 ] ) import tensorflow as tf myW_h = tf.Variable( tf.random.normal( [3,2], 0, 1 ) ) myB_h = tf.Variable( tf.zeros( [2] ) ) myH = tf.matmul( xdata, myW_h ) + myB_h myH = tf.nn.sigmoid( myH ) myW_o = tf.Variable( tf.random.normal( [2,1], 0, 1 ) ) myB_o = tf.Variable( tf.zeros( [1] ) ) myY = tf.matmul( myH, myW_o ) + myB_o AF AF myH4 myH5 # [구조 주의] myY # 3x2행렬 [왜?] VS # 2x1행렬 [왜?] myLoss = tf.reduce_mean( (myY - ydata) ** 2 ) myTrain = tf.train.GradientDescentOptimizer( 0.1 ).minimize( myLoss ) myInit = tf.global_variables_initializer() mySess = tf.Session() mySess.run( myInit ) for step in range( 20000 ) : mySess.run( myTrain ) print( mySess.run(myLoss) )

Y = (X – 0.3)* (X – 0.6)* (X – 0.9) + 5 2개의 은닉층(with 4 and 5 units for each) X Data Input my4 my5 my6 my7 FIRST Hidden AF AF AF AF my4 my5 my6 my7 my8 my9 myA my11 my12 SECOND Hidden AF AF AF AF AF my8 my9 my10 my11 my12 myY ydata Output Label

import random xdata = list() ydata = list() for num in range( 500 ) : temp = random.random() xdata.append( [ temp ] ) # [구조 주의] ydata.append( [ (temp - 0.3)*(temp - 0.6)*(temp - 0.9) + 5 ] ) # [구조 주의] import tensorflow as tf myW_h1 = tf.Variable( tf.random.normal( [1,4], 0, 1 ) ) # 첫번째 kernel myB_h1 = tf.Variable( tf.zeros( [4] ) ) myH1 = tf.matmul( xdata, myW_h1 ) + myB_h1 myH1 = tf.nn.relu( myH1 ) myW_h2 = tf.Variable( tf.random.normal( [4,5], 0, 1 ) ) # 두번째 kernel myB_h2 = tf.Variable( tf.zeros( [5] ) ) myH2 = tf.matmul( myH1, myW_h2 ) + myB_h2 myH2 = tf.nn.relu( myH2 ) myW_o = tf.Variable( tf.random.normal( [5,1], 0, 1 ) ) # 세번째 kernel myB_o = tf.Variable( tf.zeros( [1] ) ) myY = tf.matmul( myH2, myW_o ) + myB_o myLoss = tf.reduce_mean( (myY - ydata) ** 2 ) myTrain = tf.train.GradientDescentOptimizer( 0.1 ).minimize( myLoss ) myInit = tf.global_variables_initializer() mySess = tf.Session() mySess.run( myInit ) for step in range( 50000 ) : mySess.run( myTrain ) print( mySess.run(myLoss) ) import matplotlib.pyplot as plt plt.plot( xdata, ydata, 'ro' ) plt.plot( xdata, mySess.run(myY), 'bo' ) plt.show()

회귀분석 with CSV, Test and Batch Size

# 데이터 생성/import xdata = list() ydata = list() import csv file = open("data.csv") read = csv.reader(file) for row in read : xdata.append(float(row[0])) ydata.append(float(row[1])) # 데이터를 훈련데이터와 테스트데이터로 나눔. 그리고 python list를 numpy array로 변환한 후 2축으로 설정. import numpy as np trainXdata = np.array( xdata[:400] ) # 보통 전체 데이터의 80% trainXdata = np.reshape( trainXdata, (400, 1 ) ) trainYdata = np.array( ydata[:400] ) trainYdata = np.reshape( trainYdata, (400, 1 ) ) testXdata = np.array( xdata[400:] ) testYdata = np.array( ydata[400:] ) # tensorflow로 모델링 import tensorflow as tf mySess = tf.Session() myB = tf.Variable( 0.5 ) myW = tf.Variable( 0.5 ) myInit = tf.global_variables_initializer() mySess.run( myInit )

trainXdataBatch myY myLoss trainYdataBatch myTrain mySess.run( trainXdataBatch = tf.placeholder( tf.float32, [None, 1] ) trainYdataBatch = tf.placeholder( tf.float32, [None, 1] ) myY = myB + myW * trainXdataBatch myLoss = tf.reduce_mean( tf.square( myY - trainYdataBatch ) ) myTrain = tf.train.GradientDescentOptimizer( 0.1 ).minimize( myLoss ) # 학습 #np.random.seed(1) # for indentical random sequence for step in range( 100 ) : rand_index = np.random.choice(400, 100) # Batch Size: 399까지 100개의 index를 뽐음 batchXdata = trainXdata[ rand_index ] batchYdata = trainYdata[ rand_index ] mySess.run( myTrain, feed_dict={ trainXdataBatch: batchXdata, trainYdataBatch: batchYdata } ) print( mySess.run(myB), mySess.run(myW) ) trainMyY = myB + myW * trainXdata trainLoss = tf.reduce_mean( ( trainMyY - trainYdata )**2 ) print(mySess.run(trainLoss)) # 테스트 testMyY = myB + myW * testXdata testLoss = tf.reduce_mean( ( testMyY - testYdata )**2 ) print(mySess.run(testLoss)) # import matplotlib.pyplot as plt # plt.plot(testXdata, testYdata, 'ro') # plt.plot(testXdata, mySess.run(testMyY)) # plt.show() *tensorflow.constant(): 계속 고정된 값(data) tensorflow.Variable(): 변화시키면서 찾고자 하는 값(parameter) tensorflow.placeholder(): 그때 그때 입력하고자 하는 값(data batch) *random selection cf) slice selection trainXdataBatch myY myLoss trainYdataBatch myTrain mySess.run( , feed_dict={ } placeholder Placeholder 사용 구조

Batch Size : 1회 학습에 사용하는 데이터(inputs, label) 수 *Batch Size = Total 이라고 하여 한 번에 학습을 완료하는 것은 아니다. 어디까지나 “반복적 시행착오”이다. 즉, 동일한 데이터일지라도 반복하여 사용하면 추가 학습이 이루어진다. 학습속도 학습안정성 ㅇBatch Size : 1(SGD) vs Mini-Batch vs Total/Batch ㅇMini-Batch Data selection : random vs slice 손실(오차)점수 Batch Size : 1회 학습에 사용하는 데이터(inputs, label) 수 학습률(작을수록 폭이 좁음) ㅇ학습률 : 크게 vs 작게 ㅇ학습률이 작을수록 Batch Size가 작을수록 학습횟수는 많이 학습횟수 가중치 *통계적 회귀분석은 total data를 사용하여 한 번에 최저 지점으로 간다.

< 과제: 신경망 and Regression 종합 > ○ 독립변수가 3개 ○ 1000개의 data set. CSV 파일 사용 : Train set 700개, Test set 300개 ○ Batch Size 50 적용 ○ One hidden layer with 4 units/nodes and Activation Function(Relu) 적용 ○ 커널 설정은 행렬을 사용한 tf.matmul 적용 *reduce_mean()에 index 값 추가 필요? X1 data X2 data X3 data Input Kernel Hidden AF AF AF AF Kernel myY ydata Output