파이썬으로 딥러닝 모델 제작하기

import tensorflow as tf
from tensorflow import keras

model = keras.Sequential()
model.add(__넣고싶은 레이어__)
model.add(__넣고싶은 레이어__)
model.add(__넣고싶은 레이어__)

model.fit(x, y, epochs=20, batch_size=16)

import tensorflow as tf
from tensorflow import keras

inputs = keras.Input(shape=(__원하는 입력값 모양__))
x = keras.layers.__넣고싶은 레이어__(관련 파라미터)(input)
x = keras.layers.__넣고싶은 레이어__(관련 파라미터)(x)
outputs = keras.layers.__넣고싶은 레이어__(관련 파라미터)(x)

model = keras.Model(inputs=inputs, outputs=outputs)
model.fit(x,y, epochs=10, batch_size=32)

import tensorflow as tf
from tensorflow import keras

class CustomModel(keras.Model):
    def __init__(self):
        super(CustomModel, self).__init__()
        self.__정의하고자 하는 레이어__()
        self.__정의하고자 하는 레이어__()
        self.__정의하고자 하는 레이어__()
    
    def call(self, x):
        x = self.__정의하고자 하는 레이어__(x)
        x = self.__정의하고자 하는 레이어__(x)
        x = self.__정의하고자 하는 레이어__(x)
        
        return x
    
model = CustomModel()
model.fit(x,y, epochs=10, batch_size=32)

import tensorflow as tf
from tensorflow import keras
import numpy as np

# 데이터 구성부분
mnist = keras.datasets.mnist

(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0

x_train=x_train[...,np.newaxis]
x_test=x_test[...,np.newaxis]

print(len(x_train), len(x_test))

Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz
11493376/11490434 [==============================] - 0s 0us/step
11501568/11490434 [==============================] - 0s 0us/step
60000 10000

# Sequential Model을 구성해주세요.
"""
Spec:
1. 32개의 채널을 가지고, 커널의 크기가 3, activation function이 relu인 Conv2D 레이어
2. 64개의 채널을 가지고, 커널의 크기가 3, activation function이 relu인 Conv2D 레이어
3. Flatten 레이어
4. 128개의 아웃풋 노드를 가지고, activation function이 relu인 Fully-Connected Layer(Dense)
5. 데이터셋의 클래스 개수에 맞는 아웃풋 노드를 가지고, activation function이 softmax인 Fully-Connected Layer(Dense)
"""


model = tf.keras.models.Sequential([
    tf.keras.layers.Conv2D(32,3,activation='relu'),
    tf.keras.layers.Conv2D(32,3,activation='relu'),
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dense(128, activation='relu'),
    tf.keras.layers.Dense(10,activation='softmax')
                           ])


"""
model.add.Conv2D(32, 3, activation="relu")
model.add.Conv2D(64, 3, activation="relu")
model.add.Flatten()
model.add.Dense(128, activation='relu')
model.add.Dense(10, activation='softmax')
"""

'\nmodel.add.Conv2D(32, 3, activation="relu")\nmodel.add.Conv2D(64, 3, activation="relu")\nmodel.add.Flatten()\nmodel.add.Dense(128, activation=\'relu\')\nmodel.add.Dense(10, activation=\'softmax\')\n'

# 모델 학습 설정

model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

model.fit(x_train, y_train, epochs=5)

model.evaluate(x_test,  y_test, verbose=2)

Epoch 1/5
1875/1875 [==============================] - 31s 3ms/step - loss: 0.1118 - accuracy: 0.9654
Epoch 2/5
1875/1875 [==============================] - 5s 3ms/step - loss: 0.0368 - accuracy: 0.9882
Epoch 3/5
1875/1875 [==============================] - 5s 3ms/step - loss: 0.0211 - accuracy: 0.9933
Epoch 4/5
1875/1875 [==============================] - 5s 3ms/step - loss: 0.0131 - accuracy: 0.9956
Epoch 5/5
1875/1875 [==============================] - 5s 3ms/step - loss: 0.0100 - accuracy: 0.9968
313/313 - 1s - loss: 0.0516 - accuracy: 0.9878





[0.051644984632730484, 0.9878000020980835]

mnist = keras.datasets.mnist

(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0

x_train=x_train[...,np.newaxis]
x_test=x_test[...,np.newaxis]

print(len(x_train), len(x_test))

60000 10000

"""
Spec:
0. (28X28X1) 차원으로 정의된 Input
1. 32개의 채널을 가지고, 커널의 크기가 3, activation function이 relu인 Conv2D 레이어
2. 64개의 채널을 가지고, 커널의 크기가 3, activation function이 relu인 Conv2D 레이어
3. Flatten 레이어
4. 128개의 아웃풋 노드를 가지고, activation function이 relu인 Fully-Connected Layer(Dense)
5. 데이터셋의 클래스 개수에 맞는 아웃풋 노드를 가지고, activation function이 softmax인 Fully-Connected Layer(Dense)
"""

inputs = keras.Input(shape=(28,28,1))
x = keras.layers.Conv2D(32,3,activation='relu')(inputs)
x = keras.layers.Conv2D(64,3,activation='relu')(x)
x = keras.layers.Flatten()(x)
x = keras.layers.Dense(128, activation='relu')(x)
outputs = keras.layers.Dense(10, activation='softmax')(x)

model = keras.Model(inputs=inputs, outputs=outputs)


model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

model.fit(x_train, y_train, epochs=5)

model.evaluate(x_test,  y_test, verbose=2)

Epoch 1/5
1875/1875 [==============================] - 7s 3ms/step - loss: 0.1039 - accuracy: 0.9679
Epoch 2/5
1875/1875 [==============================] - 6s 3ms/step - loss: 0.0339 - accuracy: 0.9895
Epoch 3/5
1875/1875 [==============================] - 6s 3ms/step - loss: 0.0204 - accuracy: 0.9931
Epoch 4/5
1875/1875 [==============================] - 6s 3ms/step - loss: 0.0130 - accuracy: 0.9959
Epoch 5/5
1875/1875 [==============================] - 6s 3ms/step - loss: 0.0093 - accuracy: 0.9972
313/313 - 1s - loss: 0.0522 - accuracy: 0.9868





[0.05223735421895981, 0.9868000149726868]

"""
Spec:
0. keras.Model 을 상속받았으며, __init__()와 call() 메서드를 가진 모델 클래스
1. 32개의 채널을 가지고, 커널의 크기가 3, activation function이 relu인 Conv2D 레이어
2. 64개의 채널을 가지고, 커널의 크기가 3, activation function이 relu인 Conv2D 레이어
3. Flatten 레이어
4. 128개의 아웃풋 노드를 가지고, activation function이 relu인 Fully-Connected Layer(Dense)
5. 데이터셋의 클래스 개수에 맞는 아웃풋 노드를 가지고, activation function이 softmax인 Fully-Connected Layer(Dense)
6. call의 입력값이 모델의 Input, call의 리턴값이 모델의 Output
"""


class kerasModel(keras.Model):
    def __init__(self):
        super().__init__()
        
        self.Conv2D32 = keras.layers.Conv2D(32, 3, activation='relu')
        self.Conv2D64 = keras.layers.Conv2D(64, 3, activation='relu')
        self.Flatten = keras.layers.Flatten()
        self.Dense128 = keras.layers.Dense(128, activation='relu')
        self.Dense = keras.layers.Dense(10, activation='softmax')
    
    def call(self, x):
        x = self.Conv2D32(x)
        x = self.Conv2D64(x)
        x = self.Flatten(x)
        x = self.Dense128(x)
        output = self.Dense(x)
        
        return output
    
model = kerasModel()


model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

model.fit(x_train, y_train, epochs=5)

model.evaluate(x_test,  y_test, verbose=2)

Epoch 1/5
1875/1875 [==============================] - 7s 3ms/step - loss: 0.1011 - accuracy: 0.9689
Epoch 2/5
1875/1875 [==============================] - 6s 3ms/step - loss: 0.0339 - accuracy: 0.9893
Epoch 3/5
1875/1875 [==============================] - 6s 3ms/step - loss: 0.0184 - accuracy: 0.9938
Epoch 4/5
1875/1875 [==============================] - 6s 3ms/step - loss: 0.0136 - accuracy: 0.9954
Epoch 5/5
1875/1875 [==============================] - 6s 3ms/step - loss: 0.0078 - accuracy: 0.9973
313/313 - 1s - loss: 0.0581 - accuracy: 0.9853





[0.05812956392765045, 0.9853000044822693]

# 데이터 구성부분
cifar100 = keras.datasets.cifar100

(x_train, y_train), (x_test, y_test) = cifar100.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0
print(len(x_train), len(x_test))

50000 10000

# Sequential Model을 구성해주세요.
"""
Spec:
1. 16개의 채널을 가지고, 커널의 크기가 3, activation function이 relu인 Conv2D 레이어
2. pool_size가 2인 MaxPool 레이어
3. 32개의 채널을 가지고, 커널의 크기가 3, activation function이 relu인 Conv2D 레이어
4. pool_size가 2인 MaxPool 레이어
5. 256개의 아웃풋 노드를 가지고, activation function이 relu인 Fully-Connected Layer(Dense)
6. 데이터셋의 클래스 개수에 맞는 아웃풋 노드를 가지고, activation function이 softmax인 Fully-Connected Layer(Dense)
"""

model = tf.keras.models.Sequential([
    tf.keras.layers.Conv2D(16,3,activation='relu'),
    tf.keras.layers.MaxPool2D((2,2)),
    tf.keras.layers.Conv2D(32,3,activation='relu'),
    tf.keras.layers.MaxPool2D((2,2)),
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dense(256,activation='relu'),
    tf.keras.layers.Dense(100,activation='softmax')
])

model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

model.fit(x_train, y_train, epochs=5)

model.evaluate(x_test,  y_test, verbose=2)

Epoch 1/5
1563/1563 [==============================] - 5s 3ms/step - loss: nan - accuracy: 0.0100
Epoch 2/5
1563/1563 [==============================] - 5s 3ms/step - loss: nan - accuracy: 0.0100
Epoch 3/5
1563/1563 [==============================] - 5s 3ms/step - loss: nan - accuracy: 0.0100
Epoch 4/5
1563/1563 [==============================] - 5s 3ms/step - loss: nan - accuracy: 0.0100
Epoch 5/5
1563/1563 [==============================] - 5s 3ms/step - loss: nan - accuracy: 0.0100
313/313 - 1s - loss: nan - accuracy: 0.0100





[nan, 0.009999999776482582]

"""
Spec:
0. (32X32X3) 차원으로 정의된 Input
1. 16개의 채널을 가지고, 커널의 크기가 3, activation function이 relu인 Conv2D 레이어
2. pool_size가 2인 MaxPool 레이어
3. 32개의 채널을 가지고, 커널의 크기가 3, activation function이 relu인 Conv2D 레이어
4. pool_size가 2인 MaxPool 레이어
5. 256개의 아웃풋 노드를 가지고, activation function이 relu인 Fully-Connected Layer(Dense)
6. 데이터셋의 클래스 개수에 맞는 아웃풋 노드를 가지고, activation function이 softmax인 Fully-Connected Layer(Dense)
"""

inputs = tf.keras.Input(shape=(32,32,3))
x = tf.keras.layers.Conv2D(16,3,activation='relu')(inputs)
x = tf.keras.layers.MaxPool2D((2,2))(x)
x = tf.keras.layers.Conv2D(32,3,activation='relu')(x)
x = tf.keras.layers.MaxPool2D((2,2))(x)
x = tf.keras.layers.Flatten()(x)
x = tf.keras.layers.Dense(256,activation='relu')(x)
outputs = tf.keras.layers.Dense(100,activation='softmax')(x)

model = tf.keras.Model(inputs=inputs, outputs=outputs)

model.compile(optimizer='adam',
               loss='sparse_categorical_crossentropy',
               metrics=['accuracy'])

model.fit(x_train, y_train, epochs = 5)

model.evaluate(x_test, y_test, verbose =2)

Epoch 1/5
1563/1563 [==============================] - 5s 3ms/step - loss: nan - accuracy: 0.0100
Epoch 2/5
1563/1563 [==============================] - 5s 3ms/step - loss: nan - accuracy: 0.0100
Epoch 3/5
1563/1563 [==============================] - 5s 3ms/step - loss: nan - accuracy: 0.0100
Epoch 4/5
1563/1563 [==============================] - 5s 3ms/step - loss: nan - accuracy: 0.0100
Epoch 5/5
1563/1563 [==============================] - 5s 3ms/step - loss: nan - accuracy: 0.0100
313/313 - 1s - loss: nan - accuracy: 0.0100





[nan, 0.009999999776482582]

"""
Spec:
0. keras.Model 을 상속받았으며, __init__()와 call() 메서드를 가진 모델 클래스
1. 16개의 채널을 가지고, 커널의 크기가 3, activation function이 relu인 Conv2D 레이어
2. pool_size가 2인 MaxPool 레이어
3. 32개의 채널을 가지고, 커널의 크기가 3, activation function이 relu인 Conv2D 레이어
4. pool_size가 2인 MaxPool 레이어
5. 256개의 아웃풋 노드를 가지고, activation function이 relu인 Fully-Connected Layer(Dense)
6. 데이터셋의 클래스 개수에 맞는 아웃풋 노드를 가지고, activation function이 softmax인 Fully-Connected Layer(Dense)
7. call의 입력값이 모델의 Input, call의 리턴값이 모델의 Output
"""


class kerasModel(keras.Model):
    def __init__(self):
        super().__init__()
        
        self.Conv2D16 = keras.layers.Conv2D(16, 3, activation='relu')
        self.Conv2D32 = keras.layers.Conv2D(32, 3, activation='relu')
        self.Maxpool = keras.layers.MaxPool2D((2,2))
        self.Flatten = keras.layers.Flatten()
        self.Dense256 = keras.layers.Dense(256, activation='relu')
        self.Dense = keras.layers.Dense(10, activation='softmax')
    
    def call(self, x):
        x = self.Conv2D16(x)
        x = self.Maxpool(x)
        x = self.Conv2D32(x)
        x = self.Maxpool(x)
        x = self.Flatten(x)
        x = self.Dense256(x)
        output = self.Dense(x)
        
        return output
    
model = kerasModel()


model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

model.fit(x_train, y_train, epochs=5)

model.evaluate(x_test,  y_test, verbose=2)

Epoch 1/5
1563/1563 [==============================] - 5s 3ms/step - loss: nan - accuracy: 0.0100
Epoch 2/5
1563/1563 [==============================] - 5s 3ms/step - loss: nan - accuracy: 0.0100
Epoch 3/5
1563/1563 [==============================] - 5s 3ms/step - loss: nan - accuracy: 0.0100
Epoch 4/5
1563/1563 [==============================] - 5s 3ms/step - loss: nan - accuracy: 0.0100
Epoch 5/5
1563/1563 [==============================] - 5s 3ms/step - loss: nan - accuracy: 0.0100
313/313 - 1s - loss: nan - accuracy: 0.0100





[nan, 0.009999999776482582]

import tensorflow as tf
from tensorflow import keras

# 데이터 구성부분
cifar100 = keras.datasets.cifar100

(x_train, y_train), (x_test, y_test) = cifar100.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0
print(len(x_train), len(x_test))

# 모델 구성부분
class CustomModel(keras.Model):
    def __init__(self):
        super().__init__()
        self.conv1 = keras.layers.Conv2D(16, 3, activation='relu')
        self.maxpool1 = keras.layers.MaxPool2D((2,2))
        self.conv2 = keras.layers.Conv2D(32, 3, activation='relu')
        self.maxpool2 = keras.layers.MaxPool2D((2,2))
        self.flatten = keras.layers.Flatten()
        self.fc1 = keras.layers.Dense(256, activation='relu')
        self.fc2 = keras.layers.Dense(100, activation='softmax')

    def call(self, x):
        x = self.conv1(x)
        x = self.maxpool1(x)
        x = self.conv2(x)
        x = self.maxpool2(x)
        x = self.flatten(x)
        x = self.fc1(x)
        x = self.fc2(x)

        return x

model = CustomModel()

50000 10000

model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

loss_func = tf.keras.losses.SparseCategoricalCrossentropy()
optimizer = tf.keras.optimizers.Adam()

# tf.GradientTape()를 활용한 train_step
def train_step(features, labels):
    with tf.GradientTape() as tape:
        predictions = model(features)
        loss = loss_func(labels, predictions)
        gradients = tape.gradient(loss, model.trainable_variables)
    optimizer.apply_gradients(zip(gradients, model.trainable_variables))
    return loss

import time
def train_model(batch_size=32):
    start = time.time()
    for epoch in range(5):
        x_batch = []
        y_batch = []
        for step, (x, y) in enumerate(zip(x_train, y_train)):
            x_batch.append(x)
            y_batch.append(y)
            if step % batch_size == batch_size-1:
                loss = train_step(np.array(x_batch, dtype=np.float32), np.array(y_batch, dtype=np.float32))
                x_batch = []
                y_batch = []
        print('Epoch %d: last batch loss = %.4f' % (epoch, float(loss)))
    print("It took {} seconds".format(time.time() - start))

train_model()

Epoch 0: last batch loss = 3.2522
Epoch 1: last batch loss = 2.6932
Epoch 2: last batch loss = 2.4441
Epoch 3: last batch loss = 2.3071
Epoch 4: last batch loss = 2.2136
It took 85.202951669693 seconds

prediction = model.predict(x_test, batch_size=x_test.shape[0], verbose=1)
temp = sum(np.squeeze(y_test) == np.argmax(prediction, axis=1))
temp/len(y_test)  # Accuracy

1/1 [==============================] - 1s 822ms/step

0.346