[DAY10]_개발일지: Deep Learning Coding

1. 학습내용

1. Deep Learning Coding
2. 영화 리뷰 분류

2. 세부내용

import keras
keras.__version__

from keras.datasets import mnist
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()         #(xtrain, ytrain) 이라고 생각하면됨

train_images.shape        (60000, 28, 28)       #총 데이터의 각각의 이미지 자체들
train_labels.shape        (60000,)       #총 데이터의 각각의 이미지 자체들의 숫자들
test_images.shape         (10000, 28, 28)       #테스트 데이터의 각각의 이미지 자체들
test_labels.shape         (10000,)       #테스트 데이터의 각각의 이미지 자체들의 숫자들

digit = train_images[4]
plt.imshow(digit, cmap='gray')

print(train_labels[4])					#9

from keras import models
from keras import layers

network = models.Sequential()
network.add(layers.Dense(512, activation='relu', input_shape = (28 * 28,)))    
#relu는 그래프를 찾아보라
network.add(layers.Dense(10, activation='softmax'))                    
#softmax 는 총합은 1이고 나머지 요소들을 비율로 계산해줌

network.compile(optimizer='rmsprop',
loss='categorical_crossentropy',
metrics=['accuracy'])           
#rmsprop 가중치를 조절해주는 것
#loss는 손실값 계산
#metrics 지표 정확도

train_images = train_images.reshape(60000, 28 * 28)  
train_images.shape						#(60000, 784)

train_images = train_images.astype('float32') / 255

test_images = test_images.reshape(10000, 28*28)
test_images - test_images.astype('float32') / 255

from tensorflow.keras.utils import to_categorical

train_labels = to_categorical(train_labels)                
#to_categorical 원핫인코딩 = [ 10진법 -> 2진법 ]
test_labels = to_categorical(test_labels)

network.fit(train_images, train_labels, epochs=5, batch_size=128)                       
#accuracy : 훈련정확도

test_loss, test_acc = network.evaluate(test_images, test_labels)            
#loss 손실정도, #accuracy 테스트 정확도

print('test_acc:' ,test_acc)                                                
#test_acc 테스트 정확도

import keras
keras.__version__

from keras.datasets import imdb
(train_data, train_label), (test_data, test_label) = imdb.load_data(num_words=10000)

len(train_data)				#25000
len(test_data)				#25000

train_data[0]

train_label[0]				#1

# word_index는 단어와 정수 인덱스를 매핑한 딕셔너리입니다
word_index = imdb.get_word_index()
# 정수 인덱스와 단어를 매핑하도록 뒤집습니다
reverse_word_index = dict([(value, key) for (key, value) in word_index.items()])
# 리뷰를 디코딩합니다. 
# 0, 1, 2는 '패딩', '문서 시작', '사전에 없음'을 위한 인덱스이므로 3을 뺍니다
decoded_review = ' '.join([reverse_word_index.get(i - 3, '?') for i in train_data[0]])

decoded_review

import numpy as np

def vectorize_sequences(sequences, dimension=10000):                  
    results = np.zeros((len(sequences),dimension))

    for i, sequence in enumerate(sequences):
        results[i, sequence] = 1.                               
        #data들을 0과 1로 벡터화 시킴
    
    return results
#dimension = 차원

vectorize_sequences(train_data)                                 
#data들을 0과 1로 벡터화 시킴

x_train = vectorize_sequences(train_data)
x_test = vectorize_sequences(test_data)

y_train = np.asarray(train_label).astype('float32')
y_test = np.asarray(test_label).astype('float32')

from keras import models
from keras import layers

model = models.Sequential()                                              
#모델 생성
model.add(layers.Dense(16, activation='relu', input_shape=(10000,)))     
#이미 지정해서 2번째랑 3번째는 input_shape 지정 안해도됨
model.add(layers.Dense(16, activation='relu'))
model.add(layers.Dense(1, activation='sigmoid'))                         
# 마지막 층은 확률계산을 위해서 sigmoid를 사용

model.compile(optimizer='rmsprop',
              loss='binary_crossentropy',                          
              metrics=['accuracy'])

#분류:둘 중 하나(sigmoid)는 binary_crossentropy, ~중 하나(softmax)는 categorical_crossentropy

x_val = x_train[:10000]
partial_x_train = x_train[10000:]

y_val = y_train[:10000]
partial_y_train = y_train[10000:]

history = model.fit(partial_x_train,
                    partial_y_train,
                    epochs=20,
                    batch_size=512,
                    validation_data=(x_val, y_val))                  

#validation_data = train_data로 검증, history = test(particial:15000)_data 검증 자료가 저장됨

history_dict = history.history
history_dict.keys()

import matplotlib.pyplot as plt

acc = history.history['binary_accuracy']
val_acc = history.history['val_binary_accuracy']
loss = history.history['loss']
val_loss = history.history['val_loss']

epochs = range(1, len(acc) + 1)

plt.plot(epochs, loss, 'bo', label='Training loss')
plt.plot(epochs, val_loss, 'r-', label='Validation loss')

plt.title('Training and validation loss')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.legend()

plt.show()                    
#실행 4번째가 좋은 결과로 보임

plt.plot(epochs, acc, 'bo', label='Training acc')
plt.plot(epochs, val_acc, 'r-', label='Validation acc')
plt.title('Training and validation accuracy')
plt.xlabel('Epochs')
plt.ylabel('Accuracy')
plt.legend()                                    
#실행 2번째가 가장 좋다고 볼 수 있다.

#트렌드에 맞추려면 ACC가 중요
#비용을 생각하면 loss가 중요

history = model.fit(partial_x_train,
                    partial_y_train,
                    epochs=3,
                    batch_size=512,
                    validation_data=(x_val, y_val))                  
#validation_data = train_data로 검증, history = test(particial:15000)_data 검증 자료가 저장됨

history_dict = history.history
history_dict.keys()

acc = history.history['binary_accuracy']
val_acc = history.history['val_binary_accuracy']
loss = history.history['loss']
val_loss = history.history['val_loss']

epochs = range(1, len(acc) + 1)

plt.plot(epochs, loss, 'bo', label='Training loss')
plt.plot(epochs, val_loss, 'r-', label='Validation loss')

plt.title('Training and validation loss')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.legend()

plt.show()                    #4번째가 좋은 결과로 보임

plt.plot(epochs, acc, 'bo', label='Training acc')
plt.plot(epochs, val_acc, 'r-', label='Validation acc')
plt.title('Training and validation accuracy')
plt.xlabel('Epochs')
plt.ylabel('Accuracy')
plt.legend()                                    #실행 2번째가 가장 좋다고 볼 수 있다.

#트렌드에 맞추려면 ACC가 중요
#비용을 생각하면 loss가 중요

results = model.evaluate(x_test, y_test)                        #train 10000개, validation 15000개, test 25000개로 데이터를 쪼갰음

results         #[0.3050832450389862, 0.8791999816894531]

model.predict(x_test)                          
#1에 가까울수록 긍정댓글, 0에 가까울수록 부정댓글

import keras
keras.__version__

from keras import layers
from keras import models

model = models.Sequential()
model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))

model.summary()

# 4. Dense 층 추가하기
model.add(layers.Flatten())
model.add(layers.Dense(64, activation='relu'))
model.add(layers.Dense(10, activation='softmax'))

model.summary()                                            
#parameter의 갯수로 연산량과 그 깊이를 알수 있음

3. 금일소감

<ol>
	<li>오늘은 좀 어려워서 구글링하면서 수업을 들어야 했다.</li>
	<li>하다보면 익숙해지겠지... </li>
    <li>내 목표는 머신러닝이나 딥러닝을 활용해서 백엔드를 대체하는 것!</li>
</ol>