10 examples of 'keras load model and predict' in Python

80
def load_model():
81
	"""
82
	"""
83
84
	json_file = open('multilabel_model.json', 'r')
85
	loaded_model_json = json_file.read()
86
	json_file.close()
87
	model = model_from_json(loaded_model_json)
88
89
	model.load_weights('multilabel_model.h5')
90
	print("Loaded model from disk")
91
92
	model.summary()
93
94
	model.compile(loss='binary_crossentropy',
95
		optimizer='adam',
96
		metrics=[f1_score])
97
98
99
	return model

45
def load_model(
46
    has_model: bool = True, model_path: str = f"{LATEST_STABLE_MODEL}"
47
) -> LogisticRegression:
48
    """
49
        Load or create the logistic regression model.
50
51
        Returns:
52
            A logistic regression model either created from scratch or
53
            loaded from a pickle file
54
    """
55
    # Load the model from memory or from a beautiful pickle file
56
    if has_model:
57
        lr_file = open(f"{ETC_DIR}/models/{model_path}", "rb")
58
        model = pickle.load(lr_file)
59
        lr_file.close()
60
        LOGGER.info(f"Loaded model: {model_path}")
61
    else:
62
        lr_file = open(f"{ETC_DIR}/models/{model_path}", "wb")
63
        model = create_lr()
64
        pickle.dump(model, lr_file)
65
        lr_file.close()
66
        LOGGER.info(f"Created and saved: {model_path}")
67
68
    return model

120
def load_pretrained_model():
121
    weathernet = keras.models.load_model(model_filepath)
122
    return weathernet

58
def load(self, save_path):
59
    self.classifier = keras.models.load_model(save_path)

43
def loaded_model():
44
45
    json_file = open('/Users/yang/ChemTS/RNN-model/model.json', 'r')
46
    #json_file = open('/Users/yang/LSTM-chemical-project/protein-ligand/model.json', 'r')
47
    loaded_model_json = json_file.read()
48
    json_file.close()
49
    loaded_model = model_from_json(loaded_model_json)
50
51
    # load weights into new model
52
    #loaded_model.load_weights('/Users/yang/LSTM-chemical-project/protein-ligand/model.h5')
53
    loaded_model.load_weights('/Users/yang/ChemTS/RNN-model/model.h5')
54
    print("Loaded model from disk")
55
56
57
    return loaded_model

282
def load(model_name, img_dim, nb_patch, bn_mode, use_mbd, batch_size):
283
284
    if model_name == "generator_unet_upsampling":
285
        model = generator_unet_upsampling(img_dim, bn_mode, model_name=model_name)
286
        model.summary()
287
        return model
288
289
    if model_name == "generator_unet_deconv":
290
        model = generator_unet_deconv(img_dim, bn_mode, batch_size, model_name=model_name)
291
        model.summary()
292
        return model
293
294
    if model_name == "DCGAN_discriminator":
295
        model = DCGAN_discriminator(img_dim, nb_patch, bn_mode, model_name=model_name, use_mbd=use_mbd)
296
        model.summary()
297
        return model

175
def load_model(self):
176
    print("BertBiLstmModel load_model start!")
177
    # logger.info("BertBiLstmModel load_model start!")
178
    self.model.load_weights(args.path_save_model)
179
    # logger.info("BertBiLstmModel load_model end+!")
180
    print("BertBiLstmModel load_model end+!")

207
def load(path, opts, vars):
208
    try:
209
        print('\nLoading model\nCreating session and graph')   
210
        server = tf.train.Server.create_local_server()
211
        sess = tf.Session(server.target) 
212
        graph = tf.get_default_graph()
213
        backend.set_session(sess) 
214
        
215
        model_path = path + '.' + opts['network'] + '.h5'
216
        print('Loading model from {}'.format(model_path))
217
        model = load_model(model_path);     
218
219
        
220
        print('Create prediction function')
221
222
        model._make_predict_function()
223
        with graph.as_default():
224
            with sess.as_default():
225
                input_shape = list(model.layers[0].input_shape)
226
                input_shape[0] = 1
227
                model.predict(np.zeros(tuple(input_shape)))
228
229
        vars['graph'] = graph
230
        vars['session'] = sess
231
        vars['model'] = model
232
    except Exception as e:
233
        print_exception(e, 'load')
234
        sys.exit()

535
def load_model_and_predict(self):
536
    # load model
537
    print('loading model ' + self.file_name + '.h5...')
538
    model = load_model(os.path.join(self.file_path, 'model_' + self.file_name + '-' + 'seq_' + str(self.n_seq) + '.h5'))
539
    # load dataset
540
    series, series_values, raw_datetime = self.load_dataset()
541
    # In order to make fake data, we need to random shuffle the values
542
    # series, series_values = self._random_shuffle(series)
543
    # n_test = int(0.2 * series.shape[0])
544
    n_test = 30
545
    scaler, train, test = self.prepare_data(series_values, n_test, self.n_lag, self.n_seq)
546
    # make a prediction
547
    forecasts = self.make_forecasts(model, self.n_batch, test, self.n_lag, self.n_seq)
548
    # inverse transform forecasts and test        pyplot.show()
549
550
    forecasts = self.inverse_transform(series_values, forecasts, scaler, n_test + self.n_seq - 1)
551
    # map forecasts to a health score
552
    # self.get_health_score(raw_datetime, forecasts, n_test)
553
554
    actual = [row[self.n_lag:] for row in test]
555
    actual = self.inverse_transform(series_values, actual, scaler, n_test + self.n_seq - 1)
556
    # evaluate forecasts
557
    self.evaluate_forecasts(actual, forecasts, self.n_lag, self.n_seq, self.file_name)
558
    # plot forecasts
559
    # self.plot_forecasts(series_values, forecasts, n_test, self.file_name, self.sensor_name, raw_datetime, self.n_seq)
560
    self._plot(series_values, forecasts, n_test, self.file_name, self.sensor_name, raw_datetime, self.n_seq)

50
def load_model(self):
51
    depth=Input(shape=(TIME_STEPS,hd,wd,1),name='depth_flow')
52
    opflow=Input(shape=(TIME_STEPS,ho,wo,2),name='optical_flow')
53
    cnv1=TimeDistributed(Conv2D(64, (7,7),strides=2, padding='same',dilation_rate=(1, 1), activation='relu', use_bias=True, kernel_initializer='glorot_uniform', bias_initializer='zeros',kernel_regularizer=regularizers.l2(0.01),bias_regularizer=regularizers.l2(0.01),activity_regularizer=regularizers.l2(0.01)))(depth)
54
    cnv1_2=TimeDistributed(Conv2D(64, (7,7),strides=2, padding='same',dilation_rate=(1, 1), activation='relu', use_bias=True, kernel_initializer='glorot_uniform', bias_initializer='zeros',kernel_regularizer=regularizers.l2(0.01),bias_regularizer=regularizers.l2(0.01),activity_regularizer=regularizers.l2(0.01)))(cnv1)
55
    cnv2=TimeDistributed(Conv2D(128, (5,5),strides=2, padding='same',dilation_rate=(1, 1), activation='relu', use_bias=True, kernel_initializer='glorot_uniform', bias_initializer='zeros',kernel_regularizer=regularizers.l2(0.01),bias_regularizer=regularizers.l2(0.01),activity_regularizer=regularizers.l2(0.01)))(opflow)
56
    cnv2_2=TimeDistributed(Conv2D(128, (5,5),strides=2, padding='same',dilation_rate=(1, 1), activation='relu', use_bias=True, kernel_initializer='glorot_uniform', bias_initializer='zeros',kernel_regularizer=regularizers.l2(0.01),bias_regularizer=regularizers.l2(0.01),activity_regularizer=regularizers.l2(0.01)))(cnv2)
57
    merged=concatenate([cnv1_2,cnv2_2])
58
    cnv3=TimeDistributed(Conv2D(256, (5,5),strides=2, padding='same',dilation_rate=(1, 1), activation='relu', use_bias=True, kernel_initializer='glorot_uniform', bias_initializer='zeros',kernel_regularizer=regularizers.l2(0.01),bias_regularizer=regularizers.l2(0.01),activity_regularizer=regularizers.l2(0.01)))(merged)
59
    cnv3_1=TimeDistributed(Conv2D(256, (3,3),strides=1, padding='same',dilation_rate=(1, 1), activation='relu', use_bias=True, kernel_initializer='glorot_uniform', bias_initializer='zeros',kernel_regularizer=regularizers.l2(0.01),bias_regularizer=regularizers.l2(0.01),activity_regularizer=regularizers.l2(0.01)))(cnv3)
60
    cnv4=TimeDistributed(Conv2D(512, (3,3),strides=2, padding='same',dilation_rate=(1, 1), activation='relu', use_bias=True, kernel_initializer='glorot_uniform', bias_initializer='zeros',kernel_regularizer=regularizers.l2(0.01),bias_regularizer=regularizers.l2(0.01),activity_regularizer=regularizers.l2(0.01)))(cnv3_1)
61
    cnv4_1=TimeDistributed(Conv2D(512, (3,3),strides=1, padding='same',dilation_rate=(1, 1), activation='relu', use_bias=True, kernel_initializer='glorot_uniform', bias_initializer='zeros',kernel_regularizer=regularizers.l2(0.01),bias_regularizer=regularizers.l2(0.01),activity_regularizer=regularizers.l2(0.01)))(cnv4)
62
    cnv5=TimeDistributed(Conv2D(512, (3,3),strides=2, padding='same',dilation_rate=(1, 1), activation='relu', use_bias=True, kernel_initializer='glorot_uniform', bias_initializer='zeros',kernel_regularizer=regularizers.l2(0.01),bias_regularizer=regularizers.l2(0.01),activity_regularizer=regularizers.l2(0.01)))(cnv4_1)
63
    cnv5_1=TimeDistributed(Conv2D(512, (3,3),strides=1, padding='same',dilation_rate=(1, 1), activation='relu', use_bias=True, kernel_initializer='glorot_uniform', bias_initializer='zeros',kernel_regularizer=regularizers.l2(0.01),bias_regularizer=regularizers.l2(0.01),activity_regularizer=regularizers.l2(0.01)))(cnv5)
64
    cnv6=TimeDistributed(Conv2D(1024, (3,3),strides=2, padding='same',dilation_rate=(1, 1), activation='relu', use_bias=True, kernel_initializer='glorot_uniform', bias_initializer='zeros',kernel_regularizer=regularizers.l2(0.01),bias_regularizer=regularizers.l2(0.01),activity_regularizer=regularizers.l2(0.01)))(cnv5_1)
65
    drp_1=TimeDistributed(Dropout(0.5))(cnv6)
66
    flat=TimeDistributed(Flatten())(drp_1)
67
    lstm1=LSTM(LSTM_HIDDEN_SIZE,return_sequences=True)(flat)
68
    lstm2=LSTM(6,return_sequences=True,name='output')(lstm1)
69
    self.model=Model(inputs=[depth,opflow],outputs=[lstm2])
70
    adm = keras.optimizers.Adam(lr=0.0001, beta_1=0.9, beta_2=0.999, epsilon=None, decay=0.0, amsgrad=False)
71
    self.model.compile(optimizer=adm,
72
        loss=self.loss_modified)
73
    self.model.summary()
74
    if(not os.path.isdir(self.checkpoint_dir)):
75
        os.makedirs(self.checkpoint_dir)