def build_model(self, configs): timer = Timer() timer.start() for layer in configs['model']['layers']: neurons = layer['neurons'] if 'neurons' in layer else None dropout_rate = layer['rate'] if 'rate' in layer else None activation = layer['activation'] if 'activation' in layer else None return_seq = layer['return_seq'] if 'return_seq' in layer else None input_timesteps = layer[ 'input_timesteps'] if 'input_timesteps' in layer else None input_dim = layer['input_dim'] if 'input_dim' in layer else None if layer['type'] == 'dense': self.model.add(Dense(neurons, activation=activation)) if layer['type'] == 'lstm': self.model.add( LSTM(neurons, input_shape=(input_timesteps, input_dim), return_sequences=return_seq)) if layer['type'] == 'dropout': self.model.add(Dropout(dropout_rate)) self.model.compile(loss=configs['model']['loss'], optimizer=configs['model']['optimizer']) print(f'{timer.stop()} Model Compiled')
def build_cnn(self, configs): timer = Timer() timer.start() for layer in configs['cnn_model']['layers']: neurons = layer['neurons'] if 'neurons' in layer else None dropout_rate = layer['rate'] if 'rate' in layer else None activation = layer['activation'] if 'activation' in layer else None return_seq = layer['return_seq'] if 'return_seq' in layer else None input_timesteps = layer['input_timesteps'] if 'input_timesteps' in layer else None input_dim = layer['input_dim'] if 'input_dim' in layer else None
def generate_gics_sector(data: pd.DataFrame): """ Append additional column with 2-digit GICS code :param data: Original Data Frame :return: None """ print('Generating gics_sector column ...') timer = Timer().start() data.loc[:, 'gics_sector'] = data['gsubind'].apply(lambda x: str(x)[:2] if not pd.isna(x) else '') timer.stop()
def continue_training(self, epoch_start, model_fname, statistics_fname, data_obj, configs): timer = Timer() timer.start() epochs = configs['training']['epochs'] batch_size = configs['training']['batch_size'] print('[Model] Training Continuation') print('[Model] %s epochs, %s batch size' % (epochs, batch_size)) callbacks = [ ModelCheckpoint(filepath=model_fname, monitor='loss', save_best_only=True), TensorBoard(log_dir=configs['training']['log_dir'], histogram_freq=0, batch_size=configs['training']['batch_size'], write_graph=True, write_grads=False, write_images=False, embeddings_freq=0, embeddings_layer_names=None, embeddings_metadata=None, embeddings_data=None, update_freq='epoch'), ReduceLROnPlateau(monitor='loss', factor=0.5, patience=5, min_lr=1e-6, verbose=1, cooldown=0), # CyclicLR(base_lr=configs['model']['lr'], # max_lr=0.1, # step_size=8*(data_obj.train_samples-configs['data']['sequence_length'])/configs['training']['batch_size'], # scale_fn=None, # mode='triangular2'), TerminateOnNaN(), CSVLogger(statistics_fname, separator=',', append=True), EarlyStopping(monitor='loss', patience=10, verbose=1) ] try: self.model.fit_generator(data_obj.train, steps_per_epoch=None, epochs=configs['training']['epochs'], verbose=0, callbacks=callbacks, validation_data=data_obj.validation, validation_steps=None, shuffle=True, max_queue_size=100, workers=5, use_multiprocessing=False, initial_epoch=epoch_start) except KeyboardInterrupt: print( '[Model] Training Interrupted by Keyboard. Model saved as %s' % model_fname) timer.stop() return print('[Model] Training Completed. Model saved as %s' % model_fname) timer.stop()
def continue_training(self, epoch_start, model_fname, statistics_fname, data_obj, configs): timer = Timer() timer.start() epochs = configs['training']['epochs'] batch_size = configs['training']['batch_size'] print('[Model] Training Continuation') print('[Model] %s epochs, %s batch size' % (epochs, batch_size)) callbacks = [ ModelCheckpoint(filepath=model_fname, monitor='loss', save_best_only=True), TensorBoard(log_dir=configs['training']['log_dir'], histogram_freq=5, batch_size=configs['training']['batch_size'], write_graph=True, write_grads=False, write_images=False, embeddings_freq=0, embeddings_layer_names=None, embeddings_metadata=None, embeddings_data=None, update_freq='epoch'), ReduceLROnPlateau(monitor='loss', factor=0.5, patience=5, min_lr=1e-6, verbose=1, cooldown=0), TerminateOnNaN(), CSVLogger(statistics_fname, separator=',', append=True), EarlyStopping( monitor='loss', patience=10, verbose=1, min_delta=1e-8, ) ] try: self.model.fit(x=data_obj.train[0], y=data_obj.train[1], batch_size=configs['training']['batch_size'], epochs=configs['training']['epochs'], validation_data=data_obj.validation, shuffle=True, steps_per_epoch=None, validation_steps=None, callbacks=callbacks, initial_epoch=epoch_start) except KeyboardInterrupt: print( '[Model] Training Interrupted by Keyboard. Model saved as %s' % model_fname) timer.stop() return print('[Model] Training Completed. Model saved as %s' % model_fname) timer.stop()
def predict_time_left(x : np.ndarray, y : np.ndarray, name : str, mode : str = "BAYESIAN") -> int: functions = { "OLS":OLS, "RANSAC":RANSAC, "BAYESIAN":BAYESIAN } # Reshape the array as a single feature array for the predictors x = x.reshape(-1, 1) if mode in functions.keys(): logger.info("Predicting using the mode [%s]"%mode) with Timer("The prediction took {time}s"): m, q, p = functions[mode](x, y) logger.info("The coefficents predicted are m [{m}] q[{q}]".format(**locals())) if m <= 0: logger.info("The predicted line is not growing so it will never reach the max") return "inf", p time_predicted = (1 - q)/m delta = time_predicted - x[-1] if delta > MAX_TIME: logger.info(f"The predicted time [{delta}] is over [{MAX_TIME}] so it's casted to [inf]") return "inf", p return delta[0], p logger.error("Mode [%s] not found, the available ones are %s"%(mode, functions.keys())) return None, 0
def append_columns(data: pd.DataFrame, folder_path: str, file_name: str, column_list: list): """ Retroactively append columns to index data :param column_list: Columns to append :param data: Original DataFrame to append data to :param folder_path: Path to index data :param file_name: Name of file containing the additional columns :return: None """ saved_index_cols = None if isinstance(data.index, pd.RangeIndex): pass elif isinstance(data.index, pd.MultiIndex) or isinstance(data.index, pd.Index): saved_index_cols = list(data.index.names) if saved_index_cols[0] is None: saved_index_cols = None # JOB: Load DataFrame with new columns new_col_df = pd.read_csv(os.path.join(ROOT_DIR, folder_path, file_name), header=0, dtype={'gvkey': str}) new_col_df.loc[:, 'datadate'] = pd.to_datetime(new_col_df['datadate'], format='%Y%m%d') new_col_df.set_index(['datadate', 'gvkey', 'iid'], inplace=True) # JOB: Filter by relevant columns new_col_df = new_col_df.loc[:, column_list] # JOB: Merge data with new columns timer = Timer().start() if saved_index_cols is None: pass else: data.reset_index(inplace=True, drop=False) print('Resetting existing index.') print('Merging full data set with new columns ...') data.set_index(['datadate', 'gvkey', 'iid'], inplace=True) data = data.merge(new_col_df, how='left', left_index=True, right_index=True) data.reset_index(inplace=True) timer.stop() # Save to file print('\nSaving appended DataFrame to file ...') timer = Timer().start() data.to_csv(os.path.join(ROOT_DIR, folder_path, 'index_data_constituents_test.csv')) timer.stop() if saved_index_cols is not None: data.set_index(saved_index_cols, inplace=True)
def fit_one_by_one(self, x_train_o, y_train_o, x_val_o, y_val_o, batch_size, epochs, callbacks): timer = Timer() timer.start() print('[Model] Training Started') print('[Model] %s epochs, %s batch size' % (epochs, batch_size)) print('[Model] Train Shape: %s' % str(x_train_o.shape)) print('[Model] Validation Shape: %s' % str(x_val_o.shape)) try: self.model.fit(x_train_o, y_train_o, epochs=epochs, batch_size=batch_size, validation_data=[x_val_o, y_val_o], verbose=Options.KerasVerbose, callbacks=callbacks) except KeyboardInterrupt: print('Keyboard interrupt.') pass save_fname = os.path.join( Options.KerasNNSaveDirectory, '%s-e%s.hdf5' % (dt.datetime.now().strftime('%Y%m%d-%H%M%S'), str(len(self.model.history.epoch)))) self.model.save(save_fname) print('[Model] Training Completed. Model saved as %s' % save_fname) timer.stop()
def build_windowed_batch_LSTM_model(self): timer = Timer() timer.start() Options.WindowSequenceLength = 56 Options.WindowShiftStep = 1 Options.KerasEpochs = 30 Options.KerasWindowedBatchSize = 400 Options.KerasEarlyStopping = False #self.model.add(Reshape((Options.WindowSequenceLength, Options.InputFeatureSize), input_shape=(Options.WindowSequenceLength, Options.InputFeatureSize,))) self.model.add( LSTM(100, input_shape=(Options.WindowSequenceLength, Options.InputFeatureSize), return_sequences=True)) self.model.add(Dropout(0.2)) self.model.add(LSTM(100, return_sequences=True)) self.model.add(LSTM(100, return_sequences=False)) self.model.add(Dropout(0.2)) self.model.add( Dense(1, kernel_initializer='normal', activation='linear')) optimizer = RMSprop(lr=0.00050) #optimizer = Adam() self.model_loss = 'mean_squared_error' #'mean_squared_error', 'mae' self.model.compile(optimizer=optimizer, loss=self.model_loss, metrics=list(set(['mae', self.model_loss]))) print('[Model] Model Compiled') timer.stop() return self.model
def build_one_by_one_model_ngut(self): timer = Timer() timer.start() Options.KerasEarlyStopping = False self.model.add( Dense(64, activation='sigmoid', input_dim=Options.InputFeatureSize, activity_regularizer=keras.regularizers.l2(0.01))) self.model.add(BatchNormalization()) self.model.add(LeakyReLU()) self.model.add( Dense(16, activity_regularizer=keras.regularizers.l2(0.01))) self.model.add(BatchNormalization()) self.model.add(LeakyReLU()) self.model.add(Dense(1)) self.model.add(Activation('linear')) optimizer = RMSprop(lr=0.00050) self.model_loss = 'mae' #'mean_squared_error', 'mae' self.model.compile(optimizer=optimizer, loss=self.model_loss, metrics=list(set(['mae', self.model_loss]))) print('[Model] Model Compiled') print('[Model] Model Loss Function is %s.' % (self.model_loss)) timer.stop() self.model.summary() return self.model
def build_one_by_one_model_test(self): timer = Timer() timer.start() Options.KerasEarlyStopping = False self.model.add(Dropout(0.2, input_shape=(Options.InputFeatureSize, ))) self.model.add( Dense(60, input_dim=Options.InputFeatureSize, activation='sigmoid', kernel_initializer='glorot_uniform', bias_initializer='zeros')) #CAREFUL SIGMOID , NO NORMAL INIT self.model.add(Dropout(0.2)) #self.model.add(Dense(25, activation = 'relu')) self.model.add(Dense(1, activation='linear')) #CAREFUL SIGMOID optimizer = RMSprop(lr=0.00050) #optimizer = RMSprop() #optimizer = SGD() #optimizer = Adam() self.model_loss = 'mae' #'mean_squared_error', 'mae', 'logcosh' self.model.compile(optimizer=optimizer, loss=self.model_loss, metrics=list( set([ 'mae', 'mean_absolute_percentage_error', 'mean_squared_error', 'logcosh', self.model_loss ]))) print('[Model] Model Compiled') print('[Model] Model Loss Function is %s.' % (self.model_loss)) timer.stop() self.model.summary() return self.model
def train_generator(self, data_gen, epochs, batch_size, steps_per_epoch, save_dir): ''' 由data_gen数据产生器来,逐步产生训练数据,而不是一次性将数据读入到内存 ''' timer = Timer() timer.start() print('[Model] Training Started') print('[Model] %s epochs, %s batch size, %s batches per epoch' % (epochs, batch_size, steps_per_epoch)) save_fname = os.path.join( save_dir, '%s-e%s.h5' % (dt.datetime.now().strftime('%d%m%Y-%H%M%S'), str(epochs))) callbacks = [ ModelCheckpoint(filepath=save_fname, monitor='loss', save_best_only=True) ] self.model.fit_generator(data_gen, steps_per_epoch=steps_per_epoch, epochs=epochs, callbacks=callbacks, workers=1) print('[Model] Training Completed. Model saved as %s' % save_fname) timer.stop()
def train(self, x, y, epochs, batch_size): timer = Timer() timer.start() print('[Model] Training Started') print('[Model] %s epochs, %s batch size' % (epochs, batch_size)) # save_fname = 'saved_models/%s-e%s.h5' % (dt.datetime.now().strftime('%d%m%Y-%H%M%S'), str(epochs)) #for sp500 save_fname = 'saved_models/tracker.h5' #for tracker data # save_fname = 'saved_models/tracker.h5' callbacks = [ EarlyStopping(monitor='val_loss', patience=2), ModelCheckpoint(filepath=save_fname, monitor='val_loss', save_best_only=True) ] self.model.fit(x, y, epochs=epochs, batch_size=batch_size, callbacks=callbacks) self.model.save(save_fname) print('[Model] Training Completed. Model saved as %s' % save_fname) timer.stop()
def build_model(self, configs): timer = Timer() timer.start() for layer in configs['model']['layers']: neurons = layer['neurons'] if 'neurons' in layer else None dropout_rate = layer['rate'] if 'rate' in layer else None activation = layer['activation'] if 'activation' in layer else None return_seq = layer['return_seq'] if 'return_seq' in layer else None input_timesteps = layer['input_timesteps'] if 'input_timesteps' in layer else None input_dim = layer['input_dim'] if 'input_dim' in layer else None if layer['type'] == 'dense': # 加一个全连接层 self.model.add(Dense(neurons, activation=activation)) if layer['type'] == 'lstm': self.model.add(LSTM(neurons, input_shape=(input_timesteps, input_dim), return_sequences=return_seq)) if layer['type'] == 'dropout': # dropout应用于输入 self.model.add(Dropout(dropout_rate)) # 编译模型,一般在建立模型的时候才会用到,主要是配置优化器、损失函数等等,在预测的时候不用编译了。 # 编译的时候选择loss,优化器和callbacks的metrics self.model.compile(loss=configs['model']['loss'], optimizer=configs['model']['optimizer'] ,metrics=["accuracy","mae"]) print('[Model] Model Compiled') timer.stop()
def train(self, x, y, epochs, batch_size, save_dir): timer = Timer() timer.start() print("[Model] Training Started") print("[Model] %s epochs, %s batch size" % (epochs, batch_size)) save_fname = os.path.join( save_dir, "%s-e%s.h5" % (dt.datetime.now().strftime("%d%m%Y-%H%M%S"), str(epochs)), ) callbacks = [ EarlyStopping(monitor="val_loss", patience=2), ModelCheckpoint(filepath=save_fname, monitor="val_loss", save_best_only=True), ] self.model.fit(x, y, epochs=epochs, batch_size=batch_size, callbacks=callbacks) self.model.save(save_fname) print("[Model] Training Completed. Model saved as %s" % save_fname) timer.stop()
def train_generator(self, data_gen, epochs, batch_size, steps_per_epoch, save_dir, configs): timer = Timer() timer.start() print('[Model] Training Started') print('[Model] %s epochs, %s batch size, %s batches per epoch' % (epochs, batch_size, steps_per_epoch)) log_dir = "logs/fit/" + datetime.datetime.now().strftime( "%Y%m%d-%H%M%S") tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir=log_dir, histogram_freq=1) save_fname = os.path.join( save_dir, '%s-%s-e%s.h5' % (configs['data']['filename'], dt.datetime.now().strftime('%d%m%Y-%H%M%S'), str(epochs))) callbacks = [ ModelCheckpoint(filepath=save_fname, monitor='loss', save_best_only=True), tensorboard_callback ] self.model.fit_generator(data_gen, steps_per_epoch=steps_per_epoch, epochs=epochs, callbacks=callbacks, workers=1) print('[Model] Training Completed. Model saved as %s' % save_fname) timer.stop()
def train_generator(self, data_gen, epochs, batch_size, steps_per_epoch, save_dir): timer = Timer() timer.start() print('MODEL Out-of-Memory Training Started') print( f'MODEL {epochs} epochs, {batch_size} batch size, {steps_per_epoch} batches per epoch' ) save_fname = os.path.join( save_dir, '%s-e%s.h5' % (dt.datetime.now().strftime('%d%m%Y-%H%M%S'), str(epochs))) callbacks = [ ModelCheckpoint(filepath=save_fname, monitor='loss', save_best_only=True) ] self.model.fit_generator(data_gen, steps_per_epoch=steps_per_epoch, epochs=epochs, callbacks=callbacks, workers=1) print( f'MODEL Out-of-Memory Training Completed. Model saved as {save_fname}' ) timer.stop()
def train(self, x, y, epochs, batch_size, save_dir): timer = Timer() timer.start() logger.info('[Model] Training Started') logger.info('[Model] %s epochs, %s batch size' % (epochs, batch_size)) save_fname = os.path.join( save_dir, '%s-e%s.h5' % (dt.datetime.now().strftime('%d%m%Y-%H%M%S'), str(epochs))) callbacks = [ EarlyStopping(monitor='val_loss', patience=2), ModelCheckpoint(filepath=save_fname, monitor='val_loss', save_best_only=True) ] self.model.fit(x, y, epochs=epochs, batch_size=batch_size, callbacks=callbacks) self.model.save(save_fname) logger.info('[Model] Training Completed. Model saved as %s' % save_fname) timer.stop()
def demo(net, image_name): """Detect object classes in an image using pre-computed object proposals.""" # Load the demo image im_file = os.path.join(cfg.DATA_DIR, 'demo', image_name) ims = [cv2.imread(im_file)] # Detect all object classes and regress object bounds timer = Timer() timer.tic() batch_scores, batch_boxes = im_detect(net, ims) scores = batch_scores[0] boxes = batch_boxes[0] timer.toc() print('Detection took {:.3f}s for ' '{:d} object proposals').format(timer.total_time, boxes.shape[0]) # Visualize detections for each class CONF_THRESH = 0.8 NMS_THRESH = 0.3 for cls_ind, cls in enumerate(CLASSES[1:]): cls_ind += 1 # because we skipped background cls_scores = scores[:, cls_ind] cls_boxes = boxes dets = np.hstack( (cls_boxes, cls_scores[:, np.newaxis])).astype(np.float32) keep = nms(dets, NMS_THRESH, force_cpu=True) dets = dets[keep, :] vis_detections(ims[0], cls, dets, thresh=CONF_THRESH)
def train_generator(self, data_gen, epochs, batch_size, steps_per_epoch, save_dir): timer = Timer() timer.start() print("[Model] Training Started") print("[Model] %s epochs, %s batch size, %s batches per epoch" % (epochs, batch_size, steps_per_epoch)) save_fname = os.path.join( save_dir, "%s-e%s.h5" % (dt.datetime.now().strftime("%d%m%Y-%H%M%S"), str(epochs)), ) callbacks = [ ModelCheckpoint(filepath=save_fname, monitor="loss", save_best_only=True) ] self.model.fit( data_gen, steps_per_epoch=steps_per_epoch, epochs=epochs, callbacks=callbacks, workers=1, ) print("[Model] Training Completed. Model saved as %s" % save_fname) timer.stop()
def build_windowed_batch_CONV_model(self): timer = Timer() timer.start() Options.KerasEpochs = 20 Options.KerasWindowedBatchSize = 400 #self.model.add(Reshape((Options.WindowSequenceLength, Options.InputFeatureSize), input_shape=(input_shape,))) self.model.add( Conv1D(100, 10, activation='relu', input_shape=(Options.WindowSequenceLength, Options.InputFeatureSize))) self.model.add(Conv1D(100, 10, activation='relu')) self.model.add(MaxPooling1D(3)) self.model.add(Conv1D(160, 10, activation='relu')) #self.model.add(Conv1D(160, 10, activation='relu')) self.model.add(GlobalAveragePooling1D()) self.model.add(Dropout(0.5)) self.model.add(Dense(1, activation='linear')) optimizer = RMSprop(lr=0.00050) #optimizer = Adam() self.model_loss = 'mae' #'mean_squared_error', 'mae' self.model.compile(optimizer=optimizer, loss=self.model_loss, metrics=list(set(['mae', self.model_loss]))) print('[Model] Model Compiled') timer.stop()
def train(self, x, y, epochs, batch_size, save_dir, x_val, y_val): timer = Timer() timer.start() print('[Model] Training Started') print('[Model] %s epochs, %s batch size' % (epochs, batch_size)) validation_data = (x_val, y_val) if x_val and y_val else None save_fname = os.path.join( save_dir, '%s-e%s.h5' % (dt.datetime.now().strftime('%d%m%Y-%H%M%S'), str(epochs))) callbacks = [ ModelCheckpoint(filepath=save_fname, monitor='val_loss', save_best_only=True) ] hist = self.model.fit(x, y, epochs=epochs, batch_size=batch_size, callbacks=callbacks, validation_data=validation_data) self.model.save(save_fname) print('[Model] Training Completed. Model saved as %s' % save_fname) timer.stop() return hist
def train_generator(self, data_gen, epochs, batch_size, steps_per_epoch, save_dir): timer = Timer() timer.start() print('[Model] Training Started') print('[Model] %s epochs, %s batch size, %s batches per epoch' % (epochs, batch_size, steps_per_epoch)) save_fname = os.path.join( save_dir, '%s-e%s.h5' % (dt.datetime.now().strftime('%Y%m%d-%H%M%S'), str(epochs))) callbacks = [ #ModelCheckpoint(filepath=save_fname, monitor='loss', save_best_only=True), SignalStopping(doubleSignalExits=True, verbose=Options.KerasVerbose) ] self.model.fit_generator( data_gen, #validation_data = [], steps_per_epoch=steps_per_epoch, epochs=epochs, callbacks=callbacks, #,workers=1 ) print('[Model] Training Completed. Model saved as %s' % save_fname) timer.stop()
def build_model(self, configs): timer = Timer() timer.start() for layer in configs["model"]["layers"]: neurons = layer["neurons"] if "neurons" in layer else None dropout_rate = layer["rate"] if "rate" in layer else None activation = layer["activation"] if "activation" in layer else None return_seq = layer["return_seq"] if "return_seq" in layer else None input_timesteps = (layer["input_timesteps"] if "input_timesteps" in layer else None) input_dim = layer["input_dim"] if "input_dim" in layer else None if layer["type"] == "dense": self.model.add(Dense(neurons, activation=activation)) if layer["type"] == "lstm": self.model.add( LSTM( neurons, input_shape=(input_timesteps, input_dim), return_sequences=return_seq, )) if layer["type"] == "dropout": self.model.add(Dropout(dropout_rate)) self.model.compile(loss=configs["model"]["loss"], optimizer=configs["model"]["optimizer"]) print("[Model] Model Compiled") timer.stop()
def train(self, x, y, epochs, batch_size, save_dir,history,x_test = None,y_test = None): timer = Timer() timer.start() print('[Model] Training Started') print('[Model] %s epochs, %s batch size' % (epochs, batch_size)) save_fname = os.path.join(save_dir, '%s-e%s.h5' % (dt.datetime.now().strftime('%d%m%Y-%H%M%S'), str(epochs))) callbacks = [ EarlyStopping(monitor='val_loss', patience=2), ModelCheckpoint(filepath=save_fname, monitor='val_loss', save_best_only=True), history ] # fit的时候要填入交叉验证集和callback返回值 self.model.fit( x, y, epochs=epochs, batch_size=batch_size, callbacks=callbacks, validation_data=(x_test,y_test) ) self.model.save(save_fname) global newest_model newest_model = save_fname print('[Model] Training Completed. Model saved as %s' % save_fname) timer.stop()
def train(self, X, y, epochs, batch_size, save_dir, logs): timer = Timer() timer.start() print('MODEL Training Started') print(f'MODEL {epochs} epochs, {batch_size} batch size') save_fname = os.path.join( save_dir, f'{dt.datetime.now().strftime("%d%m%Y-%H%M%S")}-e{epochs}.h5') callbacks = [ EarlyStopping(monitor='val_loss', patience=2), ModelCheckpoint(filepath=save_fname, monitor='val_loss', save_best_only=True), TensorBoard( log_dir= f'{logs}/{dt.datetime.now().strftime("%d%m%Y-%H%M%S")}-e{epochs}' ) ] self.model.fit(X, y, epochs=epochs, batch_size=batch_size, callbacks=callbacks, shuffle=False) self.model.save(save_fname) print(f'MODEL Training Completed. Model saved as {save_fname}') timer.stop()
def train_generator(self, data_gen, epochs, batch_size, steps_per_epoch, save_dir, validation_data=None, validation_steps=None): timer = Timer() timer.start() print('[Model] Training Started') print('[Model] %s epochs, %s batch size, %s batches per epoch' % (epochs, batch_size, steps_per_epoch)) save_fname = os.path.join( save_dir, '%s-e%s.h5' % (dt.datetime.now().strftime('%d%m%Y-%H%M%S'), str(epochs))) callbacks = [ ModelCheckpoint(filepath=save_fname, monitor='loss', save_best_only=True) ] hist = self.model.fit_generator(data_gen, steps_per_epoch=steps_per_epoch, epochs=epochs, callbacks=callbacks, workers=1, validation_data=validation_data, validation_steps=validation_steps) print('[Model] Training Completed. Model saved as %s' % save_fname) timer.stop() return hist
def build_model(self, configs): timer = Timer() timer.start() for i, layer in enumerate(configs['model']['layers']): neurons = layer['neurons'] if 'neurons' in layer else None dropout_rate = layer['rate'] if 'rate' in layer else None activation = layer['activation'] if 'activation' in layer else None return_seq = layer['return_seq'] if 'return_seq' in layer else None input_timesteps = configs['data'][ 'sequence_length'] if 'input_timesteps' in layer else None input_dim = layer['input_dim'] if 'input_dim' in layer else None if layer['type'] == 'dense': self.model.add(Dense(neurons, activation=activation)) if layer['type'] == 'lstm': self.model.add( LSTM(neurons, input_shape=(input_timesteps, input_dim), return_sequences=return_seq)) if layer['type'] == 'dropout': self.model.add(Dropout(dropout_rate)) optimizer = Adam(lr=configs['model']['lr']) self.model.compile(loss=configs['model']['loss'], optimizer=optimizer) print('[Model] Model Compiled') print(self.model.summary()) timer.stop()
def train_generator(self, train_loader, val_loader, epochs, batch_size, steps_per_epoch, validation_steps, save_dir, log_dir): timer = Timer() timer.start() print('[Model] Training Started') print('[Model] %s epochs, %s batch size, %s batches per epoch' % (epochs, batch_size, steps_per_epoch)) time_format = time.localtime(time.time()) model_fname = 'model-%s-e{epoch:02d}-{val_loss:.5f}.h5' % ( time.strftime('%Y%m%d%H%M%S', time_format)) model_save_path = os.path.join(save_dir, model_fname) lr_schedule = lambda epoch: 0.001 * 0.95**epoch learning_rate = np.array([lr_schedule(i) for i in range(epochs)]) callbacks = [ ModelCheckpoint(filepath=model_save_path, monitor='val_loss', save_best_only=False), LearningRateScheduler(lambda epoch: float(learning_rate[epoch])), EarlyStopping(monitor='val_loss', patience=2, verbose=1), TensorBoard(log_dir=log_dir, write_graph=True) ] self.model.fit_generator(train_loader, steps_per_epoch=steps_per_epoch, epochs=epochs, validation_data=val_loader, validation_steps=validation_steps, callbacks=callbacks) print('[Model] Training Completed. Model saved as %s' % model_save_path) timer.stop()
def train_generator(self, data_gen, epochs, batch_size, steps_per_epoch, save_dir): timer = Timer() timer.start() print('[Model] Training Started') print('[Model] %s epochs, %s batch size, %s batches per epoch' % (epochs, batch_size, steps_per_epoch)) save_fname = os.path.join( save_dir, '%s-e%s.h5' % (dt.datetime.now().strftime('%d%m%Y-%H%M%S'), str(epochs))) callbacks = [ ModelCheckpoint(filepath=save_fname, monitor='loss', save_best_only=True) ] self.model.fit_generator( data_gen, steps_per_epoch= steps_per_epoch, # 开始新一轮训练之前从生成器产生的总步数(批次样本)通常等于datasize/batchsize epochs=epochs, # 训练模型的迭代总轮数 callbacks=callbacks, workers=1) print('[Model] Training Completed. Model saved as %s' % save_fname) timer.stop()