def test_restore_old_saved_model(self): saved_model_dir = os.path.join( flags.FLAGS['test_srcdir'].value, 'org_tensorflow/tensorflow/python/keras', 'mixed_precision/testdata/lso_savedmodel_tf2.2') # saved_model_dir = test.test_src_dir_path( # 'python/keras/mixed_precision/testdata/' # 'lso_savedmodel_tf2.2') model = save.load_model(saved_model_dir) expected_kernel = np.array([[9.229685, 10.901115], [10.370763, 9.757362]]) self.assertAllClose(backend.eval(model.weights[0]), expected_kernel) self.assertEqual(type(model.optimizer), loss_scale_optimizer.LossScaleOptimizer)
def test_state_saving_and_loading(self): input_data = np.random.random((1, 2)) rff_layer = kernel_layers.RandomFourierFeatures(output_dim=10, scale=3.0) inputs = input_layer.Input((2, )) outputs = rff_layer(inputs) model = training.Model(inputs, outputs) output_data = model.predict(input_data) temp_dir = self.get_temp_dir() self.addCleanup(shutil.rmtree, temp_dir) saved_model_dir = os.path.join(temp_dir, 'rff_model') model.save(saved_model_dir) new_model = save.load_model(saved_model_dir) new_output_data = new_model.predict(input_data) self.assertAllClose(output_data, new_output_data, atol=1e-4)
def __init__(self): """Initialize the alarm params, the model and faces parts classifiers""" # Prepare alarm mixer.init() self.sound = mixer.Sound('alarm.wav') self.score = 0 self.__thickness = 2 self.config = DrowsiDriveConfig() # Prepare model self.model = load_model(str(self.config.MODEL_PATH)) # Classifiers self.face_classifier = None self.left_eye_classifier = None self.right_eye_classifier = None
def load_keras_model(file): model = load_model(file) # model = load_model('model_test.h5') # model.load_weights(file) encoder_inputs = model.input[0] # input_1 encoder_outputs, state_h_enc, state_c_enc = model.layers[ 4].output # lstm_1 encoder_states = [state_h_enc, state_c_enc] decoder_inputs = model.input[1] # input_2 decoder_embedding = model.layers[3].output decoder_lstm = model.layers[5] decoder_dense = model.layers[6] return model, encoder_inputs, encoder_states, decoder_inputs, \ decoder_embedding, decoder_lstm, decoder_dense
def test_saving_model_with_custom_object(self): with generic_utils.custom_object_scope(), self.cached_session(): @generic_utils.register_keras_serializable() class CustomLoss(losses.MeanSquaredError): pass model = sequential.Sequential( [core.Dense(units=1, input_shape=(1,))]) model.compile(optimizer='sgd', loss=CustomLoss()) model.fit(np.zeros([10, 1]), np.zeros([10, 1])) temp_dir = self.get_temp_dir() filepath = os.path.join(temp_dir, 'saving') model.save(filepath) # Make sure the model can be correctly load back. _ = save.load_model(filepath, compile=True)
def predict_separate(path, test_path=config.TEST_PATH, dat_file=config.SHAPE_PREDICTOR_DAT_PATH): print('Loading Model from: ', path) name_of_model = path.split('_')[1] model = load_model(path) images_processed = 0 images_with_no_face = 0 detector = dlib.get_frontal_face_detector() predictor = dlib.shape_predictor(dat_file) y_predProbs = np.empty((0, 7)) y_true = [] for label in config.CLASS_LABEL: files = sorted(glob(os.path.join(test_path, label.lower()) + '/*.jpg')) for images in files: img = cv2.resize(cv2.imread(images), (config.TARGET_SIZE['CV2_LANDMARKS_RESIZE'][0], config.TARGET_SIZE['CV2_LANDMARKS_RESIZE'][1])) img = cv2.cvtColor(src=img, code=cv2.COLOR_BGR2GRAY) faces = detector(img) if len(faces) == 0: images_with_no_face += 1 y_predProbs = np.vstack( (y_predProbs, np.zeros(config.NUM_CLASSES))) else: row = [] for face in faces: landmarks = predictor(image=img, box=face) for n in range(0, 68): row.append(landmarks.part(n).x) row.append(landmarks.part(n).y) break y_predProbs = np.vstack( (y_predProbs, model.predict(np.array(row).reshape(1, -1), verbose=1))) y_true.append(label) images_processed += 1 print("No of Images Processed:", images_processed) print('\n\nTotal Images:', images_processed, '\nFace detected in: ', images_processed - images_with_no_face, 'images\nFace not detected in: ', images_with_no_face, 'images') return y_predProbs, y_true
def test_save_load_tf_pathlib(self): if sys.version_info < (3, 6): self.skipTest('pathlib is only available for python version >= 3.6') path = pathlib.Path(self.get_temp_dir()) / 'model' save.save_model(self.model, path, save_format='tf') save.load_model(path)
def test_save_load_tf_string(self): path = os.path.join(self.get_temp_dir(), 'model') save.save_model(self.model, path, save_format='tf') save.load_model(path)
def test_save_load_tf_pathlib(self): if sys.version_info >= (3, 4): path = pathlib.Path(self.get_temp_dir()) / 'model' save.save_model(self.model, path, save_format='tf') save.load_model(path)
def _load_and_run_model(self, distribution, saved_dir, predict_dataset, output_name): restored_keras_model = save.load_model(saved_dir) return restored_keras_model.predict( predict_dataset, steps=test_base.PREDICT_STEPS)
def test_save_model_with_dynamic_loss_scaling( self, strategy_fn, h5=False, use_v1_loss_scale_optimizer=False): # TODO(reedwm): Support and test saving model with a mixed_[b]float16 policy # as well. strategy = strategy_fn() if (isinstance(strategy, mirrored_strategy.MirroredStrategy) and not context.executing_eagerly()): # TODO(b/121381184): Enable running the test in this case. return # Create and run model. with strategy.scope(): x = layers.Input(shape=(2, ), batch_size=2, dtype=dtypes.float32) y = mp_test_util.MultiplyLayer()(x) model = models.Model(inputs=x, outputs=y) opt = gradient_descent.SGD(1.) if use_v1_loss_scale_optimizer: loss_scale = loss_scale_module.DynamicLossScale( initial_loss_scale=1., increment_period=2.) opt = loss_scale_optimizer.LossScaleOptimizerV1( opt, loss_scale) else: opt = loss_scale_optimizer.LossScaleOptimizer( opt, initial_scale=1., dynamic_growth_steps=2.) model.compile(optimizer=opt, loss='mse', run_eagerly=testing_utils.should_run_eagerly()) # Run for 3 steps (6 examples with a batch size of 2) model.fit(np.ones((6, 2)), np.zeros((6, 2)), batch_size=2) self.assertEqual(backend.get_value(opt.loss_scale), 2) self.assertEqual(backend.get_value(opt.dynamic_counter), 1) (weight, ) = model.trainable_weights orig_weight = backend.get_value(weight) # Save model weights. save_path = os.path.join(self.get_temp_dir(), 'model') model.save(save_path, save_format='h5' if h5 else 'tf') # Run model again for 1 step (2 examples with a batch size of 2) model.fit(np.ones((2, 2)), np.zeros((2, 2)), batch_size=2) new_weight = backend.get_value(weight) self.assertNotEqual(new_weight, orig_weight) self.assertEqual(backend.get_value(opt.loss_scale), 4) self.assertEqual(backend.get_value(opt.dynamic_counter), 0) # Load model weights and ensure loss scale weights are restored. model = save.load_model( save_path, custom_objects={'MultiplyLayer': mp_test_util.MultiplyLayer}) (weight, ) = model.trainable_weights loaded_weight = backend.get_value(weight) self.assertEqual(loaded_weight, orig_weight) # Currently the loss scale isn't always saved when the model is saved with # Model.save(). So we assert the loss scale either has the value when it was # saved, or the value it was initialized with. # TODO(reedwm): Always save/restore the loss scale with Model.save(). self.assertIn(backend.get_value(model.optimizer.loss_scale), (1, 2)) self.assertIn(backend.get_value(model.optimizer.dynamic_counter), (0, 1)) # Test optimizer attributes and type self.assertEqual(model.optimizer.initial_scale, 1.) self.assertEqual(model.optimizer.dynamic_growth_steps, 2.) self.assertEqual(type(model.optimizer), loss_scale_optimizer.LossScaleOptimizer)
import tensorflow as tf from tensorflow.python.keras.saving.save import load_model import tensorflow_datasets as tfds import numpy as np import pandas as pd from tensorflow.keras import layers import tensorflow_hub as hub IMAGE_SHAPE = (224, 224) classifier_model = load_model(path) classifier = tf.keras.Sequential([ hub.KerasLayer(classifier_model, input_shape=IMAGE_SHAPE+(3,)) ]) labels_path = tf.keras.utils.get_file('ImageNetLabels.txt','https://storage.googleapis.com/download.tensorflow.org/data/ImageNetLabels.txt') imagenet_labels = np.array(open(labels_path).read().splitlines()) path = <your path here> batch_size = 64 img_height = 224 img_width = 224 train_ds = tf.keras.preprocessing.image_dataset_from_directory( path, validation_split=0.2, subset="training", seed=123, image_size=(img_height, img_width), batch_size=batch_size)
def load_model(path, generator=None, augmenter=None, custom_objects=None, compile=True): """ Load the model Example ------- model = load_model('model.h5', augmenter) """ if custom_objects: if isinstance(custom_objects, dict): base_objects = CUSTOM_LAYERS custom_objects = dict( list(base_objects.items()) + list(custom_objects.items())) else: custom_objects = CUSTOM_LAYERS if isinstance(path, str): if path.endswith(".h5") or path.endswith(".hdf5"): filepath = path else: raise ValueError("file must be .h5 file") else: raise TypeError("file must be type `str`") train_model = save.load_model(filepath, custom_objects=custom_objects, compile=compile) with h5py.File(filepath, "r") as h5file: train_generator_config = h5file.attrs.get("train_generator_config") if train_generator_config is None: raise ValueError("No data generator found in config file") train_generator_config = json.loads( train_generator_config.decode("utf-8"))["config"] model_config = h5file.attrs.get("pose_model_config") if model_config is None: raise ValueError("No pose model found in config file") model_name = json.loads(model_config.decode("utf-8"))["class_name"] model_config = json.loads(model_config.decode("utf-8"))["config"] if generator: signature = inspect.signature(TrainingGenerator.__init__) keys = [key for key in signature.parameters.keys()] keys.remove("self") keys.remove("augmenter") keys.remove("generator") kwargs = {key: train_generator_config[key] for key in keys} kwargs["augmenter"] = augmenter kwargs["generator"] = generator train_generator = TrainingGenerator(**kwargs) else: train_generator = None Model = MODELS[model_name] signature = inspect.signature(Model.__init__) keys = [key for key in signature.parameters.keys()] keys.remove("self") keys.remove("train_generator") if "kwargs" in keys: keys.remove("kwargs") kwargs = {key: model_config[key] for key in keys} kwargs["train_generator"] = train_generator # Pass to skip initialization and manually intialize kwargs["skip_init"] = True model = Model(**kwargs) model.train_model = train_model model.__init_train_model__() model.__init_input__(model_config["image_shape"]) kwargs = {} kwargs["output_shape"] = model_config["output_shape"] kwargs["keypoints_shape"] = model_config["keypoints_shape"] kwargs["downsample_factor"] = model_config["downsample_factor"] kwargs["output_sigma"] = model_config["output_sigma"] model.__init_predict_model__(**kwargs) return model
model.compile(loss=loss_function, optimizer=optimizer, metrics=['accuracy']) # Start training model.fit( train_datagen, epochs=no_epochs, shuffle=False) # Save the model filepath = './saved_model' save_model(model, filepath) # Save the model in h5 format filepath = './saved_model/h5' save_model(model, filepath, save_format='h5') # load model model = load_model("./saved_model/h5") # Validate recognition img = image.load_img('Banana.jpg', target_size = (25,25)) #img = image.load_img('apricot.jpg', target_size = (25,25)) array = image.img_to_array(img) x = np.expand_dims(array, axis=0) vimage = np.vstack([x]) img_classification = model.predict(vimage) print(img_classification)
def test_save_load_hdf5_pathlib(self): path = pathlib.Path(self.get_temp_dir()) / 'model' save.save_model(self.model, path, save_format='h5') save.load_model(path)
def load_model(self, id, name): self.model = load_model(f'./models/{id}/{name}')
y_train, test_size=0.1, random_state=0) del train # 교차검증 학습 train_model(x_train, y_train, k) del x_train, y_train # 학습된 모델 저장 for n in range(k): model = load_model('models/model' + str(n) + '.h5', custom_objects={ 'score': score, 'fscore_keras': fscore_keras }) models.append(model) # 모델 성능 일반화 preds = [] for model in models: preds.append(model.predict(x_test)) print(mae_over_fscore(y_test, preds[-1])) pred = sum(preds) / len(preds) print(mae_over_fscore(y_test, pred)) print("here is rain comparision") # 강수량 비교( pred와 real의 강수량 차의 기본 통계량)
def evaluate(model, X_v, y_v): 'evaluating model performance' loss, accuracy = model.evaluate(X_v, y_v) print('Loss: %.2f' % (loss)) print('Accuracy: %.2f' % (accuracy * 100)) if __name__ == "__main__": sample_training = "../dataset/fv_train_sample.npy" sample_validation = "../dataset/fv_validation_sample.npy" save_path = "../result/nn_model.h5" X, y = load_data(sample_training) X_v, y_v = load_data(sample_validation) # model = build_feedforward_nn(X, y, save_path) model = load_model(save_path) evaluate(model, X_v, y_v) pre_y = model.predict(X_v) pre_y = np.where(pre_y >= .5, 1, 0) cnf_matrix = metrics.confusion_matrix(y_v, pre_y) print("Confusion Matrix:\n") print(cnf_matrix) print("Accuracy:", metrics.accuracy_score(y_v, pre_y)) print("Precision:", metrics.precision_score(y_v, pre_y, zero_division='warn')) print("Recall:", metrics.recall_score(y_v, pre_y, zero_division='warn')) exit()