def _load_model(folder, model, weights_only=True): latest = os.path.join(folder, "latest") if model is None and weights_only: with open(os.path.join(folder, 'model.yaml'), 'r') as yaml_file: loaded_model_yaml = yaml_file.read() model = model_from_yaml(loaded_model_yaml, custom_objects={'tf': tf}) print('Model loaded from %s' % os.path.join(folder, 'model.yaml')) if os.path.isfile(latest): with open(latest, 'r') as f: filename = f.readlines()[0] epoch = filename.split('_')[1] # If model and weights were stored separately if weights_only: try: model.load_weights(os.path.join(folder, '%s.h5' % filename)) except: print('Single gpu loading failed, try with multi-gpu loading...') from tensorflow.python.keras.utils import multi_gpu_model multi_model = multi_gpu_model(model, gpus=len(os.environ["CUDA_VISIBLE_DEVICES"].split(',')) - 1) multi_model.load_weights(os.path.join(folder, '%s.h5' % filename)) model = multi_model.layers[-2] print('Weights loaded from %s' % os.path.join(folder, '%s.h5' % filename)) elif not weights_only: model = load_model(os.path.join(folder, '%s.h5' % filename), compile=False) print('Model loaded from %s' % os.path.join(folder, '%s.h5' % filename)) return model, int(epoch) return model, 0
def load_model(input_model_path, input_json_path=None, input_yaml_path=None): if not Path(input_model_path).exists(): raise FileNotFoundError( 'Model file `{}` does not exist.'.format(input_model_path)) try: model = keras.models.load_model(input_model_path) if FLAGS.is_tiny: model = tiny_yolo_body(Input(shape=(None, None, 3)), 3, FLAGS.num_class) else: model = yolo_body(Input(shape=(None, None, 3)), 3, FLAGS.num_class) model.load_weights('input_model_path') return model except FileNotFoundError as err: logging.error('Input mode file (%s) does not exist.', FLAGS.input_model) raise err except ValueError as wrong_file_err: if input_json_path: if not Path(input_json_path).exists(): raise FileNotFoundError( 'Model description json file `{}` does not exist.'.format( input_json_path)) try: model = model_from_json(open(str(input_json_path)).read()) model.load_weights(input_model_path) return model except Exception as err: logging.error("Couldn't load model from json.") raise err elif input_yaml_path: if not Path(input_yaml_path).exists(): raise FileNotFoundError( 'Model description yaml file `{}` does not exist.'.format( input_yaml_path)) try: model = model_from_yaml(open(str(input_yaml_path)).read()) model.load_weights(input_model_path) return model except Exception as err: logging.error("Couldn't load model from yaml.") raise err else: logging.error( 'Input file specified only holds the weights, and not ' 'the model definition. Save the model using ' 'model.save(filename.h5) which will contain the network ' 'architecture as well as its weights. ' 'If the model is saved using the ' 'model.save_weights(filename) function, either ' 'input_model_json or input_model_yaml flags should be set to ' 'to import the network architecture prior to loading the ' 'weights. \n' 'Check the keras documentation for more details ' '(https://keras.io/getting-started/faq/)') raise wrong_file_err
def load_generator(self, path_yaml, path_weight): # load YAML and create model yaml_file = open(path_yaml, 'r') loaded_model_yaml = yaml_file.read() yaml_file.close() loaded_model = model_from_yaml(loaded_model_yaml) # load weights into new model loaded_model.load_weights(path_weight) print("Loaded model from disk") return loaded_model
def load_model(path): yamlPath = path[0] h5Path = path[1] yaml_file1 = open(yamlPath, 'r') loaded_model_yaml = yaml_file1.read() yaml_file1.close() model = model_from_yaml(loaded_model_yaml) # load weights into new model model.load_weights(h5Path) model._make_predict_function() return model
def __init__(self, descriptor='jtvae'): self.descriptor = descriptor self.loaded_model = None self.model = None if self.descriptor == 'ecfp_autoencoder': yaml_file = open('Models/autoencoder_optedilmemis.yaml', 'r') loaded_model_yaml = yaml_file.read() yaml_file.close() self.loaded_model = model_from_yaml(loaded_model_yaml) # load weights into new model self.loaded_model.load_weights( "Models/autoencoder_optedilmemis.h5") elif self.descriptor == 'jtvae': lg = rdkit.RDLogger.logger() lg.setLevel(rdkit.RDLogger.CRITICAL) # Jupyter notebookta hata verdiği için parser kapatıldı. # parser = OptionParser() # parser.add_option("-t", "--test", dest="test_path") # parser.add_option("-v", "--vocab", dest="vocab_path") # parser.add_option("-m", "--model", dest="model_path") # parser.add_option("-w", "--hidden", dest="hidden_size", default=450) # parser.add_option("-l", "--latent", dest="latent_size", default=56) # parser.add_option("-d", "--depth", dest="depth", default=3) # parser.add_option("-e", "--stereo", dest="stereo", default=1) # opts, args = parser.parse_args() vocab = [ x.strip("\r\n ") for x in open("unique_canonical_train_vocab.txt") ] vocab = Vocab(vocab) hidden_size = 450 latent_size = 56 depth = 3 stereo = True model = JTNNVAE(vocab, hidden_size, latent_size, depth, stereo=stereo) model.load_state_dict(torch.load("Models/model.iter-9-6000")) # opts.model_path #MPNVAE-h450-L56-d3-beta0.001/model.iter-4 self.model = model.cuda()
q = queue.Queue(BUF_SIZE) ir = queue.Queue(BUF_SIZE) kit = ServoKit(channels=16) #gamepad =InputDevice('/dev/input/event4') # target = ['Forward', 'Right', 'Left'] # labels ={'Forward':0, 'Right':1, 'Left':2} # Initialize Donkey car,.. kit.continuous_servo[0].throttle = 0 kit.servo[1].angle = 107 # Initialize Model... yaml_file = open( '/home/ponata/A1-PONATA/Hayoung/lane_model_test/lane_model_v2.yaml', 'r') loaded_model_yaml = yaml_file.read() yaml_file.close() lane_model = model_from_yaml(loaded_model_yaml) # load weights into new model lane_model.load_weights( "/home/ponata/A1-PONATA/Hayoung/lane_model_test/lane_model_v2.h5") lane_model._make_predict_function() print("Initail Settings are done.\n") # START THREAD while True: main()
output_row[labels.index(docs_y[x])] = 1 training.append(bag) output.append(output_row) training = numpy.array(training) output = numpy.array(output) with open("chatbot.pickle", "wb") as file: pickle.dump((words, labels, training, output), file) try: yaml_file = open('chatbotmodel.yaml', 'r') loaded_model_yaml = yaml_file.read() yaml_file.close() myChatModel = model_from_yaml(loaded_model_yaml) myChatModel.load_weights("chatbotmodel.h5") print("Loaded model from disk") except: # Make our neural network myChatModel = Sequential() myChatModel.add(Dense(8, input_shape=[len(words)], activation='relu')) myChatModel.add(Dense(len(labels), activation='softmax')) # optimize the model myChatModel.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) # train the model
from tensorflow.python.keras.models import Model, model_from_yaml from tensorflow.python.keras.layers import Input from tensorflow.python.keras.datasets import mnist import matplotlib.pyplot as plt import sys encoding_dim = 32 if len(sys.argv) < 2: print("Error: No model file provided") exit() model_name = sys.argv[1] h_model_yaml = open(model_name + ".yaml", "r") autoencoder = model_from_yaml(h_model_yaml.read()) h_model_yaml.close() autoencoder.load_weights(model_name + ".h5") print("No.of layers: %d" % len(autoencoder.layers)) # Encoder encoder = Model(autoencoder.layers[0].input, autoencoder.layers[1].output) # # Decoder encoded_input = Input(shape=(encoding_dim, )) decoder_layer = autoencoder.layers[-1] decoder = Model(encoded_input, decoder_layer(encoded_input)) autoencoder.compile(optimizer='adadelta', loss='binary_crossentropy') (x_train, _), (x_test, _) = mnist.load_data()