def forward(self, input_seq, input_length, max_length): reference = get_target(input_seq, start_nsw, end_nsw)[0] encoder_outputs, encoder_hidden = self.encoder(input_seq, input_length) decoder_hidden = encoder_hidden[:decoder.n_layers] decoder_input = torch.ones(1, 1, device=device, dtype=torch.long) * SOS_token all_tokens = torch.zeros([0], device=device, dtype=torch.long) all_scores = torch.zeros([0], device=device) for _ in range(max_length): decoder_output, decoder_hidden = self.decoder( decoder_input, decoder_hidden, encoder_outputs) tmp = decoder_input[0] if tmp == 2: return all_tokens, all_scores if tmp == voc.word2index[' ']: if (len(reference) >= 1): decoder_input = reference.pop(0).item() if decoder_input == w_char: decoder_input = u_char else: decoder_input = 2 #### EOS decoder_input = torch.tensor([decoder_input], device=device) else: decoder_scores, decoder_input = torch.max(decoder_output, dim=1) all_tokens = torch.cat((all_tokens, decoder_input), dim=0) all_scores = torch.cat((all_scores, decoder_scores), dim=0) decoder_input = torch.unsqueeze(decoder_input, 0) return all_tokens, all_scores
def train(model, gpt_model, iterator, optimizer, criterion, args): total_loss = 0 iter_num = 0 train_acc = 0 global iteration model.train() gpt_model.eval() if args.useKey == 'True': keyword = keyword_loader(args, 'train') for step, batch in enumerate(iterator): optimizer.zero_grad() enc_inputs = batch.que copy_dec_inputs = copy.deepcopy(batch.ans) copy_dec_target = copy.deepcopy(batch.ans) dec_inputs = get_dec_inputs(copy_dec_inputs, gpt_pad_token, gpt_eos_token) target_ = get_target(copy_dec_target, gpt_pad_token) target_ = target_.view(-1) with torch.no_grad(): dec_inputs = gpt_model(dec_inputs) #segment_ids, valid_len = get_segment_ids_vaild_len(enc_inputs, pad_token_idx) #attention_mask = gen_attention_mask(enc_inputs, valid_len) if args.useKey == 'True': outputs = model(enc_inputs, dec_inputs, keyword[step]) else: outputs = model(enc_inputs, dec_inputs, None) loss = criterion(outputs, target_) loss.backward() optimizer.step() total_loss += loss iter_num += 1 with torch.no_grad(): tr_acc = acc(outputs, target_, gpt_pad_token) train_acc += tr_acc if step % 2 == 0: total_train_loss.append(total_loss.data.cpu().numpy() / iter_num) iteration_list.append(iteration) iteration += 1 # test_time_visual(args, enc_inputs, outputs, target_, bert_tokenizer, gpt_vocab) return total_loss.data.cpu().numpy() / iter_num, train_acc.data.cpu().numpy() / iter_num
def test_target_content(): if utils.IMGFAC_URL.find("localhost") >= 0 and os.path.isfile( utils.IMGFAC_TCXML) and os.path.isfile(utils.IMGFAC_CONF): for target_imageid, target_imagestatus in target_built.itervalues(): if target_imagestatus == 'COMPLETE': imagejson = utils.get_target(target_imageid) yield _assert_target_content_installed, imagejson[ 'target'], target_imageid else: print "Skipping target images inspection: imgfac is not running locally? target_content.xml missing? imagefactory.conf misplaced?"
def forward(self, data): mse = nn.MSELoss(reduction='mean').to(self.device) l1norm = nn.L1Loss(reduction='mean').to(self.device) real_targets = utils.get_target(True, self.inverted, data.real_x_predictions.size(), self.device) synthesis_targets = utils.get_target( False, self.inverted, data.synthesis_x_predictions.size(), self.device) return mse(data.real_x_predictions, real_targets) +\ mse(data.synthesis_x_predictions, synthesis_targets) +\ mse(data.real_y_predictions, real_targets) +\ mse(data.synthesis_y_predictions, synthesis_targets) +\ self.regularizer * l1norm(data.id_x_approximations, data.real_x) +\ self.regularizer * l1norm(data.id_y_approximations, data.real_y)
def main(): df, allVisitorID = preproc.read_data() x = collect_features(df) y = utils.get_target(df, allVisitorID) # Dict: fullVisitorID to target pdb.set_trace() scaler = StandardScaler() x = scaler.fit_transform(x) clustering.apply_kmeans(x, x) clustering.apply_hierarchical(x, x) """TODO:
def test_target_content(): if ( utils.IMGFAC_URL.find("localhost") >= 0 and os.path.isfile(utils.IMGFAC_TCXML) and os.path.isfile(utils.IMGFAC_CONF) ): for target_imageid, target_imagestatus in target_built.itervalues(): if target_imagestatus == "COMPLETE": imagejson = utils.get_target(target_imageid) yield _assert_target_content_installed, imagejson["target"], target_imageid else: print "Skipping target images inspection: imgfac is not running locally? target_content.xml missing? imagefactory.conf misplaced?"
def send_json(): _handle_args(request.args) uptime = datetime.datetime.now().replace(microsecond=0) - startTime return jsonify({ 'Release': MY_RELEASE, 'StartTime': startTimeStr, 'Uptime': str(uptime), 'Hostname': utils.get_hostname(), 'LocalAddress': utils.get_local_address(), 'RemoteAddress': request.remote_addr, 'ServerHit': str(utils.get_server_hit_count()), 'WorkerInstance': utils.get_worker_instance(), 'Target': utils.get_target(), })
def valid(model, iterator, optimizer, criterion, args, bert_tok): total_loss = 0 iter_num = 0 test_acc = 0 model.eval() if args.useKey == 'True': keyword, refine_idx = keyword_loader(args, 'valid', bert_tok) with torch.no_grad(): for step, batch in enumerate(iterator): enc_inputs = batch.que copy_dec_inputs = copy.deepcopy(batch.ans) copy_dec_target = copy.deepcopy(batch.ans) dec_inputs = get_dec_inputs(copy_dec_inputs, gpt_pad_token, gpt_eos_token) target_ = get_target(copy_dec_target, gpt_pad_token) target_ = target_.view(-1) segment_ids, valid_len = get_segment_ids_vaild_len( enc_inputs, pad_token_idx) attention_mask = gen_attention_mask(enc_inputs, valid_len) if args.useKey == 'True': outputs = model(enc_inputs, dec_inputs, segment_ids, attention_mask, keyword[step], refine_idx[step]) else: outputs = model(enc_inputs, dec_inputs, segment_ids, attention_mask, None, refine_idx[step]) loss = criterion(outputs, target_) total_loss += loss iter_num += 1 te_acc = acc(outputs, target_, gpt_pad_token) test_time_visual(args, enc_inputs, outputs, target_, bert_tokenizer, gpt_vocab) test_acc += te_acc return total_loss.data.cpu().numpy() / iter_num, test_acc.data.cpu( ).numpy() / iter_num
def show_details(): _handle_args(request.args) uptime = datetime.datetime.now().replace(microsecond=0) - startTime return "<html>" + \ "<head><title>Demo Application</title></head>" + \ "<body>" + \ "<table>" + \ "<tr><td> Release </td> <td>" + MY_RELEASE + "</td> </tr>" + \ "<tr><td> Start Time </td> <td>" + startTimeStr + "</td> </tr>" + \ "<tr><td> Up Time </td> <td>" + str(uptime) + "</td> </tr>" + \ "<tr><td> Hostname </td> <td>" + utils.get_hostname() + "</td> </tr>" + \ "<tr><td> Local Address </td> <td>" + utils.get_local_address() + "</td> </tr>" + \ "<tr><td> Remote Address </td> <td>" + request.remote_addr + "</td> </tr>" + \ "<tr><td> Server Hit </td> <td>" + str(utils.get_server_hit_count()) + "</td> </tr>" + \ "<tr><td> Worker Instance </td> <td>" + utils.get_worker_instance() + "</td> </tr>" + \ "<tr><td> Target </td> <td>" + utils.get_target() + "</td> </tr>" + \ "</table>" + \ "</body>" + \ "</html>"
def test(model, gpt_model, iterator, optimizer, criterion, args): total_loss = 0 iter_num = 0 test_acc = 0 model.eval() gpt_model.eval() if args.useKey == 'True': keyword = keyword_loader(args, 'test') with torch.no_grad(): for step, batch in enumerate(iterator): enc_inputs = batch.que copy_dec_inputs = copy.deepcopy(batch.ans) copy_dec_target = copy.deepcopy(batch.ans) dec_inputs = get_dec_inputs(copy_dec_inputs, gpt_pad_token, gpt_eos_token) target_ = get_target(copy_dec_target, gpt_pad_token) target_ = target_.view(-1) with torch.no_grad(): dec_inputs = gpt_model(dec_inputs) #segment_ids, valid_len = get_segment_ids_vaild_len(enc_inputs, pad_token_idx) #attention_mask = gen_attention_mask(enc_inputs, valid_len) if args.useKey == 'True': outputs = model(enc_inputs, dec_inputs, keyword[step]) else: outputs = model(enc_inputs, dec_inputs, None) loss = criterion(outputs, target_) total_loss += loss iter_num += 1 te_acc = acc(outputs, target_, gpt_pad_token) test_acc += te_acc return total_loss.data.cpu().numpy() / iter_num, test_acc.data.cpu().numpy() / iter_num
def test_get_target(self): with patch.dict(os.environ, {'TARGET': 'foo'}): self.assertEqual('foo', utils.get_target())
def train(): parser = argparse.ArgumentParser(description='Train model.') parser.add_argument('--batch_size', type=int) parser.add_argument('--n_epochs', default=2, type=int) args = parser.parse_args() batch_size = args.batch_size n_epochs = args.n_epochs device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') torch.manual_seed(7) n_residual_blocks = 9 use_dropout = False path_train_data_x = 'trainA' path_train_data_y = 'trainB' path_model_xy = f'cyclegan_gen_AB_{n_epochs}_{batch_size}' path_model_yx = f'cyclegan_gen_BA_{n_epochs}_{batch_size}' # learning_rate = .002 regularizer = 10 n_discriminator_steps = 1 image_size = (256, 256) discr_x = Discriminator() discr_x = discr_x.to(device) discr_y = Discriminator() discr_y = discr_y.to(device) gen_xy = Generator(n_residual_blocks, use_dropout) gen_xy = gen_xy.to(device) gen_yx = Generator(n_residual_blocks, use_dropout) gen_yx = gen_yx.to(device) discr_x.apply(utils.init_weights_gaussian) discr_y.apply(utils.init_weights_gaussian) gen_xy.apply(utils.init_weights_gaussian) gen_yx.apply(utils.init_weights_gaussian) optimizer_discr_x = optim.Adam(discr_x.parameters()) optimizer_discr_y = optim.Adam(discr_y.parameters()) optimizer_gen_xy = optim.Adam(gen_xy.parameters()) optimizer_gen_yx = optim.Adam(gen_yx.parameters()) scheduler_discr_x = utils.HingeScheduler(optimizer_discr_x, .0001, n_epochs / 2, n_epochs / 2) scheduler_discr_y = utils.HingeScheduler(optimizer_discr_y, .0001, n_epochs / 2, n_epochs / 2) scheduler_gen_xy = utils.HingeScheduler(optimizer_gen_xy, .0002, n_epochs / 2, n_epochs / 2) scheduler_gen_yx = utils.HingeScheduler(optimizer_gen_yx, .0002, n_epochs / 2, n_epochs / 2) transform = utils.get_transform(image_size) train_data_x = torchvision.datasets.ImageFolder( root=path_train_data_x, transform=transform) train_data_x_loader = torch.utils.data.DataLoader( train_data_x, batch_size=batch_size, shuffle=True, num_workers=4) train_data_y = torchvision.datasets.ImageFolder( root=path_train_data_y, transform=transform) train_data_y_loader = torch.utils.data.DataLoader( train_data_y, batch_size=batch_size, shuffle=True, num_workers=4) synthesis_x_pool = utils.HistoricPool(50) synthesis_y_pool = utils.HistoricPool(50) mse = nn.MSELoss(reduction='mean').to(device) loss_function = CycleGANLoss(regularizer, False, device) for epoch_index in range(n_epochs): for _ in range(n_discriminator_steps): utils.switch_cycle_gradient_requirements( discr_x, discr_y, gen_xy, gen_yx, True) optimizer_discr_x.zero_grad() optimizer_discr_y.zero_grad() scheduler_discr_x.step() scheduler_discr_y.step() cycle_data = utils.get_cycle_data( train_data_x_loader, train_data_y_loader, discr_x, discr_y, gen_xy, gen_yx, device) synthesis_x_pool.update(cycle_data.synthesis_x) synthesis_y_pool.update(cycle_data.synthesis_y) synthesis_x_batch = synthesis_x_pool.get_batch() synthesis_y_batch = synthesis_y_pool.get_batch() # Maximizing loss function - hence inverting labels. size = cycle_data.real_x_predictions.size() real_targets = utils.get_target(True, True, size, device) synthesis_targets = utils.get_target(False, True, size, device) loss_x = mse(cycle_data.real_x_predictions, real_targets) +\ mse(discr_x(synthesis_x_batch), synthesis_targets) loss_x.backward() optimizer_discr_x.step() loss_y = mse(cycle_data.real_y_predictions, real_targets) +\ mse(discr_y(synthesis_y_batch), synthesis_targets) loss_y.backward() optimizer_discr_y.step() utils.switch_cycle_gradient_requirements( discr_x, discr_y, gen_xy, gen_yx, False) optimizer_gen_xy.zero_grad() optimizer_gen_yx.zero_grad() scheduler_gen_xy.step() scheduler_gen_yx.step() cycle_data = utils.get_cycle_data( train_data_x_loader, train_data_y_loader, discr_x, discr_y, gen_xy, gen_yx, device) loss = loss_function(cycle_data) loss.backward() optimizer_gen_xy.step() optimizer_gen_yx.step() print(epoch_index) torch.save(gen_xy.state_dict(), path_model_xy) torch.save(gen_yx.state_dict(), path_model_yx)
gt_points = gt_points.cuda() pointsReconstructed = model(pose_points, identity_points) rec_loss = torch.mean((pointsReconstructed - gt_points)**2) edg_loss = 0 for i in range(len(random_sample)): f = new_face[i].cpu().numpy() v = identity_points[i].transpose(0, 1).cpu().numpy() edg_loss = edg_loss + utils.compute_score( pointsReconstructed[i].unsqueeze(0), f, utils.get_target(v, f, 1)) edg_loss = edg_loss / len(random_sample) l2_loss = rec_loss rec_loss = rec_loss + 0.0005 * edg_loss rec_loss.backward() optimizer_G.step() total_loss = total_loss + rec_loss print('####################################') print(epoch) print(time.time() - start) mean_loss = total_loss / (j + 1) print('mean_loss', mean_loss.item()) print('####################################')
import streamlit as st from plot_func import general_plot, local_plot from utils import get_dataframe, get_shap_values, get_target, get_model_name, model_fit, get_row_number st.set_option('deprecation.showfileUploaderEncoding', False) st.markdown("<h1 style='text-align: center; '> Avec la Lab, attrapez les tous !</h1>", unsafe_allow_html=True) data = get_dataframe() target = get_target(data) model_name = get_model_name() model = model_fit(model_name, data, target) st.info(" Shap is working hard! Please wait") shap_values = get_shap_values(model_name, model, data) st.info(" Thank you") fig_general = general_plot(shap_values) st.plotly_chart(fig_general, sharing='streamlit') row = get_row_number() fig_local = local_plot(int(row), shap_values) st.plotly_chart(fig_local, sharing='streamlit')
def Reserve(self): self.open_page2("https://jayurocc.com/Reservation/Reservation") self.close_popup_class("pointBtn") self.GoToReservation(utils.get_today(), utils.get_target(21))
def artcoder(STYLE_IMG_PATH, CONTENT_IMG_PATH, CODE_PATH, OUTPUT_DIR, LEARNING_RATE=0.01, CONTENT_WEIGHT=1e8, STYLE_WEIGHT=1e15, CODE_WEIGHT=1e15, MODULE_SIZE=16, MODULE_NUM=37, EPOCHS=50000, Dis_b=80, Dis_w=180, Correct_b=50, Correct_w=200, USE_ACTIVATION_MECHANISM=True): # STYLE_IMG_PATH = './style/redwave4.jpg' # CONTENT_IMG_PATH = './content/boy.jpg' # CODE_PATH = './code/boy.jpg' # OUTPUT_DIR = './output/' utils.del_file(OUTPUT_DIR) IMAGE_SIZE = MODULE_SIZE * MODULE_NUM transform = transforms.Compose([ transforms.Resize(IMAGE_SIZE), transforms.ToTensor(), ]) vgg = Vgg16(requires_grad=False).cuda() # vgg16 model ss_layer = SSlayer(requires_grad=False).cuda() style_img = utils.load_image(filename=STYLE_IMG_PATH, size=IMAGE_SIZE) content_img = utils.load_image(filename=CONTENT_IMG_PATH, size=IMAGE_SIZE) code_img = utils.load_image(filename=CODE_PATH, size=IMAGE_SIZE) init_img = utils.add_pattern(content_img, code_img) style_img = transform(style_img) content_img = transform(content_img) init_img = transform(init_img) init_img = init_img.repeat(1, 1, 1, 1).cuda() style_img = style_img.repeat(1, 1, 1, 1).cuda() # make fake batch content_img = content_img.repeat(1, 1, 1, 1).cuda() features_style = vgg(style_img) # feature maps extracted from VGG features_content = vgg(content_img) gram_style = [utils.gram_matrix(i) for i in features_style] # gram matrix of style feature mse_loss = nn.MSELoss() y = init_img.detach( ) # y is the target output. Optimized start from the content image. y = y.requires_grad_() # let y to require grad optimizer = optim.Adam( [y], lr=LEARNING_RATE) # let optimizer to optimize the tensor y error_matrix, ideal_result = utils.get_action_matrix( img_target=utils.tensor_to_PIL(y), img_code=code_img, Dis_b=Dis_b, Dis_w=Dis_w) code_target = ss_layer( utils.get_target(ideal_result, b_robust=Correct_b, w_robust=Correct_w)) print(" Start training =============================================") for epoch in range(EPOCHS): def closure(code_target=code_target): optimizer.zero_grad() y.data.clamp_(0, 1) features_y = vgg(y) # feature maps of y extracted from VGG gram_style_y = [ utils.gram_matrix(i) for i in features_y ] # gram matrixs of feature_y in relu1_2,2_2,3_3,4_3 fc = features_content.relu3_3 # content target in relu4_3 fy = features_y.relu3_3 # y in relu4_3 style_loss = 0 # add style_losses in relu1_2,2_2,3_3,4_3 for i in [0, 1, 2, 3]: style_loss += mse_loss(gram_style_y[i], gram_style[i]) style_loss = STYLE_WEIGHT * style_loss code_y = ss_layer(y) if USE_ACTIVATION_MECHANISM == 1: error_matrix, ideal_result = utils.get_action_matrix( img_target=utils.tensor_to_PIL(y), img_code=code_img, Dis_b=Dis_b, Dis_w=Dis_w) activate_num = np.sum(error_matrix) activate_weight = torch.tensor(error_matrix.astype('float32')) code_y = code_y.cpu() * activate_weight code_target = code_target.cpu() * activate_weight else: code_y = code_y.cpu() code_target = code_target.cpu() activate_num = MODULE_NUM * MODULE_NUM code_loss = CODE_WEIGHT * mse_loss(code_target.cuda(), code_y.cuda()) content_loss = CONTENT_WEIGHT * mse_loss(fc, fy) # content loss # tv_loss = TV_WEIGHT * (torch.sum(torch.abs(y[:, :, :, :-1] - y[:, :, :, 1:])) + # torch.sum(torch.abs(y[:, :, :-1, :] - y[:, :, 1:, :]))) total_loss = style_loss + code_loss + content_loss total_loss.backward(retain_graph=True) if epoch % 20 == 0: print( "Epoch {}: Style Loss : {:4f}. Content Loss: {:4f}. Code Loss: {:4f}. Activated module number: {:4.2f}. Discriminate_b:{:4.2f}. Discriminate_w:{:4.2f}." .format(epoch, style_loss, content_loss, code_loss, activate_num, Dis_b, Dis_w)) if epoch % 200 == 0: img_name = 'epoch=' + str(epoch) + '__Wstyle=' + str( "%.1e" % STYLE_WEIGHT) + '__Wcode=' + str( "%.1e" % CODE_WEIGHT) + '__Wcontent' + str( "%.1e" % CONTENT_WEIGHT) + '.jpg' utils.save_image_epoch(y, OUTPUT_DIR, img_name, code_img, addpattern=True) print('Save output: ' + img_name) return total_loss optimizer.step(closure)
def Reserve(self): print("Reserve") self.GoToReservation(utils.get_today(), utils.get_target(21))