def main(file_path): # Validate raw data path if not os.path.exists(file_path): LOG_ERROR('Could not find file: {}'.format(file_path)) return # Validate raw data file type if not file_path.endswith('.json'): LOG_ERROR('File path must be a json file') return # Parse JSON with open(file_path, encoding='utf-8') as f: LOG_INFO('Parsing JSON file: {}'.format(file_path)) json_archive = json.load(f) if not 'conversation_state' in json_archive.keys(): LOG_ERROR('Could not find `conversation_state` in file {}'.format( file_path)) return # Parse each conversation for state in json_archive['conversation_state']: conv = Conversation(state) conv.parse() conv.print_summary() conv.serialize() LOG_INFO('Finished parsing conversations!')
def compile(self, input_placeholder, label_placeholder, loss, optimizer): x = input_placeholder for k in range(self.num_layers): x = self.layer_list[k].forward(x) self.loss = loss.forward(x, label_placeholder) self.updates = optimizer.get_updates(self.loss, self.params) self.accuracy = T.mean(T.eq(T.argmax(x, axis=-1), T.argmax(label_placeholder, axis=-1))) LOG_INFO('start compiling model...') self.train = theano.function( inputs=[input_placeholder, label_placeholder], outputs=[self.loss, self.accuracy], updates=self.updates, allow_input_downcast=True) self.test = theano.function( inputs=[input_placeholder, label_placeholder], outputs=[self.accuracy, self.loss], allow_input_downcast=True) self.predict = theano.function( inputs=[input_placeholder], outputs=[x], allow_input_downcast=True) LOG_INFO('model compilation done!')
def main(): test_loss_list = [] test_acc_list = [] train_loss_list = [] train_acc_list = [] args = get_parser() model, config, loss = get_model(args) starttime = datetime.datetime.now() for epoch in range(args.max_epoch): LOG_INFO('Training @ %d epoch...' % (epoch)) train_loss, train_acc = train_net(model, loss, config, train_data, train_label, config['batch_size'], config['disp_freq']) train_loss_list.extend(train_loss) train_acc_list.extend(train_acc) if epoch > 5: config['learning_rate'] = config['learning_rate'] * args.learning_rate_decay if epoch % config['test_epoch'] == 0: LOG_INFO('Testing @ %d epoch...' % (epoch)) test_loss, test_acc = test_net(model, loss, test_data, test_label, config['batch_size']) test_loss_list.append(test_loss) test_acc_list.append(test_acc) endtime = datetime.datetime.now() print ("total training time:",(endtime - starttime).seconds) save(args, train_loss_list, train_acc_list, test_loss_list, test_acc_list)
def compile(self, input_placeholder, label_placeholder, label_active_size_placeholder, loss, optimizer): x = input_placeholder for k in range(self.num_layers): x = self.layer_list[k].forward(x) self.loss = loss.forward(x, label_placeholder) self.updates = optimizer.get_updates(self.loss, self.params) nhot_acc = NHotAcc() self.accuracy = nhot_acc(label_placeholder, x, label_active_size_placeholder) LOG_INFO('start compiling model...') self.train = theano.function( inputs=[input_placeholder, label_placeholder, label_active_size_placeholder], outputs=[self.loss, self.accuracy, x], updates=self.updates, allow_input_downcast=True) self.test = theano.function( inputs=[input_placeholder, label_placeholder, label_active_size_placeholder], outputs=[self.accuracy, self.loss], allow_input_downcast=True) self.predict = theano.function( inputs=[input_placeholder], outputs=[x], allow_input_downcast=True) LOG_INFO('model compilation done!')
def train_model(part_name, criterion, epochs): LOSS = 100 epoch_min = 1 LOG_INFO('\n\nTraining model for %s ...' % part_name) model = models[part_name] optimizer = optimizers[part_name] scheduler = schedulers[part_name] if args.load_model == True: model = pickle.load(open('res/saved-model-%s.pth'%part_name, 'rb')) train_loader = DataLoader(train_datasets[part_name], batch_size=args.batch_size, shuffle=True, num_workers=4) valid_loader = DataLoader(valid_datasets[part_name], batch_size=args.batch_size, shuffle=True, num_workers=4) test_loader = DataLoader(test_datasets[part_name], batch_size=args.batch_size, shuffle=True, num_workers=4) for epoch in range(1, epochs + 1): train(epoch, model, train_loader, optimizer, criterion) valid_loss = evaluate(model, valid_loader, criterion) if valid_loss < LOSS: LOSS = valid_loss epoch_min = epoch pickle.dump(model, open('res/saved-model-%s.pth'%part_name, 'wb')) #scheduler.step() msg = '...Epoch %02d, val loss (%s) = %.4f' % (epoch, part_name, valid_loss) LOG_INFO(msg) model = pickle.load(open('res/saved-model-%s.pth'%part_name, 'rb')) msg = 'Min @ Epoch %02d, val loss (%s) = %.4f' % (epoch_min, part_name, LOSS) LOG_INFO(msg) test_loss = evaluate(model, test_loader, criterion) LOG_INFO('Finally, test loss (%s) = %.4f' % (part_name, test_loss))
def main(file_path): # Validate raw data path if not os.path.exists(file_path): LOG_ERROR('Could not find file: {}'.format(file_path)) return # Validate raw data file type if not file_path.endswith('.pkl'): LOG_ERROR('File path must be a pickle file') return with open(file_path, 'rb') as f: LOG_INFO('Parsing pickle file: {}'.format(file_path)) conversation = pickle.load(f) LOG_INFO('Found conversation: {}'.format(conversation['conversation_name'])) df = pd.DataFrame(conversation['messages']) df.columns = ['Timestamp', 'Type', 'Participant'] # df['Datetime'] = pd.to_datetime(df['Timestamp']) df['Datetime'] = df['Timestamp'].apply(lambda x: datetime.datetime.fromtimestamp(float(x)).toordinal()) histogram = ggplot.ggplot(df, ggplot.aes(x='Datetime', fill='Participant')) \ + ggplot.geom_histogram(alpha=0.6, binwidth=2) \ + ggplot.scale_x_date(labels='%b %Y') \ + ggplot.ggtitle(conversation['conversation_name']) \ + ggplot.ylab('Number of messages') \ + ggplot.xlab('Date') print(histogram)
def train(adj, input_feats, target_labels, config, weights=None): num_vertices = adj.shape[0] label_kind = np.max(target_labels) + 1 feat_dim = input_feats.shape[-1] layer_config = (feat_dim, config['hidden_dim'], label_kind) model, loss = GCN("GCN", adj, weights, layer_config) # model, loss = MLP("MLP", weights, layer_config) # Construct masks for training and testing train_size = int(num_vertices * config['train_portion']) train_mask = np.zeros(target_labels.shape, dtype=bool) train_mask[:train_size] = True np.random.shuffle(train_mask) test_mask = ~train_mask for epoch in range(config['max_epoch']): LOG_INFO('Training @ %d epoch...' % (epoch)) train_net(model, loss, config, input_feats, target_labels, train_mask, label_kind) if (epoch + 1) % config['test_epoch'] == 0: LOG_INFO('Testing @ %d epoch...' % (epoch)) test_net(model, loss, input_feats, target_labels, test_mask, label_kind) if (epoch + 1) % 50 == 0: config['learning_rate'] *= 0.5
def train_and_save(model, loss, train_data, test_data, train_label, test_label): best_test_loss = -1 update_round_before = 0 train_loss_list = [] train_acc_list = [] test_loss_list = [] test_acc_list = [] epoch_final = 0 for epoch in range(config['max_epoch']): LOG_INFO('Training @ %d epoch...' % (epoch)) train_loss_now, train_acc_now = train_net(model, loss, config, train_data, train_label, config['batch_size'], config['disp_freq']) train_loss_list.append(train_loss_now) train_acc_list.append(train_acc_now) if epoch % config['test_epoch'] == 0: LOG_INFO('Testing @ %d epoch...' % (epoch)) test_loss_now, test_acc_now = test_net(model, loss, test_data, test_label, config['batch_size']) test_loss_list.append(test_loss_now) test_acc_list.append(test_acc_now) if best_test_loss == -1: update_round_before = 0 best_test_loss = test_loss_now elif test_loss_now <= best_test_loss: update_round_before = 0 best_test_loss = test_loss_now else: update_round_before += 1 if update_round_before >= 5: epoch_final = epoch + 1 break save_dir = os.path.join('result', config['name']) if not os.path.exists(save_dir): os.makedirs(save_dir) result_dict = { "train_loss": train_loss_list, "train_acc": train_acc_list, "test_loss": test_loss_list, "test_acc": test_acc_list } with open(os.path.join(save_dir, "result.json"), 'w') as f: json.dump(result_dict, f) x = range(epoch_final) plt.cla() plt.plot(x, train_loss_list, label="train loss") plt.plot(x, test_loss_list, label="test loss") plt.legend() plt.savefig(os.path.join(save_dir, "loss.png")) plt.cla() plt.plot(x, train_acc_list, label="train acc") plt.plot(x, test_acc_list, label="test acc") plt.legend() plt.savefig(os.path.join(save_dir, "acc.png"))
def solve_net(model, dataset, max_epoch, disp_freq, test_freq): iter_counter = 0 loss_list = [] accuracy_list = [] test_acc = [] test_loss = [] total_loss_list = [] for k in range(max_epoch): for train_sample in dataset.train_iterator(): iter_counter += 1 train_input = train_sample.vec_input() train_label = train_sample.label() loss, accuracy, outs = \ model.train(train_input, train_label, train_sample.label_key_count()) loss_list.append(loss) accuracy_list.append(accuracy) if iter_counter % disp_freq == 0: msg = 'Training iter %d, mean loss %.5f (batch loss %.5f), mean acc %.5f' % ( iter_counter, np.mean(loss_list), loss_list[-1], np.mean(accuracy_list)) LOG_INFO(msg) loss_list = [] accuracy_list = [] # i = 0 # epsilon = 1e-5 # to_max = np.reshape(np.append(outs[i] - epsilon, np.zeros(len(outs[i]))), [2, len(outs[i])]) # v = np.max(to_max, axis=0) * (1 / (1 - epsilon)) # print("out %s" % (str(v))) if iter_counter % test_freq == 0: LOG_INFO(' Testing...') for test_sample in dataset.test_iterator(): test_input = test_sample.vec_input() test_label = test_sample.label() t_accuracy, t_loss = model.test( test_input, test_label, train_sample.label_key_count()) test_acc.append(t_accuracy) test_loss.append(t_loss) msg = ' Testing iter %d, mean loss %.5f, mean acc %.5f' % ( iter_counter, np.mean(test_loss), np.mean(test_acc)) LOG_INFO(msg) test_acc = [] test_loss = [] if iter_counter % 100 == 0: total_loss_list.append(loss)
def serialize(self, filename=None, prefix='output'): # Assemble all data from conversation hangouts_data = { 'conversation_id': self.conversation_id, 'conversation_name': self.conversation_name, 'other_conversation_names': self.conversation_names, 'message_count': self.get_total_message_count(), 'video_duration': self.get_hangout_duration_h(), 'participant_ids': [p.id for p in self.participants], 'participant_names': [p.get_name_or_id() for p in self.participants], 'messages': self.message_data } # Create output directory if it doesn't exist output_dir = os.path.join(os.getcwd(), prefix) if not os.path.isdir(output_dir): os.mkdir(output_dir) # Set default filename if filename is None: filename = '{}-parsed.pkl'.format(self.conversation_id) output_filename = os.path.join(output_dir, filename) LOG_INFO( 'Serializing conversation data to "{}"'.format(output_filename)) # Serialize the conversation and dump it to file with open(output_filename, 'wb') as f: pickle.dump(hangouts_data, f)
def train(epoch, model, iterator, optimizer, criterion): loss_list = [] acc_list = [] loss_ = [] model.train() for i, batch in enumerate(iterator): optimizer.zero_grad() predictions = model(batch.text) loss = criterion(predictions, batch.label.long()) loss.backward() optimizer.step() acc = (predictions.max(1)[1] == batch.label.long()).float().mean() loss_list.append(loss.item()) loss_.append(loss.item()) acc_list.append(acc.item()) if i % args.display_freq == 0: msg = "Epoch %02d, Iter [%03d/%03d], train loss = %.4f, train acc = %.4f" % ( epoch, i, len(iterator), np.mean(loss_list), np.mean(acc_list)) LOG_INFO(msg) loss_list.clear() acc_list.clear() return np.mean(loss_)
def train_net(model, loss, config, inputs, labels, batch_size, disp_freq): iter_counter = 0 loss_list = [] acc_list = [] for input, label in data_iterator(inputs, labels, batch_size): target = onehot_encoding(label, 10) iter_counter += 1 # forward net output = model.forward(input) # calculate loss loss_value = loss.forward(output, target) # generate gradient w.r.t loss grad = loss.backward(output, target) # backward gradient model.backward(grad) # update layers' weights model.update(config) acc_value = calculate_acc(output, label) loss_list.append(loss_value) acc_list.append(acc_value) if iter_counter % disp_freq == 0: msg = ' Training iter %d, batch loss %.4f, batch acc %.4f' % ( iter_counter, np.mean(loss_list), np.mean(acc_list)) loss_list = [] acc_list = [] LOG_INFO(msg)
def train(model, device, train_loader, optimizer, epoch): model.train() loss_list = [] loss_ = [] acc_list = [] for batch_idx, (data, target) in enumerate(train_loader): data, target = data.to(device), target.to(device) data = data.view(data.shape[0], -1) # flatten optimizer.zero_grad() output = model(data) loss = F.cross_entropy(output, target) loss.backward() optimizer.step() loss_list.append(loss.item()) pred = output.argmax( dim=1, keepdim=True) # get the index of the max log-probability acc = pred.eq(target.view_as(pred)).float().mean() acc_list.append(acc.item()) if batch_idx % LOG_INTERVAL == 0: msg = 'Train Epoch: {} [{}/{} ({:.0f}%)]\tAvg Loss: {:.4f}\tAvg Acc: {:.4f}'.format( epoch, batch_idx * len(data), len(train_loader.dataset), 100. * batch_idx / len(train_loader), np.mean(loss_list), np.mean(acc_list)) LOG_INFO(msg) loss_.append(np.mean(loss_list)) loss_list.clear() acc_list.clear() return loss_
def train(model, optimizer, epoch, sentences, labels, verbosity=True): model.train() loss_list = [] acc_list = [] batch_idx = 0 for data, target in batching.iterate_data(sentences, labels, embeddings, TRAIN_BATCH_SIZE): optimizer.zero_grad() output = model(data) loss = F.cross_entropy(output, target) loss.backward() optimizer.step() loss_list.append(loss.item()) pred = output.argmax( dim=1, keepdim=True) # get the index of the max log-probability acc = pred.eq(target.view_as(pred)).float().mean() acc_list.append(acc.item()) if batch_idx % LOG_INTERVAL == 0: if verbosity: msg = 'Train Epoch: {} [{}/{} ({:.0f}%)]\tAvg Loss: {:.4f}\tAvg Acc: {:.4f}'.format( epoch, batch_idx * len(data), len(sentences), 100. * batch_idx / len(sentences), np.mean(loss_list), np.mean(acc_list)) LOG_INFO(msg) loss_list.clear() acc_list.clear() batch_idx += 1 return loss_list, acc_list
def test_net(model, loss, inputs, labels, batch_size, epoch, layer_name): loss_list = [] acc_list = [] for input, label in data_iterator(inputs, labels, batch_size, shuffle=False): target = onehot_encoding(label, 10) output, output_visualize = model.forward(input, visualize=True, layer_name=layer_name) # collapse output_visualize into 1 channel output_visualize = np.sum(output_visualize, axis=(1)) loss_value = loss.forward(output, target) acc_value = calculate_acc(output, label) loss_list.append(loss_value) acc_list.append(acc_value) msg = ' Testing, total mean loss %.5f, total acc %.5f' % ( np.mean(loss_list), np.mean(acc_list)) LOG_INFO(msg) # save weights and biases model.save_weights(loss.name, epoch) return np.mean(loss_list), np.mean( acc_list ), output_visualize # output_visualize: batch_size x height x width
def train2(epoch, model, train_loader, optimizer): loss_list3 = [] model.train() for j, batch in enumerate(train_loader): optimizer.zero_grad() image, labels, rects = batch['image'].to(device), batch['labels'].to( device), batch['rects'].to(device) full = model(F.interpolate(image, size=[128, 128], mode='bilinear')) #full = model(image) ## Loss3 full_l = F.interpolate(labels.float(), size=[128, 128], mode='bilinear').argmax(dim=1) #full_l = labels.argmax(dim=1) loss3 = criterion3(full, full_l) ## Total loss loss3.backward() optimizer.step() loss_list3.append(loss3.item()) if j % args.display_freq == 0: msg = "Epoch %02d, Iter [%03d/%03d], train loss = %.4f" % ( epoch, j, len(train_loader), np.mean(loss_list3)) LOG_INFO(msg) loss_list3.clear()
def parse(self): LOG_INFO('Parsing conversation with ID: {}'.format( self.conversation_id)) self.parse_initial_participants() for e in self.event: self.parse_message(e)
def solve_rnn(model, train_x, train_y, test_x, test_y, max_epoch, disp_freq, test_freq): iter_counter = 0 loss_list = [] accuracy_list = [] test_acc = [] test_loss = [] test_equation_acc = [] for k in range(max_epoch): for x, y in one_sample_iterator(train_x, train_y): iter_counter += 1 loss, accuracy = model.train(x, y) loss_list.append(loss) accuracy_list.append(accuracy) if iter_counter % disp_freq == 0: msg = 'Training iter %d, mean loss %.5f (sample loss %.5f), mean acc %.5f' % (iter_counter, np.mean(loss_list), loss_list[-1], np.mean(accuracy_list)) LOG_INFO(msg) loss_list = [] accuracy_list = [] if iter_counter % test_freq == 0: LOG_INFO(' Testing...') for tx, ty in one_sample_iterator(test_x, test_y, shuffle=False): t_accuracy, t_equ_acc, t_loss = model.test(tx, ty) test_acc.append(t_accuracy) test_loss.append(t_loss) test_equation_acc.append(t_equ_acc) msg = ' Testing iter %d, mean loss %.5f, mean acc %.5f, equation acc %.5f' % (iter_counter, np.mean(test_loss), np.mean(test_acc), np.mean(test_equation_acc)) LOG_INFO(msg) test_acc = [] test_loss = [] test_equation_acc = []
def run(net_func, save_loss_path, save_acc_path, result_dir="result/"): model, config = net_func() loss_, acc_ = [], [] for epoch in range(config['max_epoch']): LOG_INFO('Training @ %d epoch...' % (epoch)) a, b = train_net(model, loss, config, train_data, train_label, config['batch_size'], config['disp_freq']) loss_ += a acc_ += b if epoch % config['test_epoch'] == 0: LOG_INFO('Testing @ %d epoch...' % (epoch)) test_net(model, loss, test_data, test_label, config['batch_size']) test_net(model, loss, test_data, test_label, config['batch_size']) if not os.path.exists(result_dir): os.mkdir(result_dir) np.save(result_dir + save_loss_path, loss_) np.save(result_dir + save_acc_path, acc_)
def solve_net(model, train_x, train_y, test_x, test_y, batch_size, max_epoch, disp_freq, test_freq): tic = time.time() iter_counter = 0 loss_list = [] accuracy_list = [] test_acc = [] test_loss = [] for k in range(max_epoch): for x, y in data_iterator(train_x, train_y, batch_size): iter_counter += 1 loss, accuracy = model.train(x, y) loss_list.append(loss) accuracy_list.append(accuracy) if iter_counter % disp_freq == 0: msg = 'Training iter %d, mean loss %.5f (batch loss %.5f), mean acc %.5f' % ( iter_counter, np.mean(loss_list), loss_list[-1], np.mean(accuracy_list)) LOG_INFO(msg) loss_list = [] accuracy_list = [] if iter_counter % test_freq == 0: LOG_INFO(' Testing...') for tx, ty in data_iterator(test_x, test_y, batch_size, shuffle=False): t_accuracy, t_loss = model.test(tx, ty) test_acc.append(t_accuracy) test_loss.append(t_loss) msg = ' Testing iter %d, mean loss %.5f, mean acc %.5f' % ( iter_counter, np.mean(test_loss), np.mean(test_acc)) LOG_INFO(msg) test_acc = [] test_loss = [] toc = time.time() print "Elapsed Time:%ds" % (toc - tic)
def test_net(model, loss, input_feats, labels, test_mask, label_kind): target = onehot_encoding(labels, label_kind) output = model.forward(input_feats) # set mask output[~test_mask] = target[~test_mask] loss_value = loss.forward(output, target) acc_value = calculate_acc(output, labels, np.sum(test_mask)) msg = ' Testing, total mean loss %.5f, total acc %.5f' % (loss_value, acc_value) LOG_INFO(msg)
def train_net(model, loss, config, inputs, labels, batch_size, disp_freq, Loss, Acur): iter_counter = 0 loss_list = [] acc_list = [] ll = [] ac = [] for input, label in data_iterator(inputs, labels, batch_size): target = onehot_encoding(label, 10) iter_counter += 1 # forward net output = model.forward(input) # calculate loss loss_value = loss.forward(output, target) # generate gradient w.r.t loss grad = loss.backward(output, target) # backward gradient model.backward(grad) if loss_value > 1: config['learning_rate'] = 0.2 elif loss_value > 0.5: config['learning_rate'] = 0.1 elif loss_value > 0.2: config['learning_rate'] = 0.05 else: config['learning_rate'] = max(loss_value / 5.0, 0.005) # update layers' weights model.update(config) acc_value = calculate_acc(output, label) loss_list.append(loss_value) acc_list.append(acc_value) ll.append(loss_value) ac.append(acc_value) if iter_counter % disp_freq == 0: msg = ' Training iter %d, batch loss %.4f, batch acc %.4f' % ( iter_counter, np.mean(loss_list), np.mean(acc_list)) Loss.append(np.mean(loss_list)) Acur.append(np.mean(acc_list)) loss_list = [] acc_list = [] LOG_INFO(msg) Loss.append(np.mean(ll)) Acur.append(np.mean(ac))
def test_net(model, loss, inputs, labels, batch_size): loss_list = [] acc_list = [] for input, label in data_iterator(inputs, labels, batch_size, shuffle=False): target = onehot_encoding(label, 10) output = model.forward(input) loss_value = loss.forward(output, target) acc_value = calculate_acc(output, label) loss_list.append(loss_value) acc_list.append(acc_value) msg = ' Testing, total mean loss %.5f, total acc %.5f' % (np.mean(loss_list), np.mean(acc_list)) LOG_INFO(msg)
def train(model, loss, train_data, test_data, train_label, test_label): best_test_loss = -1 update_round_before = 0 for epoch in range(config['max_epoch']): LOG_INFO('Training @ %d epoch...' % (epoch)) train_loss_now, train_acc_now = train_net(model, loss, config, train_data, train_label, config['batch_size'], config['disp_freq']) if epoch % config['test_epoch'] == 0: LOG_INFO('Testing @ %d epoch...' % (epoch)) test_loss_now, test_acc_now = test_net(model, loss, test_data, test_label, config['batch_size']) if best_test_loss == -1: update_round_before = 0 best_test_loss = test_loss_now elif test_loss_now <= best_test_loss: update_round_before = 0 best_test_loss = test_loss_now else: update_round_before += 1 if update_round_before >= 5: break
def test_net(model, loss, inputs, labels, batch_size): loss_list = [] acc_list = [] # test model with all the test data for input, label in data_iterator(inputs, labels, batch_size, shuffle=False): # get the expected value of this batch of input target = onehot_encoding(label, 10) output = model.forward(input) # calculate loss of this batch loss_value = loss.forward(output, target) acc_value = calculate_acc(output, label) loss_list.append(loss_value) acc_list.append(acc_value) # use the mean of all batch's loss and accuracy as the final result msg = ' Testing, total mean loss %.5f, total acc %.5f' % (np.mean(loss_list), np.mean(acc_list)) LOG_INFO(msg)
def train_net(model, loss, config, inputs, labels, batch_size, disp_freq, loss_file): iter_counter = 0 loss_list = [] acc_list = [] for input, label in data_iterator(inputs, labels, batch_size): target = onehot_encoding(label, 10) iter_counter += 1 # print "Debug: ", "input=", input.shape, " target=", target.shape # forward net output = model.forward(input) # calculate loss loss_value = loss.forward(output, target) # generate gradient w.r.t loss grad = loss.backward(output, target) # backward gradient model.backward(grad) # update layers' weights model.update(config) acc_value = calculate_acc(output, label) loss_list.append(loss_value) acc_list.append(acc_value) ''' outf = file(loss_file, "a") outf.write(str(loss_value) + ' ' + str(acc_value) + '\n') outf.close() ''' if iter_counter % disp_freq == 0: msg = ' Training iter %d, batch loss %.4f, batch acc %.4f' % (iter_counter, np.mean(loss_list), np.mean(acc_list)) outf = file(loss_file, "a") outf.write(str(np.mean(loss_list)) + ' ' + str(np.mean(acc_list)) + '\n') outf.close() loss_list = [] acc_list = [] LOG_INFO(msg)
def train1(epoch, model, train_loader, optimizer): loss_list = [] model.train() for i, batch in enumerate(train_loader): optimizer.zero_grad() image, rects = batch['image'].to(device), batch['rects'].to(device) pred_rects = model(image, rects_only=True) loss = criterion1(pred_rects, rects) loss.backward() optimizer.step() loss_list.append(loss.item()) if i % args.display_freq == 0: msg = "Epoch %02d, Iter [%03d/%03d], train loss = %.4f" % ( epoch, i, len(train_loader), np.mean(loss_list)) LOG_INFO(msg) loss_list.clear()
def train(epoch, model, train_loader, optimizer, criterion): loss_list = [] model.train() for i, batch in enumerate(train_loader): optimizer.zero_grad() image, labels = batch['image'].to(device), batch['labels'].to(device) predictions = model(image) loss = criterion(predictions, labels.argmax(dim=1, keepdim=False)) loss.backward() optimizer.step() loss_list.append(loss.item()) if i % args.display_freq == 0: msg = "Epoch %02d, Iter [%03d/%03d], train loss = %.4f" % ( epoch, i, len(train_loader), np.mean(loss_list)) LOG_INFO(msg) loss_list.clear()
def train_net(model, loss, config, input_feats, labels, train_mask, label_kind): target = onehot_encoding(labels, label_kind) # forward net output = model.forward(input_feats) # set mask output[~train_mask] = target[~train_mask] # calculate loss loss_value = loss.forward(output, target) # generate gradient w.r.t loss grad = loss.backward(output, target) # backward gradient model.backward(grad) # update layers' weights model.update(config) acc_value = calculate_acc(output, labels, np.sum(train_mask)) msg = ' Training batch loss %.4f, batch acc %.4f' % (loss_value, acc_value) LOG_INFO(msg)
def train_net(model, loss, config, inputs, labels, batch_size, disp_freq, Loss, Acur): iter_counter = 0 loss_list = [] acc_list = [] ll = [] ac = [] # train model with for input, label in data_iterator(inputs, labels, batch_size): target = onehot_encoding(label, 10) iter_counter += 1 # forward net output = model.forward(input) # calculate loss value of the whole batch loss_value = loss.forward(output, target) # generate gradient w.r.t loss, this is actually the local gradient contribution of the output layer grad = loss.backward(output, target) # backward gradient model.backward(grad) # update layers' weights: recount after the whole backward procedure model.update(config) acc_value = calculate_acc(output, label) loss_list.append(loss_value) ll.append(loss_value) acc_list.append(acc_value) ac.append(acc_value) if iter_counter % disp_freq == 0: msg = ' Training iter %d, batch loss %.4f, batch acc %.4f' % (iter_counter, np.mean(loss_list), np.mean(acc_list)) loss_list = [] acc_list = [] LOG_INFO(msg) Loss.append(np.mean(ll)) Acur.append(np.mean(ac))