def model_run(self, path):
csv_file = pd.read_csv(path + '/dataset.csv')
Y_data = csv_file[csv_file.columns[-1]]
X_data = csv_file.iloc[:, :-1]
#X_data = X_data.drop('Date', axis=1)
pre_model = self.model_create(len(X_data.columns))
X_train, X_test, y_train, y_test = train_test_split(X_data,
Y_data,
test_size=0.2)
pre_model.fit(X_train,
y_train,
epochs=int(self.epochs),
batch_size=10,
verbose=0)
plot_model(pre_model,
to_file=path + '/result.png',
show_shapes=True,
show_layer_names=True)
_, y_pred = pre_model.evaluate(X_test, y_test, verbose=0)
print('%.3f' % (y_pred * 100), '%')
def test_plot_model_with_add_loss(self):
inputs = keras.Input(shape=(None, 3))
outputs = keras.layers.Dense(1)(inputs)
model = keras.Model(inputs, outputs)
model.add_loss(math_ops.reduce_mean(outputs))
dot_img_file = 'model_3.png'
try:
vis_utils.plot_model(model,
to_file=dot_img_file,
show_shapes=True,
show_dtype=True,
expand_nested=True)
self.assertTrue(file_io.file_exists(dot_img_file))
file_io.delete_file(dot_img_file)
except ImportError:
pass
model = keras.Sequential(
[keras.Input(shape=(None, 3)),
keras.layers.Dense(1)])
model.add_loss(math_ops.reduce_mean(model.output))
dot_img_file = 'model_4.png'
try:
vis_utils.plot_model(model,
to_file=dot_img_file,
show_shapes=True,
show_dtype=True,
expand_nested=True)
self.assertTrue(file_io.file_exists(dot_img_file))
file_io.delete_file(dot_img_file)
except ImportError:
pass
def buildClassifier(input_shape=(100, 100, 3)):
# Initialising the CNN
classifier = Sequential()
classifier.add(Conv2D(32, kernel_size=(3, 3), activation='relu', input_shape=input_shape, padding='same'))
classifier.add(MaxPooling2D(pool_size=(4, 4), padding='same'))
classifier.add(Dropout(0.5)) # added extra Dropout layer
classifier.add(Conv2D(64, (3, 3), activation='relu', padding='same'))
classifier.add(MaxPooling2D(pool_size=(2, 2), padding='same'))
classifier.add(Conv2D(128, (3, 3), padding='same', activation='relu'))
classifier.add(Dropout(0.5)) # added extra dropout layer
classifier.add(Conv2D(256, (3, 3), activation='relu', padding='same'))
classifier.add(MaxPooling2D(pool_size=(2, 2), padding='same'))
classifier.add(Dropout(0.2)) # antes era 0.25
classifier.add(Conv2D(512, (3, 3), padding='same', activation='relu'))
classifier.add(Conv2D(1024, (3, 3), activation='relu', padding='same'))
classifier.add(MaxPooling2D(pool_size=(2, 2), padding='same'))
classifier.add(Dense(units=1024, activation='relu')) # added new dense layer
classifier.add(Dropout(0.2)) # antes era 0.25
# Step 3 - Flattening
classifier.add(Flatten())
classifier.add(Dense(units=1024, activation='relu')) # added new dense layer
classifier.add(Dense(units=256, activation='relu')) # added new dense layer
# Step 4 - Full connection
classifier.add(Dropout(0.2))
classifier.add(Dense(units=1, activation='sigmoid'))
classifier.summary()
# Compiling the CNN
classifier.compile(optimizer='adam',
loss='binary_crossentropy',
metrics=['accuracy'])
plot_model(classifier, to_file='model_plot.png', show_shapes=True, show_layer_names=True)
return classifier
def model(self):
# Don't train the discriminator model weights
self.discriminator.trainable = False
# Send the image to the generator model
generator_output = self.generator(self.input_image)
# Send the actual input and generator output to discriminator model
discriminator_out = self.discriminator(
[self.input_image, generator_output])
# Final Model
model = Model(self.input_image, [discriminator_out, generator_output])
optimizer = Adam(lr=0.0002, beta_1=0.5)
model.compile(loss=['binary_crossentropy', 'mae'],
optimizer=optimizer,
loss_weights=[1, 100])
print(
"\n******************************************* GAN Model ********************************************"
)
print(model.summary())
plot_model(model,
"modelplots/pix2pix/gan.png",
show_shapes=True,
show_layer_names=True)
return model
def lstm(hparams, input_dimension, output_dimension=300, max_length):
step = X_train.shape[1]
model = Sequential()
model.add(
Embedding(input_dimension, output_dimension, input_length=max_length))
model.add(Dropout(0.25))
model.add(
Bidirectional(
LSTM(input_shape=(step, 1), units=10, activation="softmax")))
model.add(
Bidirectional(
LSTM(input_shape=(step, 1), units=10, activation="softmax")))
model.add(Dense(20, activation="softmax"))
model.add(Activation('softmax'))
model.compile(loss='mean_squared_error',
optimizer='rmsprop',
metrics=['acc'])
model.summary()
plot_model(model,
to_file='model_plot.png',
show_shapes=True,
show_layer_names=True)
model.fit(X_train,
y_train,
epochs=epochs,
batch_size=hparams[HP_BATCH_SIZE]
) # Run with 1 epoch to speed things up for demo purposes
test_predictions = model.predict(X_test)
_, accuracy = model.evaluate(X_test, y_test)
return accuracy
def save_model(model_name, model, model_args, kwargs):
"""Saves a model to a folder. Also saves the configuration files necessary to load the model.
"""
paths = list(
map(lambda f: int(f[6:]),
filter(lambda s: s.startswith('model_'), os.listdir('.'))))
if len(paths) == 0:
folder = 'model_0'
else:
folder = 'model_%d' % (max(paths) + 1)
os.mkdir(folder)
model.save('%s/%s_sensor_%d_model.h5' %
(folder, model_name, kwargs['sensor_id']))
plot_model(model,
'%s/%s_sensor_%d_model.png' %
(folder, model_name, kwargs['sensor_id']),
show_shapes=True)
with open(
"%s/%s_sensor_%d_model_args.json" %
(folder, model_name, kwargs['sensor_id']), 'w') as f:
json.dump(model_args, f)
with open(
"%s/%s_sensor_%d_kwargs.json" %
(folder, model_name, kwargs['sensor_id']), 'w') as f:
json.dump(kwargs, f)
return folder
def main():
# plt.figure(figsize=(500, 500))
# plt.imshow(x_train[5])
# plt.show()
train_ds, test_ds, races, train_amount, test_amount = dataset.load_dataset_tf(
)
train_ds = train_ds.shuffle(1200).repeat().batch(BATCH_SIZE)
test_ds = test_ds.shuffle(test_amount).repeat().batch(BATCH_SIZE)
STEPS_PER_EPOCH = ceil(train_amount / BATCH_SIZE)
# for rnum in enumerate(my_ds.take(1)):
model, model_name = race_model(len(races))
model.summary()
tb_callback = TensorBoard('../logs/' + model_name)
model.fit(train_ds,
epochs=5,
steps_per_epoch=STEPS_PER_EPOCH,
callbacks=[tb_callback])
plot_model(model,
'../models/' + model_name + '.png',
show_shapes=True,
show_layer_names=True)
model.save('../models/' + model_name)
test_loss, test_acc = model.evaluate(test_ds,
steps=ceil(test_amount / BATCH_SIZE))
print('Test accuracy:', test_acc)
def test_plot_model_with_wrapped_layers_and_models(self):
inputs = keras.Input(shape=(None, 3))
lstm = keras.layers.LSTM(6, return_sequences=True, name='lstm')
x = lstm(inputs)
# Add layer inside a Wrapper
bilstm = keras.layers.Bidirectional(
keras.layers.LSTM(16, return_sequences=True, name='bilstm'))
x = bilstm(x)
# Add model inside a Wrapper
submodel = keras.Sequential(
[keras.layers.Dense(32, name='dense', input_shape=(None, 32))])
wrapped_dense = keras.layers.TimeDistributed(submodel)
x = wrapped_dense(x)
# Add shared submodel
outputs = submodel(x)
model = keras.Model(inputs, outputs)
dot_img_file = 'model_2.png'
try:
vis_utils.plot_model(model,
to_file=dot_img_file,
show_shapes=True,
show_dtype=True,
expand_nested=True)
self.assertTrue(file_io.file_exists(dot_img_file))
file_io.delete_file(dot_img_file)
except ImportError:
pass
def plot_subclass_model():
# https://stackoverflow.com/questions/61427583/how-do-i-plot-a-keras-tensorflow-subclassing-api-model
Network().build_graph(in_shape=(height, width, input_channels)).summary()
plot_model(Network().build_graph(in_shape=(height, width, input_channels)),
show_shapes=True,
show_layer_names=True,
to_file="archi.png")
print("archi.png created")
def build_and_train(cls,
X: np.array,
y: np.array,
model_path: str,
epochs: int = EPOCHS):
model = cls.build_model(X.shape[2])
plot_model(model, show_shapes=True)
# model, history = cls.train_model(model, X, y, model_path, epochs)
# show_history(history, cls.__class__.__name__)
return cls(model)
def buildClassifier(input_shape=(100, 100, 3)):
"""
This creates the CNN algorithm.
Args:
input_shape(tuple): This is the image shape of (100,100,3)
Returns:
classifier(sequential): This is the sequential model.
"""
# Initialising the CNN
opt = Adam(lr=0.0002) # lr = learning rate
classifier = Sequential()
classifier.add(
Conv2D(32,
kernel_size=(3, 3),
activation='relu',
input_shape=input_shape,
padding='same'))
classifier.add(MaxPooling2D(pool_size=(3, 3), padding='same'))
classifier.add(Dropout(0.5)) # added extra Dropout layer
classifier.add(Conv2D(64, (3, 3), activation='relu', padding='same'))
classifier.add(MaxPooling2D(pool_size=(2, 2), padding='same'))
classifier.add(Conv2D(128, (3, 3), padding='same', activation='relu'))
classifier.add(Dropout(0.5)) # added extra dropout layer
classifier.add(Conv2D(256, (3, 3), activation='relu', padding='same'))
classifier.add(MaxPooling2D(pool_size=(2, 2), padding='same'))
classifier.add(Dropout(0.2)) # antes era 0.25
classifier.add(Conv2D(512, (3, 3), padding='same', activation='relu'))
classifier.add(Conv2D(1024, (3, 3), activation='relu', padding='same'))
classifier.add(MaxPooling2D(pool_size=(2, 2), padding='same'))
classifier.add(
Flatten()) # This is added before dense layer a flatten is needed
classifier.add(Dense(units=1024,
activation='relu')) # added new dense layer
classifier.add(Dropout(0.2)) # antes era 0.25
# Step 3 - Flattening
#classifier.add(Flatten())
classifier.add(Dense(units=1024,
activation='relu')) # added new dense layer
classifier.add(Dense(units=256,
activation='relu')) # added new dense layer
# Step 4 - Full connection
classifier.add(Dropout(0.2))
classifier.add(Dense(units=1, activation='sigmoid'))
classifier.summary()
# Compiling the CNN
classifier.compile(optimizer=opt,
loss='binary_crossentropy',
metrics=['accuracy'])
plot_model(classifier,
to_file='model_plot.png',
show_shapes=True,
show_layer_names=True)
return classifier
def run_cnn(data_loader_func,
batch_size=EPOCHS,
epochs=BATCH_SIZE,
with_augmentation=True):
test_name = str(USED_MODEL_NUMBER) + '_epoch' + str(
EPOCHS) + '_batch' + str(BATCH_SIZE)
clear_logs()
print('------------- CNN model ')
print('------------- Loading data ')
X_train, y_train, X_test, y_test, X_val, y_val = pre_processing_dataset(
*data_loader_func())
log('Test name: ' + test_name + "\n")
log('Batch size: ' + str(batch_size))
log('Epochs: ' + str(epochs))
log('Started data size qty: ' + str(X_train.shape[0]))
print('------------- Creating model ')
cnn_model = create_model()
print('------------- Saving model image ')
plot_model(cnn_model,
to_file=MODELS_PATH + MODEL_IMG_PREFIX + test_name + ".png")
print('------------- Compiling model ')
compile_model(cnn_model)
start_time = time.time()
print('------------- Training model')
augm_gen_func = augm_gen if with_augmentation else None
history = feed_model(cnn_model,
X_train,
y_train,
X_val,
y_val,
batch_size,
epochs,
augm_gen_func=augm_gen_func)
print('------------- Saving data fitting history graphs ')
augm_suffix = "_augm" if with_augmentation else "_norm"
plot_history_graphs(history, MODELS_PATH,
HISTORY_IMG_PREFIX + test_name + augm_suffix)
print('------------- Making labels predictions for test data')
predictions = make_prediction(cnn_model, X_test)
print('------------- Predicting labels for test data ')
predicted_labels = predict_labels(predictions)
print('------------- Saving prediction results to file ')
save_labels_to_csv(predicted_labels, LOGS_PATH,
PREDICTIONS_PREFIX + test_name)
print('------------- Evaluating accuracy ')
loss, accuracy = evaluate_accuracy(cnn_model, X_test, y_test)
log('Prediction accuracy: ' + str(round(accuracy * 100, 2)) + '% \n' +
'Prediction loss: ' + str(round(loss, 2)) + '\n' +
'Total calculation time: ' +
str(convert_time(time.time() - start_time)))
log_printer(log_text, LOGS_PATH + LOG_PREFIX, test_name)
return predictions, predicted_labels, test_name
def test_plot_model_rnn(self):
model = keras.Sequential()
model.add(
keras.layers.LSTM(
16, return_sequences=True, input_shape=(2, 3), name='lstm'))
model.add(keras.layers.TimeDistributed(keras.layers.Dense(5, name='dense')))
dot_img_file = 'model_2.png'
try:
vis_utils.plot_model(model, to_file=dot_img_file, show_shapes=True)
self.assertTrue(file_io.file_exists(dot_img_file))
file_io.delete_file(dot_img_file)
except ImportError:
pass
def test_plot_model_cnn(self):
model = keras.Sequential()
model.add(
keras.layers.Conv2D(
filters=2, kernel_size=(2, 3), input_shape=(3, 5, 5), name='conv'))
model.add(keras.layers.Flatten(name='flat'))
model.add(keras.layers.Dense(5, name='dense'))
dot_img_file = 'model_1.png'
try:
vis_utils.plot_model(model, to_file=dot_img_file, show_shapes=True)
self.assertTrue(file_io.file_exists(dot_img_file))
file_io.delete_file(dot_img_file)
except ImportError:
pass
def test_plot_model_cnn(self):
model = keras.Sequential()
model.add(
keras.layers.Conv2D(
filters=2, kernel_size=(2, 3), input_shape=(3, 5, 5), name='conv'))
model.add(keras.layers.Flatten(name='flat'))
model.add(keras.layers.Dense(5, name='dense'))
dot_img_file = 'model_1.png'
try:
vis_utils.plot_model(model, to_file=dot_img_file, show_shapes=True)
self.assertTrue(file_io.file_exists(dot_img_file))
file_io.delete_file(dot_img_file)
except ImportError:
pass
def save_nn_model(model, output_dir='.', model_name='model.h5'):
"""Save keras model's object, weights, architecture and graph image.
Parameters
----------
model : Instance of `keras Model`
The neural network model you want to save.
output_dir : str
The directory where the model is saved.
model_name : str, default 'model.h5'
Model name with a h5(h5df) extension.
Returns
-------
None
"""
if not os.path.isdir(output_dir):
os.makedirs(output_dir)
# split model_name and extension name
name, extension = os.path.splitext(model_name)
# check extension is .h5 or .hdf5
pattern = re.compile('.(h5|hdf5)')
if not re.match(pattern, extension):
extension = '.h5'
# extension = '.h5' if not extension else extension
# save complete model
fullname = os.path.join(output_dir, model_name)
model.save(fullname)
print(model.name + ' saved as ' + fullname)
# save model architecture
fullname = os.path.join(output_dir, name + '_architecture.json')
model_json = model.to_json()
with open(fullname, "w") as json_file:
json_file.write(model_json)
print(model.name + ' saved as ' + fullname)
# save model weights
fullname = os.path.join(output_dir, name + '_weights' + extension)
model.save_weights(fullname)
print(model.name + ' saved as ' + fullname)
# save simple graph image
plot_model(model,
to_file=os.path.join(output_dir, 'model_graph.png'),
show_shapes=True)
def plot_model(self, show_shapes=True, show_layer_names=True):
"""
It creates a file with a plot of the model/network architecture. It
shows the shapes and the layers if wanted.
:param show_shapes: boolean that determines if shapes should be shown
:param show_layer_names: boolean that determines if layer names should
be shown
"""
path = \
os.path.join(self.fig_path, '{}_model_architecture_{}.png'.format(
self.name, datetime.now().strftime('%Y%m%d%H%M%S')))
plot_model(self.model,
to_file=path,
show_shapes=show_shapes,
show_layer_names=show_layer_names)
def test_plot_model_rnn(self):
model = keras.Sequential()
model.add(
keras.layers.LSTM(16,
return_sequences=True,
input_shape=(2, 3),
name='lstm'))
model.add(
keras.layers.TimeDistributed(keras.layers.Dense(5, name='dense')))
dot_img_file = 'model_2.png'
try:
vis_utils.plot_model(model, to_file=dot_img_file, show_shapes=True)
self.assertTrue(file_io.file_exists(dot_img_file))
file_io.delete_file(dot_img_file)
except ImportError:
pass
def __init__(self, game):
self.game = game
self.shape = (game._base_board.height, game._base_board.width)
self.input_board = Input(self.shape, dtype=float)
self.possible_moves_size = self.shape[1]
self.checkpoint_dir = "checkpoints"
create_dir(self.checkpoint_dir)
X = Reshape((self.shape[0], self.shape[1], 1))(self.input_board)
h_conv1 = ReLU()(BatchNormalization(axis=3)(Conv2D(config.num_channels,
3,
padding='same',
use_bias=False)(X)))
h_conv2 = ReLU()(BatchNormalization(axis=3)(Conv2D(
config.num_channels, 3, padding='same', use_bias=False)(h_conv1)))
h_conv3 = ReLU()(BatchNormalization(axis=3)(Conv2D(
config.num_channels, 3, padding='valid', use_bias=False)(h_conv2)))
h_conv4 = ReLU()(BatchNormalization(axis=3)(Conv2D(
config.num_channels, 3, padding='valid', use_bias=False)(h_conv3)))
h_conv4_flat = Reshape((config.num_channels * (self.shape[0] - 4) *
(self.shape[1] - 4), ))(h_conv4)
s_fc1 = Dropout(config.dropout)(ReLU()(BatchNormalization(axis=1)(
Dense(1024, use_bias=False)(h_conv4_flat))))
s_fc2 = Dropout(config.dropout)(ReLU()(BatchNormalization(axis=1)(
Dense(512, use_bias=False)(s_fc1))))
self.pi = Dense(self.possible_moves_size,
activation='softmax',
name='pi')(s_fc2)
self.v = Dense(1, activation='tanh', name='v')(s_fc2)
self.target_pi = Input([None, self.possible_moves_size], dtype=float)
self.target_v = Input([None], dtype=float)
model = Model(inputs=self.input_board, outputs=(self.pi, self.v))
model.compile(loss=total_loss, optimizer=Adam(config.lr))
print(model.summary())
plot_model(model,
"modelplots/model.png",
show_shapes=True,
show_layer_names=True)
self.model = model
def model(self):
down1 = self.encoder(self.input_image, 64, batch_norm=False)
down2 = self.encoder(down1, 128)
down3 = self.encoder(down2, 256)
down4 = self.encoder(down3, 512)
down5 = self.encoder(down4, 512)
down6 = self.encoder(down5, 512)
down7 = self.encoder(down6, 512)
# Not adding batch normalization and Relu to the bottle neck layer
bottleneck = Conv2D(512, (4, 4),
strides=(2, 2),
padding='same',
kernel_initializer=self.init)(down7)
bottleneck = Activation('relu')(bottleneck)
# decoder model
up1 = self.decoder(bottleneck, down7, 512)
up2 = self.decoder(up1, down6, 512)
up3 = self.decoder(up2, down5, 512)
up4 = self.decoder(up3, down4, 512, dropout=False)
up5 = self.decoder(up4, down3, 256, dropout=False)
up6 = self.decoder(up5, down2, 128, dropout=False)
up7 = self.decoder(up6, down1, 64, dropout=False)
# output
out = Conv2DTranspose(3, (4, 4),
strides=(2, 2),
padding='same',
kernel_initializer=self.init)(up7)
out_image = Activation('tanh')(out)
# define model
model = Model(self.input_image, out_image)
print(
"\n**************************************** Generator Model *****************************************"
)
print(model.summary())
plot_model(model,
"modelplots/pix2pix/generator_model.png",
show_shapes=True,
show_layer_names=True)
return model
def get_simple_cnn_model():
'''
创建cnn分类模型，输入为包含7个车牌字符的整张图像，每个字符的输出为分类one-hot编码。
'''
input_tensor = models.Input((image_height, image_width, 3))
x = input_tensor
for i in range(3):
x = layers.Conv2D(32 * 2**i, (3, 3), activation='relu')(x)
x = layers.Conv2D(32 * 2**i, (3, 3), activation='relu')(x)
x = layers.MaxPool2D(pool_size=(2, 2))(x)
x = layers.Flatten()(x)
x = layers.Dropout(0.25)(x)
x_list = []
# 经过多个全连接层，收集所有输出结果，保存为list，7个元素表示7个字符的预测结果
#xx = [layers.Reshape((-1,65))(layers.Dense(n_class ,activation='softmax', name='c%d'%(i+1))(x)) for i in range(plate_str_length)]
#print("#### ", type(xx))
for i in range(plate_str_length):
xi = layers.Dense(n_class, activation='softmax',
name='c%d' % (i + 1))(x)
xi = layers.Reshape((1, 65))(xi) # 维度 (1, 65)，reshape函数不考虑batch维
#print('### xi shape: ', xi.output_shape)
x_list.append(xi)
# 对x进行concat，在第2维上，第一维是batch_size
concated = layers.concatenate(x_list, axis=1)
#print("#### output shape: ", K.shape(concated))
model = models.Model(inputs=input_tensor, outputs=concated)
print("#### model output shape: ", model.output_shape)
# 绘制模型结构图
print("### plot model")
plot_model(model, to_file='simple_cnn.png', show_shapes=True)
return model
def base_model(self):
'''
this function combine the
:return:
'''
# create the input to our final set of layers as the *output* of both
# the MLP and CNN
combinedInput = concatenate([
self.__model_microaneurysm.output,
self.__model_hemorrhage_and_hard_exudates.output
])
# our final FC layer head will have two dense layers, the final one
# being our regression head
out = Flatten()(combinedInput)
x = Dense(64, activation="relu")(out)
x = Dense(16, activation="relu")(x)
x = Dense(5, activation="softmax")(x)
# our final model will accept categorical/numerical data on the MLP
# input and images on the CNN input, outputting a single value (the
# predicted price of the house)
self.model = Model(inputs=[
self.__model_microaneurysm.input,
self.__model_hemorrhage_and_hard_exudates.input
],
outputs=x)
opt = Adam(lr=0.001)
self.model.compile(optimizer=opt,
loss="categorical_crossentropy",
metrics=['accuracy'])
# out = Dense(1, activation='sigmoid')(concatenated)
# model = Model([digit_a, digit_b], out)
plot_model(self.model,
to_file='model_plot.png',
show_shapes=True,
show_layer_names=True)
self.model.summary()
def model(self):
out = LeakyReLU(0.2)(self.layer_1(self.merged_image))
out = LeakyReLU(0.2)(BatchNormalization()(self.layer_2(out)))
out = LeakyReLU(0.2)(BatchNormalization()(self.layer_3(out)))
out = LeakyReLU(0.2)(BatchNormalization()(self.layer_4(out)))
out = LeakyReLU(0.2)(BatchNormalization()(self.layer_5(out)))
patch_out = Activation('sigmoid')(self.layer_6(out))
model = Model([self.input_image, self.target_image], patch_out)
# Using Adam optimizer
optimizer = Adam(lr=0.0002, beta_1=0.5)
model.compile(loss='binary_crossentropy',
optimizer=optimizer,
loss_weights=[0.5])
print(
"\n************************************* Discriminator Model ****************************************"
)
print(model.summary())
plot_model(model,
"modelplots/pix2pix/discriminator_model.png",
show_shapes=True,
show_layer_names=True)
return model
def cnn(train_dir, test_dir):
# 定数定義
NUM_CLASSES = 4 # 識別クラス数
IMAGE_SIZE = 256 # 学習時の画像サイズ[px]
IMAGE_PIXELS = IMAGE_SIZE * IMAGE_SIZE * 3 # 画像の次元数
LABEL_ANNOTATION_PATH = './label_annotation.txt'
LOG_TRAINING_ACCURACY_GRAPH_PATH = './log/cnn/training_accuracy.png'
LOG_TRAINING_LOSS_GRAPH_PATH = './log/cnn/training_loss.png'
LOG_TRAINING_MODEL_PATH = './log/cnn/model.png'
TRAINING_OPTIMIZER = "SGD(確率的勾配降下法)"
ACTIVATION_FUNC = "relu" #活性化関数
# 学習データセットのインポート
train_image, train_label, train_path = import_dataset(
train_dir, IMAGE_SIZE, IMAGE_SIZE)
#Kerasの学習モデルの構築
model = Sequential()
# 畳み込み層
model.add(
Conv2D(3,
kernel_size=3,
activation=ACTIVATION_FUNC,
input_shape=(IMAGE_SIZE, IMAGE_SIZE, 3)))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(
Conv2D(3,
kernel_size=3,
activation=ACTIVATION_FUNC,
input_shape=(IMAGE_SIZE, IMAGE_SIZE, 3)))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(
Conv2D(3,
kernel_size=3,
activation=ACTIVATION_FUNC,
input_shape=(IMAGE_SIZE, IMAGE_SIZE, 3)))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Flatten())
model.add(Activation(ACTIVATION_FUNC))
model.add(Dropout(0.2))
# 全結合層
model.add(Dense(200))
model.add(Activation(ACTIVATION_FUNC))
model.add(Dropout(0.2))
model.add(Dense(200))
model.add(Activation(ACTIVATION_FUNC))
model.add(Dropout(0.2))
model.add(Dense(200))
model.add(Activation(ACTIVATION_FUNC))
model.add(Dropout(0.2))
model.add(Dense(200))
model.add(Activation(ACTIVATION_FUNC))
model.add(Dropout(0.2))
model.add(Dense(NUM_CLASSES))
model.add(Activation("softmax"))
# オプティマイザにAdamを使用
opt = Adam(lr=0.001)
# モデルをコンパイル
model.compile(loss="categorical_crossentropy",
optimizer=opt,
metrics=["accuracy"])
# 学習を実行
Y = to_categorical(train_label, NUM_CLASSES)
history = model.fit(train_image,
Y,
nb_epoch=40,
batch_size=100,
validation_split=0.1)
export.plot(history)
# テスト用データセットのインポート
test_image, test_label, test_path = import_dataset(test_dir, IMAGE_SIZE,
IMAGE_SIZE)
result = model.predict_classes(test_image)
result_prob = model.predict_proba(test_image)
sum_accuracy = 0.0
for i in range(test_image.shape[0]):
print("label:", test_label[i], "result:", result[i], "prob: ",
result_prob[i])
if test_label[i] == result[i]:
sum_accuracy += 1
sum_accuracy /= test_image.shape[0]
print("accuracy: ", sum_accuracy)
plot_model(model, show_shapes=True, to_file=LOG_TRAINING_MODEL_PATH)
#中間層の出力
imm_layer = ['conv2d', 'conv2d_1', 'conv2d_2']
for layer_name in imm_layer:
#中間層のmodelを作成
intermediate_layer_model = Model(
inputs=model.input, outputs=model.get_layer(layer_name).output)
#出力をmodel.predictで見る
intermediate_output = intermediate_layer_model.predict(test_image)
path = os.getcwd() + "/log/cnn/" + layer_name
if os.path.exists(path) == False: # 出力先ディレクトリが存在しなければ新規作成する
os.mkdir(path)
for i in range(intermediate_output.shape[0]):
cv2.imwrite(path + '/immidiate_' + str(i) + '.png',
intermediate_output[i] * 255)
#結果をhtmlファイル出力
result_dict = {'acc': 0, 'n_img': 0, 'opt': "", 'act_func': ""}
result_dict['acc'] = sum_accuracy
result_dict['n_img'] = train_image.shape[0]
result_dict['opt'] = TRAINING_OPTIMIZER
result_dict['act_func'] = ACTIVATION_FUNC
export.cnn_html(result_dict, test_image, test_label, test_path, result,
result_prob, imm_layer)
# # Beispiel der Benutzung von plot_model() # import tensorflow as tf from tensorflow import keras from tensorflow.python.keras.applications import VGG16 from tensorflow.python.keras.utils.vis_utils import plot_model model = VGG16() # Als PNG plot_model(model, to_file='model_output.png', show_shapes=True, ¿ show_layer_names=True, rankdir="TB") # Als SVG plot_model(model, to_file='model_output.svg', show_
def createCNN1model(dataType):
def getDataWithLabel():
data = pd.read_pickle("DataSets/" + dataType + "_data.pkl")
data = data.sample(frac=1).reset_index(drop=True)
#
# put labels into y_train variable
labels = data['Category']
# Drop 'label' column
data = data.drop(labels=['Category'], axis=1)
return data, labels
def labelEncode(i):
if 'blues' == i:
return 0
elif 'classical' == i:
return 1
elif 'country' == i:
return 2
elif 'disco' == i:
return 3
elif 'hiphop' == i:
return 4
elif 'jazz' == i:
return 5
elif 'metal' == i:
return 6
elif 'pop' == i:
return 7
elif 'reggae' == i:
return 8
else:
return 9
def labelDecode(i):
if 0 == i:
return 'blues'
elif 1 == i:
return "classical"
elif 2 == i:
return "country"
elif 3 == i:
return "disco"
elif 4 == i:
return "hiphop"
elif 5 == i:
return "jazz"
elif 6 == i:
return "metal"
elif 7 == i:
return "pop"
elif 8 == i:
return "reggae"
else:
return "rock"
def fitLabelEncoder(labels):
labelsEncode = []
for i in range(labels.shape[0]):
labelsEncode.append(labelEncode(labels[i]))
labelsEncode = np.array(labelsEncode)
return labelsEncode
def fitLabelDecoder(labels):
labelsDecode = []
for i in range(labels.shape[0]):
labelsDecode.append(labelDecode(labels[i]))
labelsDecode = np.array(labelsDecode)
return labelsDecode
def createTestAndTrain():
X_train, Y_train = getDataWithLabel()
# Normalize the data
X_train = X_train.astype('float16')
X_train = X_train / 255.0
print("Data was normalized..")
print("Data shape: ", X_train.shape)
#Reshape to matrix
X_train = X_train.values.reshape(-1, 240, 240, 3)
print("Data was reshaped..")
#LabelEncode
#labels = preprocessing.LabelEncoder().fit_transform(labels)
Y_train = fitLabelEncoder(Y_train)
print("Data was encoded..")
#int to vector
Y_train = to_categorical(Y_train, num_classes=10)
#train and test data split
#X_train, X_test, Y_train, Y_test= train_test_split(X_train, Y_train, test_size=0.1, random_state=42)
#return X_train, X_test, Y_train, Y_test;
return X_train, Y_train
def createModel(X_train):
model = Sequential()
#
model.add(
Conv2D(filters=16,
kernel_size=(3, 3),
padding='Same',
activation='relu',
input_shape=(X_train.shape[1], X_train.shape[2],
X_train.shape[3])))
model.add(MaxPool2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
#
model.add(
Conv2D(filters=32,
kernel_size=(3, 3),
padding='Same',
activation='relu'))
model.add(MaxPool2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
#
model.add(Flatten())
model.add(Dense(256, activation="relu"))
model.add(Dropout(0.5))
model.add(Dense(10, activation="softmax"))
# Define the optimizer
#optimizer = tf.compat.v1.train.AdamOptimizer(1e-3, epsilon=1e-4)
optimizer = tf.keras.optimizers.Adam(lr=0.001,
beta_1=0.9,
beta_2=0.999)
model.compile(optimizer=optimizer,
loss="categorical_crossentropy",
metrics=["accuracy"])
return model
#set early stopping criteria
pat = 10 #this is the number of epochs with no improvment after which the training will stop
early_stopping = EarlyStopping(monitor='val_loss', patience=pat, verbose=1)
#define the model checkpoint callback -> this will keep on saving the model as a physical file
checkpointPath = dataType + '_CNN1_checkpoint.h5'
model_checkpoint = ModelCheckpoint(checkpointPath,
verbose=1,
save_best_only=True)
def plotAccLossGraphics(history):
plt.title('Accuracies vs Epochs')
plt.plot(history.history["val_accuracy"], label='Validation Acc')
plt.plot(history.history["accuracy"], label='Training Acc')
plt.legend()
plt.show()
# Plot the loss and accuracy curves for training and validation
plt.plot(history.history['val_loss'], label="validation loss ")
plt.plot(history.history['loss'], label="train loss ")
plt.title("Test Loss")
plt.xlabel("Number of Epochs")
plt.ylabel("Loss")
plt.legend()
plt.show()
def plotCategories(y_train, val_y):
Y_train_classes = np.argmax(y_train, axis=1)
Y_train_classes = fitLabelDecoder(Y_train_classes)
plt.figure(figsize=(15, 7))
g = sns.countplot(Y_train_classes, palette="icefire")
plt.title("Train Number of digit classes")
plt.show()
Y_val_classes = np.argmax(val_y, axis=1)
Y_val_classes = fitLabelDecoder(Y_val_classes)
plt.figure(figsize=(15, 7))
g = sns.countplot(Y_val_classes, palette="icefire")
plt.title("Validation Number of digit classes")
plt.show()
gc.collect()
def fit_and_evaluate(train_x, val_x, train_y, val_y):
model = None
gc.collect()
model = createModel(train_x)
batch_size = 32
epochs = 30
gc.collect()
datagen = ImageDataGenerator(zoom_range=0.2, horizontal_flip=False)
print("DataGen Started..")
datagen.fit(train_x)
print("DataGen Finished..")
gc.collect()
results = model.fit_generator(
datagen.flow(train_x, train_y, batch_size=batch_size),
epochs=epochs,
callbacks=[early_stopping, model_checkpoint],
verbose=1,
validation_data=(val_x, val_y))
gc.collect()
print("Val Score: ", model.evaluate(val_x, val_y))
return model, results
def fitWithKfold(X, Y):
n_folds = 5
cv = model_selection.KFold(n_splits=n_folds, shuffle=True)
t0 = time.time()
i = 0
maxAcc = 0
accuracies = []
for train_index, test_index in cv.split(X):
i = i + 1
xx_train, xx_test = X[train_index], X[test_index]
yy_train, yy_test = Y[train_index], Y[test_index]
gc.collect()
print("xx_train data shape: ", xx_train.shape)
print("xx_test data shape: ", xx_test.shape)
t_x, val_x, t_y, val_y = train_test_split(
xx_train,
yy_train,
test_size=0.1,
random_state=np.random.randint(1, 1000, 1)[0])
gc.collect()
print("t_x data shape: ", t_x.shape)
plotCategories(t_y, val_y)
model, history = fit_and_evaluate(t_x, val_x, t_y, val_y)
plotAccLossGraphics(history)
gc.collect()
print("Ended Fold: ", i)
acc = predictTest(xx_test, yy_test, model, i)
accuracies.append(acc)
if acc > maxAcc:
maxAcc = acc
maxAccFold = i
bestX_test = xx_test
bestY_test = yy_test
print("max accuracy: ", maxAcc, " on fold:", maxAccFold)
return accuracies, bestX_test, bestY_test
def predictTest(X_test, Y_test, lmodel, fold):
Y_pred = lmodel.predict(X_test)
# Convert predictions classes to one hot vectors
Y_pred_classes = np.argmax(Y_pred, axis=1)
Y_pred_classes = fitLabelDecoder(Y_pred_classes)
Y_test_label = np.argmax(Y_test, axis=1)
Y_test_label = fitLabelDecoder(Y_test_label)
# compute the confusion matrix
labels = [
"blues", "classical", "country", "disco", "hiphop", "jazz",
"metal", "pop", "reggae", "rock"
]
confusion_mtx = confusion_matrix(Y_test_label, Y_pred_classes)
acc = metrics.accuracy_score(Y_test_label, Y_pred_classes) * 100
print(fold, 'th Accuracy percentage:', acc)
return acc
# confusion matrix-precios-recall
def drawConfusionMatrix(X_test, Y_test, lmodel):
Y_pred = lmodel.predict(X_test)
# Convert predictions classes to one hot vectors
Y_pred_classes = np.argmax(Y_pred, axis=1)
Y_pred_classes = fitLabelDecoder(Y_pred_classes)
Y_test_label = np.argmax(Y_test, axis=1)
Y_test_label = fitLabelDecoder(Y_test_label)
# compute the confusion matrix
labels = [
"blues", "classical", "country", "disco", "hiphop", "jazz",
"metal", "pop", "reggae", "rock"
]
confusion_mtx = confusion_matrix(Y_test_label, Y_pred_classes)
# plot the confusion matrix
f, ax = plt.subplots(figsize=(8, 8))
sns.heatmap(confusion_mtx,
annot=True,
linewidths=0.01,
cmap="Greens",
linecolor="gray",
fmt='.1f',
ax=ax,
xticklabels=labels,
yticklabels=labels)
plt.yticks(rotation=0)
plt.xlabel("Predicted Label")
plt.ylabel("True Label")
plt.title("Confusion Matrix")
plt.show()
acc = metrics.accuracy_score(Y_test_label, Y_pred_classes) * 100
print(classification_report(Y_test_label, Y_pred_classes))
score = lmodel.evaluate(X_test, Y_test, verbose=0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])
X_train, Y_train = createTestAndTrain()
#Visualize Model
from tensorflow.python.keras.utils.vis_utils import plot_model
model = createModel(X_train)
plot_model(model,
to_file='model_plot_Cnn1.png',
show_shapes=True,
show_layer_names=True)
accuraciesList, bestX_test, bestY_test = fitWithKfold(X_train, Y_train)
accuracies = np.array(accuraciesList)
meanAccuracy = np.mean(accuracies)
print(meanAccuracy)
bestModel = tf.keras.models.load_model(dataType + '_CNN1_checkpoint.h5')
drawConfusionMatrix(bestX_test, bestY_test, bestModel)
print('(3) split data set...')
p1 = int(len(data) * (1 - VALIDATION_SPLIT - TEST_SPLIT))
p2 = int(len(data) * (1 - TEST_SPLIT))
x_train = data[:p1]
y_train = labels[:p1]
x_val = data[p1:p2]
y_val = labels[p1:p2]
x_test = data[p2:]
y_test = labels[p2:]
print('train docs: ' + str(len(x_train)), 'val docs: ' + str(len(x_val)), 'test docs: ' + str(len(x_test)))
print('(4) training model...')
model = Sequential()
model.add(Embedding(len(word_index) + 1, EMBEDDING_DIM, input_length=MAX_SEQUENCE_LENGTH))
model.add(LSTM(200, dropout=0.2, recurrent_dropout=0.2))
model.add(Dropout(0.2))
model.add(Dense(labels.shape[1], activation='softmax'))
model.summary()
plot_model(model, to_file=os.path.join(ckpt_path, 'lstm_model.png'), show_shapes=True)
model.compile(loss='categorical_crossentropy', optimizer='rmsprop', metrics=['acc'])
print(model.metrics_names)
model.fit(x_train, y_train, validation_data=(x_val, y_val), epochs=2, batch_size=128)
model.save(os.path.join(ckpt_path, 'lstm.h5'))
print('(5) testing model...')
print(model.evaluate(x_test, y_test))
weights=[embedding_matrix],
input_length=MAX_SEQUENCE_LENGTH,
trainable=False)
print('(5) training model...')
model = Sequential()
model.add(embedding_layer)
model.add(Dropout(0.2))
model.add(Conv1D(250, 3, padding='valid', activation='relu', strides=1))
model.add(MaxPooling1D(3))
model.add(Flatten())
model.add(Dense(EMBEDDING_DIM, activation='relu'))
model.add(Dense(labels.shape[1], activation='softmax'))
model.summary()
plot_model(model,
to_file=os.path.join(ckpt_path, 'word_vector_cnn_model.png'),
show_shapes=True)
model.compile(loss='categorical_crossentropy',
optimizer='rmsprop',
metrics=['acc'])
print(model.metrics_names)
model.fit(x_train,
y_train,
validation_data=(x_val, y_val),
epochs=2,
batch_size=128)
model.save(os.path.join(ckpt_path, 'word_vector_cnn.h5'))
print('(6) testing model...')
print(model.evaluate(x_test, y_test))
def __init__(self,
inputs=None,
targets=None,
loss_func="mse",
optimizer="adam",
load_weights_from=None,
plot_to_file=None,
**kwargs):
# strictly check for inputs to be of type variable.
inputs = to_list(inputs)
if not all([is_variable(x) for x in inputs]):
raise ValueError(
'Please provide a `list` of `Variable` or `RadialBasis` objects for inputs. '
)
# prepare input tensors.
input_vars = []
for var in inputs:
input_vars += var.inputs
# check outputs if of correct type.
if targets is None:
if 'constraints' in kwargs:
targets = kwargs.get('constraints')
elif 'conditions' in kwargs:
targets = kwargs.get('conditions')
else:
if 'conditions' in kwargs or 'constraints' in kwargs:
raise TypeError(
'Inconsistent inputs: `constraints`, `conditions`, and `targets` are all equivalent keywords '
'- pass all targets as a list to `SciModel`. ')
# setup constraints.
targets = to_list(targets)
for i, y in enumerate(targets):
if not is_constraint(y):
if is_functional(y):
# Case of Data-type constraint.
# By default, targets are initialized with Data.
targets[i] = Data(y)
elif isinstance(y, tuple) and \
len(y) == 2 and \
is_functional(y[0]) and is_functional(y[1]):
# Case of Tie-type constraint.
targets[i] = Tie(y[0], y[1])
else:
# Not recognised.
raise ValueError(
'The {}th target entry is not of type `Constraint` or `Functional` - '
'received \n ++++++ {} '.format(i, y))
# prepare network outputs.
output_vars = []
for cond in targets:
output_vars += cond().outputs
# prepare loss_functions.
if isinstance(loss_func, str):
loss_func = SciModel.loss_functions(loss_func)
elif not callable(loss_func):
raise TypeError(
'Please provide a valid loss function from ("mse", "mae") ' +
"or a callable function for input of tensor types. ")
# Initialize the Model form super class.
model = Model(inputs=input_vars, outputs=output_vars, **kwargs)
# compile the model.
loss_weights = [K.variable(1.0) for v in output_vars]
if isinstance(optimizer, str) and \
len(optimizer.lower().split("scipy-")) > 1:
model.compile(loss=loss_func,
optimizer=GradientObserver(method=optimizer),
loss_weights=loss_weights)
else:
model.compile(loss=loss_func,
optimizer=optimizer,
loss_weights=loss_weights)
# model.train_function = True
# set initial state of the model.
if load_weights_from is not None:
if os.path.exists(load_weights_from):
model.load_weights(load_weights_from)
else:
raise Warning("File not found - load_weights_from: {}".format(
load_weights_from))
# Set the variables.
self._model = model
self._inputs = inputs
self._constraints = targets
self._loss_func = loss_func
self._optimizer = optimizer
self._loss_weights = loss_weights
self._callbacks = {}
# Plot to file if requested.
if plot_to_file is not None:
plot_model(self._model, to_file=plot_to_file)
def plot_model(self, *args, **kwargs):
""" Keras plot_model functionality.
Refer to Keras documentation for help.
"""
plot_model(self._model, *args, **kwargs)
def conv_nn(conv_depth):
x_train, y_train, x_test, y_test, x_valid, y_valid = data_preparation()
# Reshape input data from (28, 28) to (28, 28, 1)
x_train = x_train.reshape(x_train.shape[0], 28, 28, 1)
x_valid = x_valid.reshape(x_valid.shape[0], 28, 28, 1)
x_test = x_test.reshape(x_test.shape[0], 28, 28, 1)
# One-hot encode the labels
y_train = to_categorical(y_train, 10)
y_valid = to_categorical(y_valid, 10)
y_test = to_categorical(y_test, 10)
# Print training set shape
print("x_train shape:", x_train.shape, "y_train shape:", y_train.shape)
# Print the number of training, validation, and test datasets
print(x_train.shape[0], 'train set')
print(x_valid.shape[0], 'validation set')
print(x_test.shape[0], 'test set')
# Model Definition
# One hidden CONV layer
model = Sequential()
model.add(
Conv2D(filters=32,
kernel_size=2,
padding='same',
activation='relu',
input_shape=(28, 28, 1)))
model.add(MaxPooling2D(pool_size=2))
model.add(Dropout(0.3))
# Add a second hidden layer
if conv_depth > 1:
model.add(
Conv2D(filters=64,
kernel_size=2,
padding='same',
activation='relu'))
model.add(MaxPooling2D(pool_size=2))
model.add(Dropout(0.3))
# Add a third hidden layer
if conv_depth > 2:
model.add(
Conv2D(filters=128,
kernel_size=2,
padding='same',
activation='relu'))
model.add(Dropout(0.3))
model.add(Flatten())
model.add(Dense(256, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(10, activation='softmax'))
model.summary()
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
history = model.fit(x_train,
y_train,
batch_size=64,
epochs=30,
validation_data=(x_valid, y_valid),
callbacks=callbacks,
verbose=1)
test_loss, test_acc = model.evaluate(x_test, y_test, verbose=2)
print('\nTest accuracy:', test_acc)
# Training history plotting
Visualisations.plot_history(history, 'CNN')
# From one-hot-encoded representation -> back to categorical values
rounded_labels = np.argmax(y_test, axis=1)
# Model evaluation for prediction performance on the Test Set
model_eval(model, x_test, rounded_labels)
# model.save('saved/C-NN Model')
plot_model(model,
to_file='CNN_plot.png',
show_shapes=True,
show_layer_names=True)
args = parser.parse_args()
np.random.seed(args.seed)
tf.random.set_seed(args.seed)
random.seed(args.seed)
model = ResUNet(input_shape=(128, 128, 1),
classes=2,
filters_root=16,
depth=3)
model.summary()
if args.plot_model:
from tensorflow.python.keras.utils.vis_utils import plot_model
plot_model(model, show_shapes=True)
model.compile(loss="categorical_crossentropy",
optimizer="adam",
metrics=["categorical_accuracy"])
train_dataset = list(
zip(*list(SimpleDataset(args.train_dataset_dir_path)())))
train_dataset = (np.array(train_dataset[0]), np.array(train_dataset[1]))
x = np.array(train_dataset[0])
y = np.array(train_dataset[1])
validation_dataset = list(
zip(*list(SimpleDataset(args.validation_dataset_dir_path)())))
validation_dataset = (np.array(validation_dataset[0]),
np.array(validation_dataset[1]))
