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

1. 학습내용

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

2. 세부내용

  • 딥러닝 전체과정

  • Deep Learning Coding
  • 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가 중요


  • IF epokes = 3
  • 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에 가까울수록 부정댓글

  • CNN(Convolutional Neural Networks) - 합성곱 신경망
  • 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>

    좋은 웹페이지 즐겨찾기