섹션7. ML의 실용과 몇가지 팁
1. 학습 rate, Overfitting, 그리고 일반화 (Regularization)
- learning rate
굉장히 큰 값으로 정한다면 → overshooting! cost가 줄어들지 않아요!
굉장히 작은 값으로 정한다면 → cost가 너무 작게 변해!
보통 0.01로 시작합니다! - preprocessing
데이터 간 값의 차이가 너무 클 때 데이터 전처리를 해야 해!
- Standardization → 값의 분산과 평균을 가지고 !
- overfitting
train data에만 너무 딱 맞게 학습되는 경우
oeverfitting을 해결하는 방법
- train data를 많이 가지고 있기
- features의 개수를 줄이기
- Regularization! → 일반화해요 → 구부리지말구 펴! → weight값을 너무 크게 하지말자
→ regularization strength를 적당히(?)
2. Training/Testing 데이타 셋
- original data
- train set : 우리들의 교과서
- validation set : 모의시험
- test set : 실전 문제
라고 생각하면 편하답니다 ~ - Online learning
→ 데이터를 쪼개서 학습시키는 방법
나중에 데이터가 추가되었을 때 처음부터 다시 학습시키지 않고 추가적으로
해당 데이터만 학습시키면 된다는 장점! - Accuracy
최근 이미지를 예측하는 모델은 95% ~ 99% 정확도랍니다~
y값 (우리들의 lable)과 모델이 예측한 값을 비교!
3. lab 07-1: training/test dataset, learning rate, normalization (new)
→ 우리가 가진 데이터를 train과 test로 나눈다!
- learning rate
너무 작으니 수백번 반복해도 cost값이 같아! local minimum에 빠졌을 것
너무 크니 무한대로 빠졌어! 밖으로 확 튕겨나가는 순간일 것 - normalized inputs
ex) MinMaxScaler → 데이터의 값을 0과 1사이로 정규화하기
4. lab 07-2: Meet MNIST Dataset (new)
- epoch : 전체 data set을 한 번 다 학습시킨 것을 1epoch!
- batch size : 만약 100개씩 학습시킨다면 batch size는 100!
섹션8. 딥러닝의 기본 개념과, 문제, 그리고 해결
1. 딥러닝의 기본 개념: 시작과 XOR 문제
→ 뭐 .. 인간의 뇌 구조에서 영감을 얻은 처리 방식 ..?
→ Minsky 교수님 : xor은 안돼! → 여러개를 합치면 될 수도 있어!
→ Backpropagation 알고리즘 발표!
xor도 해결 가능!!! but, 복잡할 수록 앞부분 까지 에러가 전달되지 않아 학습이 잘 되지 않아 ..
2. 딥러닝의 기본 개념2: Back-propagation 과 2006/2007 ‘딥’의 출현
Neural networks → Deep Learning
유튜브 자막, 페이스북, 구글 등등이 그 예!
3. Lab : Tensor Manipulation (new)
: 김밥을 보면서 1차원 array를 생각한답니다 ..
rank : 몇차원이냐 ! shape : 원소가 몇개 있냐!
import tensorflow as tf
import numpy as np
t = tf.constant([[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]],[[13, 14, 15, 16], [17, 18, 19, 20], [21, 22, 23, 24]]]])
tf.shape(t).eval()
axis 는 안쪽에 있는 것이 가장 큰 값, 바깥으로 갈수록 가장 작은 값
but, 가장 안쪽에 있는 축은 -1이라고도 표현.
- broadcasting
→ shape이 달라도 연산이 가능하게 해주는 것matrix1= tf.constant([[3., 3.]]) matrix2= tf.constant([[2., 2.]]) (matrix1+matrix2).eval()
→ 위 세개의 모든 연산의 결과값이 같음.matrix1= tf.constant([[3., 3.]]) matrix2= tf.constant([2.]) (matrix1+matrix2).eval()
이왕이면 같은 shape의 연산을 하는 것이 좋다. matrix1= tf.constant([[3., 3.]]) matrix2= tf.constant([[2.],[2.]]) (matrix1+matrix2).eval()
- reduce mean
x= [[1., 2.],
[3., 4.]]
tf.reduce_mean(x).eval()
#축이 0일때
tf.reduce_mean(x, axis=0).eval() #array([ 2., 3.], dtype=float32)
#축이 1일때
tf.reduce_mean(x, axis=1).eval() #array([ 1.5, 3.5], dtype=float32)
#축이 -1일때 == 1
tf.reduce_mean(x, axis=-1).eval() #array([ 1.5, 3.5], dtype=float32)
보통
tf.reduce_mean(tf.reduce_sum(x, axis=-1)).eval()이렇게 많이 사용한다고 합니당.
- Argmax
→ 가장 큰 값의 위치를 반환
x= [[0, 1, 2], [2, 1, 0]] tf.argmax(x, axis=0).eval() #array([1, 0, 0]) tf.argmax(x, axis=1).eval() #array([2, 0]) tf.argmax(x, axis=-1).eval() #array([2, 0])
- Reshape → 가장 많이 사용한답니다!
내가 원하는 형태의 shape을 준다면 reshape 됨! 보통 가장 안 쪽에 있는 값은 건드리지 않아요
t= np.array([[[0, 1, 2],
[3, 4, 5]],
[[6, 7, 8],
[9, 10, 11]]])
t.shape
#(2, 2, 3)
tf.reshape(t, shape=[-1, 3]).eval()
# array([[ 0, 1, 2],
# [ 3, 4, 5],
# [ 6, 7, 8],
# [ 9, 10, 11]])
- squeeze, expand
tf.squeeze([[0], [1], [2]]).eval()
#array([0, 1, 2], dtype=int32)
tf.expand_dims([0, 1, 2], 1).eval()
#array([[0],
# [1],
# [2]], dtype=int32) -> 텐서의 차원을 추가!
- One hot
→ one hot은 자동적으로 rank하나를 expand함. 그게 싫다면!
tf.one_hot([[0], [1], [2], [0]], depth=3).eval()
#array([[[ 1., 0., 0.]],
# [[ 0., 1., 0.]],
# [[ 0., 0., 1.]],
# [[ 1., 0., 0.]]], dtype=float32) 특정 인덱스만 hot하게!
→ 다시 reshape해주세요!
t= tf.one_hot([[0], [1], [2], [0]], depth=3)
tf.reshape(t, shape=[-1, 3]).eval()
#array([[ 1., 0., 0.],
# [ 0., 1., 0.],
# [ 0., 0., 1.],
# [ 1., 0., 0.]], dtype=float32)
- Casting
tf.cast([1.8, 2.2, 3.3, 4.9], tf.int32).eval() #int로 바꾸기
tf.cast([True, False, 1 == 1, 0 == 1], tf.int32).eval() #t/f를 0/1로 바꾸기
→ accuracy 계산 시 자주 사용
- Stack
x= [1, 4]
y= [2, 5]
z= [3, 6]
# Pack along first dim.
tf.stack([x, y, z]).eval()
#array([[1, 4],
# [2, 5],
# [3, 6]], dtype=int32) -> 그대로 쌓아!
tf.stack([x, y, z], axis=1).eval()
#array([[1, 2, 3],
# [4, 5, 6]], dtype=int32) -> 설정한 축대로 쌓기
- One and Zeros like
x= [[0, 1, 2],
[2, 1, 0]]
tf.ones_like(x).eval()
#array([[1, 1, 1],
# [1, 1, 1]], dtype=int32) -> ones니까 똑같은 모양인데 다 1로 채움!
# -> zero면 0으로!
- Zip
for x, yin zip([1, 2, 3], [4, 5, 6]):
print(x, y)
#1 4
#2 5
#3 6 -> 복수개의 tensor를 zip으로 묶어서 한 번에 처리!
섹션9. Neural Network 1: XOR 문제와 학습방법, Backpropagation
1. XOR 문제 딥러닝으로 풀기
k(x) = sigmoid(xw1 + b1)
y = H(x) = sigmoid(k(x)w2 + b2) 이 식들을
k = tf.sigmoid(tf.matmul(x, w1) + b1)
hypothesis = tf.sigmoid(tf.matmul(k + w2) + b2)
이렇게 나타낼 수 있음.
2. 특별편: 10분안에 미분 정리하기
- basic derivative
- partial derivative
미분하고자 하는 변수 외에는 상수취급하기 - chain rule
chain rul은 쉽게
- x가 변화했을 때, g가 얼마나 변하는지,
-함수 g의 변화로 인해 함수 f가 얼마나 변하는 지,
- 함수 f의 인자가 함수 g면 최종 값의 변화량에 기여하는 각 함수 f, g의 기여도를 알 수 있다.
3. 딥넷트웍 학습 시키기 (backpropagation)
- back propagation
→ target과 실제 모델이 예측한 값이 얼마나 차이가 나는지를 구한 후 그 오차값을 뒤로 전파(?)해가면서 각 노드의 변수들을 업데이트 해주는 것 !
한국말로 역전파 라고 합니다.
여기서 각 노드의 변수 즉, weigth와 bias를 업데이트 할 때 chain rule을 사용하여 업데이트 해 준다는 것.
4. Lab 9-1: XOR을 위한 텐스플로우 딥넷트웍 (new)
# Lab 9 XOR
import tensorflow as tf
import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()
import numpy as npp
tf.set_random_seed(777) # for reproducibility
x_data = np.array([[0, 0], [0, 1], [1, 0], [1, 1]], dtype=np.float32)
y_data = np.array([[0], [1], [1], [0]], dtype=np.float32)
X = tf.placeholder(tf.float32, [None, 2])
Y = tf.placeholder(tf.float32, [None, 1])
W = tf.Variable(tf.random_normal([2, 1]), name="weight") #in, out
b = tf.Variable(tf.random_normal([1]), name="bias") #bias는 항상out의 수!
# Hypothesis using sigmoid: tf.div(1., 1. + tf.exp(tf.matmul(X, W)))
hypothesis = tf.sigmoid(tf.matmul(X, W) + b)
# cost/loss function
cost = -tf.reduce_mean(Y * tf.log(hypothesis) + (1 - Y) * tf.log(1 - hypothesis))
train = tf.train.GradientDescentOptimizer(learning_rate=0.1).minimize(cost)
# Accuracy computation
# True if hypothesis>0.5 else False
predicted = tf.cast(hypothesis > 0.5, dtype=tf.float32)
accuracy = tf.reduce_mean(tf.cast(tf.equal(predicted, Y), dtype=tf.float32)) #실제 정답과 비
# Launch graph
with tf.Session() as sess:
# Initialize TensorFlow variables
sess.run(tf.global_variables_initializer())
for step in range(10001):
_, cost_val, w_val = sess.run(
[train, cost, W], feed_dict={X: x_data, Y: y_data}
)
if step % 100 == 0:
print(step, cost_val, w_val)
# Accuracy report
h, c, a = sess.run(
[hypothesis, predicted, accuracy], feed_dict={X: x_data, Y: y_data}
)
print("\nHypothesis: ", h, "\nCorrect: ", c, "\nAccuracy: ", a)
→ 실망스러운 결과 …. ⇒
- Neural Net사용하기
layer1 = tf.sigmoid(tf.matmul(X, W1) + b1)
hypothesis = tf.sigmoid(tf.matmul(layer1, W2) + b2)
- wide NN
w1 = tf.Variable(tf.random_normal([2, 10]), name="weight1")
b1 = tf.Variable(tf.random_normal([10]), name="bias1")
layer1 = tf.sigmoid(tf.matmul(X, w1) + b1)
w2 = tf.Variable(tf.random_normal([10, 1]), name="weight2")
b2 = tf.Variable(tf.random_normal([1]), name="bias2")
hypothesis = tf.sigmoid(tf.matmul(X, w2) + b2)
→ 모델이 더 잘 학습됨니다!
- Deep NN
layer를 더 많이 연결하면 됨.
out값을 다음 layer의 input으로 잘 연결하기!
5. Lab 9-2: Tensor Board로 딥네트웍 들여다보기 (new)
- TensorBoard : 학습의 진행사항을 한 눈에 볼 수 있음
- 사용법
- 어떤 값을 logging할 것인지!
- merge all summaries!
- summary를 어디 위치에 저장할 것인지 파일 위치 저장
- summary를 실행시켜준 후 파일에 기록하기
- $ tensorboard - - logdir=./logs 명령어 입력하기
- name_scope
layer별로 깔끔하게 정리해줌!
섹션10. Neural Network 2: ReLU and 초기값 정하기 (2006/2007 breakthrough)
1. XSigmoid 보다 ReLU가 더 좋아
- vanishing gradient
최종 단과 가까운 곳은 괜찮지만 단 수가 깊어질수록 경사와 기울기의 의미가 없어진다. → ReLU가 해결! - ReLU
→ L1 = tf.nn.relu(tf.matmul(X, W1) + b1)
하지만 마지막 단의 출력은 sigmoid사용! 마지막 출력은 0~1사이어야 하기 때문!
2. Weight 초기화 잘해보자
- 절대로 모든 초기값에 0을 주면 안돼!
- RBM
: forward(incode), backward(decode)의 값을 같게 해주기 위해 weight를 조정하는 것 (?)
3. Dropout 과 앙상블
- dropout
서로 연결된 layer에서 랜덤하게 0-1 사이의 확률로 뉴런을 제거하는 것
train할 때 반드시 dropout을 사용
overfitting을 방지하기 위해 사용dropout_rate = tf.placeholder("float") _L1 = tf.nn.relu(tf.add(tf.matmul(X, W1), B1)) L1 = tf.nn.dropout( _L1, dropout_rate)
- Ensemble
→ 하나의 모델만을 학습시켜 사용하지 않고 여러 모델을 학습시켜 결합하는 방식으로 문제를 처리함!
성능이 효과적이다!
4. 레고처럼 넷트웍 모듈을 마음껏 쌓아 보자
- split & merge
- recurrent network (RNN) : 옆으로 뻗어 ! …
5. Lab 10: 딥러닝으로 MNIST 98%이상 해보기(new)
- NN for MNIST
# input place holders
X = tf.placeholder(tf.float32, [None, 784])
Y = tf.placeholder(tf.float32, [None, 10])
# weights & bias for nn layers
W1 = tf.Variable(tf.random_normal([784, 256]))
b1 = tf.Variable(tf.random_normal([256]))
L1 = tf.nn.relu(tf.matmul(X, W1) + b1)
W2 = tf.Variable(tf.random_normal([256, 256]))
b2 = tf.Variable(tf.random_normal([256]))
L2 = tf.nn.relu(tf.matmul(L1, W2) + b2)
W3 = tf.Variable(tf.random_normal([256, 10]))
b3 = tf.Variable(tf.random_normal([10]))
hypothesis = tf.matmul(L2, W3) + b3
→ 정확도 90에서 94로 증가!
- xavier for MNIST
W1 = tf.get_variable("W1", shape=[784, 256],
initializer=tf.contrib.layers.xavier_initializer())
#W2, W3도 동일하게 적용
→ 94에서 97.8로 증가
- Deep NN for MNIST
넓고 깊게!
5단으로 늘리고, xavier사용 but, 오히려 낮아짐 ⇒ overfittig!!! → dropout사용해바 - optimizers는 Adam 사용을 추천~
섹션11. Convolutional Neural Networks
1. ConvNet의 Conv 레이어 만들기
- stride가 1이면 필터를 1칸씩 이동!
- padding
→ 원래 입력과 출력의 이미지 사이즈를 같게하기 위해서! 정보를 잃어버리지 않으려고!
2. ConvNet Max pooling 과 Full Network
- pooling layer(sampling)
conv layer에서 하나의 layer만 뽑아내어 resize(sampling)하는 것!
그렇게 모든 layer을 사이즈를 줄여(?) 다시 쌓는 것이 pooling! - max pooling
→ 한 필터에서 가장 큰 값으로 sampling하는 것
3. ConvNet의 활용 예
- LeNet
- AlexNet
- GoodLeNet
- ResNet
4. 실습1: TensorFlow CNN 의 기본
: cnn은 이미지 처리에 강해!
image : (1, 3, 3, 1) → 1개의 3x3이미지를 사용! 마지막 1은 색을 의미
filter : (2, 2, 1, 1) → 2x2 사이즈의 필터 사용! 1은 색을 의미, 마지막 1은 개수를 의미 !
stride : 1 → 필터를 1칸씩 이동
padding : same → 원래 이미지 사이즈와 같게 해줄게!
# print("imag:\n", image)print("image.shape", image.shape)
weight= tf.constant([[[[1.]],[[1.]]],
[[[1.]],[[1.]]]])
print("weight.shape", weight.shape)
conv2d= tf.nn.conv2d(image, weight, strides=[1, 1, 1, 1], padding='SAME')
conv2d_img= conv2d.eval()
print("conv2d_img.shape", conv2d_img.shape)
conv2d_img= np.swapaxes(conv2d_img, 0, 3)
for i, one_imgin enumerate(conv2d_img):
print(one_img.reshape(3,3))
plt.subplot(1,2,i+1), plt.imshow(one_img.reshape(3,3), cmap='gray')
- max pooling
image = np.array([[[[4],[3]],
[[2],[1]]]], dtype=np.float32)
pool = tf.nn.max_pool(image, ksize=[1, 2, 2, 1],
strides=[1, 1, 1, 1], padding='VALID')
print(pool.shape)
print(pool.eval())
- MNIST Convolution layer 실습
#5sess = tf.InteractiveSession()
img = img.reshape(-1,28,28,1) #-1은 너히 알아서 계산해! (reshape의 방법)
W1 = tf.Variable(tf.random_normal([3, 3, 1, 5], stddev=0.01)) #5개의 필터 사용
conv2d = tf.nn.conv2d(img, W1, strides=[1, 2, 2, 1], padding='SAME') #SAME이지만 stride가 2이므로 14x14가 출력될
print(conv2d)
sess.run(tf.global_variables_initializer())
conv2d_img = conv2d.eval()
conv2d_img = np.swapaxes(conv2d_img, 0, 3)
for i, one_img in enumerate(conv2d_img):
plt.subplot(1,5,i+1), plt.imshow(one_img.reshape(14,14), cmap='gray')
→ 필터를 5개 사용했으므로 5개의 이미지가 출력,
→ 랜덤한 weight를 주었으므로 조금씩 다른 형태의 이미지가 출력
5. 실습2: TensorFlow로 구현하자 (MNIST 99%)
- Deep CNN
→ 단을 더 쌓기! → 정확도를 높일 수 있음. (99%)
- keep_prob을 test 할 때는 반드시 1로 ! 학습할 땐 0.5 or 0.7
# L4 FC 4x4x128 inputs -> 625 outputs
W4 = tf.get_variable("W4", shape=[128 * 4 * 4, 625],
initializer=tf.contrib.layers.xavier_initializer())
b4 = tf.Variable(tf.random_normal([625]))
L4 = tf.nn.relu(tf.matmul(L3_flat, W4) + b4)
L4 = tf.nn.dropout(L4, keep_prob=keep_prob)
# L5 Final FC 625 inputs -> 10 outputs
W5 = tf.get_variable("W5", shape=[625, 10],
initializer=tf.contrib.layers.xavier_initializer())
b5 = tf.Variable(tf.random_normal([10]))
logits = tf.matmul(L4, W5) + b5
6. 실습3: Class, tf.layers, Ensemble (MNIST 99.5%)
- class로 만들어라! 간단해!
- tf.layers : 복잡한 숫자들을 layer를 사용하여 간단하게!
- Ensemble : 여러개의 모델을 학습시켜서 조합해 …
models = []
num_models = 2
for m in range(num_models):
models.append(Model(sess, "model" + str(m)))
→ 모델을 담은 리스트와 개수를 정의
# Test model and check accuracy
test_size = len(mnist.test.labels)
predictions = np.zeros([test_size, 10])
for m_idx, m in enumerate(models):
print(m_idx, 'Accuracy:', m.get_accuracy(
mnist.test.images, mnist.test.labels))
p = m.predict(mnist.test.images)
predictions += p
ensemble_correct_prediction = tf.equal(
tf.argmax(predictions, 1), tf.argmax(mnist.test.labels, 1))
ensemble_accuracy = tf.reduce_mean(
tf.cast(ensemble_correct_prediction, tf.float32))
print('Ensemble accuracy:', sess.run(ensemble_accuracy))
→ 모델을 하나씩 꺼내와서 test데이터를 주고 예측한 값들을 더해!
섹션12. Recurrent Neural Network
1. NN의 꽃 RNN 이야기
- sequence data
말 그대로 순서가 있는 데이터 - laguage model
- RNN
입력과 출력을 시퀀스 단위로 처리!
output이 다음의 cell로 연결됨!
순차 데이터나 시계열 데이터를 이용하는 인공 신경망의 유형. - RNN의 여러가지 형태
- one to one : vanilla NN → 하나의 입력, 하나의 출력
- one to many : image Captioning → sequence of words
- many to one : Sentiment Classification → 문장을 넣고, 하나가 출력
- many to many : Machine Translation, Video classification
2. Lab 12-1 RNN - Basic (new)
- RNN in Tensorflow
cell = tf.contrib.rnn.BasicRNNcell(num_units=hidden_size) #출력의 size를 정해
outputs, _states = tf.nn.dynamic_rnn(cell, x_data, dtype=tf.float32)
- One node: 4(input-dim) in 2(hidden_size)
# One cell RNN input_dim (4) -> output_dim (2)hidden_size= 2
cell= tf.keras.layers.SimpleRNNCell(units=hidden_size)
print(cell.output_size, cell.state_size)
x_data= np.array([[h]], dtype=np.float32)
# x_data = [[[1,0,0,0]]]pp.pprint(x_data)
outputs, _states= tf.nn.dynamic_rnn(cell, x_data, dtype=tf.float32)
→ hidden size가 2 이므로 array([[[ 0.28406101, 0.53163123]]], dtype=float32) 가 출력
- sequence_length
말 그대로! hello 면 값은 5! - Batching input
batch_size! 학습을 시킬 때, 한 줄씩 학습하면 너무 비효율적 !!
→ 여러개를 한 번에 학습시키자! - ⇒ shape(3, 5, 2)에서
Hidden_size = 2, sequence_length = 5, batch_size = 3 !
3. Lab 12-2 RNN - Hi Hello Training (new)
→ hihello를 훈련시켜보기!
- one-hot encoding
- parameter
input_dim = 5
sequence_length = 6
batch_size = 1
hidden_size = 5
4.Lab 12-3 : Long Sequence RNN (new)
5. Lab12-4: Stacked RNN + Softmax Layer (new)
12-3이 학습이 잘 되지 않음 ! → RNN은 wide하고 deep하게 해줘야해!
- sol1 : stacked RNN
cell = rnn.MultiRNNCell([cell] * 2, state_is_tuple=True) # *2 하면 2개가 쌓여짐!!
- sol2 : Softmax
- softmax에 맞게 reshape해주기!
→ hidden_size에 맞게 나머지는 알아서(-1) 쌓아!X_for_sotfmax = tf.reshape(outputs, [-1, hidden_size])
- 그대로 출력한 것을 다시 펼쳐!
outputs = tf.reshape(outputs, [batch_size, seq_length, num_classes])
6. Lab12-5: Dynamic RNN (new)
- different sequence length
sequence_length = [5, 2, 3] 로 설정한 후 2인 경우, 2개의 값만 내고 나머지는 0으로 처리 !
→ 없는 데이터는 0으로 처리하여 loss가 잘 동작되도록 함!
각 문자열이 다 다른 경우!
7. Lab12-6: RNN with Time Series Data (new)
시간이 지나면서 값이 지나는 데이터를 예측해보자!
- 전체코드
import tensorflow as tf
import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()import numpy as np
import matplotlib
import os
tf.set_random_seed(777) # reproducibility
if "DISPLAY" not in os.environ:
# remove Travis CI Error
matplotlib.use('Agg')
import matplotlib.pyplot as plt
def MinMaxScaler(data):
numerator = data - np.min(data, 0)
denominator = np.max(data, 0) - np.min(data, 0)
# noise term prevents the zero division
return numerator / (denominator + 1e-7)
# train Parameters
seq_length = 7
data_dim = 5
hidden_dim = 10
output_dim = 1
learning_rate = 0.01
iterations = 500
# Open, High, Low, Volume, Close
xy = np.loadtxt('data-02-stock_daily.csv', delimiter=',')
xy = xy[::-1] # reverse order (chronically ordered)
# train/test split
train_size = int(len(xy) * 0.7)
train_set = xy[0:train_size]
test_set = xy[train_size - seq_length:] # Index from [train_size - seq_length] to utilize past sequence
# Scale each
train_set = MinMaxScaler(train_set)
test_set = MinMaxScaler(test_set)
# build datasets
def build_dataset(time_series, seq_length):
dataX = []
dataY = []
for i in range(0, len(time_series) - seq_length):
_x = time_series[i:i + seq_length, :]
_y = time_series[i + seq_length, [-1]] # Next close price
print(_x, "->", _y)
dataX.append(_x)
dataY.append(_y)
return np.array(dataX), np.array(dataY)
trainX, trainY = build_dataset(train_set, seq_length)
testX, testY = build_dataset(test_set, seq_length)
# input place holders
X = tf.placeholder(tf.float32, [None, seq_length, data_dim])
Y = tf.placeholder(tf.float32, [None, 1])
# build a LSTM network
cell = tf.contrib.rnn.BasicLSTMCell(
num_units=hidden_dim, state_is_tuple=True, activation=tf.tanh)
outputs, _states = tf.nn.dynamic_rnn(cell, X, dtype=tf.float32)
Y_pred = tf.contrib.layers.fully_connected(
outputs[:, -1], output_dim, activation_fn=None) # We use the last cell's output
# cost/loss
loss = tf.reduce_sum(tf.square(Y_pred - Y)) # sum of the squares
# optimizer
optimizer = tf.train.AdamOptimizer(learning_rate)
train = optimizer.minimize(loss)
# RMSE
targets = tf.placeholder(tf.float32, [None, 1])
predictions = tf.placeholder(tf.float32, [None, 1])
rmse = tf.sqrt(tf.reduce_mean(tf.square(targets - predictions)))
with tf.Session() as sess:
init = tf.global_variables_initializer()
sess.run(init)
# Training step
for i in range(iterations):
_, step_loss = sess.run([train, loss], feed_dict={
X: trainX, Y: trainY})
print("[step: {}] loss: {}".format(i, step_loss))
# Test step
test_predict = sess.run(Y_pred, feed_dict={X: testX})
rmse_val = sess.run(rmse, feed_dict={
targets: testY, predictions: test_predict})
print("RMSE: {}".format(rmse_val))
# Plot predictions
plt.plot(testY)
plt.plot(test_predict)
plt.xlabel("Time Period")
plt.ylabel("Stock Price")
plt.show()
섹션13, 14, 15는 정리보다는 영상 참고하여 실습하기 ! (돈없어서 못하더라구요ㅜ.ㅜ)
'WINK-(Web & App) > 인공지능 스터디' 카테고리의 다른 글
[인공지능 스터디] 이정욱 #1주차 모두를 위한 딥러닝 - 기본적인 머신러닝과 딥러닝 강좌 섹션 0 ~ 섹션 6 (1) | 2023.07.11 |
---|