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