def main(): params = {'batch_size': 64} modelname = argv[1] #Datasets partition = load_partition() print(len(partition['train'])) print(len(partition['validation'])) training_generator = DataGenerator(partition['train'], **params) validation_generator = DataGenerator(partition['validation'], **params) dm = DataManager() dm.load_tokenizer('/mnt/data/b04901058/recsys/token0_Xfull.pk') word_index, embedding_matrix = dm.embedding_matrix() cnn_model = cnn0(word_index, embedding_matrix) cnn_model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy']) checkpoint = [ ModelCheckpoint( modelname, # model filename monitor='val_loss', # quantity to monitor verbose=0, # verbosity - 0 or 1 save_best_only=True, # The latest best model will not be overwritten mode='auto'), # The decision to overwrite model is made EarlyStopping(monitor='val_loss', patience=3, verbose=0) ] cnn_model.fit_generator(generator=training_generator, validation_data=validation_generator, callbacks=checkpoint, verbose=1, use_multiprocessing=True, epochs=12, workers=3)
def train_model(self): self.logger.info(self.evaluator.metrics_info()) for epoch in range(1, self.num_epochs + 1): # Generate training instances user_input, item_input_pos, item_input_neg = DataGenerator._get_pairwise_all_data( self.dataset) data_iter = DataIterator(user_input, item_input_pos, item_input_neg, batch_size=self.batch_size, shuffle=True) total_loss = 0.0 training_start_time = time() num_training_instances = len(user_input) for bat_users, bat_items_pos, bat_items_neg in data_iter: feed_dict = { self.user_input: bat_users, self.pos_items: bat_items_pos, self.neg_items: bat_items_neg } loss, _ = self.sess.run((self.loss, self.optimizer), feed_dict=feed_dict) total_loss += loss # self.logger.info("[iter %d : loss : %f, time: %f]" % (epoch, total_loss/num_training_instances, # time()-training_start_time)) if epoch % self.verbose == 0: self.logger.info("epoch %d:\t%s" % (epoch, self.evaluate()))
def train_model(self): self.logger.info(self.evaluator.metrics_info()) # self.w=np.ones((self.n_layers+1,self.n_layers+1)) for epoch in range(1, self.num_epochs + 1): # Generate training instances user_input, item_input_pos, item_input_neg = DataGenerator._get_pairwise_all_data( self.dataset) data_iter = DataIterator(user_input, item_input_pos, item_input_neg, batch_size=self.batch_size, shuffle=True) total_loss = 0.0 training_start_time = time() for bat_users, bat_items_pos, bat_items_neg in data_iter: feed_dict = { self.user_input: bat_users, self.item_input: bat_items_pos, self.item_input_neg: bat_items_neg } loss, _ = self.sess.run((self.loss, self.optimizer), feed_dict=feed_dict) total_loss += loss self.logger.info("[iter %d : loss : %f, time: %f]" % (epoch, total_loss / len(user_input), time() - training_start_time)) # if epoch<200: # self.w=anchor_pre if epoch % 20 == 0: self.logger.info("epoch %d:\t%s" % (epoch, self.evaluate()))
def train_model(self): self.logger.info(self.evaluator.metrics_info()) best = 0.0 for epoch in range(1, self.num_epochs + 1): # Generate training instances user_input, item_input_pos, item_input_neg = DataGenerator._get_pairwise_all_data( self.dataset) data_iter = DataIterator(user_input, item_input_pos, item_input_neg, batch_size=self.batch_size, shuffle=True) total_loss = 0.0 training_start_time = time() for bat_users, bat_items_pos, bat_items_neg in data_iter: feed_dict = { self.user_input: bat_users, self.item_input: bat_items_pos, self.item_input_neg: bat_items_neg } loss, _ = self.sess.run((self.loss, self.optimizer), feed_dict=feed_dict) total_loss += loss self.logger.info("[iter %d : loss : %f, time: %f]" % (epoch, total_loss / len(user_input), time() - training_start_time)) if epoch % 20 == 0: result = self.evaluate() self.logger.info("epoch %d:\t%s" % (epoch, result)) pre = float(result.split('\t')[1]) if best < pre: best = pre bestresult = self.sess.run(self.ego_embedding) n = 0 else: n += 1 if n >= 20: np.save('tool/%s_weight.npy' % self.data_name, bestresult) break
def training_rnn(train, test): config = Config(sampling_rate=800, audio_duration=10, n_folds=n_folds, learning_rate=0.001) if DEBUG: config = Config(sampling_rate=100, audio_duration=1, n_folds=n_folds, max_epochs=1) PREDICTION_FOLDER = "predictions_rnn" if not os.path.exists(PREDICTION_FOLDER): os.mkdir(PREDICTION_FOLDER) if os.path.exists('logs/' + PREDICTION_FOLDER): shutil.rmtree('logs/' + PREDICTION_FOLDER) skf = StratifiedKFold(train.label_idx, n_folds=config.n_folds) for i, (train_split, val_split) in enumerate(skf): train_set = train.iloc[train_split] val_set = train.iloc[val_split] checkpoint = ModelCheckpoint('../model/bestrnn_%d.h5'%i, monitor='val_loss', verbose=1, save_best_only=True) early = EarlyStopping(monitor="val_loss", mode="min", patience=5) tb = TensorBoard(log_dir='./logs/' + PREDICTION_FOLDER + '/fold_%d'%i, write_graph=True) callbacks_list = [checkpoint, early, tb] print("Fold: ", i) print("#"*50) model = get_rnn_model(config) train_generator = DataGenerator(config, '../data/audio_train/', train_set.index, train_set.label_idx, batch_size=64, preprocessing_fn=audio_norm) val_generator = DataGenerator(config, '../data/audio_train/', val_set.index, val_set.label_idx, batch_size=64, preprocessing_fn=audio_norm) history = model.fit_generator(train_generator, callbacks=callbacks_list, validation_data=val_generator, epochs=config.max_epochs, use_multiprocessing=True, workers=6, max_queue_size=20) model.load_weights('../model/best1d_%d.h5'%i) # Save train predictions train_generator = DataGenerator(config, '../data/audio_train/', train.index, batch_size=128, preprocessing_fn=audio_norm) predictions = model.predict_generator(train_generator, use_multiprocessing=True, workers=6, max_queue_size=20, verbose=1) np.save(PREDICTION_FOLDER + "/train_predictions_%d.npy"%i, predictions) # Save test predictions test_generator = DataGenerator(config, '../data/audio_test/', test.index, batch_size=128, preprocessing_fn=audio_norm) predictions = model.predict_generator(test_generator, use_multiprocessing=True, workers=6, max_queue_size=20, verbose=1) np.save(PREDICTION_FOLDER + "/test_predictions_%d.npy"%i, predictions) # Make a submission file top_3 = np.array(LABELS)[np.argsort(-predictions, axis=1)[:, :3]] predicted_labels = [' '.join(list(x)) for x in top_3] test['label'] = predicted_labels test[['label']].to_csv(PREDICTION_FOLDER + "/predictions_%d.csv"%i) pred_list = [] for i in range(n_folds): pred_list.append(np.load("predictions_1d_conv/test_predictions_%d.npy"%i)) prediction = np.ones_like(pred_list[0]) for pred in pred_list: prediction = prediction*pred prediction = prediction**(1./len(pred_list)) # Make a submission file top_3 = np.array(LABELS)[np.argsort(-prediction, axis=1)[:, :3]] predicted_labels = [' '.join(list(x)) for x in top_3] test = pd.read_csv('../data/sample_submission.csv') test['label'] = predicted_labels test[['fname', 'label']].to_csv("../result/rnn_ensembled_submission.csv", index=False)
def main(args): with open(args.config, 'r') as f: config = json.load(f) if config['optimizer'] == 'SGD': optimizer = SGD(lr=config['learning_rate'], decay=config['learning_rate'] / config['epochs'], momentum=config['momentum']) else: raise Exception('Unsupported optimizer: {}.'.format( config['optimizer'])) model_name = str.lower(config['model']) if model_name == 'lstm': model = LSTM(config['input_length'], 2) elif model_name == 'conv1d': model = Conv1D(config['input_length'], 2) elif model_name == 'conv2d': model = Conv2D(config['input_length'], 2) else: raise Exception('Unsupported model: {}.'.format(config['model'])) model.compile(loss='binary_crossentropy', optimizer=optimizer, metrics=['accuracy']) wav_paths = glob('{}/**'.format(args.data_dir), recursive=True) wav_paths = [x for x in wav_paths if '.wav' in x] classes = sorted(os.listdir(args.data_dir)) le = LabelEncoder() le.fit(classes) labels = [get_class(x, args.data_dir) for x in wav_paths] labels = le.transform(labels) print('CLASSES: ', list(le.classes_)) print(le.transform(list(le.classes_))) wav_train, wav_val, label_train, label_val = train_test_split( wav_paths, labels, test_size=config['validation_split'], random_state=0) tg = DataGenerator(wav_train, label_train, config['input_length'], len(set(label_train)), batch_size=config['batch_size']) vg = DataGenerator(wav_val, label_val, config['input_length'], len(set(label_val)), batch_size=config['batch_size']) output_sub_dir = os.path.join(args.output_dir, model_name, datetime.now().strftime('%Y%m%d_%H%M%S')) os.makedirs(output_sub_dir) callbacks = [ EarlyStopping(monitor='val_loss', patience=config['patience'], restore_best_weights=True, verbose=1), ModelCheckpoint(filepath=os.path.join( output_sub_dir, 'model.{epoch:02d}-{val_loss:.4f}.h5'), monitor='val_loss', save_best_only=True, verbose=1), CSVLogger(os.path.join(output_sub_dir, 'epochs.csv')) ] model.fit(tg, validation_data=vg, epochs=config['epochs'], verbose=1, callbacks=callbacks)
print('train_img_nums:', len(train_img_names)) print('train_label_nums:', len(train_labels)) # with open(label_txt_path_test, 'r') as f: # ff = f.readlines() # for i, line in enumerate(ff): # line = line.strip() # img_name = line.split()[0] # label = line.split()[1:] # label = list(map(int,label)) # img_names_test.append(img_name) # labels_test.append(label) print('test_img_nums:', len(test_img_names)) print('test_label_nums:', len(test_labels)) train_generator = DataGenerator(img_root=imgs_path, list_IDs=train_img_names, labels=train_labels, batch_size=batch_size, label_max_length=max_labels, n_channels=3) test_generator = DataGenerator(img_root=imgs_path, list_IDs=test_img_names, labels=test_labels, batch_size=batch_size, label_max_length=max_labels, n_channels=3) # In[3]: # PE(pos, 2i) = sin(pos / 10000^(2i/d_model)) # PE(pos, 2i+1) = cos(pos / 10000^(2i/d_model)) # pos.shape: [sentence_length, 1] # i.shape : [1, d_model] # result.shape: [sentence_length, d_model] def get_angles(pos, i, d_model): angle_rates = 1 / np.power(10000,
def train(): generator = DataGenerator(batch_size=batch_size, epoch=epoch) iterator = generator.train_dataset.make_one_shot_iterator() image, noise_input = iterator.get_next() gan = SimpleGan() gen_loss, disc_loss = gan.train(noise_input, image) global_step = tf.Variable(0, trainable=False) gen_start_learning_rate = 0.000001 gen_learning_rate = tf.train.exponential_decay(gen_start_learning_rate, global_step, 100, 0.8, staircase=True) disc_start_learning_rate = 0.0001 disc_learning_rate = tf.train.exponential_decay(disc_start_learning_rate, global_step, 100, 0.8, staircase=True) train_gan = tf.contrib.layers.optimize_loss( loss=gen_loss, global_step=global_step, learning_rate=gen_learning_rate, optimizer=tf.train.AdamOptimizer, clip_gradients=9.0, summaries=["learning_rate", "loss"]) train_disc = tf.contrib.layers.optimize_loss( loss=disc_loss, global_step=global_step, learning_rate=disc_learning_rate, optimizer=tf.train.AdamOptimizer, summaries=["learning_rate", "loss"]) with tf.Session() as sess: saver = tf.train.Saver() if loading_model: saver.restore(sess, model_file) else: tf.global_variables_initializer().run() try: step = 0 while True: # _, gl = sess.run([train_gan, gen_loss]) _, dl = sess.run([train_disc, disc_loss]) for i in range(10): # _, dl = sess.run([train_disc, disc_loss]) _, gl = sess.run([train_gan, gen_loss]) _, dl = sess.run([train_disc, disc_loss]) if step % 10 == 0: print( "Minibatch at step %d ==== gen_loss: %.2f, disc_loss: %.2f" % (step, gl, dl)) # print("Minibatch at step %d ==== disc_loss: %.2f" % (step, dl)) if (step + 1) % 100 == 0 and saving_model: save_path = saver.save(sess, model_file) print("Model saved in %s" % save_path) step += 1 except tf.errors.OutOfRangeError: if saving_model: save_path = saver.save(sess, model_file) print("Model saved in %s" % save_path)