def find_automatic_alignment_stats(ave_stats_writer): # open input files hits_input = csv.reader(open(sys.argv[5], 'rU'), delimiter = ",") hits_num = 0 ave_stats = [] for row in hits_input: try: # skip first line if row[0] == "source": continue print(row[0]) print(hits_num + 1) # convert all alignment results to sets sure_sub = set(row[4].split()) sure_ans = set(row[8].split()) # calculate stats of alignment results stats_list = [precision(sure_sub, sure_ans), recall(sure_sub, sure_ans)] stats_list.append(f1(stats_list[0], stats_list[1])) # if answer key has two possible alignments, take one with the higher f1 if row[12]: print("two answers exists") sure_ans_2 = set(row[12].split()) stats_list_2 = [precision(sure_sub, sure_ans_2), recall(sure_sub, sure_ans_2)] stats_list_2.append(f1(stats_list_2[0], stats_list_2[1])) print("1st F1 value: " + str(stats_list[2])) print("2nd F1 value: " + str(stats_list_2[2])) if stats_list_2[2] > stats_list[2]: print("selected answer B") stats_list = stats_list_2 else: print("selected answer A") # add values to the average calculation # the case where this is the first HIT in the list if hits_num == 0: hits_num += 1 ave_stats = stats_list # the case where this is not the first HIT in the list else: hits_num += 1 for i in range(0, 3): ave_stats[i] = float(ave_stats[i]) + ((stats_list[i] - ave_stats[i]) / float(hits_num)) print(ave_stats) print("") except: pass # print averages ave_stats_writer.writerow(["automatic_alignments", hits_num] + ave_stats) return
def scan_results(qual_type, results, worker_dict): for row in results: try: workerId = row[15] # skip first line if row[0] == "HITId": continue print(row[0]) print("WORKERID: " + workerId) # if an "unchanged" value is encountered, replace with the proper value if row[50] == "unchanged": #sureAlignments row[50] = row[31] # convert all alignment results to sets sure_sub = set(row[50].split()) sure_ans = set(row[35].split()) # calculate stats of worker and store in stats_list # stats_list[0] = precision, stats_list[1] = recall, stats_list[2] = f1 stats_list = [precision(sure_sub, sure_ans), recall(sure_sub, sure_ans)] stats_list.append(f1(stats_list[0], stats_list[1])) # if answer key has two possible alignments, take one with the higher f1 if row[39]: sure_ans_2 = set(row[39].split()) stats_list_2 = [precision(sure_sub, sure_ans_2), recall(sure_sub, sure_ans_2)] stats_list_2.append(f1(stats_list_2[0], stats_list_2[1])) print("1st F1 value: " + str(stats_list[2])) print("2nd F1 value: " + str(stats_list_2[2])) if stats_list_2[2] > stats_list[2]: print("selected answer 2") stats_list = stats_list_2 else: print("selected answer 1") # add worker to worker_dict # the case where worker does not exist in worker_dict if workerId not in worker_dict: worker_list = [1, qual_type] worker_list = worker_list + stats_list worker_dict[workerId] = worker_list # the case where worker already exists in worker_dict else: worker_list = worker_dict[workerId] worker_list[0] = worker_list[0] + 1 worker_list[2] = float(worker_list[2]) + ((stats_list[0] - worker_list[2]) / float(worker_list[0])) worker_list[3] = float(worker_list[3]) + ((stats_list[1] - worker_list[3]) / float(worker_list[0])) worker_list[4] = float(worker_list[4]) + ((stats_list[2] - worker_list[4]) / float(worker_list[0])) except: pass print("") return
def evaluate(self, numFuncion): if numFuncion == 1: for agent in self.agents: f1(agent) elif numFuncion == 2: for agent in self.agents: f2(agent) else: for agent in self.agents: f3(agent)
def find_automatic_alignment_stats(ave_stats_writer): # open input files hits_input = csv.reader(open(sys.argv[5], 'rU'), delimiter = ",") hits_num = 0 ave_stats = [] for row in hits_input: try: # skip first line if row[0] == "source": continue print(row[0]) # if answer key has two possible alignments, choose one at random if row[8] and row[12]: print("selecting random answer") ans_string = random.choice([row[8], row[12]]) else: ans_string = row[8] if ans_string == row[8]: print("selected answer 1") else: print("selected answer 2") # convert all alignment results to sets sure_sub = set(row[4].split()) sure_ans = set(ans_string.split()) print(sure_sub) print(sure_ans) # calculate stats of alignment results stats_list = [precision(sure_sub, sure_ans), recall(sure_sub, sure_ans)] stats_list.append(f1(stats_list[0], stats_list[1])) print("selected F1 value: " + str(stats_list[2])) # add values to the average calculation # the case where this is the first HIT in the list if hits_num == 0: hits_num += 1 ave_stats = stats_list # the case where this is not the first HIT in the list else: hits_num += 1 for i in range(0, 3): ave_stats[i] = float(ave_stats[i]) + ((stats_list[i] - ave_stats[i]) / float(hits_num)) print("") except: pass # print averages ave_stats_writer.writerow(["automatic_alignments", hits_num] + ave_stats) return
def showSine(): print "Adding Sine Curve" var = Tk.BooleanVar() x = func.T1() y = func.f1(func.T1()) sine = Tk.Checkbutton(root, text="Sine Curve", variable=var, command=lambda: plot(var, x, y, "Sine")) sine.pack(side=Tk.TOP, anchor=Tk.W)
def main(): x = [[None], [None]] print("Решение системы при аналитическом методе: ") x = newton1(1, 1, 20, 1e-9, 1e-9) print("\tx0 =", x) print("Значение 1-ой функции в данной точке: ", format(f1(x[0], x[1]), '.9f')) print("Значение 2-ой функции в данной точке: ", format(f2(x[0], x[1]), '.9f')) print("\nРешение системы при численном методе: ") xM1 = newton2(1, 1, 20, 1e-9, 1e-9, 0.01) xM2 = newton2(1, 1, 20, 1e-9, 1e-9, 0.05) xM3 = newton2(1, 1, 20, 1e-9, 1e-9, 0.1) print("M = 0.01\tx0 =", xM1) print("M = 0.05\tx0 =", xM2) print("M = 0.10\tx0 =", xM3) print("Значение 1-ой функции в данной точке: ", format(f1(xM1[0], xM1[1]), '.9f')) print("Значение 2-ой функции в данной точке: ", format(f2(xM1[0], xM1[1]), '.9f'))
def print_matrix(matrix, classes): p = precision(matrix) r = recall(matrix) f = f1(p, r) table = BeautifulTable() table.column_headers = [ "Class Name", "Precision", "Recall", "F1 Score" ] for i in range(len(classes)): table.append_row([classes[i][0], p[i], r[i], f[i]]) print(table) total_f1 = np.sum(f) / len(f) print("Total F1 score: " + str(total_f1)) return total_f1
def print_score(matrix, classes, points=8): def to_str(num): return ("%." + str(points) + "f") % round(float(num), points) p = precision(matrix) r = recall(matrix) f = f1(p, r) table = BeautifulTable() table.column_headers = [ "Class Name", "Precision", "Recall", "F1 Score" ] for i in range(len(classes)): table.append_row( [classes[i][0], to_str(p[i]), to_str(r[i]), to_str(f[i])]) print(table) total_f1 = np.sum(f) / len(f) print("Total F1 score: " + to_str(total_f1)) return total_f1
def getNewY(x, y): return y - (f.f2(x, y) * f.f1_dx(x, y) - f.f1(x, y) * f.f2_dx(x, y)) / ( f.f1_dx(x, y) * f.f2_dy(x, y) - f.f2_dx(x, y) * f.f1_dy(x, y))
def getNewX(x, y): return x - (f.f1(x, y) * f.f2_dy(x, y) - f.f2(x, y) * f.f1_dy(x, y)) / ( f.f1_dx(x, y) * f.f2_dy(x, y) - f.f2_dx(x, y) * f.f1_dy(x, y))
def scan_results(qual_type, filename, worker_dict): print("****************************************************") print(qual_type) print(filename) print("****************************************************") results = csv.reader(open(filename, 'rU'), delimiter = ",") for row in results: try: print("") hit_id = row[0] worker_id = row[15] # skip first line and a particular user who was completed both "all" and "participated" HITs if hit_id == "HITId" or (worker_id == "AURYD2FH3FUOQ" and qual_type == "all"): continue print("") print(row) print("HITID: " + str(hit_id)) print("WORKERID: " + str(worker_id)) print("QUAL TYPE: " + qual_type) # make corrections to fields labeled "unchanged" or "{}" if row[46] == "unchanged": row[46] = row[31] if row[43] == "unchanged": row[43] = row[32] for i in [35, 36, 43, 46]: if row[i] == "{}": row[i] = "" sure_submission = row[46] poss_submission = row[43] sure_control = row[35] poss_control = row[36] print("defined rows") # convert all alignments to sets sure_submission_set = set(sure_submission.split()) print("SURE_SUBMISSION_STRING: " + str(sure_submission)) print("SURE_SUBMISSION_SET: " + str(sure_submission_set)) all_submission_set = set(poss_submission.split()) | sure_submission_set print("ALL_SUBMISSION_SET: " + str(all_submission_set)) sure_control_set = set(sure_control.split()) print("SURE_CONTROL_SET: " + str(sure_control_set)) all_control_set = set(poss_control.split()) | sure_control_set print("ALL_CONTROL_SET: " + str(all_control_set)) # create a list of accuracy stats for the current HIT # stats_list[0] = precision, stats_list[1] = recall, stats_list[2] = f1 stats_list = [precision(sure_submission_set, all_control_set), recall(all_submission_set, sure_control_set)] print("STATS_LIST_INITIAL: " + str(stats_list)) stats_list.append(f1(stats_list[0], stats_list[1])) print("STATS_LIST_FINAL: " + str(stats_list)) # add worker to worker_dict # the case where worker does not exist in worker_dict if worker_id not in worker_dict: worker_list = [1, qual_type] worker_list = worker_list + stats_list worker_dict[worker_id] = worker_list # the case where worker already exists in worker_dict else: worker_list = worker_dict[worker_id] worker_list[0] = worker_list[0] + 1 for i in range(0, 3): worker_list[i + 2] = float(worker_list[i + 2]) + ((stats_list[i] - worker_list[i + 2]) / float(worker_list[0])) except: pass
import functions as f while (1): print( "Press i to access function number i(eg:-1 for fun1)\nPress 6 to exit") c = int(input()) if c == 1: print("Enter x and y:") x, y = input().split() x = int(x) y = int(y) print("Result=", f.f1(x, y)) elif c == 2: print("Enter n and r:") n, r = input().split() n = int(n) r = int(r) print("Result=", f.f2(n, r)) elif c == 3: n = int(input("Enter n:")) print("Result=", f.f3(n)) elif c == 4: print("Enter m and n") m, n = input().split() m = int(m) n = int(n) print("Result=", f.f4(m, n)) elif c == 5: print("Enter m and x") m, x = input().split() m = int(m)
def scan_csv(results, worker_dict, hits_result_writer): # Dictionary indexes hits by hitId, each hitId maps to a list # where l[0] = # hits completed and l[1] = # hits correct hits_dict = {} num_rows = 0 for row in results: print(num_rows) num_rows += 1 try: hitId = row[0] workerId = row[15] print("hitId: " + hitId) print("workerId: " + workerId) # skip first line if hitId == "HITId": continue ### skip HITs 311HQEI8RS1Q91M7H2OGRN5V4US7ZI and 37Y5RYYI0PQNN46K4NY6PTLGJI8SXE ### This is because those HITs have strange answer values if hitId == "311HQEI8RS1Q91M7H2OGRN5V4US7ZI" or hitId == "37Y5RYYI0PQNN46K4NY6PTLGJI8SXE": continue # if an "unchanged" value is encountered, replace with the proper value if row[48] == "unchanged": #sureAlignments row[48] = row[31] if row[42] == "unchanged": #possAlignments row[42] = "{}" if row[44] == "unchanged": #sourceHighlights row[44] = "{}" if row[50] == "unchanged": #targetHighlights row[50] = "{}" # convert all alignment results to sets sure_sub_f = set(row[48].split()) sure_sub_i = set(row[49].split()) sure_ans = set(row[35].split()) pos_sub_f = set(row[42].split()) pos_sub_i = set(row[43].split()) pos_ans = set(row[36].split()) src_sub_f = set(row[44].split()) src_sub_i = set(row[45].split()) src_ans = set(row[37].split()) tgt_sub_f = set(row[50].split()) tgt_sub_i = set(row[51].split()) tgt_ans = set(row[38].split()) prec_i = precision(sure_sub_i, sure_ans) print("prec_i" + str(prec_i)) rec_i = recall(sure_sub_i, sure_ans) print("rec_i" + str(rec_i)) f1_i = f1(prec_i, rec_i) print("f1_i" + str(f1_i)) prec_f = precision(sure_sub_f, sure_ans) print("prec_f" + str(prec_f)) rec_f = recall(sure_sub_f, sure_ans) print("rec_f" + str(rec_f)) f1_f = f1(prec_f, rec_f) print("f1_f" + str(f1_f)) # create dictionary of HITs data if hitId not in hits_dict: hits_list = [1, 0] hits_dict[hitId] = hits_list else: hits_list = hits_dict[hitId] hits_list[0] = hits_list[0] + 1 # the case where the worker does not exist in worker_dict if workerId not in worker_dict: # initialize initial worker_list completed_HITs = [hitId] worker_list = [1, 0, 0, prec_i, rec_i, f1_i, prec_f, rec_f, f1_f, completed_HITs] worker_dict[workerId] = worker_list # check if user's final submission is correct if sure_sub_f == sure_ans and pos_sub_f == pos_ans and src_sub_f == src_ans and tgt_sub_f == tgt_ans: print("Correct submission") worker_list[1] = worker_list[1] + 1 hits_list[1] = hits_list[1] + 1 ### DELETE THIS LATER, DEBUGGING ONLY # print out errors if encountered if sure_sub_f != sure_ans: print("Sure alignments incorrect, expected " + str(sure_ans) + ", got " + str(sure_sub_f)) if pos_sub_f != pos_ans: print("Possible alignments incorrect, expected " + str(pos_ans) + ", got " + str(pos_sub_f)) if src_sub_f != src_ans: print("Source highlights incorrect, expected " + str(src_ans) + ", got " + str(src_sub_f)) if tgt_sub_f != tgt_ans: print("Target highlights incorrect, expected " + str(tgt_ans) + ", got " + str(tgt_sub_f)) #change correctness rate worker_list[2] = worker_list[1] # the case where the worker already exists in work_dict else: worker_list = worker_dict[workerId] # if user has already completed this HIT, skip if hitId in worker_list[9]: continue # mark the worker as having completed this HIT worker_list[9].append(hitId) # increase worker's completed HIT count worker_list[0] = worker_list[0] + 1 # check if user's final submission is correct if sure_sub_f == sure_ans and pos_sub_f == pos_ans and src_sub_f == src_ans and tgt_sub_f == tgt_ans: print("Correct submission") worker_list[1] = worker_list[1] + 1 hits_list[1] = hits_list[1] + 1 ### print out errors if encountered if sure_sub_f != sure_ans: print("Sure alignments incorrect, expected " + str(sure_ans) + ", got " + str(sure_sub_f)) if pos_sub_f != pos_ans: print("Possible alignments incorrect, expected " + str(pos_ans) + ", got " + str(pos_sub_f)) if src_sub_f != src_ans: print("Source highlights incorrect, expected " + str(src_ans) + ", got " + str(src_sub_f)) if tgt_sub_f != tgt_ans: print("Target highlights incorrect, expected " + str(tgt_ans) + ", got " + str(tgt_sub_f)) # update correctness rate worker_list[2] = float(worker_list[1]) / float(worker_list[0]) # update precision, recall and f1 for initial guesses worker_list[3] = float(worker_list[3]) + ((prec_i - worker_list[3]) / float(worker_list[0])) worker_list[4] = float(worker_list[4]) + ((rec_i - worker_list[4]) / float(worker_list[0])) worker_list[5] = float(worker_list[5]) + ((f1_i - worker_list[5]) / float(worker_list[0])) # update precision, recall and f1 after seeing answer key worker_list[6] = float(worker_list[6]) + ((prec_f - worker_list[6]) / float(worker_list[0])) worker_list[7] = float(worker_list[7]) + ((rec_f - worker_list[7]) / float(worker_list[0])) worker_list[8] = float(worker_list[8]) + ((f1_f - worker_list[8]) / float(worker_list[0])) print("") except: pass # write HITs statistics for hitId in hits_dict: hits_list = hits_dict[hitId] hits_result_writer.writerow([hitId, hits_list[0], hits_list[1], float(hits_list[1]) / float(hits_list[0])]) print (str(hitId) + ": [" + str(hits_list[0]) + ", " + str(hits_list[1]) + ", " + str((float(hits_list[1]) / float(hits_list[0]))) + "]") print("") return
def aggsub(x, prob, eps, mit, tau, sig1, delta, sig2, c1, c2, tlimit): """ Aggregate subgradient method for nonsmooth DC optimization. Input: x - a starting point; prob - selection of problem: 0 - PWLRL1 problem 1 - auxiliary min-problem eps - optimality tolerance; mit - maximum number of inner iterations; tau - proximity parameter, tau > 0; sig1 - decrease parameter for tau, sig1 in (0,1); delta - inner iteration tolerance, delta > 0; sig2 - decrease parameter for delta, sig2 in (0,1]; c1,c2 - line search parameters, 0 < c2 <= c1 < 1; tlimit - time limit for aggsub. Global parameters: a - an input matrix; Output: x - a solution obtained; f - the objective value at x; nit - number of iterations; nf - number of function evaluations; ng - number of subgradient evaluations; """ # Import DC functions and their subgradients import functions #print(config.a) # just testing # import time import time # Starting time for aggsub usedtime0 = time.clock() fdiff = -99.0 # Initialization if prob == 0: f1 = functions.f1(x) f2 = functions.f2(x) else: f1 = functions.auxminf1(x) f2 = functions.auxminf2(x) fold = f1 - f2 # Original function value print "f original is", fold print "Computing..." nf = 1 # Number of function evaluations. ng = 0 # Number of subgradient evaluations. nit = 0 # Number of iterations. maxii = max(min(x.size, 500), 50) # Maximum number of inner iterations. stopii = -1 # reason to stop the inner iteration: # stopii =-1 - not stopped yet; # stopii = 0 - small gradient: canditate solution; # stopii = 1 - decent direction found; # stopii = 2 - too many inner iterations without progress. small = 1e-5 nrmnew = 1e+10 ii = 0 # Outer iteration while True: # Step 1 nii = 0 # Number of inner iterations. dd = np.ones_like(x) / np.sqrt( x.size) # Initialization of the direction dd. if prob == 0: f1 = functions.f1(x) # Needed for correct confic tables. g2 = functions.df2(x) # Subgradient of the DC component f2. f1 = functions.f1(x + tau * dd) # test for bug fix g1 = functions.df1(x + tau * dd) # Subgradient of the DC component f1. else: f1 = functions.auxminf1(x) # Needed for correct confic tables. g2 = functions.dauxminf2(x) # Subgradient of the DC component f2. f1 = functions.auxminf1(x + tau * dd) # test for bug fix g1 = functions.dauxminf1( x + tau * dd) # Subgradient of the DC component f1. # No need to recompute g2 if returning from Step 6. ng += 1 sg = g1 - g2 # Approx. subgradient of the function. asg = sg # Aggregate subgradient. nrmasg = 0.0 # Norm of the aggregate subgradient. # Inner iteration while True: nii += 1 # Step 2 sgdiff = np.dot(sg - asg, sg - asg) if sgdiff > small: #lam = (nrmasg*nrmasg - np.dot(sg,asg))/sgdiff lam = -np.dot( asg, sg - asg) / sgdiff # this should be the same as above else: lam = 0.50 if lam > 1.0 or lam < 0.0: print "Projecting lambda = ", lam, "to [0,1]." if lam < 0: lam = 0.0 else: lam = 1.0 # If lam=0 nothing changes and we end up to inner iteration termination 2. # Step 3 asg = lam * sg + (1.0 - lam) * asg # The new aggregate subgradient. nrmasg = np.linalg.norm(asg) # Norm of the aggregate subgradient. if nrmasg < delta: # Inner iteration termination stopii = 0 break # With this we should go to Step 6. if nii % 5 == 0: # Inner iteration termination 2 nrmold = nrmnew nrmnew = nrmasg if np.abs(nrmold - nrmnew) < 0.0001: #print "Norm is not changing." stopii = 0 break # With this we should go to Step 6. # Step 4: Search direction dd = -asg / nrmasg # Step 5 xtau = x + tau * dd if prob == 0: f1 = functions.f1(xtau) f2 = functions.f2(xtau) else: f1 = functions.auxminf1(xtau) f2 = functions.auxminf2(xtau) fnew = f1 - f2 nf += 1 dt = fnew - fold #if (dt > -c1*tau*nrmasg and -dt/fold > 0.1): # makes results worse (limited testing) if (dt > -c1 * tau * nrmasg): # Not a descent direction #if (dt < 0 and -dt/fold > 0.05): # just for testing purposes # print "No descent but should it be?",-dt/fold,dt,-c1*tau*nrmasg,fold,fnew if prob == 0: g1 = functions.df1(xtau) else: g1 = functions.dauxminf1(xtau) sg = g1 - g2 ng += 1 else: stopii = 1 break # with this we should go to Step 7. # Additional termination from inner iteration if nii > maxii: if tau > eps: #print "Too many inner iterations. Adjusting tau." stopii = 2 else: print "Too many inner iterations with no descent direction found." #,nit,fnew,fold if ii == 0: ii = 1 nii = 0 # Number of inner iterations starts again from zero. #dd = -np.ones_like(x)/np.sqrt(x.size) # Initialization of the direction dd. dd = -dd # Opposite of the direction dd. if config.nfea < 200: # tau > 0, default = 10, if n<200, tau = 10.0 # 50, otherwise. else: tau = 50.0 if prob == 0: f1 = functions.f1(x + tau * dd) # test for bug fix g1 = functions.df1( x + tau * dd) # Subgradient of the DC component f1. else: f1 = functions.auxminf1( x + tau * dd) # test for bug fix g1 = functions.dauxminf1( x + tau * dd) # Subgradient of the DC component f1. ng += 1 sg = g1 - g2 # Approx. subgradient of the function. asg = sg # Aggregate subgradient. nrmasg = 0.0 # Norm of the aggregate subgradient. print "Trying opposite direction." print "Computing..." continue else: print "Exit." stopii = 3 break # Step 6: Stopping criterion if stopii == 0: # Small norm if tau <= eps: print "Critical point found." break # Critical point found else: tau *= sig1 delta *= sig2 stopii = -1 nit += 1 continue # Step 7: Line search elif stopii == 1: # Descent direction if ii == 1: print "Descent direction found." print "Computing..." ii = 0 step = tau # Here fnew = f(xtau), fold = f(x) count = 0 while count < 10: # Maximum of 10 search are made count += 1 step *= 2.0 xnew = x + step * dd if prob == 0: f1 = functions.f1(xnew) f2 = functions.f2(xnew) else: f1 = functions.auxminf1(xnew) f2 = functions.auxminf2(xnew) nf += 1 fdiff = f1 - f2 - fold if fdiff <= -c2 * step * nrmasg: xtau = xnew fnew = f1 - f2 else: break # Step 8: Update step # The last f1 and f2 are computed at xnew =/ xtau, need to compute f1(xtau) to get max_line correctly x = xtau fold = fnew if tau > eps: tau *= sig1 # tau too small is not good, needs safeguard elif np.abs(fdiff) < 1e-7: print "Termination with small change in function values." #,fdiff break delta *= sig2 nit += 1 # Termination with maximum number of iterations. if nit >= mit: # Number of iterations > mit print "Termination with maximum number of iterations." break # Termination with the time limit for AggSub. usedtime = time.clock() - usedtime0 if usedtime > tlimit: print "Termination with the time limit for AggSub." break # with this we should go to Step 7. if stopii == 3: #print "No decent direction found in inner iteration." break stopii = -1 # To next inner iteration. # Outer iteration ends f = fold return x, f, nit, nf, ng
import functions from State import State import numpy as np from Timer import Timer import mcmc s1 = State(np.random.randn(3), 1.0) with Timer(digits=6): functions.f1(s1, 1000) with Timer(digits=6): np.random.randn(100 * 100).sum() with Timer('test_metropolis (cython)', digits=6): mcmc.test_metropolis(1000 * 1000)