def defaultEvaluation(model: Model, test_X, test_Y):
score = model.evaluate(test_X, test_Y)
print('Test ' + str(model.loss) + ':', score[0])
index = 1
for metric in model.metrics:
print('Test ' + str(metric) + ':', score[index])
index += 1
return score
def fit_and_evaluate(model: Model, model_filename: str, t_x, val_x, t_y, val_y, epochs=20, batch_size=128) -> History:
results = model.fit(
t_x,
t_y,
epochs=epochs,
batch_size=batch_size,
callbacks=get_callbacks(model_filename),
verbose=1,
validation_data=[val_x, val_y],
)
logging.info("Score against validation set: %s", model.evaluate(val_x, val_y))
return results
output1 = Dense(
128,
activation=leakyRelu,
kernel_initializer=initializer,
)(flat_0)
output2 = Dense(num_classes, activation='softmax')(output1)
model = Model(inputs=visible, outputs=output2)
print(model.summary())
train_data = np.expand_dims(train_data, 2)
test_data = np.expand_dims(test_data, 2)
from tensorflow.python.keras.optimizers import Adam
optimizer = Adam(lr=1e-5)
model.compile(optimizer=optimizer,
loss='categorical_crossentropy',
metrics=["accuracy"])
model.fit(x=train_data, y=train_labels, epochs=100, batch_size=128)
result = model.evaluate(x=test_data, y=test_labels)
for name, value in zip(model.metrics_names, result):
print(name, value)
print("{0}: {1:.2}".format(model.metrics_names[1], result[1]))
def main():
from tensorflow.examples.tutorials.mnist import input_data
data = input_data.read_data_sets("data/MNIST/", one_hot=True)
# data_train = tfds.load(name="mnist", split="train")
# data_test = tfds.load(name="mnist", split="test")
print("Size of:")
print("- Training-set:\t\t{}".format(len(data.train.labels)))
print("- Test-set:\t\t{}".format(data.test.labels))
# Get the first images from the test-set.
data.test.cls = np.array([label.argmax() for label in data.test.labels])
# images = data.x_test[0:9]
images = data.test.images[0:9]
#Get the true classes
# cls_true = data.y_test_cls[0:9]
cls_true = data.test.cls[0:9]
# Plot the images and labels using our helper-function above.
plot_images(images=images, cls_true=cls_true)
if using_seq_model:
model = Sequential()
# Add an input layer which is similar to a feed_dict in TensorFlow.
# Note that the input-shape must be a tuple containing the image-size.
model.add(InputLayer(input_shape=(img_size_flat, )))
# The input is a flattened array with 784 elements,
# but the convolutional layers expect images with shape (28, 28, 1)
model.add(Reshape(img_shape_full))
# x = tf.placeholder(tf.float32, shape=[None, img_size_flat], name='x')
# x_image = tf.reshape(x, [-1, img_size, img_size, num_channels])
# y_true = tf.placeholder(tf.float32, shape=[None, num_classes], name='y_true')
# y_true_cls = tf.argmax(y_true, axis=1)
# First convolutional layer with ReLU-activation and max-pooling.
model.add(
Conv2D(kernel_size=5,
strides=1,
filters=16,
padding='same',
activation='relu',
name='layer_conv1'))
model.add(MaxPooling2D(pool_size=2, strides=2))
# layer_conv1, weights_conv1 = new_conv_layer(input=x_image,
# num_input_channels=num_channels,
# filter_size=filter_size1,
# num_filters=num_filters1,
# use_pooling=True)
# print (layer_conv1)
# Second convolutional layer with ReLU-activation and max-pooling.
model.add(
Conv2D(kernel_size=5,
strides=1,
filters=36,
padding='same',
activation='relu',
name='layer_conv2'))
model.add(MaxPooling2D(pool_size=2, strides=2))
# layer_conv2, weights_conv2 = new_conv_layer(input=layer_conv1,
# num_input_channels=num_filters1,
# filter_size=filter_size2,
# num_filters=num_filters2,
# use_pooling=True)
# print (layer_conv2)
# Flatten the 4-rank output of the convolutional layers
# to 2-rank that can be input to a fully-connected / dense layer.
model.add(Flatten())
# layer_flat, num_features = flatten_layer(layer_conv2)
# print (layer_flat)
# print (num_features)
# First fully-connected / dense layer with ReLU-activation.
model.add(Dense(128, activation='relu'))
# layer_fc1 = new_fc_layer(input=layer_flat,
# num_inputs=num_features,
# num_outputs=fc_size,
# use_relu=True)
# print (layer_fc1)
# Last fully-connected / dense layer with softmax-activation
# for use in classification.
model.add(Dense(num_classes, activation='softmax'))
# layer_fc2 = new_fc_layer(input=layer_fc1,
# num_inputs=fc_size,
# num_outputs=num_classes,
# use_relu=False)
# print(layer_fc2)
# y_pred = tf.nn.softmax(layer_fc2)
# y_pred_cls = tf.argmax(y_pred, axis=1)
# cross_entropy = tf.nn.softmax_cross_entropy_with_logits(logits=layer_fc2,
# labels=y_true)
# cost = tf.reduce_mean(cross_entropy)
from tensorflow.keras.optimizers import Adam
optimizer = Adam(lr=1e-3)
model.compile(optimizer=optimizer,
loss='categorical_crossentropy',
metrics=['accuracy'])
# optimizer = tf.train.AdamOptimizer(learning_rate=1e-4).minimize(cost)
# correct_prediction = tf.equal(y_pred_cls, y_true_cls)
# accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
# session = tf.Session()
# session.run(tf.global_variables_initializer())
model.fit(x=data.train.images,
y=data.train.labels,
epochs=1,
batch_size=128)
result = model.evaluate(x=data.test.images, y=data.test.labels)
print('')
for name, value in zip(model.metrics_names, result):
print(name, value)
print("{0}: {1:.2%}".format(model.metrics_names[1], result[1]))
# `save_model` requires h5py
model.save(path_model)
del model
if using_fun_model:
# Create an input layer which is similar to a feed_dict in TensorFlow.
# Note that the input-shape must be a tuple containing the image-size.
inputs = Input(shape=(img_size_flat, ))
# Variable used for building the Neural Network.
net = inputs
# The input is an image as a flattened array with 784 elements.
# But the convolutional layers expect images with shape (28, 28, 1)
net = Reshape(img_shape_full)(net)
# First convolutional layer with ReLU-activation and max-pooling.
net = Conv2D(kernel_size=5,
strides=1,
filters=16,
padding='same',
activation='relu',
name='layer_conv1')(net)
net = MaxPooling2D(pool_size=2, strides=2)(net)
# Second convolutional layer with ReLU-activation and max-pooling.
net = Conv2D(kernel_size=5,
strides=1,
filters=36,
padding='same',
activation='relu',
name='layer_conv2')(net)
net = MaxPooling2D(pool_size=2, strides=2)(net)
# Flatten the output of the conv-layer from 4-dim to 2-dim.
net = Flatten()(net)
# First fully-connected / dense layer with ReLU-activation.
net = Dense(128, activation='relu')(net)
# Last fully-connected / dense layer with softmax-activation
# so it can be used for classification.
net = Dense(num_classes, activation='softmax')(net)
# Output of the Neural Network.
outputs = net
from tensorflow.python.keras.models import Model
model2 = Model(inputs=inputs, outputs=outputs)
model2.compile(optimizer='rmsprop',
loss='categorical_crossentropy',
metrics=['accuracy'])
model2.fit(x=data.train.images,
y=data.train.labels,
epochs=1,
batch_size=128)
result = model2.evaluate(x=data.test.images, y=data.test.labels)
print('')
for name, value in zip(model2.metrics_names, result):
print(name, value)
print("{0}: {1:.2%}".format(model2.metrics_names[1], result[1]))
# `save_model` requires h5py
model2.save(path_model)
if reload_model:
from tensorflow.python.keras.models import load_model
model3 = load_model(path_model)
#images = data.x_test[0:9]
images = data.test.images[0:9]
#cls_true = data.y_test_cls[0:9]
cls_true = data.test.labels[0:9]
y_pred = model3.predict(x=images)
cls_pred = np.argmax(y_pred, axis=1)
plot_images(images=images, cls_true=cls_true, cls_pred=cls_pred)
y_pred = model3.predict(x=data.test.images)
cls_pred = np.argmax(y_pred, axis=1)
cls_true = data.test.cls
correct = (cls_true == cls_pred)
plot_example_errors(data, cls_pred=cls_pred, correct=correct)
model3.summary()
# Attention: the functional and sequential models are different in
# layers, for sequential ones:
if reading_seq_model:
layer_input = model3.layers[0]
layer_conv1 = model3.layers[1]
print(layer_conv1)
layer_conv2 = model3.layers[3]
elif reading_fun_model:
layer_input = model3.layers[0]
layer_conv1 = model3.layers[2]
print(layer_conv1)
layer_conv2 = model3.layers[4]
weights_conv1 = layer_conv1.get_weights()[0]
print(weights_conv1.shape)
plot_conv_weights(weights=weights_conv1, input_channel=0)
weights_conv2 = layer_conv2.get_weights()[0]
plot_conv_weights(weights=weights_conv2, input_channel=0)
image1 = data.test.images[0]
plot_image(image1)
# from tensorflow.keras import backend as K
# output_conv1 = K.function(inputs=[layer_input.input],
# outputs=[layer_conv1.output])
# print(output_conv1)
# print(output_conv1([[image1]]))
# layer_output1 = output_conv1([[image1]])[0]
# print(layer_output1.shape)
# plot_conv_output(values=layer_output1)
from tensorflow.keras.models import Model
output_conv2 = Model(inputs=layer_input.input,
outputs=layer_conv2.output)
layer_output2 = output_conv2.predict(np.array([image1]))
layer_output2.shape
plot_conv_output(values=layer_output2)
y_train = np_utils.to_categorical(y_train, num_classes)
y_test = np_utils.to_categorical(y_test, num_classes)
X_train = X_train.astype("float") / 255.0
X_test = X_test.astype("float") / 255.0
model = VGG16(weights='imagenet',
include_top=False,
input_shape=(image_size, image_size, 3))
top_model = Sequential()
top_model.add(Flatten(input_shape=model.output_shape[1:]))
top_model.add(Dense(256, activation='relu'))
top_model.add(Dropout(0.5))
top_model.add(Dense(num_classes, activation="softmax"))
model = Model(inputs=model.input, outputs=top_model(model.output))
for layer in model.layers[:15]:
layer.trainable = False
opt = Adam(lr=0.0001)
model.compile(loss='categorical_crossentropy',
optimizer=opt,
metrics=['accuracy'])
model.fit(X_train, y_train, batch_size=32, epochs=17)
score = model.evaluate(X_test, y_test, batch_size=32)
model.save('./vgg16_transfer.h5')
# Output of the Neural Network.
outputs = net
# Model Compilation
model2 = Model(inputs=inputs, outputs=outputs)
model2.compile(optimizer='rmsprop',
loss='categorical_crossentropy',
metrics=['accuracy'])
# Training
model2.fit(x=data.x_train, y=data.y_train, epochs=1, batch_size=128)
# Evaluation
result = model2.evaluate(x=data.x_test, y=data.y_test)
for name, value in zip(model2.metrics_names, result):
print(name, value)
print("{0}: {1:.2%}".format(model2.metrics_names[1], result[1]))
# Examples of Mis-Classified Images
y_pred = model2.predict(x=data.x_test)
cls_pred = np.argmax(y_pred, axis=1)
plot_example_errors(cls_pred)
# Save & Load Model
path_model = '../checkpoints'
if not os.path.exists(path_model):
os.makedirs(path_model)
"""
Messing around with the functional API in keras
"""
from tensorflow.python.keras import Input, layers
from tensorflow.python.keras.models import Model
import numpy as np
x_train = np.random.random((1000, 64))
y_train = np.random.random((1000, 10))
input_tensor = Input((64, ))
x = layers.Dense(32, activation='relu')(input_tensor)
x = layers.Dense(32, activation='relu')(x)
output_tensor = layers.Dense(10, activation='softmax')(x)
model = Model(input_tensor, output_tensor)
# model.summary()
model.compile(optimizer='rmsprop',
loss='categorical_crossentropy',
metrics=['accuracy'])
model.fit(x_train, y_train, epochs=5, batch_size=8)
score = model.evaluate(x_train, y_train)
# Find the following in your keras/tensorflow_backend.py file you'll add config.gpu_options.allow_growth= True in both places
#
# if _SESSION is None:
# if not os.environ.get('OMP_NUM_THREADS'):
# config = tf.ConfigProto(allow_soft_placement=True)
# config.gpu_options.allow_growth=True
# else:
# num_thread = int(os.environ.get('OMP_NUM_THREADS'))
# config = tf.ConfigProto(intra_op_parallelism_threads=num_thread,
# allow_soft_placement=True)
# config.gpu_options.allow_growth=True
# _SESSION = tf.Session(config=config)
# session = _SESSION
# In[ ]:
history = model.fit(
train_seq_mat,
train_y,
batch_size=128,
epochs=20,
validation_split=0.2,
callbacks=[EarlyStopping(monitor='val_loss', min_delta=0.0001)])
# In[22]:
test_loss, test_acc = model.evaluate(test_seq_mat, test_y)
print('Test Loss: {}'.format(test_loss))
print('Test Accuracy: {}'.format(test_acc))
metrics=['accuracy'])
cb = EarlyStopping(monitor='acc', min_delta=0.005, patience=10)
model.fit(images_train,
labels_train,
batch_size=32,
epochs=60,
verbose=1,
validation_split=0.1,
callbacks=[cb])
# model.fit(images_train, labels_train, batch_size=5, epochs=15, verbose=1, validation_split=0.1)
model.save('model.keras')
# Evaluación del modelo
result = model.evaluate(images_test, labels_test, verbose=0)
print('Testing set accuracy:', result[1])
# Imprimir perdida y precision
# for name, value in zip(model.metrics_names, result):
# print(name, value)
# #Imprimir solo precision en forma de porcentaje(%)
# print("{0}: {1:.2%}".format(model.metrics_names[1], result[1]))
#########################################
############PREDICCION###################
#########################################
imgs = images_test
#probabilities for each label
my_list = []
for i in y_prob:
my_list.append("-")
for (label, p) in zip(mlb.classes_, i):
my_list.append("{}: {:.2f}%".format(label, p * 100))
#save txt file
with open("my_list_final", "w") as output:
output.write(str(my_list))
#Model Accuracy
scores = model2.evaluate(testX, testY, verbose=0)
print("Accuracy: %.2f%%" % (scores[1]*100))
#plot analysis
def plot_analysis(model,data,labels):
output = model.predict(data)
titles= mlb.inverse_transform(labels)
it = 1
if isinstance(data,list):
it = 2
shape = output[0].shape[0]
else:
shape = output.shape[0]
class Neural:
def __init__(self, size_window_left, size_window_right, number_samples, threshold, number_epochs,
learning_patterns_per_id, optimizer_function, loss_function, dense_layers,
output_evolution_error_figures):
self.size_windows_left = size_window_left
self.size_window_right = size_window_right
self.number_samples = number_samples
self.threshold = threshold
self.number_epochs = number_epochs
self.learning_patterns_per_id = learning_patterns_per_id
self.optimizer_function = optimizer_function
self.loss_function = loss_function
self.output_evolution_error_figures = output_evolution_error_figures
self.neural_network = None
self.dense_layers = dense_layers
def create_neural_network(self):
input_size = Input(shape=(self.size_windows_left + self.size_window_right + 1,))
# Please do not change this layer
self.neural_network = Dense(20, )(input_size)
self.neural_network = Dropout(0.2)(self.neural_network)
for i in range(self.dense_layers - 1):
self.neural_network = Dense(20)(self.neural_network)
self.neural_network = Dropout(0.5)(self.neural_network)
# Please do not change this layer
self.neural_network = Dense(1, activation='sigmoid')(self.neural_network)
self.neural_network = Model(input_size, self.neural_network)
self.neural_network.summary()
self.neural_network.compile(optimizer=self.optimizer_function, loss=self.loss_function,
metrics=['mean_squared_error'])
def fit(self, x, y, x_validation, y_validation):
first_test_training = self.neural_network.evaluate(x, y)
first_test_validation = self.neural_network.evaluate(x_validation, y_validation)
history = self.neural_network.fit(x, y, epochs=self.number_epochs,
validation_data=(x_validation, y_validation), )
self.plotter_error_evaluate(history.history['mean_squared_error'], history.history['val_mean_squared_error'],
first_test_training, first_test_validation)
def plotter_error_evaluate(self, mean_square_error_training, mean_square_error_evaluate, first_error_training,
first_error_evaluate):
mean_square_error_training.insert(0, first_error_training[1])
mean_square_error_evaluate.insert(0, first_error_evaluate[1])
matplotlib.pyplot.plot(mean_square_error_training, 'b', marker='^', label="Treinamento")
matplotlib.pyplot.plot(mean_square_error_evaluate, 'g', marker='o', label="Validação")
matplotlib.pyplot.legend(loc="upper right")
matplotlib.pyplot.xlabel('Quantidade de épocas')
matplotlib.pyplot.ylabel('Erro Médio')
matplotlib.pyplot.savefig(
self.output_evolution_error_figures + "fig_Mean_square_error_" + str(datetime.datetime.now()) + ".pdf")
def predict_values(self, x):
return self.neural_network.predict(x)
def save_models(self, model_architecture_file, model_weights_file):
model_json = self.neural_network.to_json()
with open(model_architecture_file, "w") as json_file:
json_file.write(model_json)
self.neural_network.save_weights(model_weights_file)
print("Saved model {} {}".format(model_architecture_file, model_weights_file))
def load_models(self, model_architecture_file, model_weights_file):
json_file = open(model_architecture_file, 'r')
loaded_model_json = json_file.read()
json_file.close()
self.neural_network = model_from_json(loaded_model_json)
self.neural_network.load_weights(model_weights_file)
print("Loaded model {} {}".format(model_architecture_file, model_weights_file))
@staticmethod
def get_samples_vectorized(sample):
sample_vectorized = []
for i in range(len(sample)):
sample_vectorized.append(float(sample[i][2]))
return sample_vectorized, sample[5][2]
def predict(self, x):
x_axis = []
y_axis = []
results_predicted = []
for i in range(len(x)):
x_temp, y_temp = self.get_samples_vectorized(x[i])
x_axis.append(x_temp)
y_axis.append(y_temp)
predicted = self.neural_network.predict(x_axis)
for i in range(len(predicted)):
if predicted[i] > self.threshold or y_axis[i] > 0.8:
results_predicted.append(x[i][5])
return results_predicted
class SiameseModel:
def __init__(self, use_cudnn_lstm=True, plot_model_architecture=False):
n_hidden = 50
input_dim = 300
# unit_forget_bias: Boolean. If True, add 1 to the bias of the forget gate at initialization. Setting it to true will also force bias_initializer="zeros". This is recommended in Jozefowicz et al.
# he_normal: Gaussian initialization scaled by fan_in (He et al., 2014)
if use_cudnn_lstm:
# Use CuDNNLSTM instead of LSTM, because it is faster
lstm = layers.CuDNNLSTM(n_hidden,
unit_forget_bias=True,
kernel_initializer='he_normal',
kernel_regularizer='l2',
name='lstm_layer')
else:
lstm = layers.LSTM(n_hidden,
unit_forget_bias=True,
kernel_initializer='he_normal',
kernel_regularizer='l2',
name='lstm_layer')
# Building the left branch of the model: inputs are variable-length sequences of vectors of size 128.
left_input = Input(shape=(None, input_dim), name='input_1')
# left_masked_input = layers.Masking(mask_value=0)(left_input)
left_output = lstm(left_input)
# Building the right branch of the model: when you call an existing layer instance, you reuse its weights.
right_input = Input(shape=(None, input_dim), name='input_2')
# right_masked_input = layers.Masking(mask_value=0)(right_input)
right_output = lstm(right_input)
# Builds the classifier on top
l1_norm = lambda x: 1 - K.abs(x[0] - x[1])
merged = layers.Lambda(function=l1_norm,
output_shape=lambda x: x[0],
name='L1_distance')([left_output, right_output])
predictions = layers.Dense(1,
activation='tanh',
name='Similarity_layer')(merged) #sigmoid
# Instantiating and training the model: when you train such a model, the weights of the LSTM layer are updated based on both inputs.
self.model = Model([left_input, right_input], predictions)
self.__compile()
print(self.model.summary())
if plot_model_architecture:
from tensorflow.python.keras.utils import plot_model
plot_model(self.model, to_file='siamese_architecture.png')
def __compile(self):
optimizer = Adadelta(
) # gradient clipping is not there in Adadelta implementation in keras
# optimizer = 'adam'
self.model.compile(loss='mse',
optimizer=optimizer,
metrics=[pearson_correlation])
def fit(self,
left_data,
right_data,
targets,
validation_data,
epochs=5,
batch_size=128):
# The paper employ early stopping based on a validation, but they didn't mention parameters.
early_stopping_monitor = EarlyStopping(
monitor='val_pearson_correlation', mode='max', patience=20)
# callbacks = [early_stopping_monitor]
callbacks = []
history = self.model.fit(
[left_data, right_data],
targets,
validation_data=validation_data,
epochs=epochs,
batch_size=batch_size #)
,
callbacks=callbacks)
self.visualize_metric(history.history, 'loss')
self.visualize_metric(history.history, 'pearson_correlation')
self.load_activation_model()
def visualize_metric(self, history_dic, metric_name):
plt.plot(history_dic[metric_name])
legend = ['train']
if 'val_' + metric_name in history_dic:
plt.plot(history_dic['val_' + metric_name])
legend.append('test')
plt.title('model ' + metric_name)
plt.ylabel(metric_name)
plt.xlabel('epoch')
plt.legend(legend, loc='upper left')
plt.show()
def predict(self, left_data, right_data):
return self.model.predict([left_data, right_data])
def evaluate(self, left_data, right_data, targets, batch_size=128):
return self.model.evaluate([left_data, right_data],
targets,
batch_size=batch_size)
def load_activation_model(self):
self.activation_model = Model(
inputs=self.model.input[0],
outputs=self.model.get_layer('lstm_layer').output)
def visualize_activation(self, data):
activations = self.activation_model.predict(data)
plt.figure(figsize=(10, 100), dpi=80)
plt.imshow(activations, cmap='Blues')
plt.grid()
plt.xticks(ticks=range(0, 50))
plt.yticks(ticks=range(0, data.shape[0]))
plt.show()
def visualize_specific_activation(self, data, dimension_idx):
activations = self.activation_model.predict(data)
if dimension_idx >= activations.shape[1]:
raise ValueError('dimension_idx must be less than %d' %
activations.shape[1])
fig = plt.figure(figsize=(10, 1), dpi=80)
ax = fig.add_subplot(111)
plt.title('dimension_idx = %d' % dimension_idx)
weights = activations[:, dimension_idx]
plt.yticks(ticks=[0, 1])
plt.plot(weights, np.zeros_like(weights), 'o')
for i, txt in enumerate(weights):
ax.annotate((i + 1), (weights[i], 0))
plt.show()
def save(self, model_folder='./model/'):
# serialize model to JSON
model_json = self.model.to_json()
with open(model_folder + 'model.json', 'w') as json_file:
json_file.write(model_json)
# serialize weights to HDF5
self.model.save_weights(model_folder + 'model.h5')
print('Saved model to disk')
def save_pretrained_weights(
self, model_wieghts_path='./model/pretrained_weights.h5'):
self.model.save_weights(model_wieghts_path)
print('Saved pretrained weights to disk')
def load(self, model_folder='./model/'):
# load json and create model
json_file = open(model_folder + 'model.json', 'r')
loaded_model_json = json_file.read()
json_file.close()
loaded_model = model_from_json(loaded_model_json)
# load weights into new model
loaded_model.load_weights(model_folder + 'model.h5')
print('Loaded model from disk')
self.model = loaded_model
# loaded model should be compiled
self.__compile()
self.load_activation_model()
def load_pretrained_weights(
self, model_wieghts_path='./model/pretrained_weights.h5'):
# load weights into new model
self.model.load_weights(model_wieghts_path)
print('Loaded pretrained weights from disk')
self.__compile()
history = classifier.fit(
X_train,
y_train,
epochs=30,
batch_size=batch_size,
validation_data=(X_val, y_val)
)
# ## Результаты
# In[10]:
print("accuracy: {:.2f}%".format(classifier.evaluate(X_test, y_test, batch_size=batch_size)[1] * 100))
# In[11]:
fig, axis = plt.subplots(2, 2, sharey=True, sharex=True, figsize=(15, 10))
axis[0, 0].plot(history.history['loss'])
axis[0, 0].set_title('loss')
axis[0, 1].plot(history.history['val_loss'])
axis[0, 1].set_title('validation loss')
axis[1, 0].plot(history.history['acc'])
axis[1, 0].set_title('accuracy')
inp = Input(shape=img_shape_full)
model = InceptionResNetV2(weights='imagenet',
include_top=False,
input_shape=img_shape_full,
input_tensor=inp)
# Anadir capa para nuestro numero de clases
x = model.output
x = GlobalAveragePooling2D()(x)
predictions = Dense(num_classes, activation='softmax')(x)
model = Model(inputs=model.input, outputs=predictions)
# TOTAL CAPAS = 782
LAYERS_TO_FREEZE = 700
for layer in model.layers[:LAYERS_TO_FREEZE]:
layer.trainable = False
model.compile(optimizer="adam",
loss='categorical_crossentropy',
metrics=['accuracy'])
model.fit(images_train,
labels_train,
batch_size=128,
epochs=1,
verbose=1,
validation_split=0.1)
score = model.evaluate(images_test, labels_test, verbose=0)
print('Testing set accuracy:', score[1])
# tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir=log_dir, histogram_freq=1, write_images=False)
history = model.fit_generator(three_inp,
steps_per_epoch=len(X_train1) / 50,
epochs=650,
verbose=1,
validation_data=([
X_val[:, :, :, [0]], X_val[:, :, :, [1]],
X_val[:, :, :, [2]]
], y_val))
model.save(path + '\LM_model.hdf5')
print('----- Testing Model -------')
model.evaluate(
[X_test[:, :, :, [0]], X_test[:, :, :, [1]], X_test[:, :, :, [2]]], y_test)
Y_pred = model.predict(
[X_test[:, :, :, [0]], X_test[:, :, :, [1]], X_test[:, :, :, [2]]])
y_pred = np.argmax(Y_pred, axis=1)
y_test_tr = np.argmax(y_test, axis=1)
metricas(y_pred, y_test_tr)
plt.show()
print('ROC_AUC Score', roc_auc_score(y_test.ravel(), Y_pred.ravel()))
fpr_keras, tpr_keras, thresholds_keras = roc_curve(y_test.ravel(),
Y_pred.ravel())
def train(TRAIN_TSV, TEST_TSV, TRAIN_EMB_PIDS, TRAIN_EMB_DIR, TEST_EMB_PIDS,
TEST_EMB_DIR, EMB_PREFIX, EMB_BATCH_SIZE, epochs, model_out_path,
plot_path, parapair_score_path):
# Load training set
train_dat = []
with open(TRAIN_TSV, 'r') as tr:
first = True
for l in tr:
if first:
first = False
continue
train_dat.append(
[int(l.split('\t')[0]),
l.split('\t')[1],
l.split('\t')[2]])
test_dat = []
with open(TEST_TSV, 'r') as tt:
first = True
for l in tt:
if first:
first = False
continue
test_dat.append(
[int(l.split('\t')[0]),
l.split('\t')[1],
l.split('\t')[2]])
# Make word2vec embeddings
embedding_dim = 768
max_seq_length = 20
use_w2v = True
train_df, train_embeddings, train_pairs = make_psg_pair_embeddings(
train_dat, TRAIN_EMB_PIDS, TRAIN_EMB_DIR, EMB_PREFIX, EMB_BATCH_SIZE)
test_df, test_embeddings, test_pairs = make_psg_pair_embeddings(
test_dat, TEST_EMB_PIDS, TEST_EMB_DIR, EMB_PREFIX, EMB_BATCH_SIZE,
train_embeddings.shape[0])
comb_train_test_embeddings = np.vstack((train_embeddings, test_embeddings))
# Split to train validation
validation_size = int(len(train_df) * 0.1)
training_size = len(train_df) - validation_size
X = train_df[['p1', 'p2']]
Y = train_df['similar']
X_test = test_df[['p1', 'p2']]
Y_test = test_df['similar']
X_train, X_validation, Y_train, Y_validation = train_test_split(
X, Y, test_size=validation_size)
X_train = split_and_zero_padding(X_train, max_seq_length)
X_validation = split_and_zero_padding(X_validation, max_seq_length)
X_test = split_and_zero_padding(X_test, max_seq_length)
# Convert labels to their numpy representations
Y_train = Y_train.values
Y_validation = Y_validation.values
Y_test = Y_test.values
# Make sure everything is ok
assert X_train['left'].shape == X_train['right'].shape
assert len(X_train['left']) == len(Y_train)
# --
# Model variables
gpus = 2
batch_size = 1024 * gpus
n_hidden = 64
# Define the shared model
x = Sequential()
x.add(
Embedding(len(comb_train_test_embeddings),
embedding_dim,
weights=[comb_train_test_embeddings],
input_shape=(max_seq_length, ),
trainable=False))
x.add(LSTM(n_hidden))
shared_model = x
# The visible layer
left_input = Input(shape=(max_seq_length, ), dtype='int32')
right_input = Input(shape=(max_seq_length, ), dtype='int32')
# Pack it all up into a Manhattan Distance model
malstm_distance = ManDist()(
[shared_model(left_input),
shared_model(right_input)])
model = Model(inputs=[left_input, right_input], outputs=[malstm_distance])
#if gpus >= 2:
# `multi_gpu_model()` is a so quite buggy. it breaks the saved model.
#model = tf.keras_code.utils.multi_gpu_model(model, gpus=gpus)
model.compile(loss='mean_squared_error',
optimizer=tf.keras.optimizers.Adam(),
metrics=['accuracy'])
model.summary()
shared_model.summary()
# Start trainings
training_start_time = time()
malstm_trained = model.fit(
[X_train['left'], X_train['right']],
Y_train,
batch_size=batch_size,
epochs=epochs,
validation_data=([X_validation['left'],
X_validation['right']], Y_validation))
training_end_time = time()
print("Training time finished.\n%d epochs in %12.2f" %
(epochs, training_end_time - training_start_time))
# model.save('./data/SiameseLSTM.h5')
model.save(model_out_path)
# Plot accuracy
plt.subplot(211)
if 'accuracy' in malstm_trained.history.keys():
plt.plot(malstm_trained.history['accuracy'])
plt.plot(malstm_trained.history['val_accuracy'])
else:
plt.plot(malstm_trained.history['acc'])
plt.plot(malstm_trained.history['val_acc'])
plt.title('Model Accuracy')
plt.ylabel('Accuracy')
plt.xlabel('Epoch')
plt.legend(['Train', 'Validation'], loc='upper left')
# Plot loss
plt.subplot(212)
plt.plot(malstm_trained.history['loss'])
plt.plot(malstm_trained.history['val_loss'])
plt.title('Model Loss')
plt.ylabel('Loss')
plt.xlabel('Epoch')
plt.legend(['Train', 'Validation'], loc='upper right')
plt.tight_layout(h_pad=1.0)
# plt.savefig('./data/history-graph.png')
plt.savefig(plot_path)
if 'accuracy' in malstm_trained.history.keys():
print(
str(malstm_trained.history['val_accuracy'][-1])[:6] + "(max: " +
str(max(malstm_trained.history['val_accuracy']))[:6] + ")")
else:
print(
str(malstm_trained.history['val_acc'][-1])[:6] + "(max: " +
str(max(malstm_trained.history['val_acc']))[:6] + ")")
model.evaluate([X_test['left'], X_test['right']], Y_test)
yhat = model.predict([X_test['left'], X_test['right']])
test_pair_scores = {}
for i in range(len(yhat)):
test_pair_scores[test_pairs[i]] = float(yhat[i])
with open(parapair_score_path, 'w') as pps:
json.dump(test_pair_scores, pps)
print('BY1test AUC: ' + str(roc_auc_score(Y_test, yhat)))
print("Done.")
model.compile(optimizer=adam,
loss="categorical_crossentropy",
metrics=['accuracy'])
model.fit(x=X_train,
y=y_train,
epochs=30,
batch_size=8,
verbose=2,
validation_data=(X_test, y_test),
callbacks=[
early_stopper, lr_reducer, tensorboard,
developmentSetEval(y_test_saved)
])
score = model.evaluate(x=X_train, y=y_train, verbose=0)
print('Train loss:', score[0])
print('Train accuracy:', score[1])
score = model.evaluate(x=X_test, y=y_test, verbose=0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])
##validation data
print("Validation of final model")
score = model.evaluate(x=X_eval, y=y_eval, verbose=0)
print('Eval loss:', score[0])
print('Eval accuracy:', score[1])
def build_model_supervised(model_info: dict, username: str, model_path: str):
print(model_info)
user = User.objects.get(username=username)
prog = Progress.objects.get(user=user)
prog.task_id = build_model_supervised.request.id
prog.save()
history = History(timestamp=int(time.time()),
user=user,
path="",
steps_info={},
dataset=model_info["dataset"])
x_train, x_test, y_train, y_test, input_shape = get_training_data(
model_info["dataset"])
last_layer = Input(shape=input_shape)
first_layer = last_layer
for layer in model_info["layers"]:
if layer["name"] == "Dense":
last_layer = Dense(layer["units"], layer["activation"])(last_layer)
elif layer["name"] == "Dropout":
last_layer = Dropout(layer["rate"])(last_layer)
elif layer["name"] == "Conv2D":
last_layer = Conv2D(layer["units"],
(layer["kernel"]["x"], layer["kernel"]["y"]),
activation=layer["activation"])(last_layer)
elif layer["name"] == "MaxPooling2D":
last_layer = MaxPooling2D(
(layer["kernel"]["x"], layer["kernel"]["y"]),
padding=layer["padding"])(last_layer)
elif layer["name"] == "Flatten":
last_layer = Flatten()(last_layer)
model = Model(inputs=first_layer, outputs=last_layer)
model.compile(optimizer=model_info["optimizer"],
loss=model_info["loss"],
metrics=["accuracy"])
prog.running = True
prog.save()
callback = LossHistory(prog)
try:
model.fit(x_train,
y_train,
batch_size=int(model_info["batchSize"]),
epochs=int(model_info["epochs"]),
callbacks=[callback],
verbose=2,
validation_split=1.0 - model_info["trainPercentage"])
except KeyboardInterrupt:
history.steps_info = {"message": "Task cancelled by admin"}
history.save()
prog.delete()
return
except InvalidArgumentError:
history.steps_info = {
"message": "Dimensions error, probably last layer"
}
history.save()
prog.delete()
return
except:
history.steps_info = {"message": "There was an error whilst training"}
history.save()
prog.delete()
return
accuracy = model.evaluate(x_test, y_test)
path = os.path.join(model_path, "{}_{}.h5".format(username,
int(time.time())))
model.save(path)
# saved_model_path = save_keras_model(model, model_path, as_text=True)
prog.delete()
history.path = path # saved_model_path.decode()
history.accuracy = accuracy[1] if not math.isnan(accuracy[1]) else 0.0
history.loss = accuracy[0] if not math.isnan(accuracy[0]) else 0.0
history.steps_info = callback.losses
history.save()
inputs = Input((784, ))
net = Dense(500, activation="relu")(inputs)
net = Dense(500, activation="relu")(net)
print(net.shape[-1])
# net = Dense(10, activation="softmax")(net)
return Model(inputs=inputs, outputs=net)
from keras.layers import TimeDistributed
base = get_model()
inp = Input((784, ))
net = base(inp)
net = Dense(10, activation="softmax")(net)
model = Model(inputs=inp, outputs=net)
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
print(x_train.shape, y_train.shape, x_test.shape, y_test.shape)
history = model.fit(x_train,
y_train,
batch_size=200,
epochs=20,
verbose=1,
validation_data=(x_test, y_test))
score = model.evaluate(x_test, x_test, verbose=0)
# 输出训练好的模型在测试集上的表现
print('Test score:', score[0])
print('Test accuracy:', score[1])
# Start trainings
training_start_time = time()
malstm_trained = model.fit(
[X_train['left'], X_train['right']],
Y_train,
batch_size=batch_size,
epochs=n_epoch,
validation_data=([X_validation['left'],
X_validation['right']], Y_validation))
# prediction = model.predict([X_train['left'], X_train['right']])
# show_metrics(Y_train, prediction)
print(
"loss,accuracy",
model.evaluate([X_validation['left'], X_validation['right']],
batch_size=512,
y=Y_validation))
prediction = model.predict([X_validation['left'], X_validation['right']])
show_metrics(Y_validation, prediction)
training_end_time = time()
print("Training time finished.\n%d epochs in %12.2f" %
(n_epoch, training_end_time - training_start_time))
model.save('./models/SiameseLSTM.h5')
# Plot accuracy
plt.subplot(211)
plt.plot(malstm_trained.history['acc'])
plt.plot(malstm_trained.history['val_acc'])
plt.title('Model Accuracy')
from tensorflow.python.keras.callbacks import EarlyStopping, ModelCheckpoint, CSVLogger
log_folder = 'resnet-log'
NUM_EPOCHS = 6
#STEP_SIZE_TRAIN=train_generator.n//train_generator.batch_size
cb_checkpointer = ModelCheckpoint(filepath=log_folder + '/best.hdf5',
monitor='val_binary_accuracy',
save_best_only=True,
mode='auto') #
csv_record_train = CSVLogger(log_folder + '/training.log')
history = model.fit(train_flow,
epochs=NUM_EPOCHS,
validation_data=test_flow,
callbacks=[cb_checkpointer, csv_record_train])
################# PREDICTIONS #################
val_summary = model.evaluate(test_flow)
preds = model.predict(test_flow)
############## CSV ##############
def export_csv(pred, filenames, log_folder, metrics_names, val_summary):
pred_class = np.where(pred < 0.5, 0, 1)
filenames = np.asarray(filenames)
filenames = filenames.reshape((len(filenames), 1))
conc = np.concatenate((filenames, pred, pred_class), axis=1)
with open(log_folder + '/pred.csv', 'a') as csvfile:
csvfile.write("\nMETRICS\n%s:%s " % (metrics_names[0], val_summary[0]))
csvfile.write("%s:%s\n" % (metrics_names[1], val_summary[1]))
csvfile.write("FILENAMES\n")
np.savetxt(csvfile, conc, delimiter=",", fmt='%s')
def trainModel():
#########################################
############MODELO FUNCIONAL#############
#########################################
#########################################
############CONSTRUCCION MODELO##########
#########################################
# Crea una capa de entrada que es similar a un feed_dict en TensorFlow.
# Tenga en cuenta que la forma de entrada debe ser una tupla que contenga el tamaño de la imagen.
inputs = Input(shape=(img_size_flat, ))
# Variable utilizada para construir la red neuronal
net = inputs
# La entrada es una imagen como una matriz aplanada con 784 elementos.
# Pero las capas convolucionales esperan imágenes con forma (28, 28, 1)
net = Reshape(img_shape_full)(net)
# Primera capa convolucional con ReLU-activation y max-pooling.
net = Conv2D(kernel_size=5,
strides=1,
filters=16,
padding='same',
activation='relu',
name='layer_conv1')(net)
net = MaxPooling2D(pool_size=2, strides=2)(net)
# Segunda capa convolucional con ReLU-activation y max-pooling
net = Conv2D(kernel_size=5,
strides=1,
filters=36,
padding='same',
activation='relu',
name='layer_conv2')(net)
net = MaxPooling2D(pool_size=2, strides=2)(net)
# Aplanar la salida de la capa conv de 4-dim a 2-dim.
net = Flatten()(net)
# Primera capa completamente conectada con ReLU-activation.
net = Dense(128, activation='relu')(net)
# Última capa totalmente conectada con activación de softmax
# por lo que se puede utilizar para la clasificación.
net = Dense(num_classes, activation='softmax')(net)
# Salida de la red neuronal
outputs = net
#########################################
############COMPILACION MODELO###########
#########################################
model = Model(inputs=inputs, outputs=outputs)
# optimizer = Adam(lr=1e-6)
optimizer = RMSprop(lr=1e-6)
model.compile(optimizer=optimizer,
loss='categorical_crossentropy',
metrics=['accuracy'])
cb = EarlyStopping(monitor='acc', min_delta=0.005, patience=0)
model.fit(images_train,
labels_train,
batch_size=5,
epochs=30,
verbose=1,
validation_split=0.1,
callbacks=[cb])
# model.fit(images_train, labels_train, batch_size=5, epochs=15, verbose=1, validation_split=0.1)
model.save('classifier/model.keras')
# Evaluación del modelo
result = model.evaluate(images_test, labels_test, verbose=0)
print('Testing set accuracy:', result[1])
out = add([res, out]) # res & out must be same shape
return out
images = Input(shape=x_train.shape[1:])
net = Conv2D(filters=32, kernel_size=[3, 3], strides=[1, 1],
padding="same")(images)
net = Unit(net, 64, pool=True)
net = Unit(net, 128, pool=True)
net = Flatten()(net)
net = Dense(units=256, activation="relu")(net)
net = Dense(units=10, activation="softmax")(net)
model = Model(inputs=images, outputs=net)
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
model.summary()
model.fit(x_train,
y_train,
batch_size=32,
validation_data=(x_test, y_test),
epochs=5)
scores = model.evaluate(x_test, y_test, verbose=1)
print('Test accuracy:', scores[1]) # 0.6964
'''
net_final.fit_generator(train_batches,
steps_per_epoch = np.ceil(train_pic.shape[0]) // BATCH_SIZE,
epochs = NUM_EPOCHS,
verbose = 1
)
'''
net_final.fit(train_pic,
train_label,
batch_size=BATCH_SIZE,
epochs=NUM_EPOCHS,
verbose=1)
# 儲存訓練好的模型
net_final.save(WEIGHTS_FINAL)
net_final.evaluate(train_pic, train_label)
test_label = net_final.predict(np.array(test_pic))
#print(test_label)
t_label = []
for label in test_label:
m = label.argmax(axis=0)
t_label.append(m)
print(t_label)
# Record to submission.csv
submission = pd.read_csv('data/sub.csv')
print(submission.head())
submission['label'] = t_label #.flatten().astype(int)
submission.to_csv('submission.csv', index=False)
# net = Flatten()(merged)
# net = Dense(128, activation='relu')(net)
# net = Dense(num_classes, activation='softmax')(net)
#
# outputs = net
# Model Compilation
model = Model(inputs=inputs, outputs=outputs)
model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['accuracy'])
# Training
model.fit(x=data.train.images, y=data.train.labels, epochs=1, batch_size=128)
# Evaluation
result = model.evaluate(x=data.test.images, y=data.test.labels)
for name, value in zip(model.metrics_names, result):
print(name, value)
y_pred = model.predict(x=data.test.images)
print(y_pred)
cls_pred = np.argmax(y_pred, axis=1)
def plot_example_errors(cls_pred):
incorrect = (cls_pred != data.test.cls)
images = data.test.images[incorrect]
cls_pred = cls_pred[incorrect]
cls_true = data.test.cls[incorrect]
outputs = net
model = Model(inputs=inputs, outputs=outputs)
# Train Model
model.summary()
model.compile(optimizer='Adam',
loss='binary_crossentropy',
metrics=['accuracy'])
model.fit(x_train_pad,
y_train,
validation_split=0.1,
epochs=EPOCHS,
batch_size=BATCH_SIZE,
shuffle=True,
callbacks=[tb])
# Test Model
result = model.evaluate(x_test_pad, y_test)
print('Accuracy: {:.2%}'.format(result[1]))
y_pred = model.predict(x=x_test_pad)
cls_pred = np.argmax(y_pred, axis=1)
cls_true = np.argmax(y_test, axis=1)
predictions_human_readable = np.column_stack(
(np.array(x_test_seg), cls_pred, cls_true))
out_path = os.path.join(out_dir, "..", "prediction.csv")
print("Saving evaluation to {0}".format(out_path))
with open(out_path, 'w') as f:
csv.writer(f).writerows(predictions_human_readable)
class ConvMnist:
def __init__(self, filename=None):
'''
学習済みモデルファイルをロードする (optional)
'''
self.model = None
if filename is not None:
print('load model: ', filename)
self.model = load_model(filename)
self.model.summary()
def train(self):
'''
学習する
'''
# MNISTの学習用データ、テストデータをロードする
(x_train_org, y_train), (x_test_org, y_test) = mnist.load_data()
# 学習データの前処理
# X: 6000x28x28x1のTensorに変換し、値を0～1.0に正規化
# Y: one-hot化(6000x1 -> 6000x10)
x_train = np.empty((x_train_org.shape[0], x_train_org.shape[1],
x_train_org.shape[2], 3))
x_train[:, :, :, 0] = x_train_org
x_train[:, :, :, 1] = x_train_org
x_train[:, :, :, 2] = x_train_org
x_test = np.empty(
(x_test_org.shape[0], x_test_org.shape[1], x_test_org.shape[2], 3))
x_test[:, :, :, 0] = x_test_org
x_test[:, :, :, 1] = x_test_org
x_test[:, :, :, 2] = x_test_org
x_train = x_train / 255.
x_test = x_test / 255.
y_train = to_categorical(y_train, 10)
y_test = to_categorical(y_test, 10)
# 学習状態は悪用のTensorBoard設定
# tsb = TensorBoard(log_dir='./logs')
# Convolutionモデルの作成
input = Input(shape=(28, 28, 3))
conv1 = Conv2D(filters=8,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
activation='relu')(input)
pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)
conv2 = Conv2D(filters=4,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
activation='relu')(pool1)
dropout1 = Dropout(0.2)(conv2)
flatten1 = Flatten()(dropout1)
output = Dense(units=10, activation='softmax')(flatten1)
self.model = Model(inputs=[input], outputs=[output])
self.model.summary()
self.model.compile(optimizer='adam',
loss='categorical_crossentropy',
metrics=['accuracy'])
# Convolutionモデルの学習
self.model.fit(
x_train,
y_train,
batch_size=128,
epochs=10,
validation_split=0.2,
# callbacks=[tsb],
)
# 学習したモデルを使用して、テスト用データで評価する
score = self.model.evaluate(x_test, y_test, verbose=0)
print("test data score: ", score)
def save_trained_model(self, filename):
'''
学習済みモデルをファイル(h5)に保存する
'''
self.model.save(filename)
def predict(self, input_image):
'''
1つのカラー入力画像(28x28のndarray)に対して、数字(0～9)を判定する
ret: result, score
'''
if input_image.shape != (28, 28, 3):
return -1, -1
input_image = input_image.reshape(1, input_image.shape[0],
input_image.shape[1], 3)
input_image = input_image / 255.
probs = self.model.predict(input_image)
result = np.argmax(probs[0])
return result, probs[0][result]
class SVDppModel:
def __init__(self, user_ids=None, item_ids=None, rating_matrix=None, embedding_dim=None, mu=None):
"""
:param user_ids: user ids
:param item_ids: item ids
:param embedding_dim: embedding dimension
:param mu: average rate of training data
"""
if user_ids is not None:
self.user_num = len(user_ids)
if item_ids is not None:
self.item_num = len(item_ids)
self.rating_matrix = rating_matrix
self.embedding_dim = embedding_dim
self._sess = None
self._trainable_weights = None
self._aggregate_weights = None
self.user_ids = user_ids
self.item_ids = item_ids
self.mu = mu
def _build(self, lambda_u=0.0001, lambda_v=0.0001, optimizer='rmsprop',
loss='mse', metrics='mse', initializer='uniform'):
# init session on first time ref
sess = self.session
# user embedding
user_InputLayer = Input(shape=(1,), dtype='int32', name='user_input')
user_EmbeddingLayer = Embedding(input_dim=self.user_num,
output_dim=self.embedding_dim,
input_length=1,
name='user_embedding',
embeddings_regularizer=l2(lambda_u),
embeddings_initializer=initializer)(user_InputLayer)
user_EmbeddingLayer = Flatten(name='user_flatten')(user_EmbeddingLayer)
# implicit feedback
feedback_InputLayer = Input(shape=(None,), dtype='int32', name='implicit_feedback')
feedback_EmbeddingLayer = Embedding(input_dim=self.item_num + 1,
output_dim=self.embedding_dim,
name='implicit_feedback_embedding',
embeddings_regularizer=l2(lambda_v),
embeddings_initializer=initializer,
mask_zero=True)(feedback_InputLayer)
feedback_EmbeddingLayer = MeanPoolingLayer()(feedback_EmbeddingLayer)
user_EmbeddingLayer = Add()([user_EmbeddingLayer, feedback_EmbeddingLayer])
# user bias
user_BiasLayer = Embedding(input_dim=self.user_num, output_dim=1, input_length=1,
name='user_bias', embeddings_regularizer=l2(lambda_u),
embeddings_initializer=Zeros())(user_InputLayer)
user_BiasLayer = Flatten()(user_BiasLayer)
# item embedding
item_InputLayer = Input(shape=(1,), dtype='int32', name='item_input')
item_EmbeddingLayer = Embedding(input_dim=self.item_num, output_dim=self.embedding_dim, input_length=1,
name='item_embedding', embeddings_regularizer=l2(lambda_v),
embeddings_initializer=RandomNormal(mean=0, stddev=1))(item_InputLayer)
item_EmbeddingLayer = Flatten(name='item_flatten')(item_EmbeddingLayer)
# item bias
item_BiasLayer = Embedding(input_dim=self.item_num, output_dim=1, input_length=1,
name='item_bias', embeddings_regularizer=l2(lambda_v),
embeddings_initializer=Zeros())(item_InputLayer)
item_BiasLayer = Flatten()(item_BiasLayer)
# rating prediction
dotLayer = Dot(axes=-1, name='dot_layer')([user_EmbeddingLayer, item_EmbeddingLayer])
# add mu, user bias and item bias
dotLayer = ConstantLayer(mu=self.mu)(dotLayer)
dotLayer = Add()([dotLayer, user_BiasLayer])
dotLayer = Add()([dotLayer, item_BiasLayer])
# create model
self._model = Model(inputs=[user_InputLayer, item_InputLayer, feedback_InputLayer], outputs=[dotLayer])
# compile model
optimizer_instance = getattr(tf.keras.optimizers, optimizer.optimizer)(**optimizer.kwargs)
losses = getattr(tf.keras.losses, loss)
self._model.compile(optimizer=optimizer_instance,
loss=losses, metrics=metrics)
# pick user_embedding and user_bias for aggregating
self._trainable_weights = {v.name.split("/")[0]: v for v in self._model.trainable_weights}
LOGGER.debug(f"trainable weights {self._trainable_weights}")
self._aggregate_weights = {"user_embedding": self._trainable_weights["user_embedding"],
"user_bias": self._trainable_weights["user_bias"]}
def train(self, data: tf.keras.utils.Sequence, **kwargs):
epochs = 1
left_kwargs = copy.deepcopy(kwargs)
if "aggregate_every_n_epoch" in kwargs:
epochs = kwargs["aggregate_every_n_epoch"]
del left_kwargs["aggregate_every_n_epoch"]
self._model.fit(x=data, epochs=epochs, verbose=1, shuffle=True, **left_kwargs)
return epochs * len(data)
def _set_model(self, _model):
self._model = _model
@classmethod
def build_model(cls, user_ids, item_ids, rating_matrix, embedding_dim, loss, optimizer, metrics, mu):
model = cls(user_ids, item_ids, rating_matrix, embedding_dim, mu)
model._build(loss=loss, optimizer=optimizer, metrics=metrics)
return model
@classmethod
def restore_model(cls, model_bytes): # todo: restore optimizer to support incremental learning
with tempfile.TemporaryDirectory() as tmp_path:
with io.BytesIO(model_bytes) as bytes_io:
with zipfile.ZipFile(bytes_io, 'r', zipfile.ZIP_DEFLATED) as f:
f.extractall(tmp_path)
# try:
# keras_model = tf.keras.models.load_model(filepath=tmp_path,
# custom_objects={'ConstantLayer': ConstantLayer,
# 'MeanPoolingLayer': MeanPoolingLayer})
# except IOError:
# import warnings
# warnings.warn('loading the model as SavedModel is still in experimental stages. '
# 'trying tf.keras.experimental.load_from_saved_model...')
keras_model = \
tf.keras.experimental.load_from_saved_model(saved_model_path=tmp_path,
custom_objects={'ConstantLayer': ConstantLayer,
'MeanPoolingLayer': MeanPoolingLayer})
model = cls()
model._set_model(keras_model)
return model
def export_model(self):
with tempfile.TemporaryDirectory() as tmp_path:
# try:
# # LOGGER.info("Model saved with model.save method.")
# tf.keras.models.save_model(self._model, filepath=tmp_path, save_format="tf")
# except NotImplementedError:
# import warnings
# warnings.warn('Saving the model as SavedModel is still in experimental stages. '
# 'trying tf.keras.experimental.export_saved_model...')
tf.keras.experimental.export_saved_model(self._model, saved_model_path=tmp_path)
model_bytes = zip_dir_as_bytes(tmp_path)
return model_bytes
def modify(self, func: typing.Callable[[Weights], Weights]) -> Weights:
weights = self.get_model_weights()
self.set_model_weights(func(weights))
return weights
@property
def session(self):
if self._sess is None:
sess = tf.Session()
# tf.get_default_graph()
set_session(sess)
self._sess = sess
return self._sess
def get_model_weights(self) -> OrderDictWeights:
return OrderDictWeights(self.session.run(self._aggregate_weights))
def set_model_weights(self, weights: Weights):
unboxed = weights.unboxed
self.session.run([tf.assign(v, unboxed[name]) for name, v in self._aggregate_weights.items()])
def evaluate(self, data: tf.keras.utils.Sequence):
names = self._model.metrics_names
values = self._model.evaluate(x=data, verbose=1)
if not isinstance(values, list):
values = [values]
return dict(zip(names, values))
def predict(self, data: tf.keras.utils.Sequence, **kwargs):
return self._model.predict(data)
def set_user_ids(self, user_ids):
self.user_ids = user_ids
def set_item_ids(self, item_ids):
self.item_ids = item_ids
def set_rating_matrix(self, rating_matrix):
self.rating_matrix = rating_matrix
class BaseModel(object):
"""Base Model Interface
Methods
----------
fit(train_data, valid_data, epohcs, batch_size, **kwargs)
predict(X)
evaluate(X, y)
Examples
----------
>>> model = Model("example", inference, "model.h5")
>>> model.fit([X_train, y_train], [X_val, y_val])
"""
def __init__(self, name, fn, model_path):
"""Constructor for BaseModel
Parameters
----------
name : str
Name of this model
fn : function
Inference function, y = fn(X)
model_path : str
Path to a model.h5
"""
X = Input(shape=[28, 28, 1])
y = fn(X)
self.model = Model(X, y, name=name)
self.model.compile("adam", "categorical_crossentropy", ["accuracy"])
self.model.summary()
self.path = model_path
self.name = name
##self.load()
def fit(self, train_data, valid_data, epochs=10, batchsize=128, **kwargs):
"""Training function
Evaluate at each epoch against validation data
Save the best model according to the validation loss
Parameters
----------
train_data : tuple, (X_train, y_train)
X_train.shape == (N, H, W, C)
y_train.shape == (N, N_classes)
valid_data : tuple
(X_val, y_val)
epochs : int
Number of epochs to train
batchsize : int
Minibatch size
**kwargs
Keywords arguments for `fit_generator`
"""
callback_best_only = ModelCheckpoint(self.path, save_best_only=True)
train_gen, val_gen = train_generator()
X_train, y_train = train_data
X_val, y_val = valid_data
N = X_train.shape[0]
print("[DEBUG] N -> {}", X_train.shape)
N_val = X_val.shape[0]
self.model.fit_generator(train_gen.flow(X_train, y_train, batchsize),
steps_per_epoch=N / batchsize,
validation_data=val_gen.flow(
X_val, y_val, batchsize),
validation_steps=N_val / batchsize,
epochs=epochs,
callbacks=[callback_best_only],
**kwargs)
def save(self):
"""Save weights
Should not be used manually
"""
self.model.save_weights(self.path)
def freeze(self, export_dir):
""" Save Freeze Model
"""
tf.saved_model.simple_save(
K.get_session(),
os.path.join(export_dir, str(int(time.time()))),
inputs={'inputs': self.model.input},
outputs={t.name: t
for t in self.model.outputs})
def load(self):
"""Load weights from self.path """
if os.path.isfile(self.path):
self.model.load_weights(self.path)
print("Model loaded")
else:
print("No model is found")
def predict(self, X):
"""Return probabilities for each classes
Parameters
----------
X : array-like (N, H, W, C)
Returns
----------
y : array-like (N, N_classes)
Probability array
"""
return self.model.predict(X)
def evaluate(self, X, y):
"""Return an accuracy
Parameters
----------
X : array-like (N, H, W, C)
y : array-like (N, N_classes)
Returns
----------
acc : float
Accuracy
"""
return self.model.evaluate(X, y)
class MFModel:
"""
Matrix Factorization Model Class.
"""
def __init__(self, user_ids=None, item_ids=None, embedding_dim=None):
if user_ids is not None:
self.user_num = len(user_ids)
if item_ids is not None:
self.item_num = len(item_ids)
self.embedding_dim = embedding_dim
self._sess = None
self._model = None
self._trainable_weights = None
self._aggregate_weights = None
self.user_ids = user_ids
self.item_ids = item_ids
def build(self,
lambda_u=0.0001,
lambda_v=0.0001,
optimizer='rmsprop',
loss='mse',
metrics='mse',
initializer='uniform'):
"""
Init session and create model architecture.
:param lambda_u: lambda value of l2 norm for user embeddings.
:param lambda_v: lambda value of l2 norm for item embeddings.
:param optimizer: optimizer type.
:param loss: loss type.
:param metrics: evaluation metrics.
:param initializer: initializer of embedding
:return:
"""
# init session on first time ref
sess = self.session
# user embedding
user_input_layer = Input(shape=(1, ), dtype='int32', name='user_input')
user_embedding_layer = Embedding(
input_dim=self.user_num,
output_dim=self.embedding_dim,
input_length=1,
name='user_embedding',
embeddings_regularizer=l2(lambda_u),
embeddings_initializer=initializer)(user_input_layer)
user_embedding_layer = Flatten(
name='user_flatten')(user_embedding_layer)
# item embedding
item_input_layer = Input(shape=(1, ), dtype='int32', name='item_input')
item_embedding_layer = Embedding(
input_dim=self.item_num,
output_dim=self.embedding_dim,
input_length=1,
name='item_embedding',
embeddings_regularizer=l2(lambda_v),
embeddings_initializer=initializer)(item_input_layer)
item_embedding_layer = Flatten(
name='item_flatten')(item_embedding_layer)
# rating prediction
dot_layer = Dot(axes=-1, name='dot_layer')(
[user_embedding_layer, item_embedding_layer])
self._model = Model(inputs=[user_input_layer, item_input_layer],
outputs=[dot_layer])
# compile model
optimizer_instance = getattr(tf.keras.optimizers,
optimizer.optimizer)(**optimizer.kwargs)
losses = getattr(tf.keras.losses, loss)
self._model.compile(optimizer=optimizer_instance,
loss=losses,
metrics=metrics)
# pick user_embedding for aggregating
self._trainable_weights = {
v.name.split("/")[0]: v
for v in self._model.trainable_weights
}
self._aggregate_weights = {
"user_embedding": self._trainable_weights["user_embedding"]
}
def train(self, data: tf.keras.utils.Sequence, **kwargs):
"""
Train model on input data.
:param data: input data.
:param kwargs: other params.
:return: Training steps.
"""
epochs = 1
left_kwargs = copy.deepcopy(kwargs)
if "aggregate_every_n_epoch" in kwargs:
epochs = kwargs["aggregate_every_n_epoch"]
del left_kwargs["aggregate_every_n_epoch"]
self._model.fit(x=data,
epochs=epochs,
verbose=1,
shuffle=True,
**left_kwargs)
return epochs * len(data)
def set_model(self, _model):
"""
Set _model as input model.
:param _model: input model.
:return:
"""
self._model = _model
@classmethod
def build_model(cls, user_ids, item_ids, embedding_dim, loss, optimizer,
metrics):
"""
Build and return model object.
:param user_ids: user ids.
:param item_ids: item ids.
:param embedding_dim: embedding dimension.
:param loss: loss type.
:param optimizer: optimizer type.
:param metrics: evaluation metrics.
:return: model object.
"""
model = cls(user_ids, item_ids, embedding_dim)
model.build(loss=loss, optimizer=optimizer, metrics=metrics)
return model
@classmethod
# todo: restore optimizer to support incremental learning
def restore_model(cls, model_bytes):
"""
Restore model from model bytes.
:param model_bytes: model bytes of saved model.
:return: restored model object.
"""
with tempfile.TemporaryDirectory() as tmp_path:
with io.BytesIO(model_bytes) as bytes_io:
with zipfile.ZipFile(bytes_io, 'r',
zipfile.ZIP_DEFLATED) as file:
file.extractall(tmp_path)
keras_model = tf.keras.experimental.load_from_saved_model(
saved_model_path=tmp_path)
model = cls()
model.set_model(keras_model)
return model
def export_model(self):
"""
Export model to bytes.
:return: bytes of saved model.
"""
with tempfile.TemporaryDirectory() as tmp_path:
tf.keras.experimental.export_saved_model(self._model,
saved_model_path=tmp_path)
model_bytes = zip_dir_as_bytes(tmp_path)
return model_bytes
def modify(self, func: typing.Callable[[Weights], Weights]) -> Weights:
"""
Apply func on model weights.
:param func: operator to apply.
:return: updated weights.
"""
weights = self.get_model_weights()
self.set_model_weights(func(weights))
return weights
@property
def session(self):
"""
If session not created, then init a tensorflow session and return.
:return: tensorflow session.
"""
if self._sess is None:
sess = tf.Session()
tf.get_default_graph()
set_session(sess)
self._sess = sess
return self._sess
def get_model_weights(self) -> OrderDictWeights:
"""
Return model's weights as OrderDictWeights.
:return: model's weights.
"""
return OrderDictWeights(self.session.run(self._aggregate_weights))
def set_model_weights(self, weights: Weights):
"""
Set model's weights with input weights.
:param weights: input weights.
:return: updated weights.
"""
unboxed = weights.unboxed
self.session.run([
tf.assign(v, unboxed[name])
for name, v in self._aggregate_weights.items()
])
def evaluate(self, data: tf.keras.utils.Sequence):
"""
Evaluate on input data and return evaluation results.
:param data: input data sequence.
:return: evaluation results.
"""
names = self._model.metrics_names
values = self._model.evaluate(x=data, verbose=1)
if not isinstance(values, list):
values = [values]
return dict(zip(names, values))
def predict(self, data: tf.keras.utils.Sequence):
"""
Predict on input data and return prediction results.
:param data: input data.
:return: prediction results.
"""
return self._model.predict(data)
def set_user_ids(self, user_ids):
"""
set user ids.
:param user_ids:
:return:
"""
self.user_ids = user_ids
def set_item_ids(self, item_ids):
"""
set item ids
:param item_ids:
:return:
"""
self.item_ids = item_ids
