[CNN] 어제 하던 CNN드디어 train 돌아감~!~!!

[17011813]

import random
import numpy as np
import tensorflow as tf
import cv2

from random import shuffle
from tqdm import tqdm

train_dir = '/content/gdrive/My Drive/Colab Notebooks/flowers'


img_size = 28

def label_folder(folders):
    if folders == 'tulip': return [1,0,0,0,0,0,0,0,0,0]
    elif folders == 'rose': return [0,1,0,0,0,0,0,0,0,0]
    elif folders == 'cosmos': return [0,0,1,0,0,0,0,0,0,0]
    elif folders == 'cherryblossom': return [0,0,0,1,0,0,0,0,0,0]
    elif folders == 'sunflower': return [0,0,0,0,1,0,0,0,0,0]
    elif folders == 'koreaflower': return [0,0,0,0,0,1,0,0,0,0]
    elif folders == 'lily': return [0,0,0,0,0,0,1,0,0,0]
    elif folders == 'buckwheat': return [0,0,0,0,0,0,0,1,0,0]       #메밀꽃
    elif folders == 'korearosebay': return [0,0,0,0,0,0,0,0,1,0]       #진달래
    elif folders == 'forsythia': return [0,0,0,0,0,0,0,0,0,1]   #개나리

def create_train_data():
    training_data = []
    dirs = os.listdir(train_dir)
    for folders in dirs:
        label = label_folder(folders)
        req_train_dir = os.path.join(train_dir,folders)
        for img in tqdm(os.listdir(req_train_dir)):
            path = os.path.join(req_train_dir,img)
            img = cv2.imread(path,cv2.IMREAD_GRAYSCALE)
            img = cv2.resize(img, (img_size,img_size))
            training_data.append([np.array(img),np.array(label)])
    shuffle(training_data)
    np.save('flower_train_data.npy', training_data)
    return training_data

train_data = create_train_data()

여기서 npy파일 만들어서 라벨링 해줌

[17011813]

import math
import matplotlib.pyplot as plt

# Convolutional Layer 1.
filter_size1 = 4 
num_filters1 = 32
# Convolutional Layer 2.
filter_size2 = 4
num_filters2 = 64
# Convolutional Layer 3.
filter_size3 = 4
num_filters3 = 128
# Convolutional Layer 4
filter_size4 = 4
num_filters4 = 256
# Convolutional Layer 5
filter_size5 = 4
num_filters5 = 128
# Fully-connected layer.
fc_size = 1024         
# Number of color channels for the images: 1 channel for gray-scale.  ########################우선 train컬러 흑백으로 1개...?
num_channels = 1
# image dimensions (only squares for now)   #################
img_size = 28
# Size of image when flattened to a single dimension
img_size_flat = img_size * img_size * num_channels
# Tuple with height and width of images used to reshape arrays.
img_shape = (img_size, img_size)
# class 위에 순서 맞게 써줌
classes = ['tulip', 'rose','cosmos', 'cherryblossom','sunflower','koreaflower','lily', 'buckwheat', 'korearosebay','forsythia']
num_classes = len(classes)
# batch size
batch_size = 50


#data 불러옴

train_data = np.load('flower_train_data.npy',allow_pickle=True)

def new_weights(shape):
    return tf.Variable(tf.truncated_normal(shape, stddev=0.05))
def new_biases(length):
    return tf.Variable(tf.constant(0.05, shape=[length]))

def new_conv_layer(input,num_input_channels,filter_size,num_filters,use_pooling=True):  

    shape = [filter_size, filter_size, num_input_channels, num_filters]
    weights = new_weights(shape=shape)
    biases = new_biases(length=num_filters)

    layer = tf.nn.conv2d(input=input,filter=weights,strides=[1, 1, 1, 1],padding='SAME')
    layer += biases

    if use_pooling:
        layer = tf.nn.max_pool(value=layer,ksize=[1, 2, 2, 1],strides=[1, 2, 2, 1],padding='SAME')

    layer = tf.nn.relu(layer)

    return layer, weights

def new_fc_layer(input,num_inputs,num_outputs,use_relu=True): 

    weights = new_weights(shape=[num_inputs, num_outputs])
    biases = new_biases(length=num_outputs)

    layer = tf.matmul(input, weights) + biases
    
    if use_relu:
        layer = tf.nn.relu(layer)

    return layer

def flatten_layer(layer):
    
    layer_shape = layer.get_shape()
    num_features = layer_shape[1:4].num_elements()
    layer_flat = tf.reshape(layer, [-1, num_features])

    return layer_flat, num_features

x = tf.placeholder(tf.float32, shape=[None, img_size_flat], name='x')
x_image = tf.reshape(x, [-1, img_size, img_size, num_channels])
y_true = tf.placeholder(tf.float32, shape=[None, num_classes], name='y_true')
y_true_cls = tf.argmax(y_true, axis=1)

layer_conv1, weights_conv1 = new_conv_layer(input=x_image,num_input_channels=num_channels,filter_size=filter_size1,
                                            num_filters=num_filters1,use_pooling=True)
layer_conv2, weights_conv2 = new_conv_layer(input=layer_conv1,num_input_channels=num_filters1,filter_size=filter_size2,
                                            num_filters=num_filters2,use_pooling=True)
layer_conv3, weights_conv3 = new_conv_layer(input=layer_conv2,num_input_channels=num_filters2,filter_size=filter_size3,
                                            num_filters=num_filters3,use_pooling=True)
layer_conv4, weights_conv4 = new_conv_layer(input=layer_conv3,num_input_channels=num_filters3,filter_size=filter_size4,
                                            num_filters=num_filters4,use_pooling=True)
layer_conv5, weights_conv5 = new_conv_layer(input=layer_conv4,num_input_channels=num_filters4,filter_size=filter_size5,
                                            num_filters=num_filters5,use_pooling=True)

layer_flat, num_features = flatten_layer(layer_conv5)
layer_fc1 = new_fc_layer(input=layer_flat,num_inputs=num_features,num_outputs=fc_size,use_relu=True)
layer_fc2 = new_fc_layer(input=layer_fc1,num_inputs=fc_size,num_outputs=num_classes,use_relu=False)

y_pred = tf.nn.softmax(layer_fc2)
y_pred_cls = tf.argmax(y_pred, axis=1)
cross_entropy = tf.nn.softmax_cross_entropy_with_logits(logits=layer_fc2,labels=y_true)
cost = tf.reduce_mean(cross_entropy)

optimizer = tf.train.AdamOptimizer(learning_rate=1e-3).minimize(cost)
correct_prediction = tf.equal(y_pred_cls, y_true_cls)
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

train = train_data[0:-500]

x_batch = np.array([i[0] for i in train]).reshape(len(train),img_size_flat)
y_true_batch = [i[1] for i in train]

session = tf.Session()
session.run(tf.global_variables_initializer())
total_iterations = 0

def optimize(num_iterations):
    
    global total_iterations

    for i in range(total_iterations,total_iterations + num_iterations):
    	a = 0
    	for __ in range(int(len(train)/batch_size)):
        	#feed_dict_train = {x: x_batch[a:a+batch_size,:],y_true: y_true_batch[a:a+batch_size]}
        	session.run(optimizer, feed_dict={x: x_batch[a:a+batch_size,:],y_true: y_true_batch[a:a+batch_size]})
        	a = a + batch_size
 		
    	if i % 2 == 0:
    		print("Iteration = ", i, "Loss = ", session.run(cost, feed_dict={x: x_batch[a:a+batch_size,:],y_true: y_true_batch[a:a+batch_size]}),
                      "Train Accuracy = ", session.run(accuracy, feed_dict={x: x_batch[a:a+batch_size,:],y_true: y_true_batch[a:a+batch_size]}), 
                      )

optimize(num_iterations=50)

cost랑 accuracy만 보면서 코드 고치는중~!~!

그래도 돌아가서 다행이다 여기다 test코드 추가해서 우리 6만장 더 하면 훨씬 올라갈거 같앙
더알아본다아아ㅏㅇ아아아아ㅏ!!!! 뿌아아아앙!^______^

[17011813]

entropy thresholding
Batch Normalization
https://www.slideshare.net/JeongYeonwoo/mnist-classification
성능 높이기 밥먹고 해야지 배고파 ㅎㅎㅎㅎㅎ

[Eomdangyeong]

ㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋ진짜 기다린 보람이 있누.....

[ghost]

Iteration = 0 Loss = 2.2915351 Train Accuracy = 0.18 Test Accuracy = 0.22433333
Iteration = 2 Loss = 1.627243 Train Accuracy = 0.48 Test Accuracy = 0.292
Iteration = 4 Loss = 1.3869513 Train Accuracy = 0.52 Test Accuracy = 0.34633332
Iteration = 6 Loss = 1.2535464 Train Accuracy = 0.56 Test Accuracy = 0.34966666
Iteration = 8 Loss = 0.9723007 Train Accuracy = 0.68 Test Accuracy = 0.37233335
Iteration = 10 Loss = 0.82327163 Train Accuracy = 0.7 Test Accuracy = 0.387
Iteration = 12 Loss = 0.6151759 Train Accuracy = 0.78 Test Accuracy = 0.40466666
Iteration = 14 Loss = 0.48329315 Train Accuracy = 0.88 Test Accuracy = 0.41966668
Iteration = 16 Loss = 0.8776555 Train Accuracy = 0.78 Test Accuracy = 0.40666667
Iteration = 18 Loss = 0.47148696 Train Accuracy = 0.9 Test Accuracy = 0.45066667
Iteration = 20 Loss = 0.39670077 Train Accuracy = 0.9 Test Accuracy = 0.43
Iteration = 22 Loss = 0.5305547 Train Accuracy = 0.84 Test Accuracy = 0.384
Iteration = 24 Loss = 0.48535004 Train Accuracy = 0.8 Test Accuracy = 0.41766667
Iteration = 26 Loss = 0.22956605 Train Accuracy = 0.94 Test Accuracy = 0.43133333
Iteration = 28 Loss = 0.31709966 Train Accuracy = 0.92 Test Accuracy = 0.42433333
Iteration = 30 Loss = 0.13685715 Train Accuracy = 0.98 Test Accuracy = 0.46833333
Iteration = 32 Loss = 0.0816638 Train Accuracy = 0.98 Test Accuracy = 0.46033335
Iteration = 34 Loss = 0.14826852 Train Accuracy = 0.96 Test Accuracy = 0.41166666
Iteration = 36 Loss = 0.08975853 Train Accuracy = 0.96 Test Accuracy = 0.49433333
Iteration = 38 Loss = 0.046634417 Train Accuracy = 1.0 Test Accuracy = 0.458
Iteration = 40 Loss = 0.04983877 Train Accuracy = 1.0 Test Accuracy = 0.449
Iteration = 42 Loss = 0.04196478 Train Accuracy = 1.0 Test Accuracy = 0.44166666
Iteration = 44 Loss = 0.022288075 Train Accuracy = 1.0 Test Accuracy = 0.454
Iteration = 46 Loss = 0.01955667 Train Accuracy = 1.0 Test Accuracy = 0.46966666
Iteration = 48 Loss = 0.028818855 Train Accuracy = 1.0 Test Accuracy = 0.451