KERAS Archives - icodebroker

[PYTHON/KERAS] 컨볼루션 신경망 만들기 (CIFAR-10)

■ 컨볼루션 신경망을 만드는 방법을 보여준다. ▶ 예제 코드 (PY)


import keras.datasets.cifar10 as cifar10
import keras.layers.convolutional as convolutional
import keras.layers.core as core
import keras.models as models
import keras.utils.np_utils as np_utils
import matplotlib.pyplot as pp

outputLayerNodeCount = 10

# 학습 및 테스트 데이터를 로드한다.
(trainInputNDArray, trainCorrectOutputNDArray), (testInputNDArray, testCorrectOutputNDArray) = cifar10.load_data()

print("학습 입력 배열 형태 : ", trainInputNDArray.shape)

print(trainInputNDArray.shape[0], "학습 샘플 데이터"  )
print(testInputNDArray.shape[0] , "테스트 샘플 데이터")

trainCorrectOutputNDArray = np_utils.to_categorical(trainCorrectOutputNDArray, outputLayerNodeCount)
testCorrectOutputNDArray  = np_utils.to_categorical(testCorrectOutputNDArray , outputLayerNodeCount)

# 입력 데이터를 정규화 한다.
trainInputNDArray = trainInputNDArray.astype("float32")
testInputNDArray  = testInputNDArray.astype("float32")

trainInputNDArray /= 255
testInputNDArray  /= 255

# 모델을 정의한다.
model = models.Sequential()

model.add(convolutional.Conv2D(32, (3, 3), padding = "same", input_shape = (32, 32, 3)))
model.add(core.Activation("relu"))
model.add(convolutional.Conv2D(32, (3, 3), padding = "same"))
model.add(core.Activation("relu"))
model.add(convolutional.MaxPooling2D(pool_size = (2, 2)))
model.add(core.Dropout(0.25))

model.add(convolutional.Conv2D(64, (3, 3), padding = "same"))
model.add(core.Activation("relu"))
model.add(convolutional.Conv2D(64, (3, 3), padding = "same"))
model.add(core.Activation("relu"))
model.add(convolutional.MaxPooling2D(pool_size = (2, 2)))
model.add(core.Dropout(0.25))

model.add(core.Flatten())
model.add(core.Dense(512))
model.add(core.Activation("relu"))
model.add(core.Dropout(0.5))
model.add(core.Dense(outputLayerNodeCount))
model.add(core.Activation("softmax"))

model.summary()

# 모델을 컴파일한다.
model.compile(loss = "categorical_crossentropy", optimizer = "rmsprop", metrics = ["accuracy"])

# 모델을 학습시킨다.
history = model.fit(trainInputNDArray, trainCorrectOutputNDArray, batch_size = 128, epochs = 20, validation_split = 0.2, verbose = 1)

# 모델을 평가한다.
print("테스트...")

scoreList = model.evaluate(testInputNDArray, testCorrectOutputNDArray, batch_size = 128, verbose = 1)

print("테스트 스코어 : ", scoreList[0])
print("테스트 정확도 : ", scoreList[1])

# 모델을 저장한다.
json = model.to_json()

open("cifar10_model.json", "w").write(json)

model.save_weights("cifar10_weights.h5", overwrite = True)


# 히스토리의 모든 데이터 목록을 표시한다.
print(history.history.keys())

# summarize history for accuracy
pp.plot(history.history["acc"    ])
pp.plot(history.history["val_acc"])

pp.title("model accuracy")
pp.ylabel("accuracy")
pp.xlabel("epoch")
pp.legend(["train", "test"], loc = "upper left")

pp.show()

# 손실 히스토리를 표시한다.
pp.plot(history.history["loss"    ])
pp.plot(history.history["val_loss"])

pp.title("model loss")
pp.ylabel("loss")
pp.xlabel("epoch")
pp.legend(["train", "test"], loc = "upper left")

pp.show()

100

101

import keras.datasets.cifar10 as cifar10

import keras.layers.convolutional as convolutional

import keras.layers.core as core

import keras.models as models

import keras.utils.np_utils as np_utils

import matplotlib.pyplot as pp

outputLayerNodeCount = 10

# 학습 및 테스트 데이터를 로드한다.

(trainInputNDArray, trainCorrectOutputNDArray), (testInputNDArray, testCorrectOutputNDArray) = cifar10.load_data()

print("학습 입력 배열 형태 : ", trainInputNDArray.shape)

print(trainInputNDArray.shape[0], "학습 샘플 데이터" )

print(testInputNDArray.shape[0] , "테스트 샘플 데이터")

trainCorrectOutputNDArray = np_utils.to_categorical(trainCorrectOutputNDArray, outputLayerNodeCount)

testCorrectOutputNDArray = np_utils.to_categorical(testCorrectOutputNDArray , outputLayerNodeCount)

# 입력 데이터를 정규화 한다.

trainInputNDArray = trainInputNDArray.astype("float32")

testInputNDArray = testInputNDArray.astype("float32")

trainInputNDArray /= 255

testInputNDArray /= 255

# 모델을 정의한다.

model = models.Sequential()

model.add(convolutional.Conv2D(32, (3, 3), padding = "same", input_shape = (32, 32, 3)))

model.add(core.Activation("relu"))

model.add(convolutional.Conv2D(32, (3, 3), padding = "same"))

model.add(core.Activation("relu"))

model.add(convolutional.MaxPooling2D(pool_size = (2, 2)))

model.add(core.Dropout(0.25))

model.add(convolutional.Conv2D(64, (3, 3), padding = "same"))

model.add(core.Activation("relu"))

model.add(convolutional.Conv2D(64, (3, 3), padding = "same"))

model.add(core.Activation("relu"))

model.add(convolutional.MaxPooling2D(pool_size = (2, 2)))

model.add(core.Dropout(0.25))

model.add(core.Flatten())

model.add(core.Dense(512))

model.add(core.Activation("relu"))

model.add(core.Dropout(0.5))

model.add(core.Dense(outputLayerNodeCount))

model.add(core.Activation("softmax"))

model.summary()

# 모델을 컴파일한다.

model.compile(loss = "categorical_crossentropy", optimizer = "rmsprop", metrics = ["accuracy"])

# 모델을 학습시킨다.

history = model.fit(trainInputNDArray, trainCorrectOutputNDArray, batch_size = 128, epochs = 20, validation_split = 0.2, verbose = 1)

# 모델을 평가한다.

print("테스트...")

scoreList = model.evaluate(testInputNDArray, testCorrectOutputNDArray, batch_size = 128, verbose = 1)

print("테스트 스코어 : ", scoreList[0])

print("테스트 정확도 : ", scoreList[1])

# 모델을 저장한다.

json = model.to_json()

open("cifar10_model.json", "w").write(json)

model.save_weights("cifar10_weights.h5", overwrite = True)

# 히스토리의 모든 데이터 목록을 표시한다.

print(history.history.keys())

# summarize history for accuracy

pp.plot(history.history["acc" ])

pp.plot(history.history["val_acc"])

pp.title("model accuracy")

pp.ylabel("accuracy")

pp.xlabel("epoch")

pp.legend(["train", "test"], loc = "upper left")

pp.show()

# 손실 히스토리를 표시한다.

pp.plot(history.history["loss" ])

pp.plot(history.history["val_loss"])

pp.title("model loss")

pp.ylabel("loss")

pp.xlabel("epoch")

pp.legend(["train", "test"], loc = "upper left")

pp.show()

[PYTHON/KERAS] 컨볼루션 신경망 만들기 (CIFAR-10)

■ 컨볼루션 신경망을 만드는 방법을 보여준다. ▶ 예제 코드 (PY)


import keras.datasets.cifar10 as cifar10
import keras.layers.convolutional as convolutional
import keras.layers.core as core
import keras.models as models
import keras.utils.np_utils as np_utils
import matplotlib.pyplot as pp

outputLayerNodeCount = 10

# 학습 및 테스트 데이터를 로드한다.
(trainInputNDArray, trainCorrectOutputNDArray), (testInputNDArray, testCorrectOutputNDArray) = cifar10.load_data()

print("학습 입력 배열 형태 : ", trainInputNDArray.shape)

print(trainInputNDArray.shape[0], "학습 샘플 데이터"  )
print(testInputNDArray.shape[0] , "테스트 샘플 데이터")

trainCorrectOutputNDArray = np_utils.to_categorical(trainCorrectOutputNDArray, outputLayerNodeCount)
testCorrectOutputNDArray  = np_utils.to_categorical(testCorrectOutputNDArray , outputLayerNodeCount)

# 입력 데이터를 정규화 한다.
trainInputNDArray = trainInputNDArray.astype("float32")
testInputNDArray  = testInputNDArray.astype("float32")

trainInputNDArray /= 255
testInputNDArray  /= 255

# 모델을 정의한다.
model = models.Sequential()

model.add(convolutional.Conv2D(32, (3, 3), padding = "same", input_shape = (32, 32, 3)))
model.add(core.Activation("relu"))
model.add(convolutional.MaxPooling2D(pool_size = (2, 2)))
model.add(core.Dropout(0.25))
model.add(core.Flatten())
model.add(core.Dense(512))
model.add(core.Activation("relu"))
model.add(core.Dropout(0.5))
model.add(core.Dense(outputLayerNodeCount))
model.add(core.Activation("softmax"))

model.summary()

# 모델을 컴파일한다.
model.compile(loss = "categorical_crossentropy", optimizer = "rmsprop", metrics = ["accuracy"])

# 모델을 학습시킨다.
history = model.fit(trainInputNDArray, trainCorrectOutputNDArray, batch_size = 128, epochs = 20, validation_split = 0.2, verbose = 1)

# 모델을 평가한다.
print("테스트...")

scoreList = model.evaluate(testInputNDArray, testCorrectOutputNDArray, batch_size = 128, verbose = 1)

print("테스트 스코어 : ", scoreList[0])
print("테스트 정확도 : ", scoreList[1])

# 모델을 저장한다.
json = model.to_json()

open("cifar10_model.json", "w").write(json)

model.save_weights("cifar10_weights.h5", overwrite = True)


# 히스토리의 모든 데이터 목록을 표시한다.
print(history.history.keys())

# summarize history for accuracy
pp.plot(history.history["acc"    ])
pp.plot(history.history["val_acc"])

pp.title("model accuracy")
pp.ylabel("accuracy")
pp.xlabel("epoch")
pp.legend(["train", "test"], loc = "upper left")

pp.show()

# 손실 히스토리를 표시한다.
pp.plot(history.history["loss"    ])
pp.plot(history.history["val_loss"])

pp.title("model loss")
pp.ylabel("loss")
pp.xlabel("epoch")
pp.legend(["train", "test"], loc = "upper left")

pp.show()

import keras.datasets.cifar10 as cifar10

import keras.layers.convolutional as convolutional

import keras.layers.core as core

import keras.models as models

import keras.utils.np_utils as np_utils

import matplotlib.pyplot as pp

outputLayerNodeCount = 10

# 학습 및 테스트 데이터를 로드한다.

(trainInputNDArray, trainCorrectOutputNDArray), (testInputNDArray, testCorrectOutputNDArray) = cifar10.load_data()

print("학습 입력 배열 형태 : ", trainInputNDArray.shape)

print(trainInputNDArray.shape[0], "학습 샘플 데이터" )

print(testInputNDArray.shape[0] , "테스트 샘플 데이터")

trainCorrectOutputNDArray = np_utils.to_categorical(trainCorrectOutputNDArray, outputLayerNodeCount)

testCorrectOutputNDArray = np_utils.to_categorical(testCorrectOutputNDArray , outputLayerNodeCount)

# 입력 데이터를 정규화 한다.

trainInputNDArray = trainInputNDArray.astype("float32")

testInputNDArray = testInputNDArray.astype("float32")

trainInputNDArray /= 255

testInputNDArray /= 255

# 모델을 정의한다.

model = models.Sequential()

model.add(convolutional.Conv2D(32, (3, 3), padding = "same", input_shape = (32, 32, 3)))

model.add(core.Activation("relu"))

model.add(convolutional.MaxPooling2D(pool_size = (2, 2)))

model.add(core.Dropout(0.25))

model.add(core.Flatten())

model.add(core.Dense(512))

model.add(core.Activation("relu"))

model.add(core.Dropout(0.5))

model.add(core.Dense(outputLayerNodeCount))

model.add(core.Activation("softmax"))

model.summary()

# 모델을 컴파일한다.

model.compile(loss = "categorical_crossentropy", optimizer = "rmsprop", metrics = ["accuracy"])

# 모델을 학습시킨다.

history = model.fit(trainInputNDArray, trainCorrectOutputNDArray, batch_size = 128, epochs = 20, validation_split = 0.2, verbose = 1)

# 모델을 평가한다.

print("테스트...")

scoreList = model.evaluate(testInputNDArray, testCorrectOutputNDArray, batch_size = 128, verbose = 1)

print("테스트 스코어 : ", scoreList[0])

print("테스트 정확도 : ", scoreList[1])

# 모델을 저장한다.

json = model.to_json()

open("cifar10_model.json", "w").write(json)

model.save_weights("cifar10_weights.h5", overwrite = True)

# 히스토리의 모든 데이터 목록을 표시한다.

print(history.history.keys())

# summarize history for accuracy

pp.plot(history.history["acc" ])

pp.plot(history.history["val_acc"])

pp.title("model accuracy")

pp.ylabel("accuracy")

pp.xlabel("epoch")

pp.legend(["train", "test"], loc = "upper left")

pp.show()

# 손실 히스토리를 표시한다.

pp.plot(history.history["loss" ])

pp.plot(history.history["val_loss"])

pp.title("model loss")

pp.ylabel("loss")

pp.xlabel("epoch")

pp.legend(["train", "test"], loc = "upper left")

pp.show()

[PYTHON/KERAS] 컨볼루션 신경망 만들기 (MNIST)

■ 컨볼루션 신경망을 만드는 방법을 보여준다. ▶ 예제 코드 (PY)


import keras.backend as backend
import keras.datasets.mnist as mnist
import keras.layers.convolutional as convolutional
import keras.layers.core as core
import keras.models as models
import keras.utils.np_utils as np_utils
import matplotlib.pyplot as pp
import numpy as np

np.random.seed(1671)

backend.set_image_dim_ordering("th")

outputLayerNodeCount = 10

# 학습 및 테스트 데이터를 로드한다.
(trainInputNDArray, trainCorrectOutputNDArray), (testInputNDArray, testCorrectOutputNDArray) = mnist.load_data()

trainInputNDArray = trainInputNDArray.astype("float32")
testInputNDArray  = testInputNDArray.astype("float32")

# 입력 데이터를 정규화 한다.
trainInputNDArray /= 255
testInputNDArray  /= 255

# 60000개×[1×28×28] 형태의 입력을 CONVNET에 전달
trainInputNDArray = trainInputNDArray[:, np.newaxis, :, :]
testInputNDArray  = testInputNDArray[:, np.newaxis, :, :]

print(trainInputNDArray.shape[0], "학습 샘플 데이터")
print(testInputNDArray.shape[0] , "테스트 샘플 데이터")

# 범주 벡터를 이진 범주 행렬로 변환한다.
trainCorrectOutputNDArray = np_utils.to_categorical(trainCorrectOutputNDArray, outputLayerNodeCount)
testCorrectOutputNDArray  = np_utils.to_categorical(testCorrectOutputNDArray , outputLayerNodeCount)

# 모델을 정의한다.
model = models.Sequential()

model.add(convolutional.Conv2D(20, kernel_size = 5, padding = "same", input_shape = (1, 28, 28)))
model.add(core.Activation("relu"))
model.add(convolutional.MaxPooling2D(pool_size = (2, 2), strides = (2, 2)))
model.add(convolutional.Conv2D(50, kernel_size = 5, padding = "same"))
model.add(core.Activation("relu"))
model.add(convolutional.MaxPooling2D(pool_size = (2, 2), strides = (2, 2)))
model.add(core.Flatten())
model.add(core.Dense(500))
model.add(core.Activation("relu"))
model.add(core.Dense(outputLayerNodeCount))
model.add(core.Activation("softmax"))

model.compile(loss = "categorical_crossentropy", optimizer = "adam", metrics = ["accuracy"])

history = model.fit(trainInputNDArray, trainCorrectOutputNDArray, batch_size = 128, epochs = 1, verbose = 1, validation_split = 0.2)

scoreList = model.evaluate(testInputNDArray, testCorrectOutputNDArray, verbose = 1)

print("")
print("테스트 스코어 : ", scoreList[0])
print("테스트 정확도 : ", scoreList[1])

# 히스토리의 모든 데이터 목록을 표시한다.
print(history.history.keys())

# 정확도 히스토리를 표시한다.
pp.plot(history.history["acc"    ])
pp.plot(history.history["val_acc"])

pp.title("model accuracy")
pp.ylabel("accuracy")
pp.xlabel("epoch")
pp.legend(["train", "test"], loc = "upper left")

pp.show()

# 손실 히스토리를 표시한다.
pp.plot(history.history["loss"    ])
pp.plot(history.history["val_loss"])

pp.title("model loss")
pp.ylabel("loss")
pp.xlabel("epoch")
pp.legend(["train", "test"], loc = "upper left")

pp.show()

import keras.backend as backend

import keras.datasets.mnist as mnist

import keras.layers.convolutional as convolutional

import keras.layers.core as core

import keras.models as models

import keras.utils.np_utils as np_utils

import matplotlib.pyplot as pp

import numpy as np

np.random.seed(1671)

backend.set_image_dim_ordering("th")

outputLayerNodeCount = 10

# 학습 및 테스트 데이터를 로드한다.

(trainInputNDArray, trainCorrectOutputNDArray), (testInputNDArray, testCorrectOutputNDArray) = mnist.load_data()

trainInputNDArray = trainInputNDArray.astype("float32")

testInputNDArray = testInputNDArray.astype("float32")

# 입력 데이터를 정규화 한다.

trainInputNDArray /= 255

testInputNDArray /= 255

# 60000개×[1×28×28] 형태의 입력을 CONVNET에 전달

trainInputNDArray = trainInputNDArray[:, np.newaxis, :, :]

testInputNDArray = testInputNDArray[:, np.newaxis, :, :]

print(trainInputNDArray.shape[0], "학습 샘플 데이터")

print(testInputNDArray.shape[0] , "테스트 샘플 데이터")

# 범주 벡터를 이진 범주 행렬로 변환한다.

trainCorrectOutputNDArray = np_utils.to_categorical(trainCorrectOutputNDArray, outputLayerNodeCount)

testCorrectOutputNDArray = np_utils.to_categorical(testCorrectOutputNDArray , outputLayerNodeCount)

# 모델을 정의한다.

model = models.Sequential()

model.add(convolutional.Conv2D(20, kernel_size = 5, padding = "same", input_shape = (1, 28, 28)))

model.add(core.Activation("relu"))

model.add(convolutional.MaxPooling2D(pool_size = (2, 2), strides = (2, 2)))

model.add(convolutional.Conv2D(50, kernel_size = 5, padding = "same"))

model.add(core.Activation("relu"))

model.add(convolutional.MaxPooling2D(pool_size = (2, 2), strides = (2, 2)))

model.add(core.Flatten())

model.add(core.Dense(500))

model.add(core.Activation("relu"))

model.add(core.Dense(outputLayerNodeCount))

model.add(core.Activation("softmax"))

model.compile(loss = "categorical_crossentropy", optimizer = "adam", metrics = ["accuracy"])

history = model.fit(trainInputNDArray, trainCorrectOutputNDArray, batch_size = 128, epochs = 1, verbose = 1, validation_split = 0.2)

scoreList = model.evaluate(testInputNDArray, testCorrectOutputNDArray, verbose = 1)

print("")

print("테스트 스코어 : ", scoreList[0])

print("테스트 정확도 : ", scoreList[1])

# 히스토리의 모든 데이터 목록을 표시한다.

print(history.history.keys())

# 정확도 히스토리를 표시한다.

pp.plot(history.history["acc" ])

pp.plot(history.history["val_acc"])

pp.title("model accuracy")

pp.ylabel("accuracy")

pp.xlabel("epoch")

pp.legend(["train", "test"], loc = "upper left")

pp.show()

# 손실 히스토리를 표시한다.

pp.plot(history.history["loss" ])

pp.plot(history.history["val_loss"])

pp.title("model loss")

pp.ylabel("loss")

pp.xlabel("epoch")

pp.legend(["train", "test"], loc = "upper left")

pp.show()

[PYTHON/KERAS] 다층 퍼셉트론 신경망 만들기 (MNIST)

■ 다층 퍼셉트론 신경망을 만드는 방법을 보여준다. ▶ 예제 코드 (PY)


import keras.datasets.mnist as mnist
import keras.layers.core as core
import keras.models as models
import keras.utils.np_utils as np_utils
import matplotlib.pyplot as pp
import numpy as np

np.random.seed(1671)

inputLayerNodeCount  = 784
hiddenLayerNodeCount = 128
outputLayerNodeCount = 10

# 학습 및 테스트 데이터를 로드한다.
(trainInputNDArray, trainCorrectOutputNDArray), (testInputNDArray, testCorrectOutputNDArray) = mnist.load_data()

trainInputNDArray = trainInputNDArray.reshape(60000, inputLayerNodeCount)
trainInputNDArray = trainInputNDArray.astype("float32")

testInputNDArray  = testInputNDArray.reshape(10000, inputLayerNodeCount)
testInputNDArray  = testInputNDArray.astype("float32")

# 입력 데이터를 정규화 한다.
trainInputNDArray /= 255
testInputNDArray  /= 255

print(trainInputNDArray.shape[0], "학습 샘플 데이터"  )
print(testInputNDArray.shape[0] , "테스트 샘플 데이터")

# 범주 벡터를 이진 범주 행렬로 변환한다.
trainCorrectOutputNDArray = np_utils.to_categorical(trainCorrectOutputNDArray, outputLayerNodeCount)
testCorrectOutputNDArray  = np_utils.to_categorical(testCorrectOutputNDArray , outputLayerNodeCount)

# 모델을 정의한다.
model = models.Sequential()

model.add(core.Dense(hiddenLayerNodeCount, input_shape = (inputLayerNodeCount,)))
model.add(core.Activation("relu"))
model.add(core.Dropout(0.3))
model.add(core.Dense(hiddenLayerNodeCount))
model.add(core.Activation("relu"))
model.add(core.Dropout(0.3))
model.add(core.Dense(outputLayerNodeCount))
model.add(core.Activation("softmax"))

model.summary()

# 모델을 컴파일한다.
model.compile(loss = "categorical_crossentropy", optimizer = "sgd", metrics = ["accuracy"])

# 모델을 학습시킨다.
history = model.fit(trainInputNDArray, trainCorrectOutputNDArray, batch_size = 128, epochs = 20, verbose = 1, validation_split = 0.2)

# 모델을 평가한다.
scoreList = model.evaluate(testInputNDArray, testCorrectOutputNDArray, verbose = 1)

print("")
print("테스트 스코어 : ", scoreList[0])
print("테스트 정확도 : ", scoreList[1])

# 히스토리의 모든 데이터 목록을 표시한다.
print(history.history.keys())

# 정확도 히스토리를 표시한다.
pp.plot(history.history["acc"    ])
pp.plot(history.history["val_acc"])

pp.title("model accuracy")
pp.ylabel("accuracy")
pp.xlabel("epoch")
pp.legend(["train", "test"], loc = "upper left")

pp.show()

# 손실 히스토리를 표시한다.
pp.plot(history.history["loss"    ])
pp.plot(history.history["val_loss"])

pp.title("model loss")
pp.ylabel("loss")
pp.xlabel("epoch")
pp.legend(["train", "test"], loc = "upper left")

pp.show()

import keras.datasets.mnist as mnist

import keras.layers.core as core

import keras.models as models

import keras.utils.np_utils as np_utils

import matplotlib.pyplot as pp

import numpy as np

np.random.seed(1671)

inputLayerNodeCount = 784

hiddenLayerNodeCount = 128

outputLayerNodeCount = 10

# 학습 및 테스트 데이터를 로드한다.

(trainInputNDArray, trainCorrectOutputNDArray), (testInputNDArray, testCorrectOutputNDArray) = mnist.load_data()

trainInputNDArray = trainInputNDArray.reshape(60000, inputLayerNodeCount)

trainInputNDArray = trainInputNDArray.astype("float32")

testInputNDArray = testInputNDArray.reshape(10000, inputLayerNodeCount)

testInputNDArray = testInputNDArray.astype("float32")

# 입력 데이터를 정규화 한다.

trainInputNDArray /= 255

testInputNDArray /= 255

print(trainInputNDArray.shape[0], "학습 샘플 데이터" )

print(testInputNDArray.shape[0] , "테스트 샘플 데이터")

# 범주 벡터를 이진 범주 행렬로 변환한다.

trainCorrectOutputNDArray = np_utils.to_categorical(trainCorrectOutputNDArray, outputLayerNodeCount)

testCorrectOutputNDArray = np_utils.to_categorical(testCorrectOutputNDArray , outputLayerNodeCount)

# 모델을 정의한다.

model = models.Sequential()

model.add(core.Dense(hiddenLayerNodeCount, input_shape = (inputLayerNodeCount,)))

model.add(core.Activation("relu"))

model.add(core.Dropout(0.3))

model.add(core.Dense(hiddenLayerNodeCount))

model.add(core.Activation("relu"))

model.add(core.Dropout(0.3))

model.add(core.Dense(outputLayerNodeCount))

model.add(core.Activation("softmax"))

model.summary()

# 모델을 컴파일한다.

model.compile(loss = "categorical_crossentropy", optimizer = "sgd", metrics = ["accuracy"])

# 모델을 학습시킨다.

history = model.fit(trainInputNDArray, trainCorrectOutputNDArray, batch_size = 128, epochs = 20, verbose = 1, validation_split = 0.2)

# 모델을 평가한다.

scoreList = model.evaluate(testInputNDArray, testCorrectOutputNDArray, verbose = 1)

print("")

print("테스트 스코어 : ", scoreList[0])

print("테스트 정확도 : ", scoreList[1])

# 히스토리의 모든 데이터 목록을 표시한다.

print(history.history.keys())

# 정확도 히스토리를 표시한다.

pp.plot(history.history["acc" ])

pp.plot(history.history["val_acc"])

pp.title("model accuracy")

pp.ylabel("accuracy")

pp.xlabel("epoch")

pp.legend(["train", "test"], loc = "upper left")

pp.show()

# 손실 히스토리를 표시한다.

pp.plot(history.history["loss" ])

pp.plot(history.history["val_loss"])

pp.title("model loss")

pp.ylabel("loss")

pp.xlabel("epoch")

pp.legend(["train", "test"], loc = "upper left")

pp.show()

[PYTHON/KERAS] 순환 신경망 만들기 (나비야) : 상태 유지, 입력 속성 2개

■ 순환 신경망을 만드는 방법을 보여준다. ▶ 예제 코드 (PY)


import keras.callbacks as callbacks
import keras.models as models
import keras.layers as layers
import keras.utils as utils
import matplotlib.pyplot as pp
import numpy as np

np.random.seed(5)

# 손실 이력 클래스를 정의한다.
class LossHistory(callbacks.Callback):
    def init(self):
        self.lossList = []

    def on_epoch_end(self, batch, logDictionary = {}):
        self.lossList.append(logDictionary.get("loss"))

# 특징 리스트 구하기 함수를 정의한다.
def GetFeatureList(code):
    featureList = []
    featureList.append(scaleDictionary[code[0]] / float(maximumScale))
    featureList.append(lengthDictionary[code[1]])
    return featureList

# 소스 ND 배열 구하기 함수를 정의한다.
def GetSourceNDArray(sourceList, windowSize):
    targetInputList         = []
    targetCorrectOutputList = []
    for i in range(len(sourceList) - windowSize):
        subsetList = sourceList[i:(i + windowSize + 1)]
        for j in range(len(subsetList) - 1):
            featureList = GetFeatureList(subsetList[j])
            targetInputList.append(featureList)
        targetCorrectOutputList.append([codeDictionary[subsetList[windowSize]]])
    return np.array(targetInputList), np.array(targetCorrectOutputList)

print("데이터 로드를 시작합니다.")

maximumScale = 6.0

scaleDictionary  = {"c" : 0, "d" : 1, "e" : 2, "f" : 3, "g" : 4, "a" : 5, "b" : 6}

lengthDictionary = {"4" : 0, "8" : 1}

codeDictionary = {"c4" : 0, "d4" : 1, "e4" : 2, "f4" : 3 , "g4" : 4 , "a4" : 5 , "b4" : 6,
                  "c8" : 7, "d8" : 8, "e8" : 9, "f8" : 10, "g8" : 11, "a8" : 12, "b8" : 13}

indexDictionary = {0 : "c4", 1 : "d4", 2 : "e4", 3  : "f4", 4  : "g4", 5  : "a4", 6  : "b4",
                   7 : "c8", 8 : "d8", 9 : "e8", 10 : "f8", 11 : "g8", 12 : "a8", 13 : "b8"}

sequenceList = ["g8", "e8", "e4", "f8", "d8", "d4", "c8", "d8", "e8", "f8", "g8", "g8", "g4",
                "g8", "e8", "e8", "e8", "f8", "d8", "d4", "c8", "e8", "g8", "g8", "e8", "e8", "e4",
                "d8", "d8", "d8", "d8", "d8", "e8", "f4", "e8", "e8", "e8", "e8", "e8", "f8", "g4",
                "g8", "e8", "e4", "f8", "d8", "d4", "c8", "e8", "g8", "g8", "e8", "e8", "e4"]

trainInputNDArray, trainCorrectOutputNDArray = GetSourceNDArray(sequenceList, windowSize = 4)

trainInputNDArray = np.reshape(trainInputNDArray, (50, 4, 2))

trainCorrectOutputNDArray = utils.np_utils.to_categorical(trainCorrectOutputNDArray)

outputNodeCount = trainCorrectOutputNDArray.shape[1]

print("데이터 로드를 종료합니다.")

print("모델 정의를 시작합니다.")

model = models.Sequential()

model.add(layers.LSTM(128, batch_input_shape = (1, 4, 2), stateful = True))
model.add(layers.Dense(outputNodeCount, activation = "softmax"))

model.compile(loss = "categorical_crossentropy", optimizer = "adam", metrics = ["accuracy"])

print("모델 정의를 종료합니다.")

print("모델 학습을 시작합니다.")

epochCount = 2000

history = LossHistory()

history.init()

for epochIndex in range(epochCount):
    print("epoch : " + str(epochIndex))
    model.fit(trainInputNDArray, trainCorrectOutputNDArray, epochs = 1, batch_size = 1, verbose = 2, shuffle = False, callbacks = [history])
    model.reset_states()

pp.plot(history.lossList)

pp.ylabel("loss")
pp.xlabel("epoch")
pp.legend(["train"], loc = "upper left")

pp.show()

print("모델 학습을 종료합니다.")

print("모델 평가를 시작합니다.")

evaluationList = model.evaluate(trainInputNDArray, trainCorrectOutputNDArray, batch_size = 1)

print("%s : %.2f%%" %(model.metrics_names[1], evaluationList[1] * 100))

model.reset_states()

print("모델 평가를 종료합니다.")

print("모델 사용을 시작합니다.")

predictionCount = 50

print("한 스텝 예측을 시작합니다.")

resultSequenceList = ["g8", "e8", "e4", "f8"]

predictionNDArray = model.predict(trainInputNDArray, batch_size = 1)

for i in range(predictionCount):
    index = np.argmax(predictionNDArray[i])
    resultSequenceList.append(indexDictionary[index])

model.reset_states()

print("한 스텝 예측 : ", resultSequenceList)

print("한 스텝 예측을 종료합니다.")

print("곡 전체 예측을 시작합니다.")

inputSequenceList  = ["g8", "e8", "e4", "f8"]
resultSequenceList = inputSequenceList

inputSequenceFeatureList = []

for inputSequenceItem in inputSequenceList:
    featureList = GetFeatureList(inputSequenceItem)
    inputSequenceFeatureList.append(featureList)

for i in range(predictionCount):
    inputSequenceNDArray = np.array(inputSequenceFeatureList)
    inputSequenceNDArray = np.reshape(inputSequenceNDArray, (1, 4, 2)) # 샘플 수, 타임 스텝 수, 속성 수
    predictionNDArray = model.predict(inputSequenceNDArray)
    index = np.argmax(predictionNDArray)
    resultSequenceList.append(indexDictionary[index])
    featureList = GetFeatureList(indexDictionary[index])
    inputSequenceFeatureList.append(featureList)
    inputSequenceFeatureList.pop(0)

model.reset_states()

print("곡 전체 예측 : ", resultSequenceList)

print("곡 전체 예측을 종료합니다.")

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

import keras.callbacks as callbacks

import keras.models as models

import keras.layers as layers

import keras.utils as utils

import matplotlib.pyplot as pp

import numpy as np

np.random.seed(5)

# 손실 이력 클래스를 정의한다.

class LossHistory(callbacks.Callback):

def init(self):

self.lossList = []

def on_epoch_end(self, batch, logDictionary = {}):

self.lossList.append(logDictionary.get("loss"))

# 특징 리스트 구하기 함수를 정의한다.

def GetFeatureList(code):

featureList = []

featureList.append(scaleDictionary[code[0]] / float(maximumScale))

featureList.append(lengthDictionary[code[1]])

return featureList

# 소스 ND 배열 구하기 함수를 정의한다.

def GetSourceNDArray(sourceList, windowSize):

targetInputList = []

targetCorrectOutputList = []

for i in range(len(sourceList) - windowSize):

subsetList = sourceList[i:(i + windowSize + 1)]

for j in range(len(subsetList) - 1):

featureList = GetFeatureList(subsetList[j])

targetInputList.append(featureList)

targetCorrectOutputList.append([codeDictionary[subsetList[windowSize]]])

return np.array(targetInputList), np.array(targetCorrectOutputList)

print("데이터 로드를 시작합니다.")

maximumScale = 6.0

scaleDictionary = {"c" : 0, "d" : 1, "e" : 2, "f" : 3, "g" : 4, "a" : 5, "b" : 6}

lengthDictionary = {"4" : 0, "8" : 1}

codeDictionary = {"c4" : 0, "d4" : 1, "e4" : 2, "f4" : 3 , "g4" : 4 , "a4" : 5 , "b4" : 6,

"c8" : 7, "d8" : 8, "e8" : 9, "f8" : 10, "g8" : 11, "a8" : 12, "b8" : 13}

indexDictionary = {0 : "c4", 1 : "d4", 2 : "e4", 3 : "f4", 4 : "g4", 5 : "a4", 6 : "b4",

7 : "c8", 8 : "d8", 9 : "e8", 10 : "f8", 11 : "g8", 12 : "a8", 13 : "b8"}

sequenceList = ["g8", "e8", "e4", "f8", "d8", "d4", "c8", "d8", "e8", "f8", "g8", "g8", "g4",

"g8", "e8", "e8", "e8", "f8", "d8", "d4", "c8", "e8", "g8", "g8", "e8", "e8", "e4",

"d8", "d8", "d8", "d8", "d8", "e8", "f4", "e8", "e8", "e8", "e8", "e8", "f8", "g4",

"g8", "e8", "e4", "f8", "d8", "d4", "c8", "e8", "g8", "g8", "e8", "e8", "e4"]

trainInputNDArray, trainCorrectOutputNDArray = GetSourceNDArray(sequenceList, windowSize = 4)

trainInputNDArray = np.reshape(trainInputNDArray, (50, 4, 2))

trainCorrectOutputNDArray = utils.np_utils.to_categorical(trainCorrectOutputNDArray)

outputNodeCount = trainCorrectOutputNDArray.shape[1]

print("데이터 로드를 종료합니다.")

print("모델 정의를 시작합니다.")

model = models.Sequential()

model.add(layers.LSTM(128, batch_input_shape = (1, 4, 2), stateful = True))

model.add(layers.Dense(outputNodeCount, activation = "softmax"))

model.compile(loss = "categorical_crossentropy", optimizer = "adam", metrics = ["accuracy"])

print("모델 정의를 종료합니다.")

print("모델 학습을 시작합니다.")

epochCount = 2000

history = LossHistory()

history.init()

for epochIndex in range(epochCount):

print("epoch : " + str(epochIndex))

model.fit(trainInputNDArray, trainCorrectOutputNDArray, epochs = 1, batch_size = 1, verbose = 2, shuffle = False, callbacks = [history])

model.reset_states()

pp.plot(history.lossList)

pp.ylabel("loss")

pp.xlabel("epoch")

pp.legend(["train"], loc = "upper left")

pp.show()

print("모델 학습을 종료합니다.")

print("모델 평가를 시작합니다.")

evaluationList = model.evaluate(trainInputNDArray, trainCorrectOutputNDArray, batch_size = 1)

print("%s : %.2f%%" %(model.metrics_names[1], evaluationList[1] * 100))

model.reset_states()

print("모델 평가를 종료합니다.")

print("모델 사용을 시작합니다.")

predictionCount = 50

print("한 스텝 예측을 시작합니다.")

resultSequenceList = ["g8", "e8", "e4", "f8"]

predictionNDArray = model.predict(trainInputNDArray, batch_size = 1)

for i in range(predictionCount):

index = np.argmax(predictionNDArray[i])

resultSequenceList.append(indexDictionary[index])

model.reset_states()

print("한 스텝 예측 : ", resultSequenceList)

print("한 스텝 예측을 종료합니다.")

print("곡 전체 예측을 시작합니다.")

inputSequenceList = ["g8", "e8", "e4", "f8"]

resultSequenceList = inputSequenceList

inputSequenceFeatureList = []

for inputSequenceItem in inputSequenceList:

featureList = GetFeatureList(inputSequenceItem)

inputSequenceFeatureList.append(featureList)

for i in range(predictionCount):

inputSequenceNDArray = np.array(inputSequenceFeatureList)

inputSequenceNDArray = np.reshape(inputSequenceNDArray, (1, 4, 2)) # 샘플 수, 타임 스텝 수, 속성 수

predictionNDArray = model.predict(inputSequenceNDArray)

index = np.argmax(predictionNDArray)

resultSequenceList.append(indexDictionary[index])

featureList = GetFeatureList(indexDictionary[index])

inputSequenceFeatureList.append(featureList)

inputSequenceFeatureList.pop(0)

model.reset_states()

print("곡 전체 예측 : ", resultSequenceList)

print("곡 전체 예측을 종료합니다.")

[PYTHON/KERAS] 순환 신경망 만들기 (나비야) : 상태 유지, 입력 속성 1개

■ 순환 신경망을 만드는 방법을 보여준다. ▶ 예제 코드 (PY)


import keras.callbacks as callbacks
import keras.models as models
import keras.layers as layers
import keras.utils as utils
import matplotlib.pyplot as pp
import numpy as np

np.random.seed(5)

# 손실 이력 클래스를 정의한다.
class LossHistory(callbacks.Callback):
    def init(self):
        self.lossList = []

    def on_epoch_end(self, batch, logDictionary = {}):
        self.lossList.append(logDictionary.get("loss"))

# 소스 ND 배열 구하기 함수를 정의한다.
def GetSourceNDArray(sourceList, windowSize):
    targetList = []
    for i in range(len(sourceList) - windowSize):
        subsetList = sourceList[i:(i + windowSize + 1)]
        targetList.append([codeDictionary[item] for item in subsetList])
    return np.array(targetList)

print("데이터 로드를 시작합니다.")

codeDictionary = {"c4" : 0, "d4" : 1, "e4" : 2, "f4" :3 , "g4" : 4 , "a4" : 5 , "b4" : 6,
                  "c8" : 7, "d8" : 8, "e8" : 9, "f8" :10, "g8" : 11, "a8" : 12, "b8" : 13}

indexDictionary = {0 : "c4", 1 : "d4", 2 : "e4", 3  : "f4", 4  : "g4", 5  : "a4", 6  : "b4",
                   7 : "c8", 8 : "d8", 9 : "e8", 10 : "f8", 11 : "g8", 12 : "a8", 13 : "b8"}

sequenceList = ["g8", "e8", "e4", "f8", "d8", "d4", "c8", "d8", "e8", "f8", "g8", "g8", "g4",
                "g8", "e8", "e8", "e8", "f8", "d8", "d4", "c8", "e8", "g8", "g8", "e8", "e8", "e4",
                "d8", "d8", "d8", "d8", "d8", "e8", "f4", "e8", "e8", "e8", "e8", "e8", "f8", "g4",
                "g8", "e8", "e4", "f8", "d8", "d4", "c8", "e8", "g8", "g8", "e8", "e8", "e4"]

sourceNDArray = GetSourceNDArray(sequenceList, windowSize = 4)

trainInputNDArray         = sourceNDArray[:, 0:4]
trainCorrectOutputNDArray = sourceNDArray[:, 4  ]

maximumIndex = 13

trainInputNDArray = trainInputNDArray / float(maximumIndex)
trainInputNDArray = np.reshape(trainInputNDArray, (50, 4, 1))

trainCorrectOutputNDArray = utils.np_utils.to_categorical(trainCorrectOutputNDArray)

outputNodeCount = trainCorrectOutputNDArray.shape[1]

print("데이터 로드를 종료합니다.")

print("모델 정의를 시작합니다.")

model = models.Sequential()

model.add(layers.LSTM(128, batch_input_shape = (1, 4, 1), stateful = True))
model.add(layers.Dense(outputNodeCount, activation = "softmax"))

model.compile(loss = "categorical_crossentropy", optimizer = "adam", metrics = ["accuracy"])

print("모델 정의를 종료합니다.")

print("모델 학습을 시작합니다.")

epcohCount = 2000

history = LossHistory()

history.init()

for epochIndex in range(epcohCount):
    print ('epoch : ' + str(epochIndex) )
    model.fit(trainInputNDArray, trainCorrectOutputNDArray, epochs = 1, batch_size = 1, verbose = 2, shuffle = False, callbacks = [history])
    model.reset_states()

pp.plot(history.lossList)

pp.ylabel("loss")
pp.xlabel("epoch")
pp.legend(["train"], loc = "upper left")

pp.show()

print("모델 학습을 종료합니다.")

print("모델 평가를 시작합니다.")

evaluationList = model.evaluate(trainInputNDArray, trainCorrectOutputNDArray, batch_size = 1)

print("%s : %.2f%%" % (model.metrics_names[1], evaluationList[1] * 100))

model.reset_states()

print("모델 평가를 종료합니다.")

print("모델 사용을 시작합니다.")

predictionCount = 50

print("한 스텝 예측을 시작합니다.")

resultSequenceList = ["g8", "e8", "e4", "f8"]

predictionNDArray = model.predict(trainInputNDArray, batch_size = 1)

for i in range(predictionCount):
    index = np.argmax(predictionNDArray[i])
    resultSequenceList.append(indexDictionary[index])

model.reset_states()

print("한 스텝 예측 : ", resultSequenceList)

print("한 스텝 예측을 종료합니다.")

print("곡 전체 예측을 시작합니다.")

inputSequenceList  = ["g8", "e8", "e4", "f8"]
resultSequenceList = inputSequenceList
inputSequenceList  = [codeDictionary[item] / float(maximumIndex) for item in inputSequenceList]

for i in range(predictionCount):
    inputSequenceNDArray = np.array(inputSequenceList)
    inputSequenceNDArray = np.reshape(inputSequenceNDArray, (1, 4, 1)) # 샘플 수, 타입 스텝 수, 속성 수
    predictionNDArray = model.predict(inputSequenceNDArray)
    index = np.argmax(predictionNDArray)
    resultSequenceList.append(indexDictionary[index])
    inputSequenceList.append(index / float(maximumIndex))
    inputSequenceList.pop(0)

model.reset_states()

print("곡 전체 예측 : ", resultSequenceList)

print("곡 전체 예측을 종료합니다.")

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

import keras.callbacks as callbacks

import keras.models as models

import keras.layers as layers

import keras.utils as utils

import matplotlib.pyplot as pp

import numpy as np

np.random.seed(5)

# 손실 이력 클래스를 정의한다.

class LossHistory(callbacks.Callback):

def init(self):

self.lossList = []

def on_epoch_end(self, batch, logDictionary = {}):

self.lossList.append(logDictionary.get("loss"))

# 소스 ND 배열 구하기 함수를 정의한다.

def GetSourceNDArray(sourceList, windowSize):

targetList = []

for i in range(len(sourceList) - windowSize):

subsetList = sourceList[i:(i + windowSize + 1)]

targetList.append([codeDictionary[item] for item in subsetList])

return np.array(targetList)

print("데이터 로드를 시작합니다.")

codeDictionary = {"c4" : 0, "d4" : 1, "e4" : 2, "f4" :3 , "g4" : 4 , "a4" : 5 , "b4" : 6,

"c8" : 7, "d8" : 8, "e8" : 9, "f8" :10, "g8" : 11, "a8" : 12, "b8" : 13}

indexDictionary = {0 : "c4", 1 : "d4", 2 : "e4", 3 : "f4", 4 : "g4", 5 : "a4", 6 : "b4",

7 : "c8", 8 : "d8", 9 : "e8", 10 : "f8", 11 : "g8", 12 : "a8", 13 : "b8"}

sequenceList = ["g8", "e8", "e4", "f8", "d8", "d4", "c8", "d8", "e8", "f8", "g8", "g8", "g4",

"g8", "e8", "e8", "e8", "f8", "d8", "d4", "c8", "e8", "g8", "g8", "e8", "e8", "e4",

"d8", "d8", "d8", "d8", "d8", "e8", "f4", "e8", "e8", "e8", "e8", "e8", "f8", "g4",

"g8", "e8", "e4", "f8", "d8", "d4", "c8", "e8", "g8", "g8", "e8", "e8", "e4"]

sourceNDArray = GetSourceNDArray(sequenceList, windowSize = 4)

trainInputNDArray = sourceNDArray[:, 0:4]

trainCorrectOutputNDArray = sourceNDArray[:, 4 ]

maximumIndex = 13

trainInputNDArray = trainInputNDArray / float(maximumIndex)

trainInputNDArray = np.reshape(trainInputNDArray, (50, 4, 1))

trainCorrectOutputNDArray = utils.np_utils.to_categorical(trainCorrectOutputNDArray)

outputNodeCount = trainCorrectOutputNDArray.shape[1]

print("데이터 로드를 종료합니다.")

print("모델 정의를 시작합니다.")

model = models.Sequential()

model.add(layers.LSTM(128, batch_input_shape = (1, 4, 1), stateful = True))

model.add(layers.Dense(outputNodeCount, activation = "softmax"))

model.compile(loss = "categorical_crossentropy", optimizer = "adam", metrics = ["accuracy"])

print("모델 정의를 종료합니다.")

print("모델 학습을 시작합니다.")

epcohCount = 2000

history = LossHistory()

history.init()

for epochIndex in range(epcohCount):

print ('epoch : ' + str(epochIndex) )

model.fit(trainInputNDArray, trainCorrectOutputNDArray, epochs = 1, batch_size = 1, verbose = 2, shuffle = False, callbacks = [history])

model.reset_states()

pp.plot(history.lossList)

pp.ylabel("loss")

pp.xlabel("epoch")

pp.legend(["train"], loc = "upper left")

pp.show()

print("모델 학습을 종료합니다.")

print("모델 평가를 시작합니다.")

evaluationList = model.evaluate(trainInputNDArray, trainCorrectOutputNDArray, batch_size = 1)

print("%s : %.2f%%" % (model.metrics_names[1], evaluationList[1] * 100))

model.reset_states()

print("모델 평가를 종료합니다.")

print("모델 사용을 시작합니다.")

predictionCount = 50

print("한 스텝 예측을 시작합니다.")

resultSequenceList = ["g8", "e8", "e4", "f8"]

predictionNDArray = model.predict(trainInputNDArray, batch_size = 1)

for i in range(predictionCount):

index = np.argmax(predictionNDArray[i])

resultSequenceList.append(indexDictionary[index])

model.reset_states()

print("한 스텝 예측 : ", resultSequenceList)

print("한 스텝 예측을 종료합니다.")

print("곡 전체 예측을 시작합니다.")

inputSequenceList = ["g8", "e8", "e4", "f8"]

resultSequenceList = inputSequenceList

inputSequenceList = [codeDictionary[item] / float(maximumIndex) for item in inputSequenceList]

for i in range(predictionCount):

inputSequenceNDArray = np.array(inputSequenceList)

inputSequenceNDArray = np.reshape(inputSequenceNDArray, (1, 4, 1)) # 샘플 수, 타입 스텝 수, 속성 수

predictionNDArray = model.predict(inputSequenceNDArray)

index = np.argmax(predictionNDArray)

resultSequenceList.append(indexDictionary[index])

inputSequenceList.append(index / float(maximumIndex))

inputSequenceList.pop(0)

model.reset_states()

print("곡 전체 예측 : ", resultSequenceList)

print("곡 전체 예측을 종료합니다.")

[PYTHON/KERAS] 컨볼루션 신경망 만들기 (손글씨) : 데이터 확장

■ 컨볼루션 신경망을 만드는 방법을 보여준다. ▶ 예제 코드 (PY)


import keras.layers as layers
import keras.layers.convolutional as convolutional
import keras.models as models
import keras.preprocessing.image as image
import numpy as np

np.random.seed(3)

print("데이터 로드를 시작합니다.")

trainImageDataGenerator = image.ImageDataGenerator(rescale = 1. / 255,
    rotation_range = 10,
    width_shift_range = 0.2,
    height_shift_range = 0.2,
    shear_range = 0.7,
    zoom_range = [0.9, 2.2],
    horizontal_flip = True,
    vertical_flip = True,
    fill_mode = "nearest")

trainDirectoryIterator = trainImageDataGenerator.flow_from_directory("handwriting_shape/train", target_size = (24, 24), batch_size = 3, class_mode = "categorical")

testImageDataGenerator = image.ImageDataGenerator(rescale = 1. / 255)

testDirectoryIterator = testImageDataGenerator.flow_from_directory("handwriting_shape/test", target_size = (24, 24), batch_size = 3, class_mode = "categorical")

print("데이터 로드를 종료합니다.")

print("모델 정의를 시작합니다.")

model = models.Sequential()

model.add(convolutional.Conv2D(32, kernel_size = (3, 3), activation = "relu", input_shape = (24, 24, 3)))
model.add(convolutional.Conv2D(64, (3, 3), activation = "relu"))
model.add(convolutional.MaxPooling2D(pool_size = (2, 2)))
model.add(layers.Flatten())
model.add(layers.Dense(128, activation = "relu"))
model.add(layers.Dense(3, activation = "softmax"))

model.compile(loss = "categorical_crossentropy", optimizer = "adam", metrics = ["accuracy"])

print("모델 정의를 종료합니다.")

print("모델 학습을 시작합니다.")

model.fit_generator(trainDirectoryIterator, steps_per_epoch = 15 * 100, epochs = 200, validation_data = testDirectoryIterator, validation_steps = 5)

print("모델 학습을 종료합니다.")

print("모델 평가를 시작합니다.")

evaluationList = model.evaluate_generator(testDirectoryIterator, steps = 5)

print("%s : %.2f%%" % (model.metrics_names[1], evaluationList[1] * 100))

print("모델 평가를 종료합니다.")

print("모델 사용을 시작합니다.")

outputNDArray = model.predict_generator(testDirectoryIterator, steps = 5)

np.set_printoptions(formatter = {"float": lambda x: "{0:0.3f}".format(x)})

classDictionary = testDirectoryIterator.class_indices

print(classDictionary)
print(outputNDArray)

print("모델 사용을 종료합니다.")

import keras.layers as layers

import keras.layers.convolutional as convolutional

import keras.models as models

import keras.preprocessing.image as image

import numpy as np

np.random.seed(3)

print("데이터 로드를 시작합니다.")

trainImageDataGenerator = image.ImageDataGenerator(rescale = 1. / 255,

rotation_range = 10,

width_shift_range = 0.2,

height_shift_range = 0.2,

shear_range = 0.7,

zoom_range = [0.9, 2.2],

horizontal_flip = True,

vertical_flip = True,

fill_mode = "nearest")

trainDirectoryIterator = trainImageDataGenerator.flow_from_directory("handwriting_shape/train", target_size = (24, 24), batch_size = 3, class_mode = "categorical")

testImageDataGenerator = image.ImageDataGenerator(rescale = 1. / 255)

testDirectoryIterator = testImageDataGenerator.flow_from_directory("handwriting_shape/test", target_size = (24, 24), batch_size = 3, class_mode = "categorical")

print("데이터 로드를 종료합니다.")

print("모델 정의를 시작합니다.")

model = models.Sequential()

model.add(convolutional.Conv2D(32, kernel_size = (3, 3), activation = "relu", input_shape = (24, 24, 3)))

model.add(convolutional.Conv2D(64, (3, 3), activation = "relu"))

model.add(convolutional.MaxPooling2D(pool_size = (2, 2)))

model.add(layers.Flatten())

model.add(layers.Dense(128, activation = "relu"))

model.add(layers.Dense(3, activation = "softmax"))

model.compile(loss = "categorical_crossentropy", optimizer = "adam", metrics = ["accuracy"])

print("모델 정의를 종료합니다.")

print("모델 학습을 시작합니다.")

model.fit_generator(trainDirectoryIterator, steps_per_epoch = 15 * 100, epochs = 200, validation_data = testDirectoryIterator, validation_steps = 5)

print("모델 학습을 종료합니다.")

print("모델 평가를 시작합니다.")

evaluationList = model.evaluate_generator(testDirectoryIterator, steps = 5)

print("%s : %.2f%%" % (model.metrics_names[1], evaluationList[1] * 100))

print("모델 평가를 종료합니다.")

print("모델 사용을 시작합니다.")

outputNDArray = model.predict_generator(testDirectoryIterator, steps = 5)

np.set_printoptions(formatter = {"float": lambda x: "{0:0.3f}".format(x)})

classDictionary = testDirectoryIterator.class_indices

print(classDictionary)

print(outputNDArray)

print("모델 사용을 종료합니다.")

handwriting_shape.zip

[PYTHON/KERAS] 순환 신경망 만들기 (나비야)

■ 순환 신경망을 만드는 방법을 보여준다. ▶ 예제 코드 (PY)


import keras.callbacks as callbacks
import keras.models as models
import keras.layers as layers
import keras.utils as utils
import matplotlib.pyplot as pp
import numpy as np

np.random.seed(5)

# 손실 이력 클래스를 정의한다.
class LossHistory(callbacks.Callback):
    def init(self):
        self.lossList = []

    def on_epoch_end(self, batch, logDictionary = {}):
        self.lossList.append(logDictionary.get("loss"))

# 소스 ND 배열 구하기 함수를 정의한다.
def GetSourceNDArray(sourceList, windowSize):
    targetList = []
    for i in range(len(sourceList) - windowSize):
        subsetList = sourceList[i:(i + windowSize + 1)]
        targetList.append([codeDictionary[item] for item in subsetList])
    return np.array(targetList)

print("데이터 로드를 시작합니다.")

codeDictionary = {"c4" : 0, "d4" : 1, "e4" : 2, "f4" :3 , "g4" : 4 , "a4" : 5 , "b4" : 6,
                  "c8" : 7, "d8" : 8, "e8" : 9, "f8" :10, "g8" : 11, "a8" : 12, "b8" : 13}

indexDictionary = {0 : "c4", 1 : "d4", 2 : "e4", 3  : "f4", 4  : "g4", 5  : "a4", 6  : "b4",
                   7 : "c8", 8 : "d8", 9 : "e8", 10 : "f8", 11 : "g8", 12 : "a8", 13 : "b8"}

sequenceList = ["g8", "e8", "e4", "f8", "d8", "d4", "c8", "d8", "e8", "f8", "g8", "g8", "g4",
                "g8", "e8", "e8", "e8", "f8", "d8", "d4", "c8", "e8", "g8", "g8", "e8", "e8", "e4",
                "d8", "d8", "d8", "d8", "d8", "e8", "f4", "e8", "e8", "e8", "e8", "e8", "f8", "g4",
                "g8", "e8", "e4", "f8", "d8", "d4", "c8", "e8", "g8", "g8", "e8", "e8", "e4"]

sourceNDArray = GetSourceNDArray(sequenceList, windowSize = 4)

trainInputNDArray         = sourceNDArray[:, 0:4]
trainCorrectOutputNDArray = sourceNDArray[:, 4  ]

maximumIndex = 13

trainInputNDArray = trainInputNDArray / float(maximumIndex)
trainInputNDArray = np.reshape(trainInputNDArray, (50, 4, 1))

trainCorrectOutputNDArray = utils.np_utils.to_categorical(trainCorrectOutputNDArray)

outputNodeCount = trainCorrectOutputNDArray.shape[1]

print("데이터 로드를 종료합니다.")

print("모델 정의를 시작합니다.")

model = models.Sequential()

model.add(layers.LSTM(128, input_shape = (4, 1)))
model.add(layers.Dense(outputNodeCount, activation = "softmax"))

model.compile(loss = "categorical_crossentropy", optimizer = "adam", metrics = ["accuracy"])

print("모델 정의를 종료합니다.")

print("모델 학습을 시작합니다.")

history = LossHistory()

history.init()

model.fit(trainInputNDArray, trainCorrectOutputNDArray, epochs = 2000, batch_size = 14, verbose = 2, callbacks = [history])

pp.plot(history.lossList)

pp.ylabel("loss")
pp.xlabel("epoch")
pp.legend(["train"], loc = "upper left")

pp.show()

print("모델 학습을 종료합니다.")

print("모델 평가를 시작합니다.")

evaluationList = model.evaluate(trainInputNDArray, trainCorrectOutputNDArray)

print("%s : %.2f%%" % (model.metrics_names[1], evaluationList[1] * 100))

print("모델 평가를 종료합니다.")

print("모델 사용을 시작합니다.")

predictionCount = 50

print("한 스텝 예측을 시작합니다.")

resultSequenceList = ["g8", "e8", "e4", "f8"]

predictionNDArray = model.predict(trainInputNDArray)

for i in range(predictionCount):
    index = np.argmax(predictionNDArray[i])
    resultSequenceList.append(indexDictionary[index])

print("한 스텝 예측 : ", resultSequenceList)

print("한 스텝 예측을 종료합니다.")

print("곡 전체 예측을 시작합니다.")

inputSequenceList  = ["g8", "e8", "e4", "f8"]
resultSequenceList = inputSequenceList
inputSequenceList  = [codeDictionary[item] / float(maximumIndex) for item in inputSequenceList]

for i in range(predictionCount):
    inputSequenceNDArray = np.array(inputSequenceList)
    inputSequenceNDArray = np.reshape(inputSequenceNDArray, (1, 4, 1)) # 샘플 수, 타임 스텝 수, 속성 수
    predictionNDArray = model.predict(inputSequenceNDArray)
    index = np.argmax(predictionNDArray)
    resultSequenceList.append(indexDictionary[index])
    inputSequenceList.append(index / float(maximumIndex))
    inputSequenceList.pop(0)

print("곡 전체 예측 : ", resultSequenceList)

print("곡 전체 예측을 종료합니다.")