def setWeight(): if SUPERVISED: src_err, diff_marg, tar_err = FitnessFunction.domain_differece(src_feature=Core.src_feature, src_label=Core.src_label, classifier=Core.classifier, tarU_feature=Core.tarU_feature, tarL_feature=Core.tarL_feature, tarL_label=Core.tarL_label) else: src_err, diff_marg, tar_err = FitnessFunction.domain_differece(src_feature=Core.src_feature, src_label=Core.src_label, classifier=Core.classifier, tarU_feature=Core.tarU_feature) print(src_err, diff_marg, tar_err) if diff_marg == 0: FitnessFunction.margWeight = 0 else: FitnessFunction.margWeight = 1.0/diff_marg if tar_err == 0: FitnessFunction.tarWeight = 0 else: FitnessFunction.tarWeight = 1.0 / tar_err if src_err == 0: FitnessFunction.srcWeight = 0 else: FitnessFunction.srcWeight = 1.0/src_err
def setWeight(): if SUPERVISED: src_err, diff_marg, tar_err = FitnessFunction.domain_differece(src_feature=Core.src_feature, src_label=Core.src_label, classifier=Core.classifier, tarU_feature=Core.tarU_feature, tarU_soft_label=Core.tarU_soft_label, tarL_feature=Core.tarL_feature, tarL_label=Core.tarL_label) else: src_err, diff_marg, tar_err = FitnessFunction.domain_differece(src_feature=Core.src_feature, src_label=Core.src_label, classifier=Core.classifier, tarU_feature=Core.tarU_feature, tarU_soft_label=Core.tarU_soft_label) FitnessFunction.margWeight= 1.0 / diff_marg FitnessFunction.tarWeight = 1.0 / tar_err FitnessFunction.srcWeight = 1.0/src_err
def opposite_weight(): # Make sure that all the weights are not 0, so all components are evaluated FitnessFunction.srcWeight = 0.3 FitnessFunction.margWeight = 0.3 FitnessFunction.tarWeight = 0.3 src_err, diff_marg, tar_err = \ FitnessFunction.domain_differece(src_feature=Core.Xs, src_label=Core.Ys, classifier=Core.classifier, tar_feature=Core.Xt) sum = abs(src_err) + abs(diff_marg) + abs(tar_err) if diff_marg == 0: FitnessFunction.margWeight = 0 else: FitnessFunction.margWeight = diff_marg / sum if tar_err == 0: FitnessFunction.tarWeight = 0 else: FitnessFunction.tarWeight = tar_err / sum if src_err == 0: FitnessFunction.srcWeight = 0 else: FitnessFunction.srcWeight = src_err / sum
def setWeight(): # Make sure that all the weights are not 0, so all components are evaluated FitnessFunction.srcWeight = 0.3 FitnessFunction.margWeight = 0.3 FitnessFunction.tarWeight = 0.3 if SUPERVISED: src_err, diff_marg, tar_err = FitnessFunction.domain_differece( src_feature=Core.src_feature, src_label=Core.src_label, classifier=Core.classifier, tarU_feature=Core.tarU_feature, tarL_feature=Core.tarL_feature, tarL_label=Core.tarL_label) else: src_err, diff_marg, tar_err = FitnessFunction.domain_differece( src_feature=Core.src_feature, src_label=Core.src_label, classifier=Core.classifier, tarU_feature=Core.tarU_feature) if diff_marg == 0: FitnessFunction.margWeight = 0 else: FitnessFunction.margWeight = 1.0 / diff_marg if tar_err == 0: FitnessFunction.tarWeight = 0 else: FitnessFunction.tarWeight = 1.0 / tar_err if src_err == 0: FitnessFunction.srcWeight = 0 else: FitnessFunction.srcWeight = 1.0 / src_err
def normalize_weight_exp(): # Make sure that all the weights are not 0, so all components are evaluated FitnessFunction.srcWeight = 0.3 FitnessFunction.margWeight = 0.3 FitnessFunction.tarWeight = 0.3 src_err, diff_marg, tar_err = \ FitnessFunction.domain_differece(src_feature=Core.src_feature, src_label=Core.src_label, classifier=Core.classifier, tar_feature=Core.tar_feature) exp_src = math.exp(-abs(src_err)) exp_marg = math.exp(-abs(diff_marg)) exp_tar = math.exp(-abs(tar_err)) FitnessFunction.srcWeight = exp_src/((exp_src+exp_marg+exp_tar)) FitnessFunction.margWeight = exp_marg/((exp_src+exp_marg+exp_tar)) FitnessFunction.tarWeight = exp_tar /((exp_src+exp_marg+exp_tar))
def normalize_weight(): # Make sure that all the weights are not 0, so all components are evaluated FitnessFunction.srcWeight = 0.3 FitnessFunction.margWeight = 0.3 FitnessFunction.tarWeight = 0.3 src_err, diff_marg, tar_err = \ FitnessFunction.domain_differece(src_feature=Core.src_feature, src_label=Core.src_label, classifier=Core.classifier, tar_feature=Core.tar_feature) if diff_marg == 0: FitnessFunction.margWeight = 0 else: FitnessFunction.margWeight = 1.0 / abs(diff_marg) if tar_err == 0: FitnessFunction.tarWeight = 0 else: FitnessFunction.tarWeight = 1.0 / abs(tar_err) if src_err == 0: FitnessFunction.srcWeight = 0 else: FitnessFunction.srcWeight = 1.0/abs(src_err)
def main(args): global i_stick, i_pbest, i_gbest, ustks run_index = int(args[0]) random.seed(1617**2 * run_index) marg_index = int(args[1]) tar_index = int(args[2]) FitnessFunction.margVersion = marg_index FitnessFunction.tarVersion = tar_index FitnessFunction.srcVersion = 1 filename = "iteration" + str(args[0]) + ".txt" output_file = open(filename, 'w+') time_start = time.clock() # Set the weight for each components in the fitness function # normalize_weight() FitnessFunction.srcWeight = 1.0 FitnessFunction.margWeight = 0.0 FitnessFunction.tarWeight = 1.0 # print("Start setting weight") # FitnessFunction.set_weight(Core.src_feature, Core.src_label, Core.tar_feature) # print(FitnessFunction.srcWeight, FitnessFunction.margWeight, FitnessFunction.tarWeight) # print("End setting") # opposite_weight() # Initialize population and the gbest pop = toolbox.population(n=NPART) best = None to_write = ( "Core classifier: %s\nSource weight: %f\nDiff source and target weight: %f\n" "Target weight: %g\nMarginal version: %d\nTarget version: %d\n" % (str(Core.classifier), FitnessFunction.srcWeight, FitnessFunction.margWeight, FitnessFunction.tarWeight, FitnessFunction.margVersion, FitnessFunction.tarVersion)) archive = [] for g in range(NGEN): print(g) to_write += ("=====Gen %d=====\n" % g) for part in pop: # Evaluate all particles part.fitness.values = toolbox.evaluate(part) if part.best is None or part.best.fitness < part.fitness: part.best = creator.Particle(part) part.best.fitness.values = part.fitness.values # update gbest if best is None or best.fitness < part.fitness: best = creator.Particle(part) best.fitness.values = part.fitness.values if TEST: print("is=", i_stick, "ip=", i_pbest, "ig=", i_gbest, "ustks=", ustks) print("best=", best) print(best.fitness.values) print("\n") for i, part in enumerate(pop): print("Particle %d: " % i) print("Particle position:", part) print("Particle pbest:", part.best) print("Particle stickiness:", part.stk) print("\n") archive.append(best) # now update the position of each particle for part in pop: toolbox.update(part, best) # Gather all the fitness components of the gbest and print the stats indices = [index for index, entry in enumerate(best) if entry == 1.0] src_feature = Core.Xs[:, indices] tar_feature = Core.Xt[:, indices] src_err, diff_marg, tar_err = \ FitnessFunction.domain_differece(src_feature=src_feature, src_label=Core.Ys, classifier=Core.classifier, tar_feature=tar_feature) to_write += ( " Source Error: %f \n Marginal Difference: %f \n Target Error: %f \n" % (src_err, diff_marg, tar_err)) to_write += (" Fitness function of real best: %f\n" % best.fitness.values[0]) acc = 1.0 - FitnessFunction.classification_error( training_feature=src_feature, training_label=Core.Ys, classifier=Core.classifier, testing_feature=tar_feature, testing_label=Core.Yt) to_write += (" Accuracy on unlabel target: " + str(acc) + "\n") to_write += " Position:" + str(best) + "\n" print(src_err, acc, best.fitness.values[0]) # update the parameters i_stick = is_up - (is_up - is_low) * (g + 1) / NGEN i_gbest = (1 - i_stick) / (pg_rate + 1) i_pbest = pg_rate * i_gbest ustks = ustks_low + (ustks_up - ustks_low) * (g + 1) / NGEN time_elapsed = (time.clock() - time_start) to_write += "----Final -----\n" indices = [index for index, entry in enumerate(best) if entry == 1.0] src_feature = Core.Xs[:, indices] tar_feature = Core.Xt[:, indices] if WRITE_OUT: src_full = np.concatenate( (src_feature, np.reshape(Core.Ys, (Core.Ys.shape[0], 1))), axis=1) tar_full = np.concatenate( (tar_feature, np.reshape(Core.Yt, (Core.Yt.shape[0], 1))), axis=1) np.savetxt("OutGP/Source", src_full, delimiter=",") np.savetxt("OutGP/Target", tar_full, delimiter=",") nf_file = open("OutGP/noFeatures", "w") nf_file.write(str(len(indices))) acc = 1.0 - FitnessFunction.classification_error( training_feature=src_feature, training_label=Core.Ys, classifier=Core.classifier, testing_feature=tar_feature, testing_label=Core.Yt) to_write += ("Accuracy of the core classifier: " + str(acc) + "\n") to_write += ("Accuracy on the target (No TL) (core classifier): %f\n\n" % (1.0 - FitnessFunction.classification_error( training_feature=Core.ori_src_feature, training_label=Core.Ys, classifier=Core.classifier, testing_feature=Core.ori_tar_feature, testing_label=Core.Yt))) new_classifier = LinearSVC(random_state=1617) acc = 1.0 - FitnessFunction.classification_error( training_feature=src_feature, training_label=Core.Ys, classifier=new_classifier, testing_feature=tar_feature, testing_label=Core.Yt) to_write += ("Accuracy of the Linear SVM classifier: " + str(acc) + "\n") to_write += ("Accuracy on the target (No TL) of Linear SVM: %f\n\n" % (1.0 - FitnessFunction.classification_error( training_feature=Core.ori_src_feature, training_label=Core.Ys, classifier=new_classifier, testing_feature=Core.ori_tar_feature, testing_label=Core.Yt))) new_classifier = DecisionTreeClassifier(random_state=1617) acc = 1.0 - FitnessFunction.classification_error( training_feature=src_feature, training_label=Core.Ys, classifier=new_classifier, testing_feature=tar_feature, testing_label=Core.Yt) to_write += ("Accuracy of the Linear DT classifier: " + str(acc) + "\n") to_write += ("Accuracy on the target (No TL) of DT: %f\n\n" % (1.0 - FitnessFunction.classification_error( training_feature=Core.ori_src_feature, training_label=Core.Ys, classifier=new_classifier, testing_feature=Core.ori_tar_feature, testing_label=Core.Yt))) new_classifier = GaussianNB() acc = 1.0 - FitnessFunction.classification_error( training_feature=src_feature, training_label=Core.Ys, classifier=new_classifier, testing_feature=tar_feature, testing_label=Core.Yt) to_write += ("Accuracy of the Linear NB classifier: " + str(acc) + "\n") to_write += ("Accuracy on the target (No TL) of NB: %f\n\n" % (1.0 - FitnessFunction.classification_error( training_feature=Core.ori_src_feature, training_label=Core.Ys, classifier=new_classifier, testing_feature=Core.ori_tar_feature, testing_label=Core.Yt))) to_write += ("Computation time: %f\n" % time_elapsed) to_write += ("Number of features: %d\n" % len(indices)) to_write += str(best) output_file.write(to_write) output_file.close()
def main(args): global SUPERVISED, NO_SUB_IND, toolbox #For elitism, at least the best individual #is recorded NO_ELI = (int)(POP_SIZE * GP_ELI) if NO_ELI < 10: NO_ELI = 10 filename = "iteration"+str(args[0])+".txt" file = open(filename,'w+') run_index = int(args[0]) supervised = int(args[1]) if supervised == 0: SUPERVISED = False else: SUPERVISED = True #setWeight() NO_SUB_IND = int(args[2]) toolbox.register("individual", tools.initRepeat, creator.Individual, toolbox.sub_individual, n=NO_SUB_IND) toolbox.register("population", tools.initRepeat, list, toolbox.individual, n=POP_SIZE) random.seed(1617**2*run_index) #FitnessFunction.setWeight(src_feature=Core.src_feature, src_label=Core.src_label, # tarU_feature=Core.tarU_feature, tarU_label=Core.tarU_soft_label) time_start = time.clock() pop = toolbox.population() hof = tools.HallOfFame(NO_ELI) #evaluate the population fitness = toolbox.map(toolbox.evaluate, pop) for ind, fit in zip(pop, fitness): ind.fitness.values = fit #Update the HoF hof.update(pop) towrite = "Supervised: %r \n" \ "Number of sub tree: %d\n" \ "Source weight: %f\n" \ "Diff source and target weight: %f\n" \ "Target weight: %g \n" % (SUPERVISED, NO_SUB_IND, FitnessFunction.srcWeight, FitnessFunction.margWeight, FitnessFunction.tarWeight) for gen in range(NGEN): print(gen) towrite = towrite + ("----Generation %i -----\n" %gen) #Select the next generation individuals #Leave space for elitism offspringS = toolbox.select(pop, len(pop)-NO_ELI) # Clone the selected individuals offspring = [toolbox.clone(ind) for ind in offspringS] #go through each individual for i in range(1, len(offspring), 2): if random.random() < GP_CXPB: #perform crossover for all the features first = offspring[i-1] second = offspring[i] first, second = crossoverEach(first, second) del first.fitness.values del second.fitness.values for i in range(len(offspring)): if random.random() < GP_MUTBP: parent = pop[i] for j in range(1, len(parent)): if random.random() < GP_MUTSUB: parent[j] = toolbox.mutate(parent[j]) del parent.fitness.values #Now put HOF back to offspring for ind in hof: offspring.append(toolbox.clone(ind)) # Evaluate the individuals with an invalid fitness invalid_ind = [ind for ind in offspring if not ind.fitness.valid] fitnesses = toolbox.map(toolbox.evaluate, invalid_ind) for ind, fit in zip(invalid_ind, fitnesses): ind.fitness.values = fit #Now update the hof for the next iteration hof.update(offspring) pop[:] = offspring # Gather all the fitnesses in one list and print the stats fits = [ind.fitness.values[0] for ind in pop] length = len(pop) mean = sum(fits) / length sum2 = sum(x*x for x in fits) std = abs(sum2 / length - mean**2)**0.5 towrite = towrite + (" Min %s\n" % min(fits)) towrite = towrite + (" Max %s\n" % max(fits)) towrite = towrite + (" Avg %s\n" % mean) towrite = towrite + (" Std %s\n" % std) bestInd = hof[0] funcs = [toolbox.compile(expr=tree) for tree in bestInd] src_feature = GPUtility.buildNewFeatures(Core.src_feature, funcs) tarU_feature = GPUtility.buildNewFeatures(Core.tarU_feature, funcs) tarL_feature = GPUtility.buildNewFeatures(Core.tarL_feature, funcs) if SUPERVISED: src_err, diff_marg, tar_err = FitnessFunction.domain_differece(src_feature=src_feature, src_label=Core.src_label, classifier=Core.classifier, tarU_feature=tarU_feature, tarU_soft_label=Core.tarU_soft_label, tarL_feature=tarL_feature, tarL_label=Core.tarL_label) else: src_err, diff_marg, tar_err = FitnessFunction.domain_differece(src_feature=src_feature, src_label=Core.src_label, classifier=Core.classifier, tarU_feature=tarU_feature, tarU_soft_label=Core.tarU_soft_label) towrite = towrite + (" Source Error: %f \n Diff Marg: %f \n Target Error: %f \n" %(src_err, diff_marg, tar_err)) acc = 1.0 - FitnessFunction.classification_error(training_feature=src_feature, training_label=Core.src_label, classifier=Core.classifier, testing_feature=tarU_feature, testing_label=Core.tarU_label) towrite = towrite + (" Accuracy on unlabel target: "+str(acc) + "\n") # Update the pseudo label and weight Core.classifier.fit(src_feature, Core.src_label) Core.tarU_soft_label = Core.classifier.predict(tarU_feature) #FitnessFunction.setWeight(Core.src_feature, Core.src_label, Core.tarU_feature, Core.tarU_SoftLabel) time_elapsed = (time.clock() - time_start) #process the result bestInd = hof[0] towrite = towrite + "----Final -----\n" funcs = [toolbox.compile(expr=tree) for tree in bestInd] src_feature = GPUtility.buildNewFeatures(Core.src_feature, funcs) tarU_feature = GPUtility.buildNewFeatures(Core.tarU_feature, funcs) acc = 1.0 - FitnessFunction.classification_error(training_feature=src_feature, training_label=Core.src_label, classifier=Core.classifier, testing_feature=tarU_feature, testing_label=Core.tarU_label) towrite = towrite + ("Accuracy on the target (TL): %f\n" % acc) towrite = towrite + "Accuracy on the target (No TL): %f\n" % ( 1.0 - FitnessFunction.classification_error(training_feature=Core.src_feature, training_label=Core.src_label, classifier=Core.classifier, testing_feature=Core.tarU_feature, testing_label=Core.tarU_label)) towrite = towrite + ("Computation time: %f\n" % time_elapsed) towrite = towrite + ("Number of features: %d\n" % len(bestInd)) file.write(towrite) file.close()
def main(args): global i_stick, i_pbest, i_gbest, ustks, SUPERVISED run_index = int(args[0]) random.seed(1617**2 * run_index) time_start = time.clock() SUPERVISED = False #supervised = int(args[1]) #if supervised == 0: # SUPERVISED = False #else: # SUPERVISED = True cond_index = 1 FitnessFunction.tarVersion = cond_index # set weight for normalization # setWeight() # after normalization, we assign a weight to that normalized values # weight = int(args[1])/10.0 FitnessFunction.margWeight = 0.0 # weight*FitnessFunction.margWeight FitnessFunction.tarWeight = 0.9 # (1.0-weight)*FitnessFunction.condWeight FitnessFunction.srcWeight = 0.1 filename = args[0] + "_" + args[1] + ".txt" file = open("Optimize/" + filename, 'w+') # Initialize population and the gbest pop = toolbox.population(n=NPART) best = None toWrite = ("Supervised: %r \n" \ "Source weight: %f\n" \ "Diff source and target weight: %f\n" \ "Target weight: %g\n" \ "Conditional version: %d\n" % (SUPERVISED, FitnessFunction.srcWeight, FitnessFunction.margWeight, FitnessFunction.tarWeight, FitnessFunction.tarVersion)) for g in range(NGEN): toWrite += ("=====Gen %d=====\n" % g) for part in pop: # Evaluate all particles part.fitness.values = toolbox.evaluate(part) if part.best is None or part.best.fitness < part.fitness: part.best = creator.Particle(part) part.best.fitness.values = part.fitness.values # update gbest if best is None or best.fitness < part.fitness: best = creator.Particle(part) best.fitness.values = part.fitness.values if TEST: print("is=", i_stick, "ip=", i_pbest, "ig=", i_gbest, "ustks=", ustks) print("best=", best) print(best.fitness.values) print("\n") for i, part in enumerate(pop): print("Particle %d: " % i) print("Particle position:", part) print("Particle pbest:", part.best) print("Particle stickiness:", part.stk) print("\n") # now update the position of each particle for part in pop: toolbox.update(part, best) # Gather all the fitness components of the gbest and print the stats indices = [index for index, entry in enumerate(best) if entry == 1.0] src_feature = Core.src_feature[:, indices] tarU_feature = Core.tarU_feature[:, indices] tarL_feature = Core.tarL_feature[:, indices] if SUPERVISED: src_err, diff_marg, tar_err = FitnessFunction.domain_differece( src_feature=src_feature, src_label=Core.src_label, classifier=Core.classifier, tarU_feature=tarU_feature, tarL_feature=tarL_feature, tarL_label=Core.tarL_label) else: src_err, diff_marg, tar_err = FitnessFunction.domain_differece( src_feature=src_feature, src_label=Core.src_label, classifier=Core.classifier, tarU_feature=tarU_feature) toWrite += ( " Source Error: %f \n Diff Marg: %f \n Target Error: %f \n" % (src_err, diff_marg, tar_err)) toWrite += (" Fitness function of real best: %f\n" % best.fitness.values[0]) # update the parameters i_stick = is_up - (is_up - is_low) * (g + 1) / NGEN i_gbest = (1 - i_stick) / (pg_rate + 1) i_pbest = pg_rate * i_gbest ustks = ustks_low + (ustks_up - ustks_low) * (g + 1) / NGEN time_elapsed = (time.clock() - time_start) toWrite += "----Final -----\n" indices = [index for index, entry in enumerate(best) if entry == 1.0] src_feature = Core.src_feature[:, indices] tarU_feature = Core.tarU_feature[:, indices] src_err = FitnessFunction.nfold_classification_error( src_feature, Core.src_label, Core.classifier, 10) toWrite += ("Accuracy on source: " + str(1 - src_err) + "\n") toWrite += ("Number of features: %d\n" % len(indices)) toWrite += str(best) file.write(toWrite) file.close()
def main(args): global i_stick, i_pbest, i_gbest, ustks, SUPERVISED run_index = int(args[0]) random.seed(1617 ** 2 * run_index) filename = "iteration"+str(args[0])+".txt" file = open(filename, 'w+') time_start = time.clock() SUPERVISED = False #supervised = int(args[1]) #if supervised == 0: # SUPERVISED = False #else: # SUPERVISED = True cond_index = int(args[1]) FitnessFunction.tarVersion = cond_index #setWeight() #FitnessFunction.setWeight(Core.src_feature, Core.src_label, Core.tarU_feature, Core.tarU_soft_label) # Set the weight for each components in the fitness function #FitnessFunction.setWeight(src_feature=Core.src_feature, src_label=Core.src_label, # tarU_feature=Core.tarU_feature, tarU_label=Core.tarU_soft_label) FitnessFunction.srcWeight = 0.0 FitnessFunction.margWeight = 1.0 FitnessFunction.tarWeight = 0.0 # Initialize population and the gbest pop = toolbox.population(n=NPART) best = None toWrite = ("Supervised: %r \n" \ "Source weight: %f\n" \ "Diff source and target weight: %f\n" \ "Target weight: %g\n" \ "Conditional version: %d\n" % (SUPERVISED, FitnessFunction.srcWeight, FitnessFunction.margWeight, FitnessFunction.tarWeight, FitnessFunction.tarVersion)) for g in range(NGEN): print(g) toWrite += ("=====Gen %d=====\n" % g) for part in pop: # Evaluate all particles part.fitness.values = toolbox.evaluate(part) if part.best is None or part.best.fitness < part.fitness: part.best = creator.Particle(part) part.best.fitness.values = part.fitness.values # update gbest if best is None or best.fitness < part.fitness: best = creator.Particle(part) best.fitness.values = part.fitness.values if TEST: print("is=", i_stick, "ip=", i_pbest, "ig=", i_gbest, "ustks=", ustks ) print("best=", best) print(best.fitness.values) print("\n") for i, part in enumerate(pop): print("Particle %d: " % i) print("Particle position:",part) print("Particle pbest:",part.best) print("Particle stickiness:",part.stk) print("\n") # now update the position of each particle for part in pop: toolbox.update(part, best) # Gather all the fitness components of the gbest and print the stats indices = [index for index, entry in enumerate(best) if entry == 1.0] src_feature = Core.src_feature[:, indices] tarU_feature = Core.tarU_feature[:, indices] tarL_feature = Core.tarL_feature[:, indices] if SUPERVISED: src_err, diff_marg, tar_err = FitnessFunction.domain_differece(src_feature=src_feature, src_label=Core.src_label, classifier=Core.classifier, tarU_feature=tarU_feature, tarL_feature=tarL_feature, tarL_label=Core.tarL_label) else: src_err, diff_marg, tar_err = FitnessFunction.domain_differece(src_feature=src_feature, src_label=Core.src_label, classifier=Core.classifier, tarU_feature=tarU_feature) toWrite += (" Source Error: %f \n Diff Marg: %f \n Target Error: %f \n" %(src_err, diff_marg, tar_err)) toWrite += (" Fitness function of real best: %f\n" % best.fitness.values[0]) acc = 1.0 - FitnessFunction.classification_error(training_feature=src_feature, training_label=Core.src_label, classifier=Core.classifier, testing_feature=tarU_feature, testing_label=Core.tarU_label) toWrite += (" Accuracy on unlabel target: " + str(acc) + "\n") toWrite += " Position:"+str(best)+"\n" # update the parameters i_stick = is_up - (is_up - is_low)*(g+1)/NGEN i_gbest = (1-i_stick)/(pg_rate+1) i_pbest = pg_rate*i_gbest ustks = ustks_low + (ustks_up-ustks_low)*(g+1)/NGEN # Update the pseudo label (only when the cond_index is equal to 2) if cond_index == 3 & g % 10==0: Core.classifier.fit(src_feature, Core.src_label) Core.tarU_soft_label = Core.classifier.predict(tarU_feature) FitnessFunction.set_weight(src_feature, Core.src_label, tarU_feature, Core.tarU_soft_label) # Need to update the fitness value of best and pbest again best.fitness.values = FitnessFunction.fitness_function(src_feature, Core.src_label, tarU_feature, Core.tarU_soft_label, Core.classifier), for part in pop: indices = [index for index, entry in enumerate(part.best) if entry == 1.0] p_src_feature = Core.src_feature[:, indices] p_tarU_feature = Core.tarU_feature[:, indices] part.best.fitness.values = FitnessFunction.fitness_function(p_src_feature, Core.src_label, p_tarU_feature, Core.tarU_soft_label, Core.classifier), time_elapsed = (time.clock() - time_start) toWrite += "----Final -----\n" indices = [index for index, entry in enumerate(best) if entry == 1.0] src_feature = Core.src_feature[:, indices] tarU_feature = Core.tarU_feature[:, indices] acc = 1.0 - FitnessFunction.classification_error(training_feature=src_feature, training_label=Core.src_label, classifier=Core.classifier, testing_feature=tarU_feature, testing_label=Core.tarU_label) toWrite += ("Accuracy on unlabel target: " + str(acc) + "\n") toWrite += ("Accuracy on the target (No TL): %f\n" % ( 1.0 - FitnessFunction.classification_error(training_feature=Core.src_feature, training_label=Core.src_label, classifier=Core.classifier, testing_feature=Core.tarU_feature, testing_label=Core.tarU_label))) toWrite += ("Computation time: %f\n" % time_elapsed) toWrite += ("Number of features: %d\n" % len(indices)) toWrite += str(best) file.write(toWrite) file.close()