def init_model_for_thread(example): import tensorflow as tf from tensorflow.contrib.keras import models # create tensorflow graph graph = tf.get_default_graph() with graph.as_default(): sess = tf.Session() #tf.contrib.keras.backend.get_session() sess.run(tf.global_variables_initializer()) NN_MODEL = models.load_model(NN_MODEL_FILE) # global variable with all the data to be shared model = {} model["NN_MODEL"] = NN_MODEL # dummy run to create graph x = tf.contrib.keras.preprocessing.sequence.pad_sequences( [example], maxlen=300, padding='post') x = x.reshape(x.shape + (1, )) y = NN_MODEL.predict(x) print('Testing model inference: {}'.format(y)) # PROBLEM: I want, but cannot lock graph, as child process # wants to run its own tf.global_variables_initializer() graph.finalize() model["GRAPH"] = graph return model
def train(neurons, hidden, act, epochs=10, repetition=0, summary=False): samples = int(1e6) h = 1 norms = np.random.uniform(0, 3, (samples, 1)) kn = gaussian(norms, h) X = norms y = kn inputs = layers.Input(shape=(1, )) x = layers.Dense(neurons, activation=act)(inputs) for i in range(hidden - 1): x = layers.Dense(neurons, activation=act)(x) outputs = layers.Dense(1, activation='linear')(x) save_path = "models/kernel/h{}/nn_{}_{}.h5".format(hidden, neurons, repetition) model = models.Model(inputs=inputs, outputs=outputs) early_stop = callbacks.EarlyStopping(monitor='val_mean_absolute_percentage_error', patience=10) check_point = callbacks.ModelCheckpoint(save_path, monitor='val_mean_absolute_percentage_error', save_best_only=True, mode='min') opt = optimizers.Adam(lr=1e-3, decay=1e-5) model.compile(optimizer=opt, loss='mean_squared_error', metrics=['mean_absolute_percentage_error']) if summary: model.summary() history = model.fit(X, y, epochs=epochs, batch_size=50, callbacks=[check_point, early_stop], validation_split=0.01) return models.load_model(save_path)
def restore_model(self, model_path): """Restore the underlying model from `model_path`""" if not self._loss_func: # Have to initialize this to load the model self._init_loss_func() cust_objects = {self._loss_func.__name__: self._loss_func} self.model = models.load_model(model_path, custom_objects=cust_objects) self._all_layers = self.model.layers
def init_model_for_process(): # importing tensorflow for each process separately # import tensorflow as tf from tensorflow.contrib.keras import models model = models.load_model(NN_MODEL_FILE) return model
def restore_model(self, model_path, training_betas=None, num_perplexities=None): """Restore the underlying model from `model_path`""" if not self._loss_func: # Have to initialize this to load the model self.num_perplexities = self._get_num_perplexities(training_betas, num_perplexities) self._init_loss_func() cust_objects = {self._loss_func.__name__: self._loss_func} self.model = models.load_model(model_path, custom_objects=cust_objects) self._all_layers = self.model.layers
def __init__(self): """Constructor that loads all used models""" self.fr = self.init_face_model() self.pr = PersonDetection(self.PATH_PERSON_DETECTION_MODEL) self.vgg = models.load_model(self.PATH_TRAINED_VGG, custom_objects={ 'precision_male': precision_male, "precision_female": precision_female, "precision": precision, 'recall_male': recall_male, "recall_female": recall_female, "recall": recall, "f1_score_male": f1_score_male, "f1_score_female": f1_score_female, "f1_score": precision })
def constantize(fname): K.clear_session() tf.reset_default_graph() K.set_learning_phase(False) mod = models.load_model(fname) outputs = mod.output if not isinstance(outputs, collections.Sequence): outputs = [outputs] output_names = [] for output in outputs: output_names.append(output.name.split(':')[0]) sess = K.get_session() cg = graph_util.convert_variables_to_constants( sess, sess.graph.as_graph_def(add_shapes=True), output_names) K.clear_session() return cg
def init_model_for_process(example): # restore in eager execution # https://github.com/keras-team/keras/issues/8136 NN_MODEL = models.load_model(NN_MODEL_FILE) # Need to add some optimizer to make model compiled # Only TF native optimizers are supported in Eager mode. NN_MODEL.compile(optimizer=tf.train.GradientDescentOptimizer(0.01), loss='mean_squared_error') # global variable with all the data to be shared model = {} model["NN_MODEL"] = NN_MODEL ''' _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= gru_1 (GRU) (None, 300, 50) 7800 _________________________________________________________________ gru_2 (GRU) (None, 1) 156 _________________________________________________________________ activation_1 (Activation) (None, 1) 0 ================================================================= Total params: 7,956 Trainable params: 7,956 Non-trainable params: 0 _________________________________________________________________ ''' # Testing x = tf.contrib.keras.preprocessing.sequence.pad_sequences([example], maxlen=300, padding='post') # now it wants float somewhy x = np.array(x.reshape(x.shape + (1, )), dtype=float) y = NN_MODEL.predict(x) print('Testing model inference: {}'.format(y)) return model
def train(neurons, hidden=1, act='relu', epochs=10, repetition=0): samples = int(1e6) norms = np.random.uniform(0, 3, samples) veldiffs = np.random.uniform(0, 1, samples) dkn = dgaussian(norms, 1) cont = continuity(veldiffs, dkn) X = np.zeros((samples, 2)) X[:, 0] = norms / 3 X[:, 1] = veldiffs y = cont inputs = layers.Input(shape=(2, )) x = layers.Dense(neurons, activation=act)(inputs) for i in range(hidden - 1): x = layers.Dense(neurons, activation=act)(x) outputs = layers.Dense(1, activation='linear')(x) save_path = "models/continuity/h{}/nn_{}_{}.h5".format( hidden, neurons, repetition) model = models.Model(inputs=inputs, outputs=outputs) early_stop = callbacks.EarlyStopping(monitor='val_loss', patience=10) check_point = callbacks.ModelCheckpoint(save_path, monitor='val_loss', save_best_only=True, mode='min') opt = optimizers.Adam(lr=1e-3, decay=1e-5) model.compile(optimizer=opt, loss='mean_squared_error', metrics=['mean_absolute_percentage_error']) history = model.fit(X, y, epochs=epochs, batch_size=100, callbacks=[early_stop, check_point], validation_split=0.01) return models.load_model(save_path)
def dice_loss(y_true, y_pred): loss = 1 - dice_coeff(y_true, y_pred) return loss def bce_dice_loss(y_true, y_pred): loss = losses.binary_crossentropy(y_true, y_pred) + dice_loss(y_true, y_pred) return loss # imports data from directory and returns numpy arrays input and labels with size [512, 512, num_slices] # load trained model print("Loading model") save_model_path = './temp/weights.hdf5' model = models.load_model(save_model_path, custom_objects={'bce_dice_loss': bce_dice_loss, 'dice_loss': dice_loss}) files = os.listdir(directoryOfFiles) input_size = len(files) for filename in files: input_shape = [512, 512] input_matrix = np.zeros((input_shape[0], input_shape[1], 0)) print("Start importing data from: " + filename) directory = directoryOfFiles + filename if directory.find("normalized") >= 0: current_image = nib.load(directory).get_fdata() input_matrix = np.concatenate((input_matrix, current_image), axis=2) print("Import done, Input Size:")
from models import kerasmodels from data import dataload from tasking import general from tensorflow.contrib.keras import models import numpy as np import pandas as pd display = 5 X_test, y_test, filenames = dataload.load_general_patch( resolution=100, path='C:/Dataset/img/Test', input_size=10000) X_test_reshape = general.simple_reshape(X_test, 100) X_test_reshape = general.simple_norm(X_test_reshape) model = models.load_model('repo/DogCat100.h5') predictions = model.predict(X_test_reshape) predictions = np.array(predictions).reshape(len(predictions), ) predictions = [round(a, 4) for a in predictions ] # round prediction to 5 digits / no need more ds = pd.DataFrame() ds['index'] = range(len(y_test)) ds['filename'] = pd.Series(filenames) ds['y_test'] = pd.Series(y_test) ds['predictions'] = pd.Series(predictions) ###################################################################################### #few most correct dogs # indexes,predict = dogcat.most_correct_dogs(ds)
from tensorflow.contrib.keras import models import matplotlib.pyplot as plt from generate_data import retrieve_data import numpy as np import tables # model = models.load_model('model.hdf5') model = models.load_model('1000_epochs_600_samples.hdf5') _, t, _, _, _, _ = retrieve_data(False, False) def test_sample(index): index_test = index E_actual = E_real[index_test] + 1j * E_imag[index_test] pred = model.predict(frog[index_test].reshape(1, 58, 106, 1)) E_imag_pred = pred[0][128:] E_real_pred = pred[0][:128] E_pred = E_real_pred + 1j * E_imag_pred fig, ax = plt.subplots(2, 2) # ax[0][0].pcolormesh(frog[index_test].reshape(58, 106), cmap='jet') ax[1][1].plot(t, np.abs(E_pred), color='blue', linestyle='dashed') ax[1][1].plot(t, np.real(E_pred), color='blue') ax[1][1].plot(t, np.imag(E_pred), color='red') ax[0][0].pcolormesh(frog[index_test].reshape(58, 106), cmap='jet')
# Per non iniziare da 0 puoi caricare in model un modello salvato, ma il conto delle epoch parte da 0 di nuovo # model = tf.keras.models.load_model('saved_models/transfer_learning_epoch_03_0.9185.h5') # INIZIA TRAINING history = model.fit_generator( generator=batch_generator(train_files, BATCH_SIZE), epochs=NUM_EPOCHS, steps_per_epoch=STEPS_PER_EPOCH, class_weight=cl_weight, validation_data=batch_generator(val_files, BATCH_SIZE), validation_steps=VAL_STEPS, callbacks=callbacks_list, ) # Da qui in poi si fa la predizione per creare la confusion matrix # Carica un modello salvato, magari saltanto la fase di training model = models.load_model( filepath='saved_models/transfer_learning_epoch_03_0.9185.h5') TEST_STEPS = len(test_files) // BATCH_SIZE # Fai tutte le predizioni pred_probs = model.predict_generator(generator=batch_generator( test_files, BATCH_SIZE), steps=TEST_STEPS) pred = np.argmax(pred_probs, axis=-1) from sklearn.metrics import confusion_matrix, accuracy_score import itertools def plot_confusion_matrix(cm, classes,
import numpy as np import matplotlib.pyplot as plt from tensorflow.contrib.keras import models from ann.equations import dgaussian, continuity from sph.tools import check_dir save_path = "../models/continuity/" check_dir(save_path) model1 = models.load_model(save_path + "h1/nn_250_0.h5") model2 = models.load_model(save_path + "h2/nn_250_0.h5") model3 = models.load_model(save_path + "h3/nn_250_0.h5") X = np.linspace(0, 3, 250) V = np.linspace(0, 1, 250) X, V = np.meshgrid(X, V) X = X.reshape((-1, 1)) V = V.reshape((-1, 1)) dkn = dgaussian(X, 1) y = continuity(V, dkn).ravel() y_pred1 = model1.predict(np.concatenate((X, V), axis=-1)).ravel() y_pred2 = model2.predict(np.concatenate((X, V), axis=-1)).ravel() y_pred3 = model3.predict(np.concatenate((X, V), axis=-1)).ravel() plt.plot(X, y) plt.plot(X, y_pred3) plt.show() plt.plot(y, abs(y - y_pred3.ravel()) / y, 'g.', label='3 capas') plt.plot(y, abs(y - y_pred2.ravel()) / y, 'c.', label='2 capas') plt.plot(y, abs(y - y_pred1.ravel()) / y, 'm.', label='1 capa')
frogtrace, tau_frog, w_frog = plot_frog(E=E_pred, t=t, w=w, dt=dt, w0=w0, plot=False) ax4 = plt.subplot2grid((4, 2), (3, 0), rowspan=1, colspan=2) ax4.pcolormesh(frogtrace, cmap="jet") ax4.set_title("Network Reconstructed FROG trace") ax4.set_xticks([]) ax4.set_yticks([]) # add y labels on left side of graph only if j == 0: ax1.set_ylabel('Actual E(t)') ax2.set_ylabel('FROG trace') ax3.set_ylabel('Retrieved E(t)') ax4.set_ylabel("Reconstructed FROG trace") # load model model = models.load_model("./model.hdf5") # load test data hdf5_file = tables.open_file('frogtestdata.hdf5', mode='r') E_real = hdf5_file.root.E_real[:, :] E_imag = hdf5_file.root.E_imag[:, :] frog = hdf5_file.root.frog[:, :] # print((frog[1].reshape(58, 106))) # image = frog[1].reshape(58, 106) # plt.imshow(image) # plt.show() E_apended = np.concatenate((E_real, E_imag), 1) hdf5_file.close() results = model.evaluate(frog.reshape(-1, 58, 106, 1), E_apended)
def __init__(self, isVideo=False): self.model = models.load_model('vgg_pretrained.h5') self.prev_detections = None self.frames_since_full_search = 0 self.frame_count = 0 self.isVideo = isVideo
import tensorflow as tf from tensorflow.contrib.keras import models import numpy as np tf.enable_eager_execution() from keras.datasets import imdb (X_train, y_train), (X_test, y_test) = imdb.load_data(num_words=100) example = X_test[1] # restore in eager execution # https://github.com/keras-team/keras/issues/8136 NN_MODEL = models.load_model("model_without_opt.h5") # Need to add some optimizer to make model compiled # Only TF native optimizers are supported in Eager mode. NN_MODEL.compile(optimizer=tf.train.GradientDescentOptimizer(0.01), loss='mean_squared_error') x = tf.contrib.keras.preprocessing.sequence.pad_sequences([example], maxlen=300, padding='post') # now it wants float somewhy x = np.array(x.reshape(x.shape + (1, )), dtype=float) # returns numpy, strangely. Not tensor y = NN_MODEL.predict(x) print('Testing model inference: {}'.format(y)) # [[0.49816433]] '''
def loadFileModel(path): model = models.load_model(path) return model