def CAE_AE_TRAIN(shapes, task_samples, iterations): global stage global student_model global vae_optimizer student_model = models.CAE() #.to(device) vae_optimizer = optim.Adam(student_model.parameters(), lr=0.0001) #, amsgrad=True) student_model.train() print("len of takssample is", len(task_samples)) accuracies = np.zeros((iterations, len(task_samples))) for i in range(0, len(task_samples) - len(Skill_Mu)): Skill_Mu.append([]) for batch_idx in range(1, iterations): randPerm = np.random.permutation(len(task_samples)) #randPerm,nReps = helper_functions.biased_permutation(stage+1,nBiased,trainBias,len(task_samples),minReps) print(randPerm, nReps) for s in randPerm: skill = s vae_optimizer.zero_grad() data = Variable(torch.FloatTensor( task_samples[skill])) #.to(device) hidden_representation, recons_x = student_model(data) W = student_model.state_dict()['fc2.weight'] loss, con_mse, con_loss, closs_mul_lam = helper_functions.Contractive_loss_function( W, data.view(-1, 61326), recons_x, hidden_representation, lam) Skill_Mu[skill] = hidden_representation loss.backward() vae_optimizer.step() print('Train Iteration: {},tLoss: {:.6f},picked skill {}'.format( batch_idx, loss.data[0], skill)) if batch_idx % 1 == 0: values = 0 for i in range(0, len(task_samples)): mu1 = Skill_Mu[i][0] task_sample = student_model.decoder(mu1).cpu() sample = task_sample.data.numpy().reshape(61326) #print('MSE IS',i,mean_squared_error(task_sample.data.numpy(),Variable(torch.FloatTensor(task_samples[i])).data.numpy())) #mse=mean_squared_error(task_sample.data.numpy(),Variable(torch.FloatTensor(task_samples[i])).data.numpy()) final_weights = helper_functions.unFlattenNetwork( sample, shapes) loadWeights_cifar(final_weights, net) if i >= 6: load_individual_class([i], [0, 1, 2, 3]) else: load_individual_class([i], [6, 7, 8, 9]) Avg_Accuracy = test() accuracies[batch_idx, i] = Avg_Accuracy if round(Avg_Accuracy + 0.5) >= int(Actual_Accuracy[i]): values = values + 1 if values == len(task_samples): print("########## \n Batch id is", batch_idx, "\n#########") threshold_batchid.append(batch_idx) break stage = stage + 1 return accuracies
def CAE_AE_TRAIN(shapes, task_samples, iterations): global stage student_model.train() accuracies = np.zeros((iterations, len(task_samples))) for i in range(0, len(task_samples) - len(Skill_Mu)): Skill_Mu.append([]) for batch_idx in range(1, iterations): #randPerm = np.random.permutation(len(task_samples)) randPerm, nReps = helper_functions.biased_permutation( stage + 1, nBiased, trainBias, len(task_samples), minReps) print(randPerm, nReps) for s in randPerm: skill = s vae_optimizer.zero_grad() data = Variable(torch.FloatTensor(task_samples[skill])).to(device) hidden_representation, recons_x = student_model(data) W = student_model.state_dict()['fc2.weight'] loss, con_mse, con_loss, closs_mul_lam = helper_functions.Contractive_loss_function( W, data.view(-1, 21840), recons_x, hidden_representation, lam) Skill_Mu[skill] = hidden_representation loss.backward() vae_optimizer.step() print('Train Iteration: {},tLoss: {:.6f},picked skill {}'.format( batch_idx, loss.data[0], skill)) if batch_idx % 1 == 0: values = 0 for i in range(0, len(task_samples)): mu1 = Skill_Mu[i][0] task_sample = student_model.decoder(mu1).cpu() sample = task_sample.data.numpy().reshape(21840) print( 'MSE IS', i, mean_squared_error( task_sample.data.numpy(), Variable(torch.FloatTensor( task_samples[i])).data.numpy())) #mse=mean_squared_error(task_sample.data.numpy(),Variable(torch.FloatTensor(task_samples[i])).data.numpy()) final_weights = helper_functions.unFlattenNetwork( sample, shapes) loadWeights_mnsit(final_weights, model) test_loader = RELOAD_DATASET(idx_permute[i]) Avg_Accuracy = test(args, model, device, test_loader) accuracies[batch_idx, i] = Avg_Accuracy if round(Avg_Accuracy + 0.5) >= int(Actual_Accuracy[i] - 1): values = values + 1 if values == len(task_samples): print("########## \n Batch id is", batch_idx, "\n#########") threshold_batchid.append(batch_idx) break stage = stage + 1 return accuracies
def CAE_AE_TRAIN(shapes, task_samples, iterations): global stage global Skill_Mu splitted_input = [] skills = [] task_samples_copy = task_samples total = len(task_samples) final_dataframe_1 = pd.DataFrame() accuracies = np.zeros((iterations, len(task_samples))) for t_input in range(0, len(task_samples)): #print("split is",len(task_samples[t_input])) splitted_input = np.array_split(task_samples[t_input], 3) for i in range(0, len(splitted_input)): #print("split is",len(splitted_input[i])) if (len(splitted_input[i]) == 20668): splitted_input[i] = np.concatenate((splitted_input[i], [0])) skills.append(splitted_input[i]) task_samples = skills Skill_Mu = [[] for _ in range(0, len(task_samples))] global student_model global vae_optimizer student_model.train() iterations = iterations for batch_idx in range(1, iterations): randPerm = np.random.permutation(len(task_samples)) #randPerm,nReps = helper_functions.biased_permutation(stage+1,nBiased,trainBias,total*3,minReps) print(randPerm, nReps) resend = [] for s in randPerm: skill = s vae_optimizer.zero_grad() data = Variable(torch.FloatTensor(task_samples[skill])).to(device) hidden_representation, recons_x = student_model(data) W = student_model.state_dict()['fc2.weight'] loss, con_mse, con_loss, closs_mul_lam = helper_functions.Contractive_loss_function( W, data.view(-1, 20669), recons_x, hidden_representation, lam) Skill_Mu[skill] = hidden_representation loss.backward() vae_optimizer.step() print('Train Iteration: {},tLoss: {:.6f},picked skill {}'.format( batch_idx, loss.data[0], skill)) #print(float(loss.data[0] * 1000)) if float(loss.data[0] * 1000) >= 1.00: resend.append(s) print("RESEND List", resend) for s in resend: skill = s #print("resending skills",resend) vae_optimizer.zero_grad() data = Variable(torch.FloatTensor(task_samples[skill])).to(device) hidden_representation, recons_x = student_model(data) W = student_model.state_dict()['fc2.weight'] loss, con_mse, con_loss, closs_mul_lam = helper_functions.Contractive_loss_function( W, data.view(-1, 20669), recons_x, hidden_representation, lam) Skill_Mu[skill] = hidden_representation loss.backward() vae_optimizer.step() print('Train Iteration: {},tLoss: {:.6f},picked skill {}'.format( batch_idx, loss.data[0], skill)) if batch_idx % 1 == 0: m = 0 n = 3 tl = 0 values = 0 for i in range(0, int(len(task_samples) / 3)): collect_data_1 = [] global net RELOAD_DATASET() Avg_Accuracy = 0 load_individual_class(list(range(i * 10, (i + 1) * 10)), []) sample = [] for k in range(m, n): mu1 = Skill_Mu[k][0] mini_task_sample = student_model.decoder(mu1).cpu() task_sample = mini_task_sample.data.numpy().reshape(20669) sample = np.concatenate([sample, task_sample]) m = m + 3 n = n + 3 final_weights = helper_functions.unFlattenNetwork( torch.from_numpy(sample).float(), shapes) loadWeights_cifar(final_weights, net) Avg_Accuracy = test() print(len(sample), len(task_samples_copy[i])) mse = mean_squared_error( sample[0:62006], Variable(torch.FloatTensor( task_samples_copy[i][0:62006])).data.numpy()) accuracies[batch_idx, i] = Avg_Accuracy collect_data_1.extend([ batch_idx, i, mse, Avg_Accuracy, Actual_Accuracy[i], len(resend) ]) final_dataframe_1 = pd.concat([ final_dataframe_1, pd.DataFrame(collect_data_1).transpose() ]) # if total<=7: # if round(Avg_Accuracy+0.5)>=int(Actual_Accuracy[i]-1): # values=values+1 # else: # if round(Avg_Accuracy+0.5)>=int(Actual_Accuracy[i]-2): # print("verifying the degrading threshold") # values=values+1 # if values==total: # print("########## \n Batch id is",batch_idx,"\n#########") # threshold_batchid.append(batch_idx) # break final_dataframe_1.columns = [ 'batch_idx', 'skill', 'caluclated_mse', 'Accuracy', 'Actual_Accuracy', 'Resend_len' ] final_dataframe_1.to_hdf( 'MSE_Fixed_Iter/' + str(len(task_samples_copy)) + '_MSE_acc-2-200', 'key1') stage = stage + 3 return accuracies
def CAE_AE_TRAIN(shapes, task_samples, iterations): global stage global Skill_Mu global lam global student_model global vae_optimizer options = dict(fillarea=True, width=400, height=400, xlabel='Iterations', ylabel='Loss', title='CAE_skills' + str(len(task_samples))) options_2 = dict(fillarea=True, width=400, height=400, xlabel='Iterations', ylabel='Accuracy', title='CAE_skills' + str(len(task_samples))) options_mse = dict(fillarea=True, width=400, height=400, xlabel='Iterations', ylabel='MSE', title='CAE_MSE_skills' + str(len(task_samples))) options_mse_org = dict(fillarea=True, width=400, height=400, xlabel='Iterations', ylabel='Cosine_Similarity', title='Cosine_Similariyu' + str(len(task_samples))) win = vis.line(X=np.array([0]), Y=np.array([0.005]), win='CAE_skills ' + str(len(task_samples)), name='CAE_skills' + str(len(task_samples)), opts=options) win_2 = vis.line(X=np.array([0]), Y=np.array([0]), win='CAE_Acc_skills ' + str(len(task_samples)), name='CAE_skills' + str(len(task_samples)), opts=options_2) win_mse = vis.line(X=np.array([0]), Y=np.array([0]), win='CAE_MSE_skills ' + str(len(task_samples)), name='CAE_MSE_skills' + str(len(task_samples)), opts=options_mse) win_mse_org = vis.line(X=np.array([0]), Y=np.array([0]), win='Cosine_similarity ' + str(len(task_samples)), name='Cosine_similarity' + str(len(task_samples)), opts=options_mse_org) splitted_input = [] skills = [] task_samples_copy = task_samples total = len(task_samples) total_resend = 0 final_dataframe_1 = pd.DataFrame() accuracies = np.zeros((iterations, len(task_samples))) for t_input in range(0, len(task_samples)): splitted_input = np.array_split(task_samples[t_input], 3) for i in range(0, len(splitted_input)): skills.append(splitted_input[i]) task_samples = skills Skill_Mu = [[] for _ in range(0, len(task_samples))] student_model.train() iterations = iterations for batch_idx in range(1, iterations): randPerm = np.random.permutation(len(task_samples)) #randPerm,nReps = helper_functions.biased_permutation(stage+1,nBiased,trainBias,total*3,minReps) print(randPerm, nReps) resend = [] for s in randPerm: skill = s vae_optimizer.zero_grad() data = Variable(torch.FloatTensor(task_samples[skill])).to(device) hidden_representation, recons_x = student_model(data) W = student_model.state_dict()['fc2.weight'] loss, con_mse, con_loss, closs_mul_lam = helper_functions.Contractive_loss_function( W, data.view(-1, 20442), recons_x, hidden_representation, lam) Skill_Mu[skill] = hidden_representation loss.backward() vis.line(X=np.array([batch_idx]), Y=np.array([loss.item()]), win=win, name='Loss_Skill_' + str(skill), update='append') vae_optimizer.step() print('Train Iteration: {},tLoss: {:.6f},picked skill {}'.format( batch_idx, loss.data[0], skill)) # recon=torch.FloatTensor(recons_x.cpu()).data.numpy().reshape(20442) # b=torch.FloatTensor(task_samples[i]).data.numpy() # small_cosine_sim=dot(b, recon)/(norm(b)*norm(recon)) # if small_cosine_sim<=0.99: # print(small_cosine_sim) # resend.append(s) if float(loss.data[0] * 1000000) >= 1.00: resend.append(s) print("RESEND List", resend) total_resend = total_resend + len(resend) for s in resend: skill = s vae_optimizer.zero_grad() data = Variable(torch.FloatTensor(task_samples[skill])).to(device) hidden_representation, recons_x = student_model(data) W = student_model.state_dict()['fc2.weight'] loss, con_mse, con_loss, closs_mul_lam = helper_functions.Contractive_loss_function( W, data.view(-1, 20442), recons_x, hidden_representation, lam) Skill_Mu[skill] = hidden_representation loss.backward() vis.line(X=np.array([batch_idx + 0.5]), Y=np.array([loss.item()]), win=win, name='Loss_Skill_' + str(skill), update='append') vae_optimizer.step() print('Train Iteration: {},tLoss: {:.6f},picked skill {}'.format( batch_idx, loss.data[0], skill)) if batch_idx % 1 == 0: m = 0 n = 3 tl = 0 values = 0 for i in range(0, int(len(task_samples) / 3)): collect_data_1 = [] Avg_Accuracy = 0 if i >= 6: Train_loader, Test_loader = load_individual_class( [i], [0, 1, 2, 3]) else: print("++++++++++") Train_loader, Test_loader = load_individual_class( [i], [6, 7, 8, 9]) sample = [] for k in range(m, n): mu1 = Skill_Mu[k][0] mini_task_sample = student_model.decoder(mu1).cpu() task_sample = mini_task_sample.data.numpy().reshape(20442) sample = np.concatenate([sample, task_sample]) m = m + 3 n = n + 3 #print('MSE IS',i,mean_squared_error(task_sample.data.numpy(),Variable(torch.FloatTensor(task_samples[i])).data.numpy())) final_weights = helper_functions.unFlattenNetwork( torch.from_numpy(sample).float(), shapes) model_x = loadWeights_cifar(final_weights, model) Avg_Accuracy = test(model_x, Test_loader) mse = mean_squared_error( sample, Variable(torch.FloatTensor( task_samples_copy[i])).data.numpy()) mse_orginal = mean_squared_error(sample, Actual_task_net_weights[i]) b = torch.FloatTensor(task_samples_copy[i]).data.numpy() b1 = torch.FloatTensor(Actual_task_net_weights[i]).data.numpy() COSINE_SIMILARITY = dot(sample, b) / (norm(sample) * norm(b)) jacrad_similarity = jaccard_similarity(list(b), sample) COSINE_SIMILARITY_wrt_orginal = dot( sample, b1) / (norm(sample) * norm(b1)) collect_data_1.extend([ total, batch_idx, i, mse, mse_orginal, Avg_Accuracy, Actual_Accuracy[i], len(resend), sample, torch.FloatTensor(task_samples[i]).data.numpy(), jacrad_similarity, COSINE_SIMILARITY, COSINE_SIMILARITY_wrt_orginal ]) final_dataframe_1 = pd.concat([ final_dataframe_1, pd.DataFrame(collect_data_1).transpose() ]) accuracies[batch_idx, i] = Avg_Accuracy vis.line(X=np.array([batch_idx]), Y=np.array([Avg_Accuracy]), win=win_2, name='Acc_Skill_' + str(i), update='append') vis.line(X=np.array([batch_idx]), Y=np.array([mse]), win=win_mse, name='MSE_Skill_' + str(i), update='append') vis.line(X=np.array([batch_idx]), Y=np.array([COSINE_SIMILARITY]), win=win_mse_org, name='Cosine_Similarity_Skill_' + str(i), update='append') #,opts=options_lgnd) if COSINE_SIMILARITY > 0.993: values = values + 1 if values == total: print("########## \n Batch id is", batch_idx, "\n#########") threshold_batchid.append(batch_idx) threshold_net_updates.append((batch_idx * total) + total_resend) break stage = stage + 3 final_dataframe_1.columns = [ 'no_of_skills', 'batch_idx', 'skill', 'caluclated_mse', 'mse_wrt_orginal', 'Accuracy', 'Actual_Accuracy', 'Resend_len', 'sample', 'task_sample', 'jacrad_similarity', 'COSINE_SIMILARITY', 'COSINE_SIMILARITY_wrt_orginal' ] final_dataframe_1.to_hdf( 'Collected_Data/' + str(len(task_samples)) + '_data', 'key1') return accuracies
def CAE_AE_TRAIN(shapes, task_samples, iterations): global stage options = dict(fillarea=True, width=400, height=400, xlabel='Iterations', ylabel='Loss', title='CAE_skills' + str(len(task_samples))) options_2 = dict(fillarea=True, width=400, height=400, xlabel='Iterations', ylabel='Accuracy', title='CAE_skills' + str(len(task_samples))) options_mse = dict(fillarea=True, width=400, height=400, xlabel='Iterations', ylabel='MSE', title='CAE_MSE_skills' + str(len(task_samples))) options_mse_org = dict(fillarea=True, width=400, height=400, xlabel='Iterations', ylabel='MSE_Orginal', title='CAE_MSE_WRT_Orginal_skills' + str(len(task_samples))) win = vis.line(X=np.array([0]), Y=np.array([0.005]), win='CAE_skills ' + str(len(task_samples)), name='CAE_skills' + str(len(task_samples)), opts=options) win_2 = vis.line(X=np.array([0]), Y=np.array([0]), win='CAE_Acc_skills ' + str(len(task_samples)), name='CAE_skills' + str(len(task_samples)), opts=options_2) win_mse = vis.line(X=np.array([0]), Y=np.array([0]), win='CAE_MSE_skills ' + str(len(task_samples)), name='CAE_MSE_skills' + str(len(task_samples)), opts=options_mse) win_mse_org = vis.line(X=np.array([0]), Y=np.array([0]), win='CAE_MSE_Org_skills ' + str(len(task_samples)), name='CAE_MSE_Orgskills' + str(len(task_samples)), opts=options_mse_org) student_model.train() final_dataframe_1 = pd.DataFrame() accuracies = np.zeros((iterations, len(task_samples))) for i in range(0, len(task_samples) - len(Skill_Mu)): Skill_Mu.append([]) for batch_idx in range(1, iterations): randPerm = np.random.permutation(len(task_samples)) #randPerm,nReps = helper_functions.biased_permutation(stage+1,nBiased,trainBias,len(task_samples),minReps) #print(randPerm,nReps) resend = [] for s in randPerm: skill = s vae_optimizer.zero_grad() data = Variable(torch.FloatTensor(task_samples[skill])).to(device) hidden_representation, recons_x = student_model(data) W = student_model.state_dict()['fc2.weight'] loss, con_mse, con_loss, closs_mul_lam = helper_functions.Contractive_loss_function( W, data.view(-1, 21840), recons_x, hidden_representation, lam) Skill_Mu[skill] = hidden_representation loss.backward() #options_lgnd = dict(fillarea=True, legend=['Loss_Skill_'+str(skill)]) vis.line(X=np.array([batch_idx]), Y=np.array([loss.item()]), win=win, name='Loss_Skill_' + str(skill), update='append') #,opts=options_lgnd) vae_optimizer.step() print('Train Iteration: {},tLoss: {:.6f},picked skill {}'.format( batch_idx, loss.data[0], skill)) if float(loss.data[0] * 10000) >= 1.00: resend.append(s) print("RESEND List", resend) for s in resend: skill = s vae_optimizer.zero_grad() data = Variable(torch.FloatTensor(task_samples[skill])).to(device) hidden_representation, recons_x = student_model(data) W = student_model.state_dict()['fc2.weight'] loss, con_mse, con_loss, closs_mul_lam = helper_functions.Contractive_loss_function( W, data.view(-1, 21840), recons_x, hidden_representation, lam) Skill_Mu[skill] = hidden_representation loss.backward() #options_lgnd = dict(fillarea=True, legend=['Loss_Skill_'+str(skill)]) vis.line(X=np.array([batch_idx]), Y=np.array([loss.item()]), win=win, name='Loss_Skill_' + str(skill), update='append') #,opts=options_lgnd) vae_optimizer.step() print('Train Iteration: {},tLoss: {:.6f},picked skill {}'.format( batch_idx, loss.data[0], skill)) if batch_idx % 1 == 0: values = 0 for i in range(0, len(task_samples)): collect_data_1 = [] mu1 = Skill_Mu[i][0] task_sample = student_model.decoder(mu1).cpu() sample = task_sample.data.numpy().reshape(21840) #print('MSE IS',i,mean_squared_error(task_sample.data.numpy(),Variable(torch.FloatTensor(task_samples[i])).data.numpy())) #mse=mean_squared_error(task_sample.data.numpy(),Variable(torch.FloatTensor(task_samples[i])).data.numpy()) final_weights = helper_functions.unFlattenNetwork( sample, shapes) loadWeights_mnsit(final_weights, model) Train_loader, Test_loader = RELOAD_DATASET(idx_permute[i]) mse = mean_squared_error( sample, Variable(torch.FloatTensor(task_samples[i])).data.numpy()) mse_orginal = mean_squared_error(sample, Actual_task_net_weights[i]) Avg_Accuracy = test(model, Test_loader) collect_data_1.extend([ batch_idx, i, mse, mse_orginal, Avg_Accuracy, Actual_Accuracy[i], len(resend) ]) final_dataframe_1 = pd.concat([ final_dataframe_1, pd.DataFrame(collect_data_1).transpose() ]) accuracies[batch_idx, i] = Avg_Accuracy if len(task_samples) > 6: if round(Avg_Accuracy + 0.5) >= int(Actual_Accuracy[i] - 1): values = values + 1 else: if round(Avg_Accuracy + 0.5) >= int(Actual_Accuracy[i]): values = values + 1 vis.line(X=np.array([batch_idx]), Y=np.array([Avg_Accuracy]), win=win_2, name='Acc_Skill_' + str(i), update='append') vis.line(X=np.array([batch_idx]), Y=np.array([mse]), win=win_mse, name='MSE_Skill_' + str(i), update='append') vis.line(X=np.array([batch_idx]), Y=np.array([mse_orginal]), win=win_mse_org, name='MSE_Org_Skill_' + str(i), update='append') #,opts=options_lgnd) if values == len(task_samples): print("########## \n Batch id is", batch_idx, "\n#########") threshold_batchid.append(batch_idx) break stage = stage + 1 final_dataframe_1.columns = [ 'batch_idx', 'skill', 'caluclated_mse', 'mse_wrt_orginal', 'Accuracy', 'Actual_Accuracy', 'Resend_len' ] final_dataframe_1.to_hdf( 'Collected_Data/' + str(len(task_samples)) + '_data', 'key1') return accuracies
def CAE_AE_TRAIN(shapes,task_samples,iterations): global stage encoded_task=[] global running_losses global running_thresholds global initial_fmse_threshold global total_update_count global running_update_counts global average_relative_accuracies #task_samples=task_samples.to(device) student_model.train() final_dataframe=pd.DataFrame() final_dataframe_1=pd.DataFrame() for i in range(0,len(task_samples)-len(Skill_Mu)): Skill_Mu.append([]) curr_batch_avg_loss = 10 batch_idx = -1 curr_batch_max_loss = torch.Tensor([10.0]) #while the thresholds have not been met, train # while np.all(running_losses[:-(10-len(task_samples))] >= running_thresholds[:-(10-len(task_samples))]): # while curr_batch_avg_loss >= initial_fmse_threshold: for batch_idx in range(1,iterations): batch_idx += 1 train_loss = 0 randPerm = np.random.permutation(len(task_samples)) # adjust_learning_rate(vae_optimizer, batch_idx) #print("after lr change",vae_optimizer) # randPerm,nReps = helper_functions.biased_permutation(stage+1,nBiased,trainBias,len(task_samples),minReps) print(randPerm) #sys.exit() # avg_loss = torch.Tensor([0.0]) total_loss = torch.Tensor([0.0]) batch_losses = [0.0 for x in range(len(task_samples))] for s in randPerm: total_update_count += 1 collect_data=[] skill=s#randint(0,len(task_samples)-1) F_s = fisher_matrix[s] vae_optimizer.zero_grad() data=Variable(torch.FloatTensor(task_samples[skill])).to(device) hidden_representation, recons_x = student_model(data) W = student_model.state_dict()['fc2.weight'] loss,con_mse,con_loss,closs_mul_lam = helper_functions.Contractive_loss_function(W, data.view(-1, 21432), recons_x,hidden_representation, lam) # loss,con_mse,con_loss,closs_mul_lam = helper_functions.Contractive_FMSE(W, data.view(-1, 21432), recons_x,hidden_representation, lam, F_s) # loss = loss*((total_update_count-running_update_counts[s])/total_update_count) running_update_counts[s] += 1 Skill_Mu[skill]=hidden_representation batch_losses[s] = loss #update the current loss for this network # avg_loss += loss total_loss += loss print('Train Iteration: {},tLoss: {:.6f},picked skill {}'.format(batch_idx,loss.data[0],skill )) # avg_loss /= len(task_samples) curr_batch_avg_loss = total_loss/len(task_samples) #get the temporary running losses if we stopped training right here tmp_running_losses = [0.0 for x in range(len(task_samples))] for idx, x in enumerate(batch_losses): tmp_running_losses[idx] = (running_losses[idx] + x)-10 #we need to train more on the skill where the temporary running loss deviates the most from the running threshold losses_wrt_thresholds = [0.0 for x in range(len(task_samples))] for idx,x in enumerate(batch_losses): losses_wrt_thresholds[idx] = round((batch_losses[idx].data.numpy()/running_thresholds[idx])[0], 2) curr_batch_max_loss = max(batch_losses) curr_batch_avg_loss.backward() vae_optimizer.step() if batch_idx %199==0: # accuray_threshlod=[] values=0 initial_fmse_threshold += 0.0004 avg_relative_accuracy = 0.0 for i in range(0,len(task_samples)): # Avg_Accuracy=0 #model=models.Net() collect_data_1=[] mu1=Skill_Mu[i][0] task_sample = student_model.decoder(mu1).cpu() sample=task_sample.data.numpy().reshape(21432) #print('MSE IS',mean_squared_error(task_sample.data.numpy(),Variable(torch.FloatTensor(task_samples[i])).data.numpy())) #mse=mean_squared_error(task_sample.data.numpy(),Variable(torch.FloatTensor(task_samples[i])).data.numpy()) final_weights=helper_functions.unFlattenNetwork(sample, shapes) loadWeights_mnsit(final_weights,model) if i%2==0: load_individual_class([i],[1,3,5,7]) else: load_individual_class([i],[0,2,4,6]) Avg_Accuracy= test(args, model, device, test_loader) if len(task_samples) == 10: avg_relative_accuracy += round((Avg_Accuracy/Actual_Accuracy[i][len(Actual_Accuracy[i])-1])*100, 2) print("ORIGINAL PERFORMANCE: "+str(Actual_Accuracy[i][len(Actual_Accuracy[i])-1])+"%\n") print("RELATIVE PERFORMANCE TO ORIGINAL: "+str(round((Avg_Accuracy/Actual_Accuracy[i][len(Actual_Accuracy[i])-1])*100, 2))+"%\n") print("LOSS: ", batch_losses[i]) # if round(Avg_Accuracy+0.5)>=int(Actual_Accuracy[i]): values=values+1 #update running_thresholds and running losses running_losses[i] += batch_losses[i] # if len(task_samples)>=3: # inc = -(i-(len(task_samples)+1)) # running_thresholds[i] = initial_fmse_threshold*np.log(max(3,inc)) # if len(task_samples) > 2: # running_thresholds = [initial_fmse_threshold*np.log(len(task_samples)*1.3) for x in range(10)] print(running_thresholds) if len(task_samples) == 10: avg_relative_accuracy /= len(task_samples) average_relative_accuracies.append(avg_relative_accuracy) if values==len(task_samples) and len(task_samples) == 10: print("########## \n Batch id is",batch_idx,"\n#########") break stage=stage+1
def CAE_AE_TRAIN(shapes, task_samples, iterations): #vae_optimizer = optim.Adam(student_model.parameters(), lr = 0.001) global stage encoded_task = [] accuracies = np.zeros((iterations, len(task_samples))) #task_samples=task_samples.to(device) student_model.train() final_dataframe = pd.DataFrame() final_dataframe_1 = pd.DataFrame() for i in range(0, len(task_samples) - len(Skill_Mu)): Skill_Mu.append([]) for batch_idx in range(1, iterations): train_loss = 0 randPerm = np.random.permutation(len(task_samples)) #adjust_learning_rate(vae_optimizer, batch_idx) #print("after lr change",vae_optimizer) #randPerm,nReps = helper_functions.biased_permutation(stage+1,nBiased,trainBias,len(task_samples),minReps) print(randPerm) resend = [] for s in randPerm: #collect_data=[] skill = s #randint(0,len(task_samples)-1) vae_optimizer.zero_grad() data = Variable(torch.FloatTensor(task_samples[skill])).to(device) hidden_representation, recons_x = student_model(data) W = student_model.state_dict()['fc2.weight'] loss, con_mse, con_loss, closs_mul_lam = helper_functions.Contractive_loss_function( W, data.view(-1, 21432), recons_x, hidden_representation, lam) Skill_Mu[skill] = hidden_representation loss.backward() vae_optimizer.step() print('Train Iteration: {},tLoss: {:.6f},picked skill {}'.format( batch_idx, loss.data[0], skill)) if float(loss.data[0] * 1000000) >= 1.00: resend.append(s) print("resending skills", resend) # for s in resend: # skill=s # vae_optimizer.zero_grad() # data=Variable(torch.FloatTensor(task_samples[skill])).to(device) # hidden_representation, recons_x = student_model(data) # W = student_model.state_dict()['fc2.weight'] # loss,con_mse,con_loss,closs_mul_lam = helper_functions.Contractive_loss_function(W, # data.view(-1, 21432), recons_x,hidden_representation, lam) # Skill_Mu[skill]=hidden_representation # loss.backward() # vae_optimizer.step() if batch_idx % 1 == 0: # accuray_threshlod=[] values = 0 for i in range(0, len(task_samples)): # Avg_Accuracy=0 #model=models.Net() collect_data_1 = [] mu1 = Skill_Mu[i][0] task_sample = student_model.decoder(mu1).cpu() sample = task_sample.data.numpy().reshape(21432) #print('MSE IS',mean_squared_error(task_sample.data.numpy(),Variable(torch.FloatTensor(task_samples[i])).data.numpy())) #mse=mean_squared_error(task_sample.data.numpy(),Variable(torch.FloatTensor(task_samples[i])).data.numpy()) final_weights = helper_functions.unFlattenNetwork( sample * SUM[i], shapes) loadWeights_mnsit(final_weights, model) if i >= 6: load_individual_class([i], [1, 2, 3, 4]) else: load_individual_class([i], [6, 7, 8, 9]) Avg_Accuracy = test(args, model, device, test_loader) mse = mean_squared_error( sample, Variable(torch.FloatTensor(task_samples[i])).data.numpy()) collect_data_1.extend([ batch_idx, i, mse, Avg_Accuracy, Actual_Accuracy[i], len(resend) ]) final_dataframe_1 = pd.concat([ final_dataframe_1, pd.DataFrame(collect_data_1).transpose() ]) accuracies[batch_idx, i] = Avg_Accuracy if round(Avg_Accuracy + 0.5) >= int(Actual_Accuracy[i]): values = values + 1 if values == len(task_samples): print("########## \n Batch id is", batch_idx, "\n#########") threshold_batchid.append(batch_idx) break stage = stage + 1 final_dataframe_1.columns = [ 'batch_idx', 'skill', 'caluclated_mse', 'Accuracy', 'Actual_Accuracy', 'Resend_len' ] final_dataframe_1.to_hdf( 'MSE_Iter/' + str(len(task_samples)) + '_MSE_fixed_iter', 'key1') return accuracies
def CAE_AE_TRAIN(shapes, task_samples, iterations): global stage options = dict(fillarea=True, width=400, height=400, xlabel='Iterations', ylabel='Loss', title='CAE_skills' + str(len(task_samples))) options_2 = dict(fillarea=True, width=400, height=400, xlabel='Iterations', ylabel='Accuracy', title='CAE_skills' + str(len(task_samples))) options_mse = dict(fillarea=True, width=400, height=400, xlabel='Iterations', ylabel='MSE', title='CAE_MSE_skills' + str(len(task_samples))) options_mse_org = dict(fillarea=True, width=400, height=400, xlabel='Iterations', ylabel='MSE_Orginal', title='CAE_MSE_WRT_Orginal_skills' + str(len(task_samples))) win = vis.line(X=np.array([0]), Y=np.array([0.005]), win='CAE_skills ' + str(len(task_samples)), name='CAE_skills' + str(len(task_samples)), opts=options) win_2 = vis.line(X=np.array([0]), Y=np.array([0]), win='CAE_Acc_skills ' + str(len(task_samples)), name='CAE_skills' + str(len(task_samples)), opts=options_2) win_mse = vis.line(X=np.array([0]), Y=np.array([0]), win='CAE_MSE_skills ' + str(len(task_samples)), name='CAE_MSE_skills' + str(len(task_samples)), opts=options_mse) win_mse_org = vis.line(X=np.array([0]), Y=np.array([0]), win='CAE_MSE_Org_skills ' + str(len(task_samples)), name='CAE_MSE_Orgskills' + str(len(task_samples)), opts=options_mse_org) total_resend = 0 total = len(task_samples) accuracies = np.zeros((iterations, len(task_samples))) #task_samples=task_samples.to(device) student_model.train() final_dataframe = pd.DataFrame() final_dataframe_1 = pd.DataFrame() for i in range(0, len(task_samples) - len(Skill_Mu)): Skill_Mu.append([]) for batch_idx in range(1, iterations): train_loss = 0 randPerm = np.random.permutation(len(task_samples)) #adjust_learning_rate(vae_optimizer, batch_idx) #print("after lr change",vae_optimizer) #randPerm,nReps = helper_functions.biased_permutation(stage+1,nBiased,trainBias,len(task_samples),minReps) print(randPerm) resend = [] for s in randPerm: #collect_data=[] skill = s #randint(0,len(task_samples)-1) vae_optimizer.zero_grad() data = Variable(torch.FloatTensor(task_samples[skill])).to(device) hidden_representation, recons_x = student_model(data) W = student_model.state_dict()['fc2.weight'] loss, con_mse, con_loss, closs_mul_lam = helper_functions.Contractive_loss_function( W, data.view(-1, 21432), recons_x, hidden_representation, lam) Skill_Mu[skill] = hidden_representation loss.backward() vis.line(X=np.array([batch_idx]), Y=np.array([loss.item()]), win=win, name='Loss_Skill_' + str(skill), update='append') #,opts=options_lgnd) vae_optimizer.step() print('Train Iteration: {},tLoss: {:.6f},picked skill {}'.format( batch_idx, loss.data[0], skill)) if float(loss.data[0] * 1000000) >= 1.00: resend.append(s) print("resending skills", resend) total_resend = total_resend + len(resend) for s in resend: skill = s vae_optimizer.zero_grad() data = Variable(torch.FloatTensor(task_samples[skill])).to(device) hidden_representation, recons_x = student_model(data) W = student_model.state_dict()['fc2.weight'] loss, con_mse, con_loss, closs_mul_lam = helper_functions.Contractive_loss_function( W, data.view(-1, 21432), recons_x, hidden_representation, lam) Skill_Mu[skill] = hidden_representation loss.backward() vis.line(X=np.array([batch_idx]), Y=np.array([loss.item()]), win=win, name='Loss_Skill_' + str(skill), update='append') #,opts=options_lgnd) vae_optimizer.step() if batch_idx % 1 == 0: values = 0 for i in range(0, len(task_samples)): collect_data_1 = [] mu1 = Skill_Mu[i][0] task_sample = student_model.decoder(mu1).cpu() sample = task_sample.data.numpy().reshape(21432) #print('MSE IS',mean_squared_error(task_sample.data.numpy(),Variable(torch.FloatTensor(task_samples[i])).data.numpy())) #mse=mean_squared_error(task_sample.data.numpy(),Variable(torch.FloatTensor(task_samples[i])).data.numpy()) mse = mean_squared_error( sample, Variable(torch.FloatTensor(task_samples[i])).data.numpy()) mse_orginal = mean_squared_error(sample, Actual_task_net_weights[i]) final_weights = helper_functions.unFlattenNetwork( sample, shapes) model_x = loadWeights_mnsit(final_weights, model) if i >= 6: Train_loader, Test_loader = load_individual_class( [i], [1, 2, 3, 4]) else: Train_loader, Test_loader = load_individual_class( [i], [6, 7, 8, 9]) Avg_Accuracy = test(model_x, Test_loader) b = torch.FloatTensor(task_samples[i]).data.numpy() b1 = torch.FloatTensor(Actual_task_net_weights[i]).data.numpy() COSINE_SIMILARITY = dot(sample, b) / (norm(sample) * norm(b)) COSINE_SIMILARITY_wrt_orginal = dot( sample, b1) / (norm(sample) * norm(b1)) collect_data_1.extend([ total, batch_idx, i, mse, mse_orginal, Avg_Accuracy, Actual_Accuracy[i], len(resend), sample, torch.FloatTensor(task_samples[i]).data.numpy(), COSINE_SIMILARITY, COSINE_SIMILARITY_wrt_orginal ]) final_dataframe_1 = pd.concat([ final_dataframe_1, pd.DataFrame(collect_data_1).transpose() ]) accuracies[batch_idx, i] = Avg_Accuracy if COSINE_SIMILARITY > 0.99: values = values + 1 # if len(task_samples)>6: # if round(Avg_Accuracy+0.5)>=int(Actual_Accuracy[i]-1): # values=values+1 # else: # if round(Avg_Accuracy+0.5)>=int(Actual_Accuracy[i]): # values=values+1 vis.line(X=np.array([batch_idx]), Y=np.array([Avg_Accuracy]), win=win_2, name='Acc_Skill_' + str(i), update='append') vis.line(X=np.array([batch_idx]), Y=np.array([mse]), win=win_mse, name='MSE_Skill_' + str(i), update='append') vis.line(X=np.array([batch_idx]), Y=np.array([mse_orginal]), win=win_mse_org, name='MSE_Org_Skill_' + str(i), update='append') #,opts=options_lgnd) if values == len(task_samples): print("########## \n Batch id is", batch_idx, "\n#########") threshold_batchid.append(batch_idx) threshold_net_updates.append((batch_idx * total) + total_resend) break stage = stage + 1 final_dataframe_1.columns = [ 'no_of_skills', 'batch_idx', 'skill', 'caluclated_mse', 'mse_wrt_orginal', 'Accuracy', 'Actual_Accuracy', 'Resend_len', 'sample', 'task_sample', 'COSINE_SIMILARITY', 'COSINE_SIMILARITY_wrt_orginal' ] final_dataframe_1.to_hdf( 'Collected_Data/' + str(len(task_samples)) + '_data', 'key1') return accuracies
def CAE_AE_TRAIN(shapes, task_samples, iterations): global stage global Skill_Mu global lam global student_model global vae_optimizer options = dict(fillarea=True, width=400, height=400, xlabel='Iterations', ylabel='Loss', title='CAE_skills' + str(len(task_samples))) options_2 = dict(fillarea=True, width=400, height=400, xlabel='Iterations', ylabel='Accuracy', title='CAE_skills' + str(len(task_samples))) options_mse = dict(fillarea=True, width=400, height=400, xlabel='Iterations', ylabel='MSE', title='CAE_MSE_skills' + str(len(task_samples))) options_mse_org = dict(fillarea=True, width=400, height=400, xlabel='Iterations', ylabel='MSE_Orginal', title='CAE_MSE_WRT_Orginal_skills' + str(len(task_samples))) win = vis.line(X=np.array([0]), Y=np.array([0.005]), win='CAE_skills ' + str(len(task_samples)), name='CAE_skills' + str(len(task_samples)), opts=options) win_2 = vis.line(X=np.array([0]), Y=np.array([0]), win='CAE_Acc_skills ' + str(len(task_samples)), name='CAE_skills' + str(len(task_samples)), opts=options_2) win_mse = vis.line(X=np.array([0]), Y=np.array([0]), win='CAE_MSE_skills ' + str(len(task_samples)), name='CAE_MSE_skills' + str(len(task_samples)), opts=options_mse) win_mse_org = vis.line(X=np.array([0]), Y=np.array([0]), win='CAE_MSE_Org_skills ' + str(len(task_samples)), name='CAE_MSE_Orgskills' + str(len(task_samples)), opts=options_mse_org) splitted_input = [] skills = [] task_samples_copy = task_samples total = len(task_samples) total_resend = 0 final_dataframe_1 = pd.DataFrame() accuracies = np.zeros((iterations, len(task_samples))) for t_input in range(0, len(task_samples)): splitted_input = np.array_split(task_samples[t_input], 3) for i in range(0, len(splitted_input)): skills.append(splitted_input[i]) task_samples = skills Skill_Mu = [[] for _ in range(0, len(task_samples))] # student_model=models.SPLIT_CIFAR_CAE_TWO_SKILLS()#.to(device) # vae_optimizer = optim.Adam(student_model.parameters(), lr = 0.0001)#, amsgrad=True) student_model.train() iterations = iterations # if total>=8: # print("Decreasing the Lamda") # lam=0.0001 for batch_idx in range(1, iterations): randPerm = np.random.permutation(len(task_samples)) #randPerm,nReps = helper_functions.biased_permutation(stage+1,nBiased,trainBias,total*3,minReps) print(randPerm, nReps) resend = [] for s in randPerm: skill = s vae_optimizer.zero_grad() data = Variable(torch.FloatTensor(task_samples[skill])).to(device) #print(data) hidden_representation, recons_x = student_model(data) W = student_model.state_dict()['fc2.weight'] loss, con_mse, con_loss, closs_mul_lam = helper_functions.Contractive_loss_function( W, data.view(-1, 20442), recons_x, hidden_representation, lam) Skill_Mu[skill] = hidden_representation loss.backward() vis.line(X=np.array([batch_idx]), Y=np.array([loss.item()]), win=win, name='Loss_Skill_' + str(skill), update='append') vae_optimizer.step() print('Train Iteration: {},tLoss: {:.6f},picked skill {}'.format( batch_idx, loss.data[0], skill)) #print(float(loss.data[0] * 1000)) if float(loss.data[0] * 10000) >= 1.00: resend.append(s) print("RESEND List", resend) total_resend = total_resend + len(resend) # if len(resend)>1: for s in resend: skill = s #print("resending skills",resend) vae_optimizer.zero_grad() data = Variable(torch.FloatTensor(task_samples[skill])).to(device) hidden_representation, recons_x = student_model(data) W = student_model.state_dict()['fc2.weight'] loss, con_mse, con_loss, closs_mul_lam = helper_functions.Contractive_loss_function( W, data.view(-1, 20442), recons_x, hidden_representation, lam) Skill_Mu[skill] = hidden_representation loss.backward() vis.line(X=np.array([batch_idx + 0.5]), Y=np.array([loss.item()]), win=win, name='Loss_Skill_' + str(skill), update='append') vae_optimizer.step() print('Train Iteration: {},tLoss: {:.6f},picked skill {}'.format( batch_idx, loss.data[0], skill)) # else: # print("The Length of resend list is ",len(resend)) # for s in randPerm: # skill=s # vae_optimizer.zero_grad() # data=Variable(torch.FloatTensor(task_samples[skill])).to(device) # #print(data) # hidden_representation, recons_x = student_model(data) # W = student_model.state_dict()['fc2.weight'] # loss,con_mse,con_loss,closs_mul_lam = helper_functions.Contractive_loss_function(W, # data.view(-1, 20442), recons_x,hidden_representation, lam) # Skill_Mu[skill]=hidden_representation # loss.backward() # vae_optimizer.step() # print('Train Iteration: {},tLoss: {:.6f},picked skill {}'.format(batch_idx,loss.data[0],skill )) if batch_idx % 1 == 0: m = 0 n = 3 tl = 0 values = 0 for i in range(0, int(len(task_samples) / 3)): collect_data_1 = [] Avg_Accuracy = 0 if i >= 6: Train_loader, Test_loader = load_individual_class( [i], [0, 1, 2, 3]) else: print("++++++++++") Train_loader, Test_loader = load_individual_class( [i], [6, 7, 8, 9]) sample = [] for k in range(m, n): mu1 = Skill_Mu[k][0] mini_task_sample = student_model.decoder(mu1).cpu() task_sample = mini_task_sample.data.numpy().reshape(20442) sample = np.concatenate([sample, task_sample]) m = m + 3 n = n + 3 #print('MSE IS',i,mean_squared_error(task_sample.data.numpy(),Variable(torch.FloatTensor(task_samples[i])).data.numpy())) final_weights = helper_functions.unFlattenNetwork( torch.from_numpy(sample).float(), shapes) model_x = loadWeights_cifar(final_weights, model) Avg_Accuracy = test(model_x, Test_loader) mse = mean_squared_error( sample, Variable(torch.FloatTensor( task_samples_copy[i])).data.numpy()) mse_orginal = mean_squared_error(sample, Actual_task_net_weights[i]) collect_data_1.extend([ batch_idx, i, mse, mse_orginal, Avg_Accuracy, Actual_Accuracy[i], len(resend) ]) final_dataframe_1 = pd.concat([ final_dataframe_1, pd.DataFrame(collect_data_1).transpose() ]) accuracies[batch_idx, i] = Avg_Accuracy vis.line(X=np.array([batch_idx]), Y=np.array([Avg_Accuracy]), win=win_2, name='Acc_Skill_' + str(i), update='append') vis.line(X=np.array([batch_idx]), Y=np.array([mse]), win=win_mse, name='MSE_Skill_' + str(i), update='append') vis.line(X=np.array([batch_idx]), Y=np.array([mse_orginal]), win=win_mse_org, name='MSE_Org_Skill_' + str(i), update='append') #,opts=options_lgnd) if total <= 7: if round(Avg_Accuracy + 0.5) >= int(Actual_Accuracy[i]): values = values + 1 else: if round(Avg_Accuracy + 0.5) >= int(Actual_Accuracy[i]): print("verifying the degrading threshold") values = values + 1 if values == total: print("########## \n Batch id is", batch_idx, "\n#########") threshold_batchid.append(batch_idx) threshold_net_updates.append((batch_idx * total) + total_resend) break stage = stage + 3 print(final_dataframe_1.head(5)) final_dataframe_1.columns = [ 'batch_idx', 'skill', 'caluclated_mse', 'mse_wrt_orginal', 'Accuracy', 'Actual_Accuracy', 'Resend_len' ] final_dataframe_1.to_hdf( 'Collected_Data/' + str(len(task_samples)) + '_data', 'key1') return accuracies
def CAE_AE_TRAIN(shapes, task_samples, iterations): global stage global Skill_Mu global student_model global vae_optimizer options = dict(fillarea=True, width=400, height=400, xlabel='Iterations', ylabel='Loss', title='CAE_skills' + str(len(task_samples))) options_2 = dict(fillarea=True, width=400, height=400, xlabel='Iterations', ylabel='Accuracy', title='Acc_skills_' + str(len(task_samples))) options_mse = dict(fillarea=True, width=400, height=400, xlabel='Iterations', ylabel='MSE', title='MSE_skills_' + str(len(task_samples))) options_mse_org = dict(fillarea=True, width=400, height=400, xlabel='Iterations', ylabel='Cosine_Similarity', title='Cosine_Similarity_' + str(len(task_samples))) options_cosine_org_orginal = dict(fillarea=True, width=400, height=400, xlabel='Iterations', ylabel='Cosine_Similarity', title='Cosine_Sim_wrt_org_' + str(len(task_samples))) win = vis.line(X=np.array([0]), Y=np.array([0.005]), win='Loss_skills_' + str(len(task_samples)), name='Loss_skills' + str(len(task_samples)), opts=options) # win_2 = vis.line(X=np.array([0]),Y=np.array([0]),win='Acc_skills_'+str(len(task_samples)),name='Acc_skills_'+str(len(task_samples)),opts=options_2) win_mse = vis.line(X=np.array([0]), Y=np.array([0]), win='MSE_skills_' + str(len(task_samples)), name='MSE_skills_' + str(len(task_samples)), opts=options_mse) win_mse_org = vis.line(X=np.array([0]), Y=np.array([0]), win='Cosine_Sim ' + str(len(task_samples)), name='Cosine_similarity_' + str(len(task_samples)), opts=options_mse_org) win_cosine_org_orginal = vis.line( X=np.array([0]), Y=np.array([0]), win='Cosine_Sim_orginal ' + str(len(task_samples)), name='Cosine_sim_wrt_org' + str(len(task_samples)), opts=options_cosine_org_orginal) splitted_input = [] skills = [] total_resend = 0 task_samples_copy = task_samples total = len(task_samples) final_dataframe_1 = pd.DataFrame() accuracies = np.zeros((iterations, len(task_samples))) for t_input in range(0, len(task_samples)): task_sample_append = np.concatenate( (task_samples[t_input], task_samples[t_input][-diff_count[t_input]:])) splitted_input = np.array_split(task_sample_append, split_size) for i in range(0, len(splitted_input)): # if(len(task_samples[t_input])==842407): # splitted_input[i]=np.concatenate((splitted_input[i], [0.05])) # else: # splitted_input[i]=np.concatenate((splitted_input[i], [0.05])) print(len(splitted_input[i])) skills.append(splitted_input[i]) task_samples = skills student_model.train() iterations = iterations for batch_idx in range(1, iterations): randPerm = np.random.permutation(len(task_samples)) #randPerm,nReps = helper_functions.biased_permutation(stage+1,nBiased,trainBias,total*3,minReps) resend = [] for s in randPerm: skill = s vae_optimizer.zero_grad() data = Variable(torch.FloatTensor(task_samples[skill])).to(device) hidden_representation, recons_x = student_model(data) W = student_model.state_dict()['fc2.weight'] loss, con_mse, con_loss, closs_mul_lam = helper_functions.Contractive_loss_function( W, data.view(-1, input_size), recons_x, hidden_representation, lam) Skill_Mu[skill] = hidden_representation vis.line(X=np.array([batch_idx]), Y=np.array([loss.item()]), win=win, name='Loss_Skill_' + str(skill), update='append') loss.backward() vae_optimizer.step() print('Train Iteration: {},tLoss: {:.6f},picked skill {}'.format( batch_idx, loss.data[0], skill)) cosine = F.cosine_similarity(recons_x, data.view(-1, input_size)) if cosine <= 0.991: resend.append(s) print("RESEND List", resend) total_resend = total_resend + len(resend) for s in resend: skill = s vae_optimizer.zero_grad() data = Variable(torch.FloatTensor(task_samples[skill])).to(device) hidden_representation, recons_x = student_model(data) W = student_model.state_dict()['fc2.weight'] loss, con_mse, con_loss, closs_mul_lam = helper_functions.Contractive_loss_function( W, data.view(-1, input_size), recons_x, hidden_representation, lam) Skill_Mu[skill] = hidden_representation vis.line(X=np.array([batch_idx]), Y=np.array([loss.item()]), win=win, name='Loss_Skill_' + str(skill), update='append') loss.backward() vae_optimizer.step() print('Train Iteration: {},tLoss: {:.6f},picked skill {}'.format( batch_idx, loss.data[0], skill)) if batch_idx % 1 == 0: m = 0 n = split_size values = 0 for i in range(0, int(len(task_samples_copy))): collect_data_1 = [] sample = [] for k in range(m, n): mu1 = Skill_Mu[k][0] mini_task_sample = student_model.decoder(mu1).cpu() task_sample = mini_task_sample.data.numpy().reshape( input_size) sample = np.concatenate([sample, task_sample]) #print("in cae test len is",len(sample)) # if len(Actual_task_net_weights[i])==841893: # sample=np.concatenate([sample,task_sample[0:-3]]) # else: sample = sample[0:-diff_count[i]] m = m + split_size n = n + split_size model_z = models.NNPolicy(1, 256, games_config[i]) FI, net_shapes = helper_functions.flattenNetwork(model_z.cpu()) final_weights = helper_functions.unFlattenNetwork( torch.from_numpy(sample).float(), net_shapes) #print("lksfkfjf",diff_count,len(sample),len(task_samples_copy[i])) model_x = loadWeights_cifar(final_weights, model_z) mse = mean_squared_error( sample, Variable(torch.FloatTensor( task_samples_copy[i])).data.numpy()) mse_orginal = mean_squared_error(sample, Actual_task_net_weights[i]) # sample=sample[:-diff_count[i]] b = torch.FloatTensor( task_samples_copy[i]).data.numpy() #[:-diff_count[i]] b1 = torch.FloatTensor(Actual_task_net_weights[i]).data.numpy() COSINE_SIMILARITY = dot(sample, b) / (norm(sample) * norm(b)) COSINE_SIMILARITY_wrt_orginal = dot( sample, b1) / (norm(sample) * norm(b1)) if COSINE_SIMILARITY >= 0.998: torch.save( model_x.state_dict(), './New_Games/' + str(games[i][0:10]) + '_' + str(total) + '_' + str(COSINE_SIMILARITY) + '_' + str(batch_idx) + '.pt') values = values + 1 # else: # if COSINE_SIMILARITY>=0.998: # torch.save(model_x.state_dict(),'./Latest_Cae/'+str(games[i][0:10])+'_'+str(total)+'_'+str(COSINE_SIMILARITY)+'_'+str(batch_idx)+'.pt') # values=values+1 #torch.save(model_x.state_dict(),'./Latest_Cae/'+str(games[i][0:10])+'_'+str(total)+'_'+str(COSINE_SIMILARITY)+'.pt') vis.line(X=np.array([batch_idx]), Y=np.array([mse]), win=win_mse, name='MSE_Skill_' + str(i), update='append') vis.line(X=np.array([batch_idx]), Y=np.array([COSINE_SIMILARITY]), win=win_mse_org, name='Cos_Sim_Skill_' + str(i), update='append') #,opts=options_lgnd) vis.line(X=np.array([batch_idx]), Y=np.array([COSINE_SIMILARITY_wrt_orginal]), win=win_cosine_org_orginal, name='Cos_wrt_org_Sim_Skill_' + str(i), update='append') #,opts=options_lgnd) if values == len(task_samples_copy): print("########## \n Batch id is", batch_idx, "\n#########") threshold_batchid.append(batch_idx + total_resend) break return accuracies
def CAE_AE_TRAIN(shapes, task_samples, iterations): global stage global Skill_Mu options = dict(fillarea=True, width=400, height=400, xlabel='Iterations', ylabel='Loss', title='CAE_skills' + str(len(task_samples))) options_2 = dict(fillarea=True, width=400, height=400, xlabel='Iterations', ylabel='Accuracy', title='Acc_skills_' + str(len(task_samples))) options_mse = dict(fillarea=True, width=400, height=400, xlabel='Iterations', ylabel='MSE', title='MSE_skills_' + str(len(task_samples))) options_mse_org = dict(fillarea=True, width=400, height=400, xlabel='Iterations', ylabel='Cosine_Similarity', title='Cosine_Similarity_' + str(len(task_samples))) win = vis.line(X=np.array([0]), Y=np.array([0.005]), win='Loss_skills_' + str(len(task_samples)), name='Loss_skills' + str(len(task_samples)), opts=options) win_2 = vis.line(X=np.array([0]), Y=np.array([0]), win='Acc_skills_' + str(len(task_samples)), name='Acc_skills_' + str(len(task_samples)), opts=options_2) win_mse = vis.line(X=np.array([0]), Y=np.array([0]), win='MSE_skills_' + str(len(task_samples)), name='MSE_skills_' + str(len(task_samples)), opts=options_mse) win_mse_org = vis.line(X=np.array([0]), Y=np.array([0]), win='Cosine_Sim ' + str(len(task_samples)), name='Cosine_similarity_' + str(len(task_samples)), opts=options_mse_org) splitted_input = [] skills = [] total_resend = 0 task_samples_copy = task_samples total = len(task_samples) final_dataframe_1 = pd.DataFrame() accuracies = np.zeros((iterations, len(task_samples))) for t_input in range(0, len(task_samples)): #print("split is",len(task_samples[t_input])) splitted_input = np.array_split(task_samples[t_input], 3) for i in range(0, len(splitted_input)): #print("split is",len(splitted_input[i])) if (len(splitted_input[i]) == 20668): splitted_input[i] = np.concatenate((splitted_input[i], [0])) skills.append(splitted_input[i]) task_samples = skills Skill_Mu = [[] for _ in range(0, len(task_samples))] global student_model global vae_optimizer student_model.train() iterations = iterations for batch_idx in range(1, iterations): randPerm = np.random.permutation(len(task_samples)) #randPerm,nReps = helper_functions.biased_permutation(stage+1,nBiased,trainBias,total*3,minReps) print(randPerm, nReps) resend = [] for s in randPerm: skill = s vae_optimizer.zero_grad() data = Variable(torch.FloatTensor(task_samples[skill])).to(device) hidden_representation, recons_x = student_model(data) W = student_model.state_dict()['fc2.weight'] loss, con_mse, con_loss, closs_mul_lam = helper_functions.Contractive_loss_function( W, data.view(-1, 20669), recons_x, hidden_representation, lam) Skill_Mu[skill] = hidden_representation vis.line(X=np.array([batch_idx]), Y=np.array([loss.item()]), win=win, name='Loss_Skill_' + str(skill), update='append') loss.backward() vae_optimizer.step() print('Train Iteration: {},tLoss: {:.6f},picked skill {}'.format( batch_idx, loss.data[0], skill)) #print(float(loss.data[0] * 1000)) if float(loss.data[0] * 1000000) >= 1.00: resend.append(s) print("RESEND List", resend) total_resend = total_resend + len(resend) for s in resend: skill = s #print("resending skills",resend) vae_optimizer.zero_grad() data = Variable(torch.FloatTensor(task_samples[skill])).to(device) hidden_representation, recons_x = student_model(data) W = student_model.state_dict()['fc2.weight'] loss, con_mse, con_loss, closs_mul_lam = helper_functions.Contractive_loss_function( W, data.view(-1, 20669), recons_x, hidden_representation, lam) Skill_Mu[skill] = hidden_representation vis.line(X=np.array([batch_idx]), Y=np.array([loss.item()]), win=win, name='Loss_Skill_' + str(skill), update='append') loss.backward() vae_optimizer.step() print('Train Iteration: {},tLoss: {:.6f},picked skill {}'.format( batch_idx, loss.data[0], skill)) if batch_idx % 1 == 0: m = 0 n = 3 values = 0 for i in range(0, int(len(task_samples) / 3)): collect_data_1 = [] RELOAD_DATASET() Avg_Accuracy = 0 Train_loader, Test_loader = load_individual_class( list(range(i * 10, (i + 1) * 10)), []) sample = [] for k in range(m, n): mu1 = Skill_Mu[k][0] mini_task_sample = student_model.decoder(mu1).cpu() task_sample = mini_task_sample.data.numpy().reshape(20669) sample = np.concatenate([sample, task_sample]) m = m + 3 n = n + 3 final_weights = helper_functions.unFlattenNetwork( torch.from_numpy(sample).float(), shapes) model_x = loadWeights_cifar(final_weights, model) Avg_Accuracy = test(model_x, Test_loader) mse = mean_squared_error( sample[0:62006], Variable(torch.FloatTensor( task_samples_copy[i][0:62006])).data.numpy()) mse_orginal = mean_squared_error(sample[0:62006], Actual_task_net_weights[i]) b = torch.FloatTensor(task_samples_copy[i]).data.numpy() b1 = torch.FloatTensor(Actual_task_net_weights[i]).data.numpy() COSINE_SIMILARITY = dot(sample[0:62006], b[0:62006]) / ( norm(sample[0:62006]) * norm(b[0:62006])) COSINE_SIMILARITY_wrt_orginal = dot( sample[0:62006], b1[0:62006]) / (norm(sample[0:62006]) * norm(b1[0:62006])) collect_data_1.extend([ total, batch_idx, i, mse, mse_orginal, Avg_Accuracy, Actual_Accuracy[i], len(resend), COSINE_SIMILARITY, COSINE_SIMILARITY_wrt_orginal ]) final_dataframe_1 = pd.concat([ final_dataframe_1, pd.DataFrame(collect_data_1).transpose() ]) final_dataframe_1 = pd.concat([ final_dataframe_1, pd.DataFrame(collect_data_1).transpose() ]) vis.line(X=np.array([batch_idx]), Y=np.array([Avg_Accuracy]), win=win_2, name='Acc_Skill_' + str(i), update='append') vis.line(X=np.array([batch_idx]), Y=np.array([mse]), win=win_mse, name='MSE_Skill_' + str(i), update='append') vis.line(X=np.array([batch_idx]), Y=np.array([COSINE_SIMILARITY]), win=win_mse_org, name='Cos_Sim_Skill_' + str(i), update='append') #,opts=options_lgnd) if (COSINE_SIMILARITY) >= (0.996): values = values + 1 # if total<=7: # if (Avg_Accuracy)>=(Actual_Accuracy[i]): # values=values+1 # else: # if (Avg_Accuracy)>=(Actual_Accuracy[i]): # print("verifying the degrading threshold") # values=values+1 if values == total: print("########## \n Batch id is", batch_idx, "\n#########") threshold_batchid.append(batch_idx) threshold_net_updates.append((batch_idx * total) + total_resend) break final_dataframe_1.columns = [ 'no_of_skills', 'batch_idx', 'skill', 'caluclated_mse', 'mse_wrt_orginal', 'Accuracy', 'Actual_Accuracy', 'Resend_len', 'COSINE_SIMILARITY', 'COSINE_SIMILARITY_wrt_orginal' ] final_dataframe_1.to_hdf( 'Collected_Data/' + str(len(task_samples_copy)) + '_test_data.hdf', 'key1') stage = stage + 3 return accuracies
def CAE_AE_TRAIN(shapes,task_samples,iterations): names=[] global total_update_count global running_update_count for legend in range(0,len(task_samples)): names.append('Loss_Skill_'+str(legend)) print("Lengend names",names) options = dict(fillarea=True,width=400,height=400,xlabel='Iterations',ylabel='Loss',title='CAE_skills'+str(len(task_samples))) options_2 = dict(fillarea=True,width=400,height=400,xlabel='Iterations',ylabel='Accuracy',title='CAE_skills'+str(len(task_samples))) options_mse = dict(fillarea=True,width=400,height=400,xlabel='Iterations',ylabel='MSE',title='CAE_MSE_skills'+str(len(task_samples))) options_mse_org = dict(fillarea=True,width=400,height=400,xlabel='Iterations',ylabel='MSE_Orginal',title='CAE_MSE_WRT_Orginal_skills'+str(len(task_samples))) win = vis.line(X=np.array([0]),Y=np.array([0.005]),win='CAE_skills '+str(len(task_samples)),name='CAE_skills'+str(len(task_samples)),opts=options) win_2 = vis.line(X=np.array([0]),Y=np.array([0]),win='CAE_Acc_skills '+str(len(task_samples)),name='CAE_skills'+str(len(task_samples)),opts=options_2) win_mse = vis.line(X=np.array([0]),Y=np.array([0]),win='CAE_MSE_skills '+str(len(task_samples)),name='CAE_MSE_skills'+str(len(task_samples)),opts=options_mse) win_mse_org = vis.line(X=np.array([0]),Y=np.array([0]),win='CAE_MSE_Org_skills '+str(len(task_samples)),name='CAE_MSE_Orgskills'+str(len(task_samples)),opts=options_mse_org) global stage student_model.train() accuracies = np.zeros((iterations,len(task_samples))) for i in range(0,len(task_samples)-len(Skill_Mu)): Skill_Mu.append([]) for batch_idx in range(1,iterations): randPerm = np.random.permutation(len(task_samples)) #randPerm,nReps = helper_functions.biased_permutation(stage+1,nBiased,trainBias,len(task_samples),minReps) #print(randPerm,nReps) for s in randPerm: skill=s vae_optimizer.zero_grad() data=Variable(torch.FloatTensor(task_samples[skill])).to(device) hidden_representation, recons_x = student_model(data) W = student_model.state_dict()['fc2.weight'] loss,con_mse,con_loss,closs_mul_lam = helper_functions.Contractive_loss_function(W, data.view(-1, 21840), recons_x,hidden_representation, lam) Skill_Mu[skill]=hidden_representation if len(task_samples)>6: print("Updating the loss") loss=loss*(total_update_count-running_update_count[skill])/total_update_count total_update_count=total_update_count+1 running_update_count[skill]=running_update_count[skill]+1 loss.backward() #options_lgnd = dict(fillarea=True, legend=['Loss_Skill_'+str(skill)]) vis.line(X=np.array([batch_idx]),Y=np.array([loss.item()]),win=win,name='Loss_Skill_'+str(skill),update='append')#,opts=options_lgnd) vae_optimizer.step() print('Train Iteration: {},tLoss: {:.6f},picked skill {}'.format(batch_idx,loss.data[0],skill )) if batch_idx %1==0: values=0 for i in range(0,len(task_samples)): mu1=Skill_Mu[i][0] task_sample = student_model.decoder(mu1).cpu() sample=task_sample.data.numpy().reshape(21840) #print('MSE IS',i,mean_squared_error(task_sample.data.numpy(),Variable(torch.FloatTensor(task_samples[i])).data.numpy())) #mse=mean_squared_error(task_sample.data.numpy(),Variable(torch.FloatTensor(task_samples[i])).data.numpy()) final_weights=helper_functions.unFlattenNetwork(sample, shapes) loadWeights_mnsit(final_weights,model) test_loader=RELOAD_DATASET(idx_permute[i]) mse=mean_squared_error(sample,Variable(torch.FloatTensor(task_samples[i])).data.numpy()) mse_orginal=mean_squared_error(sample,Actual_task_net_weights[i]) Avg_Accuracy= test(args, model, device, test_loader) accuracies[batch_idx,i] = Avg_Accuracy if len(task_samples)>6: if round(Avg_Accuracy+0.5)>=int(Actual_Accuracy[i]): values=values+1 else: if round(Avg_Accuracy+0.5)>=int(Actual_Accuracy[i]-1): values=values+1 vis.line(X=np.array([batch_idx]),Y=np.array([Avg_Accuracy]),win=win_2,name='Acc_Skill_'+str(i),update='append') vis.line(X=np.array([batch_idx]),Y=np.array([mse]),win=win_mse,name='MSE_Skill_'+str(i),update='append') vis.line(X=np.array([batch_idx]),Y=np.array([mse_orginal]),win=win_mse_org,name='MSE_Org_Skill_'+str(i),update='append')#,opts=options_lgnd) if values==len(task_samples): print("########## \n Batch id is",batch_idx,"\n#########") threshold_batchid.append(batch_idx) break stage=stage+1 return accuracies
def CAE_AE_TRAIN(shapes, task_samples, iterations): batch_idx = 0 global stage encoded_task = [] global running_update_counts global total_update_count #task_samples=task_samples.to(device) student_model.train() final_dataframe = pd.DataFrame() final_dataframe_1 = pd.DataFrame() for i in range(0, len(task_samples) - len(Skill_Mu)): Skill_Mu.append([]) # for batch_idx in range(1,iterations): while True: batch_idx += 1 train_loss = 0 randPerm = np.random.permutation(len(task_samples)) # adjust_learning_rate(vae_optimizer, batch_idx) #print("after lr change",vae_optimizer) # randPerm,nReps = helper_functions.biased_permutation(stage+1,nBiased,trainBias,len(task_samples),minReps) print(randPerm) #sys.exit() for s in randPerm: collect_data = [] skill = s #randint(0,len(task_samples)-1) vae_optimizer.zero_grad() # F_s = fisher_matrix[s] data = Variable(torch.FloatTensor(task_samples[skill])).to(device) hidden_representation, recons_x = student_model(data) W = student_model.state_dict()['fc2.weight'] loss, con_mse, con_loss, closs_mul_lam = helper_functions.Contractive_loss_function( W, data.view(-1, 21432), recons_x, hidden_representation, lam) # loss,con_mse,con_loss,closs_mul_lam = helper_functions.Contractive_FMSE(W, data.view(-1, 21432), recons_x,hidden_representation, lam, F_s) # loss = loss*((total_update_count-running_update_counts[s])/total_update_count) total_update_count += 1 running_update_counts[s] += 1 Skill_Mu[skill] = hidden_representation loss.backward() vae_optimizer.step() print('Train Iteration: {},tLoss: {:.6f},picked skill {}'.format( batch_idx, loss.data[0], skill)) # if batch_idx %1==0: if True: # accuray_threshlod=[] values = 0 for i in range(0, len(task_samples)): # Avg_Accuracy=0 #model=models.Net() collect_data_1 = [] mu1 = Skill_Mu[i][0] task_sample = student_model.decoder(mu1).cpu() sample = task_sample.data.numpy().reshape(21432) #print('MSE IS',mean_squared_error(task_sample.data.numpy(),Variable(torch.FloatTensor(task_samples[i])).data.numpy())) #mse=mean_squared_error(task_sample.data.numpy(),Variable(torch.FloatTensor(task_samples[i])).data.numpy()) final_weights = helper_functions.unFlattenNetwork( sample, shapes) loadWeights_mnsit(final_weights, model) if i % 2 == 0: load_individual_class([i], [1, 3, 5, 7]) else: load_individual_class([i], [0, 2, 4, 6]) Avg_Accuracy = test(args, model, device, test_loader) if round(Avg_Accuracy + 0.5) >= int(Actual_Accuracy[i]): values = values + 1 if values == len(task_samples): print("########## \n Batch id is", batch_idx, "\n#########") break stage = stage + 1