def save(self, location: str): import json import pickle from tensorflow.keras.models import save_model #type: ignore if location[-1] != '/': location += '/' try: mkdir(location) except FileExistsError: pass #Save metadata metadata: Dict[str, Any] = { 'brainType': self.brain_type, 'maxSequenceLength': self._max_sequence_length, 'includeCasingInformation': self.include_casing_information, 'bidirectional': self.bidirectional } json.dump(metadata, open(location + 'metadata.json', 'w')) #Save tokenizer pickle.dump(self.tokenizer, open(location + 'tokenizer.pickle', 'wb')) #Save model save_model(self.model, location + 'model')
def train_simple(x_train, y_train, vad_train, batch_size=64, epochs=10, model_name="model.h5"): """ This simple RNN model also can do similar jobs. Compared to the complex RNNoise-like model: it take the same input as the other one, but train with only the gains (without VAD) it also have a simple straight forward structure (no concatenate). """ input_feature_size = x_train.shape[-1] output_feature_size = y_train.shape[-1] timestamp_size = batch_size input = Input(shape=(1, input_feature_size), batch_size=timestamp_size) x = GRU(96, return_sequences=True, stateful=True, recurrent_dropout=0.3)(input) x = GRU(96, return_sequences=True, stateful=True, recurrent_dropout=0.3)(x) x = GRU(48, return_sequences=True, stateful=True, recurrent_dropout=0.3)(x) x = Flatten()(x) x = Dense(output_feature_size)(x) x = Activation("hard_sigmoid")(x) # use hard sigmoid for better resolution in fixed-point model model = Model(inputs=input, outputs=[x]) model.compile("adam", loss=["MSE"], metrics=[msse]) model.summary() history = model.fit(x_train, y_train, batch_size=timestamp_size, epochs=epochs, verbose=2, shuffle=False, # shuffle must be false callbacks=[reset_state_after_batch()]) # free the session to avoid nesting naming while we load the best model after. save_model(model, model_name) del model tf.keras.backend.clear_session() return history
def main(): #Initialize GPU load_device() #Paths to image data DATADIR = os.path.join(os.getcwd(), 'dataset', 'kaggle') paths = [os.path.join(DATADIR + '\\train'), os.path.join(DATADIR+ '\\valid'), os.path.join(DATADIR+ '\\test')] #paths to save callbacks for tensorboard and checkpoints tb_name = 'fit' checkpoint_path = "checkpoint/cp-{epoch:04d}.ckpt" checkpoint_dir = os.path.dirname(checkpoint_path) #load Data train_batches, valid_batches, test_batches = load_data(paths=paths, dim=(224, 224), class_names=['cats', 'dogs'], batch_size=32) #create model model = create_model() model.summary() #start training train_model() #test model and generate classification report and confusion matrix class_names=['cats', 'dogs'] test_model(class_names) #save model save_model('./models') #test model using saved weights model = load_model('./models') test_model()
def train_and_evaluate(batch_size, epochs, job_dir, output_path): # Download the data x_train, y_train, x_test, y_test = _download_data() # Preprocess the data x_train, y_train = _preprocess_data(x_train, y_train) x_test, y_test = _preprocess_data(x_test, y_test) # Build the model model = _build_model() model.compile(loss=losses.categorical_crossentropy, optimizer=optimizers.Adam(), metrics=[metrics.categorical_accuracy]) # Train the model # Use tensorboard in the Cloud Shell without slash at the end # e.g. tensorboard --logdir gs://BUCKET/tmp/logs <-- no slash logdir = os.path.join(job_dir, "logs/scalars/" + time.strftime("%Y%m%d-%H%M%S")) tb_callback = callbacks.TensorBoard(log_dir=logdir) model.fit(x_train, y_train, epochs=epochs, batch_size=batch_size, callbacks=[tb_callback]) # Evaluate the model loss_value, accuracy = model.evaluate(x_test, y_test) LOGGER.info(" *** LOSS VALUE: %f ACCURACY: %.4f" % (loss_value, accuracy)) # Save model in TF SavedModel Format model_dir = os.path.join(output_path, VERSION) models.save_model(model, model_dir, save_format='tf')
def test_maxpool(self, _model_maxpool2D_1_last, _config_last): """Test maxpooling.""" config = _config_last path_wd = config.get('paths', 'path_wd') model_name = config.get('paths', 'filename_ann') models.save_model(_model_maxpool2D_1_last, os.path.join(path_wd, model_name + '.h5')) updates = { 'tools': { 'evaluate_ann': False, 'normalize': False }, 'simulation': { 'duration': 100, 'num_to_test': 100, 'batch_size': 50 }, 'output': { 'log_vars': {'activations_n_b_l', 'spiketrains_n_b_l_t'} } } config.read_dict(updates) acc = run_pipeline(config) acc_ann = get_ann_acc(config) assert acc[0] >= 0.9 * acc_ann corr = get_correlations(config) assert np.all(corr[:-1] > 0.99) assert corr[-1] > 0.90
def test_inisim(self, _model_2, _config): path_wd = _config.get('paths', 'path_wd') model_name = _config.get('paths', 'filename_ann') models.save_model(_model_2, os.path.join(path_wd, model_name + '.h5')) updates = { 'tools': { 'evaluate_ann': False }, 'simulation': { 'duration': 100, 'num_to_test': 100, 'batch_size': 50 }, 'output': { 'log_vars': {'activations_n_b_l', 'spiketrains_n_b_l_t'} } } _config.read_dict(updates) acc = run_pipeline(_config) assert acc[0] >= 0.95 corr = get_correlations(_config) assert np.all(corr[:-1] > 0.99) assert corr[-1] > 0.90
def save_to_dir(self, directory: str): params = self.get_params() with open(path.join(directory, "params.json"), "w") as f: json.dump(params, f) if hasattr(self, "model") and self.model is not None: save_model( self.model, filepath=path.join(directory, "model.h5"), include_optimizer=True, save_format="h5", ) if ( hasattr(self.model, "history") and self.model.history.history is not None ): f_name = path.join(directory, "history.pkl") with open(f_name, "wb") as history_file: pickle.dump( ( self.model.history.history, self.model.history.params, self.model.history.epoch, ), history_file, )
def on_epoch_end(self, epoch, logs={}): val_loss = logs['loss'] val_acc = logs['acc'] if val_acc > self.best_acc: self.best_acc = val_acc self.best_loss = val_loss # Filenames hdf5Filename = os.path.join( self.bestdir, "Bestmodel_{:06d}_{:.4f}_{:.4f}.hdf5".format( epoch + 1, val_acc, val_loss)) yamlFilename = os.path.join( self.bestdir, "Bestmodel_{:06d}_{:.4f}_{:.4f}.yaml".format( epoch + 1, val_acc, val_loss)) # YAML yamlModel = self.model.to_yaml() with open(yamlFilename, "w") as yamlFile: yamlFile.write(yamlModel) # HDF5 KM.save_model(self.model, hdf5Filename) with H.File(hdf5Filename, "r+") as f: f.require_dataset("initialEpoch", (), "uint64", True)[...] = int(epoch + 1) f.flush() # Print L.getLogger("train").info( "Saved best model to {:s} at epoch {:5d}".format( hdf5Filename, epoch + 1))
def __export__(self, path): """ Saves a CNN to a .model file :param path: path to the .model file to be saved :return: void """ save_model(self.model, path)
def train(model=model(), checkpoint="latest.hdf5"): dataset = build_dataset() callback = TensorBoard("_tensor_board") callback.set_model(model) labels = interested_words for i in range(10000): save_model(model, "checkpoint.model") print("Chunk " + str(i) + " of 10000...") X, Y = get_batch(dataset, batchsize=1000) for j in range(10): logs = model.train_on_batch(np.array(X), np.array(Y)) print("loss:", logs) write_log(callback, ["training loss"], [logs], i * 10 + j) X, Y = get_batch(dataset, batchsize=100, batchtype="test") results = model.predict(X) accuracy = 0 for result, actual in zip(results, Y): #print("running test") x = np.argmax(result) j = np.argmax(actual) try: print("expected " + labels[j], " got " + labels[x]) except: pass if x == j: accuracy += 1 write_log(callback, ["test accuracy"], [accuracy], i)
def main(self, data_file_path, model_file_path): data = pd.read_csv(data_file_path) train_tweets, val_tweets, train_label, val_label = self.preprocess_data( data["text"], data["target"]) result, model = self.train_model(train_tweets, val_tweets, train_label, val_label) save_model(model, model_file_path)
def retrain(): ''' Retrain the LSTM ''' X = [] Y = [] f = open("assets/data/name_gender.csv") data = f.readlines() f.close() for line in data: name, gender = line.split(',') if name and gender: tensor = extract(name) if type(tensor) == np.ndarray: X.extend(tensor.tolist()) Y.append([1, 0] if gender.strip("\n") == 'M' else [0, 1]) X = np.array(X) Y = np.array(Y) if X.shape[0] > 0 and Y.shape[0] > 0: callback = EarlyStopping( monitor='val_loss', min_delta=0, patience=3, verbose=0, mode='auto', baseline=None, restore_best_weights=True ) model = load_model("assets/model/LSTMSimple") model.fit(X, Y, batch_size=1, epochs=X.shape[0], validation_data=(X, Y), callbacks=[callback]) save_model(model, "assets/model/LSTMSimple", save_format="h5") #if __name__ == '__main__': # retrain()
def create_model(): MODEL_FILENAME = "build/model/digit_model.h5" # Load Data mnist = tf.keras.datasets.mnist (x_train, y_train), (x_test, y_test) = mnist.load_data() # Normalize pixel grayscale to be between 0 and 1: x_train, x_test = x_train / 255.0, x_test / 255.0 model = tf.keras.models.Sequential([ tf.keras.layers.Flatten(), tf.keras.layers.Dense(512, activation=tf.nn.relu), tf.keras.layers.Dropout(0.2), tf.keras.layers.Dense(10, activation=tf.nn.softmax) ]) model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy']) model.fit(x_train, y_train, epochs=5) #Create Path if not os.path.exists(os.path.dirname(MODEL_FILENAME)): try: os.makedirs(os.path.dirname(MODEL_FILENAME)) except OSError as exc: # Guard against race condition if exc.errno != errno.EEXIST: raise save_model(model, MODEL_FILENAME) del model # delete
def train(x_train, y_train, x_test, y_test, type, batch_size=64, epochs=100): inputs = Input(shape=x_train.shape[1:]) x = Conv1D(16, kernel_size=5, strides=1)(inputs) x = LSTM(32, return_sequences=True)(x) x = LSTM(32, return_sequences=True)(x) x = Flatten()(x) x = Dense(128)(x) x = Dropout(0.3)(x) x = Dense(type)(x) predictions = Softmax()(x) model = Model(inputs=inputs, outputs=predictions) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) model.summary() history = model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, verbose=2, validation_data=(x_test, y_test)) # free the session to avoid nesting naming while we load the best model after. save_model(model, model_path) del model tf.keras.backend.clear_session() return history
def train_and_evaluate(batch_size, epochs, job_dir, output_path): # Donwload the data x_train, y_train, x_test, y_test = _download_data() # Preprocess the data x_train, y_train = _preprocess_data(x_train, y_train) x_test, y_test = _preprocess_data(x_test, y_test) # Build the model model = _build_model() model.compile(loss=losses.categorical_crossentropy , optimizer=optimizers.Adam() , metrics=[metrics.categorical_accuracy]) # Train the model logdir = os.path.join(job_dir, "logs/scalars/" + time.strftime("%Y%m%d-%H%M%S")) tb_callback = callbacks.TensorBoard(log_dir=logdir) model.fit(x_train, y_train , batch_size=batch_size , epochs=epochs , callbacks=[tb_callback]) # , validation_split=0.15) no se utiliza # Evaluate the model loss_value, accuracy = model.evaluate(x_test, y_test) #print(accuracy) -- se puede hacer pero mejor logger LOGGER.info(f" **** LOSS VALUE:{loss_value}, ACCURACY:{round(accuracy,4)}") # Save model in TF scikit - pickle in tensorflow save model model_dir = os.path.join(output_path, VERSION) models.save_model(model, model_dir)
def save_model_to(self, output_name=None): if output_name: filepath = os.path.join('models', output_name) else: filepath = Path(self.model_dir) save_model(self.Model, filepath=filepath) save_config(self.config, os.path.join(filepath, 'config.json'))
def create_model(): """Create image classification object""" file_name = "./resnet50.h5" dir_path = os.path.dirname(os.path.realpath(__file__)) full_path = os.path.join(dir_path, file_name) if os.path.exists(full_path): model = load_model(full_path, custom_objects=None, compile=True) else: model = InceptionResNetV2( include_top=True, weights="imagenet", input_tensor=None, input_shape=None, pooling=None, classes=1000, ) save_model(model, full_path, overwrite=True, include_optimizer=True, save_format=None, signatures=None, options=None) data = {"model": model} return data
def test_maxpool_first(self, _model_maxpool2D_1_first, _config_first): """Test that maxpooling fails with data format channels_first.""" config = _config_first path_wd = config.get('paths', 'path_wd') model_name = config.get('paths', 'filename_ann') models.save_model(_model_maxpool2D_1_first, os.path.join(path_wd, model_name + '.h5')) updates = { 'tools': { 'evaluate_ann': False, 'normalize': False }, 'simulation': { 'duration': 100, 'num_to_test': 100, 'batch_size': 50 }, 'output': { 'log_vars': {'activations_n_b_l', 'spiketrains_n_b_l_t'} } } config.read_dict(updates) run_pipeline(config)
def save(self, path): """ Saves the current state """ with ZipFile(path, mode='w') as package: print('Creating zip package:', path) tmpfile = NamedTemporaryFile(suffix='.h5') print('Temporarily saving keras model to', tmpfile.name) models.save_model(self.model, tmpfile.name) print('Adding', tmpfile.name, 'to package as model.h5') package.write(tmpfile.name, 'model.h5') print('Adding glove.bin', len(pickle.dumps(self.glove)), 'bytes.') package.writestr('glove.bin', pickle.dumps(self.glove)) print('Adding tfidf_model.bin', len(pickle.dumps(self.tfidf_model)), 'bytes.') package.writestr('tfidf_model.bin', pickle.dumps(self.tfidf_model)) print('Adding keyphraseness_model.bin', len(pickle.dumps(self.keyphraseness_model)), 'bytes.') package.writestr('keyphraseness_model.bin', pickle.dumps(self.keyphraseness_model)) print('Adding pos_tag_model.bin', len(pickle.dumps(self.pos_tag_model)), 'bytes.') package.writestr('pos_tag_model.bin', pickle.dumps(self.pos_tag_model)) print('Adding settings.json', len(json.dumps(self.settings, default=lambda x: x.__dict__)), 'characters.') package.writestr( 'settings.json', json.dumps(self.settings, default=lambda x: x.__dict__))
def test_maxpool_fallback(self, _model_maxpool2D_1, _config): """Test that maxpooling falls back on average pooling.""" path_wd = _config.get('paths', 'path_wd') model_name = _config.get('paths', 'filename_ann') models.save_model(_model_maxpool2D_1, os.path.join(path_wd, model_name + '.h5')) updates = { 'tools': { 'evaluate_ann': False, 'normalize': False }, 'conversion': { 'max2avg_pool': True }, 'simulation': { 'duration': 100, 'num_to_test': 100, 'batch_size': 50 }, 'output': { 'log_vars': {'activations_n_b_l', 'spiketrains_n_b_l_t'} } } _config.read_dict(updates) acc = run_pipeline(_config) assert acc[0] >= 0.8 corr = get_correlations(_config) assert np.all(corr[:-1] > 0.99) assert corr[-1] > 0.90
def on_epoch_end(self, epoch, logs=None): train_loss = round(logs.get('loss'), 4) val_loss = round(logs.get('val_loss'), 4) # Save model as h5 file model_filepath = f'{self.model_dir}/model-{epoch + 1}-{train_loss}-{val_loss}.h5' save_model(self.model, model_filepath) # Save model weights as h5 file weights_filepath = f'{self.model_dir}/model-weights-{epoch + 1}-{train_loss}-{val_loss}.h5' self.model.save_weights(weights_filepath) # Save optimizer state as pickle file optimizer_weights_filepath = f'{self.model_dir}/optimizer-weights-{epoch + 1}-{train_loss}-{val_loss}.pkl' with open(optimizer_weights_filepath, 'wb') as f: pickle.dump( K.batch_get_value(getattr(self.model.optimizer, 'weights')), f) # Update the checkpoint epoch self.checkpoint['epoch'] += 1 if val_loss < self.best_val_loss: self.checkpoint['best_model'] = model_filepath self.best_val_loss = val_loss self.checkpoint['last_model'] = model_filepath self.checkpoint['last_weights'] = weights_filepath self.checkpoint['last_optimizer_weights'] = optimizer_weights_filepath with open(f"{self.checkpoint['checkpoint_dir']}/checkpoint.json", "w") as f: json.dump(self.checkpoint, f, indent=4)
def test_spinnaker_sparse(self, _model_3, _config): path_wd = _config.get('paths', 'path_wd') model_name = _config.get('paths', 'filename_ann') models.save_model(_model_3, os.path.join(path_wd, model_name + '.h5')) updates = { 'tools': { 'evaluate_ann': False }, 'input': { 'poisson_input': True }, 'simulation': { 'simulator': 'spiNNaker', 'duration': 100, 'num_to_test': 1, # smaller to make more feasible 'batch_size': 1 }, 'output': { 'log_vars': {'activations_n_b_l', 'spiketrains_n_b_l_t'} } } _config.read_dict(updates) initialize_simulator(_config) acc = run_pipeline(_config) assert acc[0] >= 0.95 corr = get_correlations(_config) assert np.all(corr[:-1] > 0.97) assert corr[-1] > 0.5
def get_measure_tf_lite(model, number_of_measures, tmp_keras_file, tmp_tflite_file, benchmark_loc): """given a model, loads that model in tf_lite and benchmarks the time needed for a prediction in C++ using the benchmark tool associated with tf-lite (this tool does not return median but only mean so we will use that instead) :return: the mean of number_of_measures trials""" model.compile(optimizer=SGD(), loss='binary_crossentropy') save_model(model, tmp_keras_file) # Convert to TensorFlow Lite model. converter = lite.TFLiteConverter.from_keras_model_file(tmp_keras_file) tflite_model = converter.convert() with open(tmp_tflite_file, "wb") as file: file.write(tflite_model) # Loads TFLite model and get measures command_line = "{} --graph={} --min_secs=0 --warmup_min_secs=0 --num_runs={} |& tr -d '\n' | awk {}".format( benchmark_loc, tmp_tflite_file, number_of_measures, "'{print $NF}'") # tr removes the \n and awk gets # the last element of the outputs message, |& is used before tr because we want to pipe strderr and not # stdout result = float( subprocess.check_output(command_line, shell=True, executable='/bin/bash')) / 10**6 # result # given in microseconds return result
def model_train_one_it(df, i, model_path): import numpy as np import time from tensorflow.keras.models import Model, load_model, save_model import tensorflow as tf config = tf.compat.v1.ConfigProto() config.gpu_options.allow_growth = True sess = tf.compat.v1.Session(config=config) X_inpre = df['X'][i] y_inpre = df['y_in'][i] y_outpre = df['y'][i] characters = y_outpre.shape[0] letters = y_outpre.shape[1] X_in = np.stack([X_inpre for x in range(characters)]) y_in = np.array(y_inpre).reshape(characters, 1, letters) y_out = np.array(y_outpre).reshape(characters, 1, letters) model = load_model(model_path) history = model.fit([X_in, y_in], y_out, batch_size=32, max_queue_size=256, use_multiprocessing=True) save_model(model, model_path, save_format='h5') return history
def get_median_measure_tf_lite_python(model, number_of_measures, tmp_keras_file, tmp_tflite_file): """given a model, loads that model in tf_lite and benchmarks the time needed for a prediction in python :return: the median of number_of_measures trials""" measures = np.zeros(number_of_measures) model.compile(optimizer=SGD(), loss='binary_crossentropy') save_model(model, tmp_keras_file) # Convert to TensorFlow Lite model. converter = lite.TFLiteConverter.from_keras_model_file(tmp_keras_file) tflite_model = converter.convert() with open(tmp_tflite_file, "wb") as file: file.write(tflite_model) # Load TFLite model and get measures interpreter = lite.Interpreter(model_path=tmp_tflite_file) interpreter.allocate_tensors() input_details = interpreter.get_input_details() for k in range(number_of_measures): # Test model on random input data. input_shape = input_details[0]['shape'] input_data = np.array(np.random.random_sample(input_shape), dtype=np.float32) interpreter.set_tensor(input_details[0]['index'], input_data) begin = time.perf_counter() interpreter.invoke() measures[k] = time.perf_counter() - begin return np.median(measures)
def model_training(): df = pd.read_csv("results.csv") X = df[["date", "home_team", "away_team", "country", "neutral"]] y = df[["home_score", "away_score"]] X_train, X_valid, y_train, y_valid = train_test_split(X, y, train_size=0.80) preprocessor = ColumnTransformer( transformers=[('date_scale', StandardScaler(), ['date']), ('neutral', OrdinalEncoder(), ['neutral']), ('home', OneHotEncoder(handle_unknown='ignore', sparse=False), ['home_team']), ('away', OneHotEncoder(handle_unknown='ignore', sparse=False), ['away_team'])]) pipeline = Pipeline(steps=[('date', DateTransformer()), ('pre', preprocessor)], verbose=True) X_train = pipeline.fit_transform(X_train) X_valid = pipeline.transform(X_valid) input_shape = [X_train.shape[1]] model = models.Sequential([ layers.Dense(512, activation='relu', input_shape=input_shape), layers.Dense(512, activation='relu'), layers.Dense(2) ]) model.compile(loss='mse', optimizer=optimizers.Adam(learning_rate=0.01)) early_stopping = callbacks.EarlyStopping( patience=5, min_delta=0.001, restore_best_weights=True, ) history = model.fit(X_train, y_train, validation_data=(X_valid, y_valid), epochs=500, batch_size=64, callbacks=[early_stopping], verbose=1) curr_dir = Path(__file__).resolve().parent with open("model_count.txt", "r") as mc: cnt = mc.read() models.save_model( model, Path(curr_dir, 'Saved Neural Network Models', f'model_{cnt}')) joblib.dump( pipeline, Path(curr_dir, 'Saved Fitted Preprocessing Pipelines', f'pipeline_{cnt}.pkl')) with open("model_count.txt", "w") as mc: new_cnt = str(int(cnt) + 1) mc.write(new_cnt)
def on_epoch_end(self, epoch, logs={}): if (epoch + 1) % self.period_of_epochs == 0: # Filenames baseHDF5Filename = "ModelChkpt{:06d}.hdf5".format(epoch + 1) baseYAMLFilename = "ModelChkpt{:06d}.yaml".format(epoch + 1) hdf5Filename = os.path.join(self.chkptsdir, baseHDF5Filename) yamlFilename = os.path.join(self.chkptsdir, baseYAMLFilename) # YAML yamlModel = self.model.to_yaml() with open(yamlFilename, "w") as yamlFile: yamlFile.write(yamlModel) # HDF5 KM.save_model(self.model, hdf5Filename) with H.File(hdf5Filename, "r+") as f: f.require_dataset("initialEpoch", (), "uint64", True)[...] = int(epoch + 1) f.flush() # Symlink to new HDF5 file, then atomically rename and replace. os.symlink(baseHDF5Filename, self.linkFilename + ".rename") os.rename(self.linkFilename + ".rename", self.linkFilename) # Print L.getLogger("train").info( "Saved checkpoint to {:s} at epoch {:5d}".format( hdf5Filename, epoch + 1))
def train_conv_net_cpu(train_data, train_labels, val_data, val_labels, conv_net_hyperparameters, num_processors, seed, dtype="float32", inter_op_threads=2,trial=None): """ Train a convolutional neural network on the CPU. """ np.random.seed(seed) if "get_visible_devices" in dir(tf.config.experimental): gpus = tf.config.experimental.get_visible_devices("GPU") else: gpus = tf.config.get_visible_devices("GPU") if len(gpus) > 0: for device in gpus: tf.config.experimental.set_memory_growth(device, True) tf.config.threading.set_inter_op_parallelism_threads(inter_op_threads) tf.config.threading.set_intra_op_parallelism_threads(num_processors) if tf.__version__[0] == "1": tf.set_random_seed(seed) else: tf.random.set_seed(seed) K.set_floatx(dtype) with tf.device("/CPU:0"): scn = ResNet(**conv_net_hyperparameters) history = scn.fit(train_data, train_labels, val_x=val_data, val_y=val_labels) #scn.fit(train_data, train_labels, val_x=val_data, val_y=val_labels) time_str = pd.Timestamp.now().strftime("%d/%m/%Y %I:%M:%S") with open('AUC_history.csv','w') as f: for key in history.history.keys(): f.write("%s,%s\n"%(key,history.history[key])) epoch_times = scn.time_history.times batch_loss = np.array(scn.loss_history.losses).ravel().tolist() epoch_loss = np.array(scn.loss_history.val_losses).ravel().tolist() date_time = str(datetime.now()) save_model(scn.model, 'goes16ci_model_cpu' + date_time + '.h5', save_format = 'h5') return epoch_times, batch_loss, epoch_loss
def main(output, ftpath, corpus, kg_url, cpu): """ Train a Classification model :param output: output path for the TF model :param ftpath: path for Fasttext word embedding model :param corpus: path to a text file of documents. One sentence per line. Separate documents with an empty line : """ logger.setLevel(logging.DEBUG) docs = read_corpus(corpus) logger.info("Loading fasttext model") ft_model = FastText.load(ftpath) kg = get_lemmatized_kg(kg_url) if cpu: sess = nongpu_session() else: sess = gpu_session() # non with sess.as_default(): k_model, loss, accuracy, history = make_classifier(ft_model, docs, kg) logger.info("Model trained, saving") save_model(k_model, output, overwrite=True, include_optimizer=True) return output
def __getstate__(self): model_str = "" with tempfile.NamedTemporaryFile(suffix='.hdf5', delete=True) as fd: keras_models.save_model(self, fd.name, overwrite=True) model_str = fd.read() d = {'model_str': model_str} return d
def train(model = model(),checkpoint = "latest.hdf5"): dataset = build_dataset() callback = TensorBoard("_tensor_board") callback.set_model(model) labels = interested_words for i in range(10000): save_model(model, "checkpoint.model") print("Chunk "+str(i)+" of 10000...") X,Y = get_batch(dataset,batchsize=1000) for j in range(10): logs = model.train_on_batch(np.array(X),np.array(Y)) print("loss:",logs) write_log(callback, ["training loss"], [logs], i*10+j) X,Y = get_batch(dataset,batchsize=100,batchtype="test") results = model.predict(X) accuracy = 0 for result,actual in zip(results,Y): #print("running test") x =np.argmax(result) j =np.argmax(actual) try: print("expected "+labels[j]," got "+labels[x]) except: pass if x == j: accuracy += 1 write_log(callback,["test accuracy"],[accuracy],i)
def _run(args): """ TODO(praneetdutta): Formalize train sub-routine """ with tf.Session() as sess: env = gym.make(args[0].environment) env = StackFrameEnv(env, args[0].frame_stack, args[0].img_height, args[0].img_width) state = env.reset() num_actions = env.action_space.n if args[0].mode == 'Train': # Add timestamp; important for HP tuning so models don't clobber each # other. model_dir = hp_directory(args[0].model_dir) else: model_dir = args[0].model_dir agent = Agent( height=args[0].img_height, width=args[0].img_width, actions=env.action_space.n, channels=args[0].frame_stack, model_dir=model_dir, discount=args[0].discount_factor) agent.create_model(lr=args[0].learning_rate) print ("STARTING...") if not os.path.exists(model_dir) and args[0].save_model: os.makedirs(model_dir) print("MODEL WILL BE STORED AT: ", model_dir) target_agent = Agent(height=args[0].img_height, width=args[0].img_width, actions=env.action_space.n, channels=args[0].frame_stack) target_agent.create_model(args[0].learning_rate) target_network = target_agent.model target_network.set_weights(agent.model.get_weights()) if args[0].mode != 'Train': trained_model_path = args[0].load_model try: agent.model.load_weights(trained_model_path) except: print('{} is not a valid .h5 model.'.format(trained_model_path)) eta = args[0].init_eta Buffer = ExpBuffer(max_size=args[0].buffer_size, min_size=args[0].start_train) episode_reward, episode_number, done = 0, 0, False episode_run = True for curr_step in range(args[0].steps): if (episode_number % DISPLAY_RESULTS == 0 and episode_run) or args[0].mode != 'Train': episode_reward = agent.play(env, model_dir, args[0].mode) print('CURRENT STEP: {}, EPISODE_NUMBER: {}, EPISODE REWARD: {},' 'EPSILON: {}'.format(curr_step, episode_number, episode_reward, eta)) episode_run = False if args[0].mode == 'Train': eta = anneal_exploration(eta, curr_step, args[0].steps / 10.0, args[0].start_train, args[0].init_eta, args[0].min_eta, 'linear') if eta > np.random.rand() or curr_step < args[0].start_train: action = env.action_space.sample() else: action = agent.predict_action(state) next_state, reward, done, info = env.step(action) Buffer.add_exp([state, next_state, reward, action, done]) ready_to_update_model = curr_step > args[0].start_train and len( Buffer.buffer) > Buffer.min_size if ready_to_update_model: exp_state, exp_next_state, exp_reward, exp_action, exp_done = Buffer.sample_experiences( args[0].batch_size) agent.batch_train(exp_state, exp_next_state, exp_reward, exp_action, exp_done, target_network, args[0].Q_learning) if curr_step % args[0].update_target == 0: target_network.set_weights(agent.model.get_weights()) if curr_step % (SAVE_STEPS_FACTOR * args[0].update_target) == 0 and args[0].save_model: print('SAVING MODEL AT STEP: ', curr_step) models.save_model( agent.model, model_dir + 'model_' + str(episode_number) + '_.h5') #Resets state if done or args[0].mode != 'Train': episode_number += 1 episode_run = True state = env.reset() else: state = next_state