def test_nested_sequential(in_tmpdir): (x_train, y_train), (x_test, y_test) = _get_test_data() inner = Sequential() inner.add(Dense(num_hidden, input_shape=(input_dim,))) inner.add(Activation('relu')) inner.add(Dense(num_class)) middle = Sequential() middle.add(inner) model = Sequential() model.add(middle) model.add(Activation('softmax')) model.compile(loss='categorical_crossentropy', optimizer='rmsprop') model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, verbose=1, validation_data=(x_test, y_test)) model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, verbose=2, validation_split=0.1) model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, verbose=0) model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, verbose=1, shuffle=False) model.train_on_batch(x_train[:32], y_train[:32]) loss = model.evaluate(x_test, y_test, verbose=0) model.predict(x_test, verbose=0) model.predict_classes(x_test, verbose=0) model.predict_proba(x_test, verbose=0) fname = 'test_nested_sequential_temp.h5' model.save_weights(fname, overwrite=True) inner = Sequential() inner.add(Dense(num_hidden, input_shape=(input_dim,))) inner.add(Activation('relu')) inner.add(Dense(num_class)) middle = Sequential() middle.add(inner) model = Sequential() model.add(middle) model.add(Activation('softmax')) model.compile(loss='categorical_crossentropy', optimizer='rmsprop') model.load_weights(fname) os.remove(fname) nloss = model.evaluate(x_test, y_test, verbose=0) assert(loss == nloss) # test serialization config = model.get_config() Sequential.from_config(config) model.summary() json_str = model.to_json() model_from_json(json_str) yaml_str = model.to_yaml() model_from_yaml(yaml_str)
def test_nested_sequential(in_tmpdir): (x_train, y_train), (x_test, y_test) = _get_test_data() inner = Sequential() inner.add(Dense(num_hidden, input_shape=(input_dim,))) inner.add(Activation('relu')) inner.add(Dense(num_classes)) middle = Sequential() middle.add(inner) model = Sequential() model.add(middle) model.add(Activation('softmax')) model.compile(loss='categorical_crossentropy', optimizer='rmsprop') model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, verbose=1, validation_data=(x_test, y_test)) model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, verbose=2, validation_split=0.1) model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, verbose=0) model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, verbose=1, shuffle=False) model.train_on_batch(x_train[:32], y_train[:32]) loss = model.evaluate(x_test, y_test, verbose=0) model.predict(x_test, verbose=0) model.predict_classes(x_test, verbose=0) model.predict_proba(x_test, verbose=0) fname = 'test_nested_sequential_temp.h5' model.save_weights(fname, overwrite=True) inner = Sequential() inner.add(Dense(num_hidden, input_shape=(input_dim,))) inner.add(Activation('relu')) inner.add(Dense(num_classes)) middle = Sequential() middle.add(inner) model = Sequential() model.add(middle) model.add(Activation('softmax')) model.compile(loss='categorical_crossentropy', optimizer='rmsprop') model.load_weights(fname) os.remove(fname) nloss = model.evaluate(x_test, y_test, verbose=0) assert(loss == nloss) # test serialization config = model.get_config() Sequential.from_config(config) model.summary() json_str = model.to_json() model_from_json(json_str) yaml_str = model.to_yaml() model_from_yaml(yaml_str)
def test_merge_sum(): (x_train, y_train), (x_test, y_test) = _get_test_data() left = Sequential() left.add(Dense(num_hidden, input_shape=(input_dim,))) left.add(Activation('relu')) right = Sequential() right.add(Dense(num_hidden, input_shape=(input_dim,))) right.add(Activation('relu')) model = Sequential() model.add(Merge([left, right], mode='sum')) model.add(Dense(num_class)) model.add(Activation('softmax')) model.compile(loss='categorical_crossentropy', optimizer='rmsprop') model.fit([x_train, x_train], y_train, batch_size=batch_size, epochs=epochs, verbose=0, validation_data=([x_test, x_test], y_test)) model.fit([x_train, x_train], y_train, batch_size=batch_size, epochs=epochs, verbose=0, validation_split=0.1) model.fit([x_train, x_train], y_train, batch_size=batch_size, epochs=epochs, verbose=0) model.fit([x_train, x_train], y_train, batch_size=batch_size, epochs=epochs, verbose=0, shuffle=False) loss = model.evaluate([x_test, x_test], y_test, verbose=0) model.predict([x_test, x_test], verbose=0) model.predict_classes([x_test, x_test], verbose=0) model.predict_proba([x_test, x_test], verbose=0) # test weight saving fname = 'test_merge_sum_temp.h5' model.save_weights(fname, overwrite=True) left = Sequential() left.add(Dense(num_hidden, input_shape=(input_dim,))) left.add(Activation('relu')) right = Sequential() right.add(Dense(num_hidden, input_shape=(input_dim,))) right.add(Activation('relu')) model = Sequential() model.add(Merge([left, right], mode='sum')) model.add(Dense(num_class)) model.add(Activation('softmax')) model.load_weights(fname) os.remove(fname) model.compile(loss='categorical_crossentropy', optimizer='rmsprop') nloss = model.evaluate([x_test, x_test], y_test, verbose=0) assert(loss == nloss) # test serialization config = model.get_config() Sequential.from_config(config) model.summary() json_str = model.to_json() model_from_json(json_str) yaml_str = model.to_yaml() model_from_yaml(yaml_str)
def test_merge_sum(): (X_train, y_train), (X_test, y_test) = _get_test_data() left = Sequential() left.add(Dense(nb_hidden, input_shape=(input_dim,))) left.add(Activation('relu')) right = Sequential() right.add(Dense(nb_hidden, input_shape=(input_dim,))) right.add(Activation('relu')) model = Sequential() model.add(Merge([left, right], mode='sum')) model.add(Dense(nb_class)) model.add(Activation('softmax')) model.compile(loss='categorical_crossentropy', optimizer='rmsprop') model.fit([X_train, X_train], y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=0, validation_data=([X_test, X_test], y_test)) model.fit([X_train, X_train], y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=0, validation_split=0.1) model.fit([X_train, X_train], y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=0) model.fit([X_train, X_train], y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=0, shuffle=False) loss = model.evaluate([X_test, X_test], y_test, verbose=0) model.predict([X_test, X_test], verbose=0) model.predict_classes([X_test, X_test], verbose=0) model.predict_proba([X_test, X_test], verbose=0) # test weight saving fname = 'test_merge_sum_temp.h5' model.save_weights(fname, overwrite=True) left = Sequential() left.add(Dense(nb_hidden, input_shape=(input_dim,))) left.add(Activation('relu')) right = Sequential() right.add(Dense(nb_hidden, input_shape=(input_dim,))) right.add(Activation('relu')) model = Sequential() model.add(Merge([left, right], mode='sum')) model.add(Dense(nb_class)) model.add(Activation('softmax')) model.load_weights(fname) os.remove(fname) model.compile(loss='categorical_crossentropy', optimizer='rmsprop') nloss = model.evaluate([X_test, X_test], y_test, verbose=0) assert(loss == nloss) # test serialization config = model.get_config() Sequential.from_config(config) model.summary() json_str = model.to_json() model_from_json(json_str) yaml_str = model.to_yaml() model_from_yaml(yaml_str)
def test_vector_classification(): ''' Classify random float vectors into 2 classes with logistic regression using 2 layer neural network with ReLU hidden units. ''' (x_train, y_train), (x_test, y_test) = get_test_data(num_train=500, num_test=200, input_shape=(20, ), classification=True, num_classes=num_classes) y_train = to_categorical(y_train) y_test = to_categorical(y_test) # Test with Sequential API model = Sequential([ layers.Dense(16, input_shape=(x_train.shape[-1], ), activation='relu'), layers.Dense(8), layers.Activation('relu'), layers.Dense(num_classes, activation='softmax') ]) model.compile(loss='categorical_crossentropy', optimizer=keras.optimizers.Adam(1e-3), metrics=['accuracy']) model.summary() history = model.fit(x_train, y_train, epochs=15, batch_size=16, validation_data=(x_test, y_test), verbose=0) assert (history.history['val_accuracy'][-1] > 0.8) config = model.get_config() model = Sequential.from_config(config)
def randomize_layers(nb_layers, old_model, model_type='Model'): """ Randomize the n top layers of a model. In lack of a better solution, for now this function generate a new model, and then copy the weigts of the old model.""" config = old_model.get_config() if model_type == 'Model': new_model = Model.from_config(config) elif model_type == 'Sequential': new_model = Sequential.from_config(config) else: print('Wrong parameter, model can only be Sequential or Model.') if nb_layers == -1: nb_layers = len(new_model.layers) else: nb_layers = min(nb_layers, len(new_model.layers)) # Copy the weights of the non-randomized layers. for layer_i in range(len(new_model.layers) - nb_layers): new_model.layers[layer_i].set_weights( old_model.layers[layer_i].get_weights()) del old_model return new_model
def _build_models(self, batch_size, embedding_size, rnn_size, num_layers): model = Sequential() model.add( Embedding(self.vectorizer.vocab_size, embedding_size, batch_input_shape=(batch_size, None))) for layer in range(num_layers): model.add(LSTM(rnn_size, stateful=True, return_sequences=True)) model.add(Dropout(0.2)) model.add( TimeDistributed( Dense(self.vectorizer.vocab_size, activation='softmax'))) # With sparse_categorical_crossentropy we can leave as labels as # integers instead of one-hot vectors model.compile(loss='sparse_categorical_crossentropy', optimizer='rmsprop', metrics=['accuracy']) model.summary() # Keep a separate model with batch_size 1 for training self.train_model = model config = model.get_config() config[0]['config']['batch_input_shape'] = (1, None) self.sample_model = Sequential.from_config(config) self.sample_model.trainable = False
def create_duplicate_model(model): """Create a duplicate keras model.""" new_model = Sequential.from_config(model.get_config()) new_model.set_weights(copy.deepcopy(model.get_weights())) new_model.compile(loss=model.loss, optimizer=model.optimizer) return new_model
def test_image_classification(): np.random.seed(1337) input_shape = (16, 16, 3) (x_train, y_train), (x_test, y_test) = get_test_data(num_train=500, num_test=200, input_shape=input_shape, classification=True, num_classes=4) y_train = to_categorical(y_train) y_test = to_categorical(y_test) model = Sequential([ layers.Conv2D(filters=8, kernel_size=3, activation='relu', input_shape=input_shape), layers.MaxPooling2D(pool_size=2), layers.Conv2D(filters=4, kernel_size=(3, 3), activation='relu', padding='same'), layers.GlobalAveragePooling2D(), layers.Dense(y_test.shape[-1], activation='softmax') ]) model.compile(loss='categorical_crossentropy', optimizer='rmsprop', metrics=['accuracy']) model.summary() history = model.fit(x_train, y_train, epochs=10, batch_size=16, validation_data=(x_test, y_test), verbose=0) assert history.history['val_acc'][-1] > 0.75 config = model.get_config() model = Sequential.from_config(config)
def test_vector_classification(): ''' Classify random float vectors into 2 classes with logistic regression using 2 layer neural network with ReLU hidden units. ''' (x_train, y_train), (x_test, y_test) = get_test_data(num_train=500, num_test=200, input_shape=(20,), classification=True, num_classes=2) y_train = to_categorical(y_train) y_test = to_categorical(y_test) # Test with Sequential API model = Sequential([ layers.Dense(16, input_shape=(x_train.shape[-1],), activation='relu'), layers.Dense(8), layers.Activation('relu'), layers.Dense(y_train.shape[-1], activation='softmax') ]) model.compile(loss='categorical_crossentropy', optimizer='rmsprop', metrics=['accuracy']) model.summary() history = model.fit(x_train, y_train, epochs=15, batch_size=16, validation_data=(x_test, y_test), verbose=0) assert(history.history['val_acc'][-1] > 0.8) config = model.get_config() model = Sequential.from_config(config)
def __init__(self, num_actions, input_shape, **kwargs): # set params self.time_step = 0 self.num_actions = num_actions self.discount = kwargs.get('discount', 0.99) self.c = kwargs.get( 'c', 10000) # how many time steps between target network updates self.batch_size = kwargs.get('batch_size', 32) self.hist_length = kwargs.get('hist_length', 4) # build conv model q_model = Sequential() q_model.add( Convolution2D(32, (8, 8), activation='relu', input_shape=input_shape, dim_ordering='th', strides=(4, 4))) q_model.add(BatchNormalization()) q_model.add( Convolution2D(64, (4, 4), activation='relu', strides=(2, 2))) q_model.add(BatchNormalization()) q_model.add( Convolution2D(64, (3, 3), activation='relu', strides=(1, 1))) q_model.add(BatchNormalization()) q_model.add(Flatten()) q_model.add(Dense(512, activation='relu')) q_model.add(BatchNormalization()) q_model.add(Dense(num_actions, activation='linear')) q_model.compile(optimizer='RMSprop', loss=huber_loss) self.q_model = q_model self.q_target_model = Sequential.from_config( q_model.get_config()) # create target model
def test_temporal_classification(): ''' Classify temporal sequences of float numbers of length 3 into 2 classes using single layer of GRU units and softmax applied to the last activations of the units ''' np.random.seed(1337) (x_train, y_train), (x_test, y_test) = get_test_data(num_train=200, num_test=20, input_shape=(3, 4), classification=True, num_classes=2) y_train = to_categorical(y_train) y_test = to_categorical(y_test) model = Sequential() model.add(layers.GRU(8, input_shape=(x_train.shape[1], x_train.shape[2]))) model.add(layers.Dense(y_train.shape[-1], activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer='rmsprop', metrics=['accuracy']) model.summary() history = model.fit(x_train, y_train, epochs=5, batch_size=10, validation_data=(x_test, y_test), verbose=0) assert(history.history['accuracy'][-1] >= 0.8) config = model.get_config() model = Sequential.from_config(config)
def test_nested_sequential(): (X_train, y_train), (X_test, y_test) = _get_test_data() inner = Sequential() inner.add(Dense(nb_hidden, input_shape=(input_dim,))) inner.add(Activation("relu")) inner.add(Dense(nb_class)) middle = Sequential() middle.add(inner) model = Sequential() model.add(middle) model.add(Activation("softmax")) model.compile(loss="categorical_crossentropy", optimizer="rmsprop") model.fit(X_train, y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=1, validation_data=(X_test, y_test)) model.fit(X_train, y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=2, validation_split=0.1) model.fit(X_train, y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=0) model.fit(X_train, y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=1, shuffle=False) model.train_on_batch(X_train[:32], y_train[:32]) loss = model.evaluate(X_test, y_test, verbose=0) model.predict(X_test, verbose=0) model.predict_classes(X_test, verbose=0) model.predict_proba(X_test, verbose=0) fname = "test_nested_sequential_temp.h5" model.save_weights(fname, overwrite=True) inner = Sequential() inner.add(Dense(nb_hidden, input_shape=(input_dim,))) inner.add(Activation("relu")) inner.add(Dense(nb_class)) middle = Sequential() middle.add(inner) model = Sequential() model.add(middle) model.add(Activation("softmax")) model.compile(loss="categorical_crossentropy", optimizer="rmsprop") model.load_weights(fname) os.remove(fname) nloss = model.evaluate(X_test, y_test, verbose=0) assert loss == nloss # test serialization config = model.get_config() new_model = Sequential.from_config(config) model.summary() json_str = model.to_json() new_model = model_from_json(json_str) yaml_str = model.to_yaml() new_model = model_from_yaml(yaml_str)
def test_recursive(): # test layer-like API graph = Graph() graph.add_input(name='input1', input_shape=(32, )) graph.add_node(Dense(16), name='dense1', input='input1') graph.add_node(Dense(4), name='dense2', input='input1') graph.add_node(Dense(4), name='dense3', input='dense1') graph.add_output(name='output1', inputs=['dense2', 'dense3'], merge_mode='sum') seq = Sequential() seq.add(Dense(32, input_shape=(32, ))) seq.add(graph) seq.add(Dense(4)) seq.compile('rmsprop', 'mse') seq.fit(X_train_graph, y_train_graph, batch_size=10, nb_epoch=10) loss = seq.evaluate(X_test_graph, y_test_graph) # test serialization config = seq.get_config() new_graph = Sequential.from_config(config) seq.summary() json_str = seq.to_json() new_graph = model_from_json(json_str) yaml_str = seq.to_yaml() new_graph = model_from_yaml(yaml_str)
def Initialize(self): self.SetStartDate(2019, 1, 1) # Set Start Date self.SetEndDate(2020, 4, 1) # Set End Date self.SetCash(100000) # Set Strategy Cash self.modelBySymbol = {} for ticker in ["SPY", "QQQ", "TLT"]: symbol = self.AddEquity(ticker).Symbol # Read the model saved in the ObjectStore if self.ObjectStore.ContainsKey(f'{symbol}_model'): modelStr = self.ObjectStore.Read(f'{symbol}_model') config = json.loads(modelStr)['config'] self.modelBySymbol[symbol] = Sequential.from_config(config) self.Debug( f'Model for {symbol} sucessfully retrieved from the ObjectStore' ) # Look-back period for training set self.lookback = 30 # Train Neural Network every monday self.Train(self.DateRules.Every(DayOfWeek.Monday), self.TimeRules.AfterMarketOpen("SPY"), self.NeuralNetworkTraining) # Place trades on Monday, 30 minutes after the market is open self.Schedule.On(self.DateRules.EveryDay("SPY"), self.TimeRules.AfterMarketOpen("SPY", 30), self.Trade)
def test_image_classification(): np.random.seed(1337) input_shape = (16, 16, 3) (x_train, y_train), (x_test, y_test) = get_test_data(num_train=500, num_test=200, input_shape=input_shape, classification=True, num_classes=4) y_train = to_categorical(y_train) y_test = to_categorical(y_test) model = Sequential([ layers.Conv2D(filters=8, kernel_size=3, activation='relu', input_shape=input_shape), layers.MaxPooling2D(pool_size=2), layers.Conv2D(filters=4, kernel_size=(3, 3), activation='relu', padding='same'), layers.GlobalAveragePooling2D(), layers.Dense(y_test.shape[-1], activation='softmax') ]) model.compile(loss='categorical_crossentropy', optimizer='rmsprop', metrics=['accuracy']) model.summary() history = model.fit(x_train, y_train, epochs=10, batch_size=16, validation_data=(x_test, y_test), verbose=0) assert history.history['val_acc'][-1] > 0.75 config = model.get_config() model = Sequential.from_config(config)
def get_hard_target_model_updates(target, source, dueling=False): """Return list of target model update ops. These are hard target updates. The source weights are copied directly to the target network. Parameters ---------- target: keras.models.Model The target model. Should have same architecture as source model. source: keras.models.Model The source model. Should have same architecture as target model. dueling: Boolean Dueling architecture Returns ------- list(tf.Tensor) List of tensor update ops. """ config_src = source.get_config() weights_src = source.get_weights() if dueling: target = Model.from_config(config_src) else: target = Sequential.from_config(config_src) target.set_weights(weights_src) return target
def model(self): """ Model component of Learner object, implemented as cached_property so that model persisitance can be achieved with all of the different types of models from different libraries. """ # scikit-learn model definition if isinstance(self._model, BaseEstimator): model = self._model # keras classifier object elif 'KerasClassifier' in str(type(self._model)): model = self._model # keras model definition elif isinstance(self._model, dict) and 'config' in self._model: from keras.models import Sequential from keras.wrappers import scikit_learn cl = getattr(scikit_learn, self._model['type'])(lambda: 1) cl.model = Sequential.from_config(self._model['config']) cl.model.set_weights(self._model['weights']) if self._model['type'] == 'KerasClassifier': cl.classes_ = self._model['classes'] cl.n_classes_ = self._model['n_classes'] model = cl # pickle object elif isinstance(self._model, basestring): model = joblib.load(self._model) return model
def test_recursive(): # test layer-like API graph = Graph() graph.add_input(name='input1', input_shape=(32,)) graph.add_node(Dense(16), name='dense1', input='input1') graph.add_node(Dense(4), name='dense2', input='input1') graph.add_node(Dense(4), name='dense3', input='dense1') graph.add_output(name='output1', inputs=['dense2', 'dense3'], merge_mode='sum') seq = Sequential() seq.add(Dense(32, input_shape=(32,))) seq.add(graph) seq.add(Dense(4)) seq.compile('rmsprop', 'mse') seq.fit(X_train_graph, y_train_graph, batch_size=10, nb_epoch=10) loss = seq.evaluate(X_test_graph, y_test_graph) # test serialization config = seq.get_config() new_graph = Sequential.from_config(config) seq.summary() json_str = seq.to_json() new_graph = model_from_json(json_str) yaml_str = seq.to_yaml() new_graph = model_from_yaml(yaml_str)
def fisher_sample(self): if self.sampler is None: print("preprocessing") if self.dico_fisher is None: print('you need to compute the fisher information first') return self.sampler = Sampling(self.build_mean(), self.dico_fisher) print('sampling ok') config = self.network.get_config() if self.network.__class__.__name__=='Sequential': new_model = Sequential.from_config(config) else: new_model = Model.from_config(config) new_params = self.sampler.sample() """ means = self.sampler.mean for key in means: if np.max(np.abs(means[key] - new_params[key]))==0: print key print('kikou') import pdb; pdb.set_trace() """ #tmp_prob = self.sampler.prob(new_params) new_model.compile(loss=self.network.loss, optimizer=str.lower(self.network.optimizer.__class__.__name__), metrics = self.network.metrics) new_model.set_weights(self.network.get_weights()) self.copy_weights(new_model, new_params) return new_model
def test_temporal_classification(): ''' Classify temporal sequences of float numbers of length 3 into 2 classes using single layer of GRU units and softmax applied to the last activations of the units ''' np.random.seed(1337) (x_train, y_train), (x_test, y_test) = get_test_data(num_train=200, num_test=20, input_shape=(3, 4), classification=True, num_classes=2) y_train = to_categorical(y_train) y_test = to_categorical(y_test) model = Sequential() model.add(layers.GRU(8, input_shape=(x_train.shape[1], x_train.shape[2]))) model.add(layers.Dense(y_train.shape[-1], activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer='rmsprop', metrics=['accuracy']) model.summary() history = model.fit(x_train, y_train, epochs=4, batch_size=10, validation_data=(x_test, y_test), verbose=0) assert(history.history['acc'][-1] >= 0.8) config = model.get_config() model = Sequential.from_config(config)
def create_duplicate_model(model): """Create a duplicate keras model.""" new_model = Sequential.from_config(model.get_config()) new_model.set_weights(copy.deepcopy(model.get_weights())) new_model.compile(loss=model.loss,optimizer=model.optimizer) return new_model
def clone_model(model, custom_objects={}): config = model.get_config() try: clone = Sequential.from_config(config, custom_objects) except: clone = Model.from_config(config, custom_objects) clone.set_weights(model.get_weights()) return clone
def clone_model(model, custom_objects={}): config = model.get_config() try: clone = Sequential.from_config(config, custom_objects) except: clone = Model.from_config(config, custom_objects) clone.set_weights(model.get_weights()) return clone
def export_model_to_tensorflow(path_to_trained_keras_model: str): print("Loading model for exporting to Protocol Buffer format...") model = keras.models.load_model(path_to_trained_keras_model) sess = K.get_session() # serialize the model and get its weights, for quick re-building config = model.get_config() weights = model.get_weights() # re-build a model where the learning phase is now hard-coded to 0 new_model = Sequential.from_config(config) new_model.set_weights(weights) export_path = os.path.abspath(os.path.join("export", "simple")) # where to save the exported graph os.makedirs(export_path) checkpoint_state_name = "checkpoint_state" export_version = 1 # version number (integer) saver = tensorflow.train.Saver(sharded=True, name=checkpoint_state_name) model_exporter = exporter.Exporter(saver) signature = exporter.classification_signature(input_tensor=model.input, scores_tensor=model.output) # # Version 1 of exporter # model_exporter.init(sess.graph.as_graph_def(), default_graph_signature=signature) # model_exporter.export(export_path, tensorflow.constant(export_version), sess) # # # Version 2 of exporter # tensorflow.train.write_graph(sess.graph.as_graph_def(), logdir=".", name="simple.pbtxt", as_text=True) # Version 3 with Freezer from https://github.com/tensorflow/tensorflow/blob/master/tensorflow/python/tools/freeze_graph_test.py input_graph_name = "input_graph.pb" output_graph_name = "output_graph.pb" saver_write_version = saver_pb2.SaverDef.V2 # We'll create an input graph that has a single variable containing 1.0, # and that then multiplies it by 2. saver = tensorflow.train.Saver(write_version=saver_write_version) checkpoint_path = saver.save(sess, export_path, global_step=0, latest_filename=checkpoint_state_name) graph_io.write_graph(sess.graph, export_path, input_graph_name) # We save out the graph to disk, and then call the const conversion # routine. input_graph_path = os.path.join(export_path, input_graph_name) input_saver_def_path = "" input_binary = False output_node_names = "output_node/Softmax" restore_op_name = "save/restore_all" filename_tensor_name = "save/Const:0" output_graph_path = os.path.join(export_path, output_graph_name) clear_devices = False freeze_graph.freeze_graph(input_graph_path, input_saver_def_path, input_binary, checkpoint_path, output_node_names, restore_op_name, filename_tensor_name, output_graph_path, clear_devices, "") shutil.copy(os.path.join("export", "simple", "output_graph.pb"), output_graph_name) shutil.rmtree("export") print("Exported model: {0}".format(os.path.abspath(output_graph_name)))
def load_model(self, model_bin): model_data = pickle.loads(model_bin) m_model, m_weights = model_data['model'], model_data['weights'] self.__X_scale, self.__Y_scale = model_data['x_scale'], model_data[ 'y_scale'] self.__model = Sequential.from_config(m_model) self.__model.set_weights(np.array(m_weights))
def __init__ (self, model, max_memory=2000, discount=0.7, unfreeze_count=5): self.max_memory = max_memory self.discount = discount self.unfreeze_count = unfreeze_count self.memory = [] self.buffer = [] self.frozen_model = Sequential.from_config (model.get_config ()) self.frozen_model.compile (sgd(lr=.01), "mse")
def _clone_model(self, model: Model): ''' Clone an existing Keras model :return: A copy of the input model ''' if isinstance(model, Sequential): return Sequential.from_config(model.get_config()) elif isinstance(model, Model): return Model.from_config(model.get_config())
def __init__(self, config, training, evaluating): self.config = config self.model = Sequential.from_config(self.config['sequential']) self.model.compile(loss = self.config['compilation']['loss'], optimizer = self.config['compilation']['optimizer'], metrics = self.config['compilation']['metrics']) self.training = training self.evaluating = evaluating self.config = deepcopy(config) # for the sake of simplicity later: self.config["compilation"]["metrics"] = ['loss'] + self.config["compilation"]["metrics"]
def __init__ (self, model, max_memory, discount, unfreeze_count, num_actions): self.max_memory = max_memory self.discount = discount self.unfreeze_count = unfreeze_count self.num_actions = num_actions self.memory = list () # TODO dont assume sequential model # note taining algo has no affect because frozen model is never trianed self.frozen_model = Sequential.from_config (model.get_config ()) self.frozen_model.compile (sgd(lr=.01), "mse")
def build_inference_model(model, batch_size=1, seq_len=1): """ Build inference model from model config. Input shape modified to (1, 1) """ logger.info("building inference model.") config = model.get_config() # Edit batch_size and seq_len config[0]["config"]["batch_input_shape"] = (batch_size, seq_len) inference_model = Sequential.from_config(config) inference_model.trainable = False return inference_model
def keras_model_deep_copy(keras_model): config = keras_model.get_config() if isinstance(keras_model, Sequential): new_model = Sequential.from_config(config) else: new_model = model_from_config(config) shuffle_weights(new_model) loss = keras_model.loss metrics = keras_model.metrics optimizer = keras_model.optimizer new_model.compile(optimizer, loss, metrics) return new_model
def deepcopy_CNN(self, base_estimator0): #Copy CNN (self.base_estimator_) to estimator: config=base_estimator0.get_config() #estimator = Models.model_from_config(config) estimator = Sequential.from_config(config) weights = base_estimator0.get_weights() estimator.set_weights(weights) estimator.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) return estimator
def build_model(self): super(DoubleDQN, self).build_model() model2 = Sequential.from_config(self.model.get_config()) logger.info("Model 2 summary") model2.summary() self.model2 = model2 self.model2.compile( loss='mean_squared_error', optimizer=self.optimizer) logger.info("Models built and compiled") return self.model, self.model2
def load(self, path=None): if path: self.model_path = path print('Loading..') with open(self.model_path) as f: data = json.load(f) self.inputs, self.targets = data["inputs"], data["targets"] keras_model = Sequential.from_config(data["k_model"]) keras_model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) self.model = Model(kmodel=keras_model) return self
def clone_model(model, custom_objects={}): if len(custom_objects) > 0: warnings.warn('Due to an API problem with Keras, custom_objects is currently ignored. Sorry about that.') config = model.get_config() try: # TODO: re-enable custom_objects clone = Sequential.from_config(config) except: # TODO: re-enable custom_objects clone = Model.from_config(config) clone.set_weights(model.get_weights()) return clone
def _build_inference_model(model: Model, batch_size=1, seq_len=1) -> Model: """ build inference model from model config input shape modified to (1, 1) """ print("building inference model.") config = model.get_config() # edit batch_size and seq_len config[0]["config"]["batch_input_shape"] = (batch_size, seq_len) inference_model = Sequential.from_config(config) inference_model.trainable = False return inference_model
def Mitosis_IA(Player,grupo): # No se como hacer un metodo que replique otro individuo sin liarme con los atributos, por eso he hecho una funcion externa, # pero igual es mejor un metodo para que sea todo mas elegante jugador = player_IA() # Nuevo agente new_model = Sequential.from_config(Player.config_model) # Mismo red neuronal new_model.set_weights(Player.Pesos) # Mismos pesos jugador.model = new_model # Asignacion de la red clonada jugador.config_model = Player.config_model # Almacena su nuevo modelo por si se reproduce jugador.Pesos = Player.Pesos # Almacena sus nuevos pesos por si se reproduce jugador.energia = Player.energia / 10 # Se quedan un 10% de la energia que tenia el individuo original perdiendo un 80% en el proceso Player.energia = Player.energia / 10 # Se quedan un 10% de la energia que tenia el individuo original perdiendo un 80% en el proceso jugador.vmax = Player.vmax + Player.vmax * (rd.random() - rd.random()) # Puede aumentar o disminuir la velocidad del nuevo individuo grupo.add(jugador) # Se añade a la lista de agentes return grupo
def build_model_from_file(model_file): # a,b,c = pickle.load(open(model_file, 'rb')) print(model_file) structure, weights = pickle.load(open(model_file, 'rb')) # print("XXXXXXXXXXXXXXXX"+str(structure)) model = Sequential.from_config(structure) # print("YYYYYYYYYYYYYYy") model.set_weights(weights) # print("zzzzzzzzzzzzzzz") return model
def keras_spark_predict(model_path, weights_path, partition): # load model model = Sequential.from_config(model_path.value) model.set_weights(weights_path.value) # Create a list containing features. featurs_list = map(lambda x: [x[:]], partition) featurs_df = pd.DataFrame(featurs_list) # predict with keras model predictions = model.predict_on_batch(featurs_df) predictions_return = map(lambda prediction: Row(prediction=prediction[0].item()), predictions) return iter(predictions_return)
def create_dropout_predict_function(model, dropout): """ Create a keras function to predict with dropout model : keras model dropout : fraction dropout to apply to all layers Returns predict_with_dropout : keras function for predicting with dropout """ # Load the config of the original model conf = model.get_config() # Add the specified dropout to all layers for layer in conf['layers']: # Dropout layers if layer["class_name"] == "Dropout": layer["config"]["rate"] = dropout print('config-rate') # Recurrent layers with dropout elif "dropout" in layer["config"].keys(): layer["config"]["dropout"] = dropout print(layer["config"]["dropout"],'config-droupout') # Create a new model with specified dropout if type(model) == Sequential: # Sequential newmodel = keras.models.clone_model(model) # newmodel.compile(optimizer='adam', # loss='mse', # metric='mse') # newmodel.set_weights(model.get_weights()) model_dropout = Sequential.from_config(conf) # print('model1') else: # Functional model_dropout = Model.from_config(conf) # print('model2') model_dropout.set_weights(model.get_weights()) # model_dropout.compile(optimizer='adam', # loss='mse') # final_conv_layer = get_output_layer(model, "conv5_3") # get_output = K.function([model.layers[0].input], # [final_conv_layer.output, model.layers[-1].output]) # [conv_outputs, predictions] = get_output([img]) # Create a function to predict with the dropout on predict_with_dropout = K.function([model_dropout.layers[0].input,K.learning_phase()], [model_dropout.layers[-1].output]) return predict_with_dropout
def cross_valid(model, model_name, input_type='2d', epochs=5, batch_size=32): (xtrain, ytrain), (xvalid, yvalid), (xtest, ytest) = md.load_mnist() #model = create_model(model_name) #history=HistoryCallback() model_config = model.get_config() print(model.summary()) if (not model_name in os.listdir(".")): os.mkdir(model_name) os.chdir(model_name) md.save_model(model_name, model) out_name = "{0}_train_res.txt".format(model_name) res = open(out_name, "w") for i in range(1, 6): print("\nИтерация {}".format(i)) #model = create_model() #history=HistoryCallback() h = model.fit(xtrain, ytrain, epochs=epochs, batch_size=batch_size, validation_data=(xvalid, yvalid)) swap_intl = range((i - 1) * 10000, (i * 10000 - 1)) swap = (xtrain[swap_intl], ytrain[swap_intl]) (xtrain[swap_intl], ytrain[swap_intl]) = (xvalid[0:9999], yvalid[0:9999]) (xvalid, yvalid) = swap model.save_weights("{}-{}_weights.h5".format(model_name, i)) print("evaluating...") score = model.evaluate(xtest, ytest) res.write("#, vloss, vacc, tloss, tvacc, %\n") y = model.predict(xtest) pc = md.predict_percent(y, ytest) res.write("{0},{1},{2},{3},{4},{5}\n".format(i, h.history["val_loss"], h.history["val_acc"], score[0], score[1], pc)) res.flush() del model model = Sequential.from_config(model_config) model.compile(loss=keras.losses.categorical_crossentropy, optimizer=keras.optimizers.Adadelta(), metrics=['accuracy']) res.close() os.chdir("..")
def test_merge_overlap(): (X_train, y_train), (X_test, y_test) = _get_test_data() left = Sequential() left.add(Dense(nb_hidden, input_shape=(input_dim,))) left.add(Activation('relu')) model = Sequential() model.add(Merge([left, left], mode='sum')) model.add(Dense(nb_class)) model.add(Activation('softmax')) model.compile(loss='categorical_crossentropy', optimizer='rmsprop') model.fit(X_train, y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=1, validation_data=(X_test, y_test)) model.fit(X_train, y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=2, validation_split=0.1) model.fit(X_train, y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=0) model.fit(X_train, y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=1, shuffle=False) model.train_on_batch(X_train[:32], y_train[:32]) loss = model.evaluate(X_test, y_test, verbose=0) model.predict(X_test, verbose=0) model.predict_classes(X_test, verbose=0) model.predict_proba(X_test, verbose=0) fname = 'test_merge_overlap_temp.h5' print(model.layers) model.save_weights(fname, overwrite=True) print(model.trainable_weights) model.load_weights(fname) os.remove(fname) nloss = model.evaluate(X_test, y_test, verbose=0) assert(loss == nloss) # test serialization config = model.get_config() new_model = Sequential.from_config(config) model.summary() json_str = model.to_json() new_model = model_from_json(json_str) yaml_str = model.to_yaml() new_model = model_from_yaml(yaml_str)
def __init__(self, env, nn = None, **config): """ Based on: https://www.cs.toronto.edu/~vmnih/docs/dqn.pdf Parameters """ # if not isinstance(env.action_space, discrete.Discrete): # raise UnsupportedSpace('Action space {} incompatible with {}. (Only supports Discrete action spaces.)'.format(action_space, self)) self.env = env self.config = { 'eps': 0.05, 'gamma': 0.95, 'store_every':5, 'train_every':5, 'minibatch_size': 1, 'max_experience': 5000, 'target_nn_update_rate': 0.01, 'maxepoch': 100, 'maxstep': 100, 'outdir': '/tmp/brainresults', 'plot': True, 'render': True, } self.config.update(config) self.plotter = LivePlot(self.config['outdir']) # Deep Q Agent State self._action_ctr = 0 # actions excuted so far self._iter_ctr = 0 self._store_ctr = 0 self._train_ctr = 0 self._experience = deque() self.nn = nn # The keras network should be compiled outside self.tnn = Sequential.from_config(nn.get_config()) # Init target NN self.tnn.set_weights(self.nn.get_weights())
def load_keras_model_from_disk( model_json_path, weights_hdf_path, name=None): """ Loads a model from two files on disk: a JSON configuration and HDF5 weights. Parameters ---------- model_json_path : str weights_hdf_path : str name : str, optional Returns a Keras model. """ if not exists(model_json_path): raise ValueError("Model file %s (name = %s) not found" % ( model_json_path, name,)) with open(model_json_path, "r") as f: config_dict = json.load(f) if isinstance(config_dict, list): # not sure if this is a Keras bug but depending on the model I get back # either a list or a dict, the list is only usable with a Sequential # model model = Sequential.from_config(config_dict) else: model = model_from_config(config_dict) if weights_hdf_path is not None: if not exists(weights_hdf_path): raise ValueError( "Missing model weights file %s (name = %s)" % (weights_hdf_path, name)) model.load_weights(weights_hdf_path) return model
def test_sequential_deferred_build(): model = keras.models.Sequential() model.add(keras.layers.Dense(3)) model.add(keras.layers.Dense(3)) model.compile('sgd', 'mse') assert model.built is False assert len(model.layers) == 2 assert len(model.weights) == 0 model.train_on_batch( np.random.random((2, 4)), np.random.random((2, 3))) assert model.built is True assert len(model.layers) == 2 assert len(model.weights) == 4 # Test serialization config = model.get_config() assert 'name' in config new_model = Sequential.from_config(config) assert new_model.built is True assert len(new_model.layers) == 2 assert len(new_model.weights) == 4
def test_sequential(in_tmpdir): (x_train, y_train), (x_test, y_test) = _get_test_data() # TODO: factor out def data_generator(x, y, batch_size=50): index_array = np.arange(len(x)) while 1: batches = make_batches(len(x_test), batch_size) for batch_index, (batch_start, batch_end) in enumerate(batches): batch_ids = index_array[batch_start:batch_end] x_batch = x[batch_ids] y_batch = y[batch_ids] yield (x_batch, y_batch) model = Sequential() model.add(Dense(num_hidden, input_shape=(input_dim,))) model.add(Activation('relu')) model.add(Dense(num_classes)) model.add(Activation('softmax')) model.compile(loss='categorical_crossentropy', optimizer='rmsprop') model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, verbose=1, validation_data=(x_test, y_test)) model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, verbose=2, validation_split=0.1) model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, verbose=0) model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, verbose=1, shuffle=False) model.train_on_batch(x_train[:32], y_train[:32]) loss = model.evaluate(x_test, y_test) prediction = model.predict_generator(data_generator(x_test, y_test), 1, max_queue_size=2, verbose=1) gen_loss = model.evaluate_generator(data_generator(x_test, y_test, 50), 1, max_queue_size=2) pred_loss = K.eval(K.mean(losses.get(model.loss)(K.variable(y_test), K.variable(prediction)))) assert(np.isclose(pred_loss, loss)) assert(np.isclose(gen_loss, loss)) model.predict(x_test, verbose=0) model.predict_classes(x_test, verbose=0) model.predict_proba(x_test, verbose=0) fname = 'test_sequential_temp.h5' model.save_weights(fname, overwrite=True) model = Sequential() model.add(Dense(num_hidden, input_shape=(input_dim,))) model.add(Activation('relu')) model.add(Dense(num_classes)) model.add(Activation('softmax')) model.compile(loss='categorical_crossentropy', optimizer='rmsprop') model.load_weights(fname) os.remove(fname) nloss = model.evaluate(x_test, y_test, verbose=0) assert(loss == nloss) # Test serialization config = model.get_config() assert 'name' in config new_model = Sequential.from_config(config) assert new_model.weights # Model should be built. model.summary() json_str = model.to_json() model_from_json(json_str) yaml_str = model.to_yaml() model_from_yaml(yaml_str)
import json from keras.models import model_from_json from keras.datasets import mnist from keras.utils import np_utils from keras.models import Sequential (X_train, y_train), (X_test, y_test) = mnist.load_data() X_test = X_test.reshape(X_test.shape[0], 1, 28, 28) X_test = X_test.astype('float32') X_test /= 255 nb_classes = 10 Y_test = np_utils.to_categorical(y_test, nb_classes) # Load trained model json_string = open('model.json').read() model_config = model_from_json(json_string).get_config() model = Sequential.from_config(model_config) model.compile(loss = 'categorical_crossentropy', optimizer = 'adadelta', metrics=['accuracy']) model.load_weights('modelweights.hdf5') # Evaluate with previously trained model score = model.evaluate(X_test, Y_test, verbose = 0) print('Test score:', score[0]) print('Test accuracy:', score[1])
def visualizeSequentialOutput(model, layerIdx, df): if not os.path.exists(cc.cfg['plots']['seq_output_dir']): os.makedirs(cc.cfg['plots']['seq_output_dir']) if cc.cfg['plots']['seq_output_seq_input_name'] == 'smiles': input = data.formatSequentialInput(df) elif cc.cfg['plots']['seq_output_seq_input_name'] == 'fasta': input = data.formatFastaInput(df) else: raise 'visual err' # model.layers[layerIdx].return_sequences = True # model.compile(loss="mean_squared_error", optimizer="rmsprop") cfg = model.get_config()[:4] cfg = model.get_config()[:layerIdx+1] del cfg[2] layerIdx -= 1 # print cfg cfg[layerIdx]['config']['return_sequences'] = True seqModel = Sequential.from_config(cfg) seqModel.set_weights(model.get_weights()) seqModel.layers[layerIdx].return_sequences = True outputFunction = K.function([seqModel.layers[0].input], [seqModel.layers[layerIdx].output]) output = outputFunction([input])[0] ''' sns.set() for i,smilesOutput in enumerate(output): g = sns.clustermap(smilesOutput.T, col_cluster=False, method='single',metric='cosine') g.savefig('{}/seq_output.png'.format(cc.cfg['plots']['seq_output_dir'])) ''' dropSet = Set(cc.cfg['plots']['seq_output_ignore_neurons']) if cc.cfg['plots']['seq_output_select_neurons']: arrMask = cc.cfg['plots']['seq_output_select_neurons'] else: arrMask = list(range(output.shape[2])) arrMask = np.array([x for x in arrMask if not x in dropSet]) fig = plt.figure(figsize=(input.shape[1] * 0.3,len(arrMask) * len(df) * 1.5)) for i,seqOutput in enumerate(output): # print seqOutput.shape # print seqOutput selected = seqOutput.T[arrMask] Z = sch.linkage(selected, method='single', metric='cosine') leaves = sch.leaves_list(Z) # leaves = range(len(selected)) reordered = selected[leaves] ax = fig.add_subplot(len(df),1,i+1) print 'foo' ppl.pcolormesh(fig, ax, reordered, xticklabels=list(df.values[i][0]), yticklabels=arrMask[leaves], vmin=-1, vmax=1) print 'foo' print 'bar' fig.savefig('{}/{}'.format(cc.cfg['plots']['seq_output_dir'],cc.cfg['plots']['seq_output_name'])) print 'bar'
def printPrediction(model, smilesData): # FIXME hardcoded smilesDf = pd.DataFrame(smilesData, columns=[cc.exp['params']['data']['smiles']]) input = data.formatSequentialInput(smilesDf) output = model.predict(input) for i, smiles in enumerate(smilesData): print 'Prediction for {}'.format(smiles) print output[i] distanceMatrixCosine = pairwise_distances(output, metric='cosine') distanceMatrixCorrel = pairwise_distances(output, metric='correlation') distanceMatrixEuclid = pairwise_distances(output, metric='euclidean') print 'Distance matrix cosine' print distanceMatrixCosine print 'Distance matrix correlation' print distanceMatrixCorrel print 'Distance matrix euclid' print distanceMatrixEuclid ''' layerIdx = 1 cfg = model.get_config()[:layerIdx+1] cfg[0]['config']['dropout_U'] = 0 cfg[0]['config']['dropout_W'] = 0 print cfg[0] print cfg[1] # del cfg[1] # layerIdx -= 1 # print cfg cfg[layerIdx]['config']['return_sequences'] = True ''' layerIdx = 2 cfg = model.get_config()[:layerIdx+1] del cfg[1] layerIdx -= 1 # print cfg cfg[layerIdx]['config']['return_sequences'] = True seqModel = Sequential.from_config(cfg) seqModel.set_weights(model.get_weights()) seqModel.layers[layerIdx].return_sequences = True outputFunction = K.function([seqModel.layers[0].input], [seqModel.layers[layerIdx].output]) outputSymbols = outputFunction([input])[0] outputLastSymbol = outputSymbols[:,outputSymbols.shape[1]-1,:] distanceMatrixLastSymbolCorrel = np.corrcoef(outputLastSymbol) print 'Distance matrix last symbol correlation' print distanceMatrixLastSymbolCorrel
def test_merge_recursivity(): (X_train, y_train), (X_test, y_test) = _get_test_data() left = Sequential() left.add(Dense(nb_hidden, input_shape=(input_dim,))) left.add(Activation("relu")) right = Sequential() right.add(Dense(nb_hidden, input_shape=(input_dim,))) right.add(Activation("relu")) righter = Sequential() righter.add(Dense(nb_hidden, input_shape=(input_dim,))) righter.add(Activation("relu")) intermediate = Sequential() intermediate.add(Merge([left, right], mode="sum")) intermediate.add(Dense(nb_hidden)) intermediate.add(Activation("relu")) model = Sequential() model.add(Merge([intermediate, righter], mode="sum")) model.add(Dense(nb_class)) model.add(Activation("softmax")) model.compile(loss="categorical_crossentropy", optimizer="rmsprop") model.fit( [X_train, X_train, X_train], y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=0, validation_data=([X_test, X_test, X_test], y_test), ) model.fit( [X_train, X_train, X_train], y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=0, validation_split=0.1 ) model.fit([X_train, X_train, X_train], y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=0) model.fit([X_train, X_train, X_train], y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=0, shuffle=False) loss = model.evaluate([X_test, X_test, X_test], y_test, verbose=0) model.predict([X_test, X_test, X_test], verbose=0) model.predict_classes([X_test, X_test, X_test], verbose=0) model.predict_proba([X_test, X_test, X_test], verbose=0) fname = "test_merge_recursivity_temp.h5" model.save_weights(fname, overwrite=True) model.load_weights(fname) os.remove(fname) nloss = model.evaluate([X_test, X_test, X_test], y_test, verbose=0) assert loss == nloss # test serialization config = model.get_config() new_model = Sequential.from_config(config) model.summary() json_str = model.to_json() new_model = model_from_json(json_str) yaml_str = model.to_yaml() new_model = model_from_yaml(yaml_str)
def test_sequential(): (X_train, y_train), (X_test, y_test) = _get_test_data() # TODO: factor out def data_generator(x, y, batch_size=50): index_array = np.arange(len(x)) while 1: batches = make_batches(len(X_test), batch_size) for batch_index, (batch_start, batch_end) in enumerate(batches): batch_ids = index_array[batch_start:batch_end] x_batch = x[batch_ids] y_batch = y[batch_ids] yield (x_batch, y_batch) model = Sequential() model.add(Dense(nb_hidden, input_shape=(input_dim,))) model.add(Activation("relu")) model.add(Dense(nb_class)) model.add(Activation("softmax")) model.compile(loss="categorical_crossentropy", optimizer="rmsprop") model.fit(X_train, y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=1, validation_data=(X_test, y_test)) model.fit(X_train, y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=2, validation_split=0.1) model.fit(X_train, y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=0) model.fit(X_train, y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=1, shuffle=False) model.train_on_batch(X_train[:32], y_train[:32]) loss = model.evaluate(X_test, y_test) prediction = model.predict_generator(data_generator(X_test, y_test), X_test.shape[0], max_q_size=2) gen_loss = model.evaluate_generator(data_generator(X_test, y_test, 50), X_test.shape[0], max_q_size=2) pred_loss = K.eval(K.mean(objectives.get(model.loss)(K.variable(y_test), K.variable(prediction)))) assert np.isclose(pred_loss, loss) assert np.isclose(gen_loss, loss) model.predict(X_test, verbose=0) model.predict_classes(X_test, verbose=0) model.predict_proba(X_test, verbose=0) fname = "test_sequential_temp.h5" model.save_weights(fname, overwrite=True) model = Sequential() model.add(Dense(nb_hidden, input_shape=(input_dim,))) model.add(Activation("relu")) model.add(Dense(nb_class)) model.add(Activation("softmax")) model.compile(loss="categorical_crossentropy", optimizer="rmsprop") model.load_weights(fname) os.remove(fname) nloss = model.evaluate(X_test, y_test, verbose=0) assert loss == nloss # test serialization config = model.get_config() new_model = Sequential.from_config(config) model.summary() json_str = model.to_json() new_model = model_from_json(json_str) yaml_str = model.to_yaml() new_model = model_from_yaml(yaml_str)
def fam(train_i, train_o, test_i, test_o): sess = tf.Session() K.set_session(sess) K.set_learning_phase(1) batch_size = 60 nb_classes = len(MOD) nb_epoch = 20 img_rows, img_cols = 2 * P * L, 2 * Np nb_filters = 96 nb_pool = 2 X_train,Y_train = shuffle_in_unison_inplace( np.array(train_i) , np.array(train_o) ) model = Sequential() model.add(Convolution2D(64, 11, 11,subsample=(2,2), input_shape=(1, img_rows, img_cols))) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Convolution2D(128, 3, 3)) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2,2))) model.add(Flatten()) model.add(Dense(512,activation='relu')) model.add(Dropout(0.5)) model.add(Dense(512,activation='relu')) model.add(Dropout(0.5)) model.add(Dense(nb_classes,init='normal')) model.add(Activation('softmax', name="out")) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) """ datagen = ImageDataGenerator( #featurewise_center=True, #featurewise_std_normalization=True, rotation_range=20, #width_shift_range=0.3, #height_shift_range=0.3, #zoom_range=[0,1.3], horizontal_flip=True, vertical_flip=True) datagen.fit(X_train) model.fit_generator(datagen.flow(X_train, Y_train, batch_size=batch_size,shuffle=True), samples_per_epoch=len(X_train), nb_epoch=5,verbose=1,validation_data=(test_i[0], test_o[0])) """ model.fit(X_train, Y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=1, shuffle=True, validation_data=(test_i[0], test_o[0])) for s in range(len(test_i)): if len(test_i[s]) == 0: continue X_test = test_i[s] Y_test = test_o[s] score = model.evaluate(X_test, Y_test, verbose=0) print("SNR", SNR[s], "Test accuracy:", score[1]) K.set_learning_phase(0) config = model.get_config() weights = model.get_weights() new_model = Sequential.from_config(config) new_model.set_weights(weights) export_path = "/tmp/fam" export_version = 1 labels_tensor = tf.constant(MOD) saver = tf.train.Saver(sharded=True) model_exporter = exporter.Exporter(saver) signature = exporter.classification_signature( input_tensor=new_model.input,classes_tensor=labels_tensor,scores_tensor=new_model.output) model_exporter.init( sess.graph.as_graph_def(), default_graph_signature=signature) model_exporter.export(export_path, tf.constant(export_version), sess)