Python keras.models 模块，model_from_json() 实例源码

def init(): 
    json_file = open('model.json','r')
    loaded_model_json = json_file.read()
    json_file.close()
    loaded_model = model_from_json(loaded_model_json)
    #load woeights into new model
    loaded_model.load_weights("model.h5")
    print("Loaded Model from disk")

    #compile and evaluate loaded model
    loaded_model.compile(loss='categorical_crossentropy',optimizer='adam',metrics=['accuracy'])
    #loss,accuracy = model.evaluate(X_test,y_test)
    #print('loss:', loss)
    #print('accuracy:', accuracy)
    graph = tf.get_default_graph()

    return loaded_model,graph

def __init__(self, nb_classes, resnet_layers, input_shape, weights):
        """Instanciate a PSPNet."""
        self.input_shape = input_shape
        json_path = join("weights", "keras", weights + ".json")
        h5_path = join("weights", "keras", weights + ".h5")
        if isfile(json_path) and isfile(h5_path):
            print("Keras model & weights found, loading...")
            with open(json_path, 'r') as file_handle:
                self.model = model_from_json(file_handle.read())
            self.model.load_weights(h5_path)
        else:
            print("No Keras model & weights found, import from npy weights.")
            self.model = layers.build_pspnet(nb_classes=nb_classes,
                                             resnet_layers=resnet_layers,
                                             input_shape=self.input_shape)
            self.set_npy_weights(weights)

def load_model(self):
        self.model = model_from_json(open(self.model_filename).read())
        self.model.load_weights(self.weights_filename)
        self.categories = np.load(self.categories_filename)
        with open(self.categories_filename, 'r') as infile:
            self.categories = pickle.load(infile)
        self.inv_categories = {v: k for k, v in self.categories.items()}

        if self.verbose:
            print 'compiling model ... '
            start_time = time.time()

        self.model.compile(optimizer=self.optimizer, loss='categorical_crossentropy', metrics=['accuracy'])

        if self.verbose:
            end_time = time.time()
            self.print_time(start_time,end_time,'compiling model')

def load_model(self):
        self.model = model_from_json(open(self.model_filename).read())
        self.model.load_weights(self.weights_filename)
        self.categories = np.load(self.categories_filename)
        with open(self.categories_filename, 'r') as infile:
            self.categories = pickle.load(infile)
        self.inv_categories = {v: k for k, v in self.categories.items()}

        if self.verbose:
            print 'compiling model ... '
            start_time = time.time()

        self.model.compile(optimizer=self.optimizer, loss='categorical_crossentropy', metrics=['accuracy'])

        if self.verbose:
            end_time = time.time()
            self.print_time(start_time,end_time,'compiling model')

def load_model_from_checkpoint(model_dir):

    '''Loads the best performing model from checkpoint_dir'''
    with open(os.path.join(model_dir, 'model.json'), 'r') as f:
        model = model_from_json(f.read())

    epoch = 0
    newest_checkpoint = max(glob.iglob(model_dir + 
                            '/checkpoints/*.hdf5'), 
                            key=os.path.getctime)

    if newest_checkpoint: 
       epoch = int(newest_checkpoint[-22:-19])
       model.load_weights(newest_checkpoint)

    return model, epoch

def main():
    # Get Model:
    model_file = open('Data/Model/model.json', 'r')
    model = model_file.read()
    model_file.close()
    model = model_from_json(model)
    model.load_weights("Data/Model/weights.h5")

    # Get camera:
    cap = cv2.VideoCapture(0)

    # Open game in browser:
    open_game(browser='chrome', url='http://apps.thecodepost.org/trex/trex.html')

    while 1:
        # Get image from camera:
        ret, img = cap.read()
        Y = predict(model, img)
        if Y == 0:
            release()
        elif Y == 1:
            press()
    cap.release()

def load_model(name):
    from keras.models import model_from_json
    """
    Loads a Keras model from disk. The model should be contained in two files:
    a .json with description of the architecture and a .h5 with model weights.
    See save_model() to save the model.
    Reference: http://keras.io/faq/#how-can-i-save-a-keras-model
    Parameters:
    -----------
    name: Name of the model contained in the file names:
        <name>_architecture.json
        <name>_weights.h5
    Returns:
    --------
    model: Keras model object.
    """
    # Uses 'with' to ensure that file is closed properly
    with open(name + '_architecture.json') as f:
        model = model_from_json(f.read())
    model.load_weights(name + '_weights.h5')
    return model

def get_model(self, filename=None):
        """Given a filename, load that model file; otherwise, generate a new model."""
        model = None
        if filename:
            info('attempting to load model {}'.format(filename))
            try:
                model = model_from_json(open(filename).read())
            except FileNotFoundError:
                print('could not load file {}'.format(filename))
                quit()
            print('loaded model file {}'.format(filename))
        else:
            print('no model file loaded, generating new model.')
            size = self.reversi.size ** 2
            model = Sequential()
            model.add(Dense(HIDDEN_SIZE, activation='relu', input_dim=size))
            # model.add(Dense(HIDDEN_SIZE, activation='relu'))
            model.add(Dense(size))

        model.compile(loss='mse', optimizer=optimizer)
        return model

def player(cls, config, env_factory, model_json, ctrl_queue, out_queue, done_rewards_queue):
        os.environ['CUDA_VISIBLE_DEVICES'] = ''
        with tf.device("/cpu:0"):
            model = model_from_json(model_json)
            players = [Player(env_factory(), config.a3c_steps, config.a3c_gamma, config.max_steps, idx)
                       for idx in range(config.swarm_size)]
            # input_t, conv_out_t = atari.net_input(players[0].env)
            # n_actions = players[0].env.action_space.n
            # model = make_run_model(input_t, conv_out_t, n_actions)
            while True:
                # check ctrl queue for new model
                if not ctrl_queue.empty():
                    weights = ctrl_queue.get()
                    # stop requested
                    if weights is None:
                        break
                    model.set_weights(weights)

                for sample in Player.step_players(model, players):
                    out_queue.put(sample)
                for rw in Player.gather_done_rewards(*players):
                    done_rewards_queue.put(rw)

def __init__(self):
        self.dataclose = self.datas[0].close
        self.order = None
        self.order_dict = {}

        # self.signal_add(bt.SIGNAL_LONG, bt.ind.CrossOver(sma1, sma2))
        # load json and create model
        json_file = open('model.json', 'r')
        loaded_model_json = json_file.read()
        json_file.close()
        self.model = model_from_json(loaded_model_json)
        # load weights into new model
        self.model.load_weights("model.h5")
        print("Loaded model from disk")

        # evaluate loaded model on test data
        self.model.compile(loss='mean_squared_error', optimizer='adam')

def __init__(self):
        self.dataclose = self.datas[0].close
        self.order = None
        self.orefs = list()

        # self.signal_add(bt.SIGNAL_LONG, bt.ind.CrossOver(sma1, sma2))
        # load json and create model
        json_file = open('model.json', 'r')
        loaded_model_json = json_file.read()
        json_file.close()
        self.model = model_from_json(loaded_model_json)
        # load weights into new model
        self.model.load_weights("model.h5")
        print("Loaded model from disk")

        # evaluate loaded model on test data
        self.model.compile(loss='mean_squared_error', optimizer='adam')

def __init__(self):
        self.dataclose = self.datas[0].close
        self.order = None

        # self.signal_add(bt.SIGNAL_LONG, bt.ind.CrossOver(sma1, sma2))
        # load json and create model
        json_file = open('model.json', 'r')
        loaded_model_json = json_file.read()
        json_file.close()
        self.model = model_from_json(loaded_model_json)
        # load weights into new model
        self.model.load_weights("model.h5")
        print("Loaded model from disk")

        # evaluate loaded model on test data
        self.model.compile(loss='mean_squared_error', optimizer='adam')

def load_keras_model(weights, yaml=None, json=None,
                     normalise_conv_for_one_hot_encoded_input=False,
                     axis_of_normalisation=None,
                     name_of_conv_layer_to_normalise=None): 
    if (normalise_conv_for_one_hot_encoded_input):
        assert axis_of_normalisation is not None,\
         "specify axis of normalisation for normalising one-hot encoded input"
    assert yaml is not None or json is not None,\
     "either yaml or json must be specified"
    assert yaml is None or json is None,\
     "only one of yaml or json must be specified"
    if (yaml is not None):
        from keras.models import model_from_yaml 
        model = model_from_yaml(open(yaml).read()) 
    else:
        from keras.models import model_from_json 
        model = model_from_json(open(json).read()) 
    model.load_weights(weights) 
    if (normalise_conv_for_one_hot_encoded_input):
        mean_normalise_first_conv_layer_weights(
         model,
         axis_of_normalisation=axis_of_normalisation,
         name_of_conv_layer_to_normalise=name_of_conv_layer_to_normalise)
    return model

def predict_by_one(cube):
    # load json and create model
    json_file = open('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.hdf5")
    print("Loaded model from disk")
    sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)
    loaded_model.compile(loss='categorical_crossentropy', optimizer=sgd,metrics=['accuracy'])
    x = cube.reshape(-1,1,6,20,20)
    print(x.shape)
    result = loaded_model.predict(x,batch_size=10, verbose=0)
    # print(result.shape)
    # show result
    for i in result:
        print(i[0],i[1])
    return result

def main():

    with open("text_model.json", 'r') as content_file:
        json_string = content_file.read()
    model = model_from_json(json_string)
    model.load_weights('on-texts-weights-improvement-09-0.96.hdf5')

    while True:
        phrase = input("Russian phrase to accentuate: ")
        words = parse_the_phrase(phrase)
        accented_phrase = []
        pluswords = add_endings(words)

        for w in pluswords:
            if not bool(re.search(REG, w)):
                accented_phrase.append(w)
            else:
                accented_phrase.append(predict(model, w))
        accented_phrase = ' '.join(accented_phrase)
        print(accented_phrase)

def for_bot(phrase):
    # with open("text_model.json", 'r') as content_file:
    #     json_string = content_file.read()
    # model = model_from_json(json_string)
    # model.load_weights('on-texts-weights-improvement-09-0.96.hdf5')
    words = parse_the_phrase(phrase)
    accented_phrase = []
    pluswords = add_endings(words)

    for w in pluswords:
        if w == "_":
            continue
        elif not bool(re.search(REG, w)):
            accented_phrase.append(w)
        else:
            accented_phrase.append(predict(model, w))
    accented_phrase = ' '.join(accented_phrase)
    return accented_phrase

def test():
    with open(model_file, 'r') as jfile:
        model = model_from_json(jfile.read(), {'HighwayUnit': HighwayUnit()})

    model.compile(optimizer='adam', loss='sparse_categorical_crossentropy')
    # weights_file = model_file.replace('json', 'h5')
    # model.load_weights(weights_file)
    model.load_weights(weight_file)

    # load data
    images, image_id, species = load_test_data()

    # load training mean and standard dev
    train_mean = np.load('train_mean.npy')
    train_std = np.load('train_std.npy')

    images = (images - train_mean)/train_std

    test_dataset = reformat(images)

    yP = model.predict(test_dataset)
    np.save('testProbs', yP)
    print('Completed processing {} test images'.format(str(image_id.shape[0])))
    write_results_to_file(species, image_id, yP)

def load_model():
    try:
        json_file = open('model.json', 'r')
        loaded_model_json = json_file.read()
        json_file.close()
        model = model_from_json(loaded_model_json)
        model.load_weights("weights.hdf5")
        print("Model successfully loaded from disk.")

        #compile again
        model.compile(optimizer = 'adam', loss = 'categorical_crossentropy', metrics = ['accuracy'])
        return model
    except:
        print("""Model not found. Please train the CNN by running the script 
cnn_train.py. Note that the training and test samples should be properly 
set up in the dataset directory.""")
        return None

def unserialize(self, d, epoch=None, load_everything=True):
        self.model = model_from_json(open(op.join(d, 'model.json')).read())
        weights_file = ('weights.h5' if epoch is None else
                        'weights_epoch%d.h5' % epoch)
        self.model.load_weights(op.join(d, weights_file))

        if load_everything:
            class_data_file = op.join(d, 'class_data.pickle')
            if op.exists(class_data_file):
                class_data = pickle.load(open(class_data_file))
                for x in self.serialized_attributes:
                    setattr(self, x, class_data[x])

            test_results = op.join(d, 'test_results.csv')
            if os.path.exists(test_results):
                self.test_results = pd.read_csv(test_results)

            training_history = op.join(d, 'training_history.json')
            if os.path.exists(training_history):
                self.training_history = json.load(open(training_history))

def __init__(self, architecture_file=None, weight_file=None, optimizer=None):
        # Generate mapping for softmax layer to characters
        output_str = '0123456789abcdefghijklmnopqrstuvwxyz '
        self.output = [x for x in output_str]
        self.L = len(self.output)

        # Load model and saved weights
        from keras.models import model_from_json
        if architecture_file is None:
            self.model = model_from_json(open('char2_architecture.json').read())
        else:
            self.model = model_from_json(open(architecture_file).read())

        if weight_file is None:
            self.model.load_weights('char2_weights.h5')
        else:
            self.model.load_weights(weight_file)

        if optimizer is None:
            from keras.optimizers import SGD
            optimizer = SGD(lr=0.1, decay=1e-6, momentum=0.9, nesterov=True)
        self.model.compile(loss='categorical_crossentropy', optimizer=optimizer)

def load_model(model):

    # Load model
    _, model_basename = split(model.rstrip(sep))
    model_arch = join(model, model_basename + '_architecture.json')
    model_weights = join(model, model_basename + '_best_weights.h5')

    if not isfile(model_arch):
        raise IOError('Unable to locate model architecture (.json)')

    if not isfile(model_weights):
        raise IOError('Unable to locate model weights (.h5)')

    model = model_from_json(open(model_arch).read())
    model.load_weights(model_weights)

    return model

def build_model(model_in=None, model_out=None):
    if model_in:
        print("Reading model...")
        with open(model_in+'.json', 'r') as model_file:
            model = model_from_json(model_file.read())

    else:
        print('Build model...')
        model = Sequential()
        model.add(LSTM(64, return_sequences=True, input_shape=(seqlen, len(chars))))
        model.add(Dropout(0.2))
        model.add(LSTM(64, return_sequences=False))
        model.add(Dropout(0.2))
        model.add(Dense(len(chars)))
        model.add(Activation('softmax'))

    model.compile(loss='categorical_crossentropy', optimizer='rmsprop')

    if model_out:
        print("Saving model...")
        with open(model_out+'.json', 'w') as model_file:
            model_file.write(model.to_json())

    return model

def load_model(self, model_name):
        '''
        Load a model
        INPUT  (1) string 'model_name': filepath to model and weights, not including extension
        OUTPUT: Model with loaded weights. can fit on model using loaded_model=True in fit_model method
        '''
        print 'Loading model {}'.format(model_name)
        model_toload = '{}.json'.format(model_name)
        weights = '{}.hdf5'.format(model_name)
        with open(model_toload) as f:
            m = f.next()
        model_comp = model_from_json(json.loads(m))
        model_comp.load_weights(weights)
        print 'Model loaded.'
        self.model = model_comp
        return model_comp

def init(): 
    json_file = open('model.json','r')
    loaded_model_json = json_file.read()
    json_file.close()
    loaded_model = model_from_json(loaded_model_json)
    #load woeights into new model
    loaded_model.load_weights("model.h5")
    print("Loaded Model from disk")

    #compile and evaluate loaded model
    loaded_model.compile(loss='categorical_crossentropy',optimizer='adam',metrics=['accuracy'])
    #loss,accuracy = model.evaluate(X_test,y_test)
    #print('loss:', loss)
    #print('accuracy:', accuracy)
    graph = tf.get_default_graph()

    return loaded_model,graph

def get_reconst_from_embed(self, embed, node_l=None, filesuffix=None):
        if filesuffix is None:
            if node_l is not None:
                return self._decoder.predict(
                    embed,
                    batch_size=self._n_batch)[:, node_l]
            else:
                return self._decoder.predict(embed, batch_size=self._n_batch)
        else:
            try:
                decoder = model_from_json(
                    open('decoder_model_' + filesuffix + '.json').read()
                )
            except:
                print('Error reading file: {0}. Cannot load previous model'.format('decoder_model_'+filesuffix+'.json'))
                exit()
            try:
                decoder.load_weights('decoder_weights_' + filesuffix + '.hdf5')
            except:
                print('Error reading file: {0}. Cannot load previous weights'.format('decoder_weights_'+filesuffix+'.hdf5'))
                exit()
            if node_l is not None:
                return decoder.predict(embed, batch_size=self._n_batch)[:, node_l]
            else:
                return decoder.predict(embed, batch_size=self._n_batch)

def model_predict(X, pipeline):
    if model_type == "mlp":
        json_file = open(projectfolder + '/model.json', 'r')
        loaded_model_json = json_file.read()
        json_file.close()
        model = model_from_json(loaded_model_json)
        model.load_weights(projectfolder + "/weights.hdf5")
        model.compile(loss=pipeline['options']['loss'], optimizer=pipeline['options']['optimizer'],
                         metrics=pipeline['options']['scoring'])
        if type(X) is pandas.DataFrame:
            X = X.values
        Y = model.predict(X)
    else:
        picklefile = projectfolder + "/model.out"
        with open(picklefile, "rb") as f:
            model = pickle.load(f)
        Y = model.predict(X)

    return Y

def load_model(architecture_fp, weights_fp):
    """
    Load architecture and weights for a Keras model
    Args:
        architecture_fp (str): File path to the model architecture
        (in JSON format)
        weights_fp (str): File path to the model weights (in HDF5 format)
    Retruns:
        A Keras trained model
    """
    # Load architecture
    with open(architecture_fp, 'r') as architecture_file:
        model_architecture = json.load(architecture_file)

    loaded_model = model_from_json(model_architecture)

    # Load weights
    loaded_model.load_weights(weights_fp)
    return loaded_model

def readModel(path):
    """
    Loads the model found at path.

    Parameters
    ----------
    path: str
        The path to the model to be loaded. Note that the end of the path should
        give the name of the network but not the file extensions, which are
        added automatically.

    Returns
    -------
    Model
        A Keras neural network with the structure and weights of the one found
        at path.
    """

    model = model_from_json(open(os.path.join(path + 'Structure.json')).read())
    model.load_weights(os.path.join(path + 'Weights.h5'))
    return model

def loadModel(self, path):
        """
        Loads the neural network saved at path.

        Parameters
        ----------
        path: string
            The path to the stored model.

        Returns:
        Keras.models.Sequential
            The neural network, compiled and ready to run.
        """

        model = model_from_json(open(os.path.join(path + 'Structure.json')).read())
        model.load_weights(os.path.join(path + 'Weights.h5'))
        model.compile(optimizer='adadelta', loss='categorical_crossentropy',
                                                              metrics=['accuracy'])
        return model

def main(img_dir):
    img = get_img(img_dir).astype('float32')
    img /= 255.
    # Getting model:
    model_file = open('Data/Model/model.json', 'r')
    model = model_file.read()
    model_file.close()
    model = model_from_json(model)
    # Getting weights
    model.load_weights("Data/Model/weights.h5")
    Y = predict(model, img)
    name = 'segmentated.jpg'
    save_img(Y, name)
    print('Segmentated image saved as '+name)

def logoPredictor(path, rows, cols):
    model = model_from_json(open(path+'logo_architecture.json').read())
    model.load_weights(path+'logo_weights.h5')
    model.compile(optimizer = 'adam', loss='categorical_crossentropy',metrics=['accuracy'])

    imgs, imgNames = loadImgs(path+'logo_test/', rows, cols)
    imgs = imgs.reshape(imgs.shape[0], 1, rows, cols)

    classes = model.predict_classes(imgs)
    _, model_Dict = modelDict(path)
    output = []
    for cls in classes:
        output.append(model_Dict.keys()[model_Dict.values().index(int(cls))])

    return output #A Numpy array of predictions

def load_model():
    global classifier
    model_file=open('Trex_game/model.json', 'r')
    loaded_model=model_file.read()
    model_file.close()
    classifier=model_from_json(loaded_model)
    #load weights into new model
    classifier.load_weights("Trex_game/weights.hdf5")
    print("Model loaded successfully")


#get ready to roll

def read_model(cross=''):
    json_name = '../src/cache/architecture_4_50_2017-07-06-07-46.json'
    weight_name = '../src/cache/resnet_full_2017-07-07-08-40.hdf5'
    model = model_from_json(open(json_name).read())
    model.load_weights(weight_name)
    return model

def read_model(cross=''):
    json_name = 'architecture_' + cross + '.json'
    weight_name = 'model_weights_' + cross + '.h5'
    model = model_from_json(open(os.path.join('../src/cache', json_name)).read())
    model.load_weights(os.path.join('../src/cache', weight_name))
    return model

def read_model(cross=''):
    json_name = 'architecture_' + cross + '.json'
    weight_name = 'model_weights_' + cross + '.h5'
    model = model_from_json(open(os.path.join('../src/cache', json_name)).read())
    model.load_weights(os.path.join('../src/cache', weight_name))
    return model

def read_model(cross=''):
    json_name = 'architecture_' + cross + '.json'
    weight_name = 'model_weights_' + cross + '.h5'
    model = model_from_json(open(os.path.join('../src/cache', json_name)).read())
    model.load_weights(os.path.join('../src/cache', weight_name))
    return model

def read_model(cross=''):
    json_name = '../src/cache/architecture_24_50_2017-07-03-14-07.json'
    weight_name = '../src/cache/resnet_full_2017-07-04-11-57.hdf5'
    model = model_from_json(open(json_name).read())
    model.load_weights(weight_name)
    return model

def _load_model_config(model_cfg, model_weights):
        if type(model_cfg) == str:
            if not os.path.exists(model_cfg):
                try:
                    class_ = getattr(applications, model_cfg)
                    return class_(weights=model_weights)
                except AttributeError:
                    available_mdls = [attr for attr in dir(applications) if callable(getattr(applications, attr))]
                    raise ValueError('Could not load pretrained model with key {}. '
                                     'Available models: {}'.format(model_cfg, ', '.join(available_mdls)))

            with open(model_cfg, 'r') as fileh:
                try:
                    return model_from_json(fileh)
                except ValueError:
                    pass

                try:
                    return model_from_yaml(fileh)
                except ValueError:
                    pass

            raise ValueError('Could not load model from configuration file {}. '
                             'Make sure the path is correct and the file format is yaml or json.'.format(model_cfg))
        elif type(model_cfg) == dict:
            return Model.from_config(model_cfg)
        elif type(model_cfg) == list:
            return Sequential.from_config(model_cfg)

        raise ValueError('Could not load model from configuration object of type {}.'.format(type(model_cfg)))

def load_model(saved_model):

    '''Load Model

    WHAT: Loads a saved model and makes it available for
    prediction use by predictor().

    '''

    json_file = open(saved_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(saved_model + '.h5')

    f = open(saved_model+".x", 'r')
    temp = f.read()
    try:
        X = map(int, temp.split()[:-1])
    except ValueError:
        X = temp.split()[:-1]

    try:
        flatten = float(temp.split()[-1])

    except ValueError:
        flatten = temp.split()[-1]

    f.close()

    if type(X) == list and len(X) == 1:
        X = X[0]

    return loaded_model, X, flatten

def model_trainer(fileModelJSON):
    print("Model Trainer Thread Starting...")

    fileWeights = fileModelJSON.replace('json', 'h5')
    with open(fileModelJSON, 'r') as jfile:
        model = model_from_json(json.load(jfile))

    adam = Adam(lr=0.00001, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0)
    model.compile(optimizer=adam, loss="mse", metrics=['accuracy'])
    model.load_weights(fileWeights)
    print("Loaded model from disk:")
    model.summary()

    # start training loop...
    while 1:
        if len(X) > 100:
            batch_size = 20
            samples_per_epoch = int(len(X)/batch_size)
            val_size = int(samples_per_epoch/10)
            if val_size < 10:
                val_size = 10
            nb_epoch = 100

            history = model.fit_generator(batchgen(X,Y),
                                samples_per_epoch=samples_per_epoch, nb_epoch=nb_epoch,
                                validation_data=batchgen(X,Y),
                                nb_val_samples=val_size,
                                verbose=1)

            print("Saving model to disk: ",fileModelJSON,"and",fileWeights)
            if Path(fileModelJSON).is_file():
                os.remove(fileModelJSON)
            json_string = model.to_json()
            with open(fileModelJSON,'w' ) as f:
                json.dump(json_string, f)
            if Path(fileWeights).is_file():
                os.remove(fileWeights)
            model.save_weights(fileWeights)
        else:
            print("Not Ready!  Sleeping for 5...")
            sleep(5)

def load_model(model_name, yaml=True):
    """

    :rtype: object
    """
    if yaml:
        ext = '.yaml'
        model = model_from_yaml(open(model_name + ext).read())
    else:
        ext = '.json'
        model = model_from_json(open(model_name + ext).read())
    model.load_weights(model_name + '_weights.h5')
    # model.compile(loss='mean_squared_error', optimizer='rmsprop', metrics=['accuracy'])
    print("model " + model_name + " loaded")
    return model

def get_pretrained_squeezenet(model_path, weights_path):

    model = model_from_json(open(model_path).read())
    model.load_weights(weights_path)
    return model

def get_pretrained_squeezenet(model_path, weights_path):

    model = model_from_json(open(model_path).read())
    model.load_weights(weights_path)
    return model

# Experimental network design for small images !

def _load_model(self, model_network_path, model_weight_path):
        """Load a keras model from disk

        Parameters
        ----------
        model_network_path: str
            Path where the model network path is (json file)

        model_weight_path: str
            Path where the model network weights are (hd5 file)

        Returns
        -------
        model: A keras model
        """
        from keras.models import model_from_json

        # Load the model network
        json_file = open(model_network_path, 'r')
        loaded_model_json = json_file.read()
        json_file.close()

        # Load the model weights
        loaded_model = model_from_json(loaded_model_json, custom_objects={
            'relu6': _keras.applications.mobilenet.relu6,
            'DepthwiseConv2D': _keras.applications.mobilenet.DepthwiseConv2D})

        if model_weight_path != None:
            if os.path.isfile(model_weight_path):
                loaded_model.load_weights(model_weight_path)
                self.weight_loaded = True
                print("Network file [{}] and [{}] is loaded successfully.".format(model_network_path, model_weight_path))

            else:
                print("Warning: Weights File [%s] is not found." % (model_weight_path))

        return loaded_model

def _load_keras_model(model_network_path, model_weight_path):
    """Load a keras model from disk

    Parameters
    ----------
    model_network_path: str
        Path where the model network path is (json file)

    model_weight_path: str
        Path where the model network weights are (hd5 file)

    Returns
    -------
    model: A keras model
    """
    from keras.models import model_from_json
    import json

    # Load the model network
    json_file = open(model_network_path, 'r')
    loaded_model_json = json_file.read()
    json_file.close()

    # Load the model weights
    loaded_model = model_from_json(loaded_model_json)
    loaded_model.load_weights(model_weight_path)

    return loaded_model

def _load_keras_model(model_network_path, model_weight_path):
    """Load a keras model from disk

    Parameters
    ----------
    model_network_path: str
        Path where the model network path is (json file)

    model_weight_path: str
        Path where the model network weights are (hd5 file)

    Returns
    -------
    model: A keras model
    """
    from keras.models import model_from_json
    import json

    # Load the model network
    json_file = open(model_network_path, 'r')
    json_string = json_file.read()
    json_file.close()
    loaded_model_json = json.loads(json_string)

    # Load the model weights
    loaded_model = model_from_json(loaded_model_json)
    loaded_model.load_weights(model_weight_path)

    return loaded_model

def load_model(self, json_model_file, h5_model_file):
        #### load the model ####
        json_file = open(json_model_file, 'r')
        loaded_model_json = json_file.read()
        json_file.close()
        loaded_model = model_from_json(loaded_model_json)
        loaded_model.load_weights(h5_model_file)
        print("Loaded model from disk")

        #### compile the model ####
        self.model = loaded_model
        self.compile_model()

def __init__(self, *args, **kwds):
        BaseEngine.__init__(self, *args, **kwds)

        self.model = model_from_json(open(model_filename).read())
        #self.model.compile(loss='categorical_crossentropy', optimizer='adam')
        self.model.load_weights(weights_filename)

def load_model(self):
        if True:
            model_file = open('model2.json', 'r')
            loaded_model = model_file.read()
            model_file.close()
            model = model_from_json(loaded_model)
            #load weights into new model
            model.load_weights("weights2.hdf5")
            print("Model loaded successfully")
            return model

        else:
            print("Error importing the model. Make sure the model has\
            been trained\nand the model.json and weights.hdf5 files are in place, and try again.")
            os._exit(0)

def get(self):
        batch_size = 1
        rolling_window_size = 5
        # r = requests.get('http://localhost:5000/api/v1/neural_data') # Call neural_data
        # print(r)
        Neural_Data.get(Neural_Data)
        data = list(mongo.db.neural_data.find({}).sort('timestamp', -1).limit(5))
        arr = create_rolling_window(data, rolling_window_size)
        X = np.array([arr])
        X = np.reshape(X, (X.shape[0], 1, X.shape[1]))

        json_file = open('model.json', 'r')
        loaded_model_json = json_file.read()
        json_file.close()
        model = model_from_json(loaded_model_json)
        # load weights into new model
        model.load_weights("model.h5")
        print("Loaded model from disk")

        prediction = model.predict(X, batch_size=batch_size, verbose=1)
        prediction = prediction.tolist()[0][0]
        print(colored.green("Make new prediction...And its {}".format(prediction)))
        prediction = round(prediction, 0)
        result = {
            'price_growth': True
        }
        if prediction == 0:
            result["price_growth"] = False
            print('Price will fall')
        else:
            print('Price will growth')

        return jsonify(result)