def __init__(self, number, myWorldState, agType=""): # the environment self.agOperatingSets = [] self.number = number # self.news = np.zeros(common.dim+3) # contiene l'ultima notizia # [id-fonte, id-mittente, data, topics(dim)] if myWorldState != 0: self.myWorldState = myWorldState self.agType = agType self.state = np.array([random.random() for i in range(common.dim)]) self.state = self.state / self.state.sum() if graph.getGraph() == 0: graph.createGraph() # if first agent create the graph common.G.add_node(self.number, agent=self) # adds himself if common.cycle == 1: # create link only if you are only at the first step of the clock and if you are the last user if len(common.G.nodes()) == common.N_AGENTS: graph.initializeEdges() # if last creates edges self.active = True self.databaseCols = [ 'id-n', 'new', 'id-source', 'date-creation', 'relevance', 'id-send', 'date-send', 'id-recive', 'date-recive' ] self.database = {} print("agent", self.agType, "#", self.number, "has been created")
def main(): # user input print('1 - Input K and calculate') print('2 - Input your own test data raw') # print('3 - Draw graph") user_input = raw_input("Please enter k for calulation: ") if user_input == '1': calculateWithK(-1) if user_input == '2': receiveTestDataInputByUser() if user_input == '3': createGraph()
def aPosterioriDecoding(seq, fileNameEmis, fileNameTrans): statesGraph = graph.createGraph(fileNameEmis, fileNameTrans) # it's a dictionary f = forward(seq, fileNameEmis, fileNameTrans) b = backward(seq, fileNameEmis, fileNameTrans) seq = seq[1:-1] psm = f[len(f) - 1][len(f[0]) - 1] pi = matrix.createMatrix(len(statesGraph["A"]["A", "States"]), len(seq), 0.) print "F:" matrix.printMatrix(f) print "B:" matrix.printMatrix(b) print "Seq:", seq print "Size of Seq: ", len(seq) for i in range(len(seq)): #pi(i) -> position in the sequence = collunms scores = [] for k in range(1, len(statesGraph["A"][ "A", "States"])): #num of states that produce chars = lines scores.append((f[k][i + 1] * b[k][i + 1]) / psm) pi[0][i] = scores.index(max(scores)) + 1 #states are from 1 to lines-1 pi[1][i] = scores[0] pi[2][i] = scores[1] del (scores) return pi
def compile(regex): result = syntax.test(regex) if result >= 0: print "{0}{1}{2}{3}".format(regex[:result], bcolors.FAIL, regex[result:], bcolors.ENDC) print "regex.compile: Error at index " + str(result) return None else: return graph.createGraph(regex)
def run(): for test in testGraphs: g = graph.createGraph(test[0]) found = findAll(test[1], g) if len(test[2]) != len(found): for i in found: print i print for i in test[2]: print i raise Exception("Expected array of length {0} but got {1}.".format(len(test[2]), len(found))) for result in test[2]: if not result in found: raise Exception("Expected [{0}] in {1}".format(result, [str(s) for s in found]))
def viterbi(seq, filenameEmission, filenameTransmission): forwardGraph = graph.createGraph(filenameEmission, filenameTransmission) #print forwardGraph char = seq[1] states = forwardGraph["E"]["E", "States"] statesCompl = states[:] statesCompl.insert(0, "0") statesCompl.append("0") m = matrix.createMatrix(len(states) + 2, len(seq), 0) trace = matrix.createMatrix(len(states) + 2, len(seq), -1) # intialisation part matrix.atualiseValueIntoMatrix(m, 0, 0, 1) # recurrence part # recurrence 1 trace[1][1] = trace[2][1] = 0 for i in range(1, len(m) - 1): m[i][1] = float(forwardGraph["A"]["0", statesCompl[i]]) * float( forwardGraph["E"][statesCompl[i], char]) # recurrence 2 for j in range(2, len(m[0]) - 1): #jump the first 2 collumns char = seq[j] for i in range(1, len(m) - 1): # jump the begin and end states scores = [] for l in range(1, len(m) - 1): #print "L:",statesCompl[l],", K:",statesCompl[i] scores.append( float(m[l][j - 1]) * float(forwardGraph["A"][statesCompl[l], statesCompl[i]]) * float(forwardGraph["E"][statesCompl[i], char])) '''print "partial value: ",scores[-1] print "lines value:", float(m[l][j-1]) print "AKL: ",float(forwardGraph["A"][statesCompl[l],statesCompl[i]]) print "Elc: ", float(forwardGraph["E"][statesCompl[i],char])''' m[i][j] = max(scores) #print "Max: ", scores.index(max(scores))+1 trace[i][j] = scores.index(max(scores)) + 1 #print (m[i][j]) #print "---------------------------------" del (scores) scores = [] for i in range(1, len(m) - 1): scores.append( float(m[i][len(m[0]) - 2]) * float(forwardGraph["A"][statesCompl[i], "0"])) m[len(m) - 1][len(m[0]) - 1] = max(scores) trace[len(m) - 1][len(m[0]) - 1] = scores.index(max(scores)) + 1 #print "__________________________" #matrix.printMatrix(m) #matrix.printMatrix(trace) return trace
def run(): for test in testGraphs: g = graph.createGraph(test[0]) found = findAll(test[1], g) if len(test[2]) != len(found): for i in found: print i print for i in test[2]: print i raise Exception("Expected array of length {0} but got {1}.".format( len(test[2]), len(found))) for result in test[2]: if not result in found: raise Exception("Expected [{0}] in {1}".format( result, [str(s) for s in found]))
def entry(): # Read posted values _name = request.form['inputName'] _type = request.form['inputType'] _excl = request.form['exclusivity'] _genres = request.form.getlist('check') _runtime = request.form['runtime'] # Validate information if _name and _type: results = json.loads(duos.run(_name, _type, _excl, _genres, _runtime)) if results['Error'] == 1: return "Couldn't find " + json.loads(results)['Person'] + "!" else: # pprint.pprint(results) return graph.createGraph(results) else: return "Complete required fields!"
def writeVideo(path, listOfPic, listOfRec, numOfPic): global lenOfPic global widOfPic lenOfPic = len(listOfPic[0][0]) widOfPic = len(listOfPic[0]) graphPoints = [] for i in range(0, numOfPic): # the i th picture in the video # get list of all of information of rectangles in the i th picture temp = slicing.slicingFunction(listOfPic[i], listOfRec[i], i + 1, path, widOfPic, lenOfPic) graphPoints.append(temp) graphs = [] x = 0 # to found a directory if not os.path.exists(path + '/GXL'): os.makedirs(path + '/GXL') for graphPoint in graphPoints: # to create graphs for pictures according to the list of all of information of rectangles G = graph.createGraph(graphPoint, 150) # to save these graphs graph.writeGraph(G, x, path + "/GXL/") graphs.append(G) x += 1 for i in range(0, len(graphs) - 1): match.match2Graph(graphs[i], graphs[i + 1]) drawNewGraph(graphs[i], path, i) drawNewGraph(graphs[len(graphs) - 1], path, len(graphs) - 1) size = (lenOfPic, widOfPic) productVideo.picvideo(path + '/graphs', size) print("done")
def backward(seq, filenameEmission, filenameTransmission): backwardGraph = graph.createGraph(filenameEmission, filenameTransmission) #print backwardGraph char = seq[len(seq) - 2] states = backwardGraph["E"]["E", "States"] statesCompl = states[:] statesCompl.insert(0, "0") statesCompl.append("0") seq = seq[:-1] m = matrix.createMatrix(len(states) + 2, len(seq), 0) # intialisation part # the final state for i in range(1, len(m) - 1): m[i][len(m[0]) - 1] = float(backwardGraph["A"][statesCompl[i], "0"]) #matrix.printMatrix(m) # recurrence for j in range(len(m[0]) - 2, 0, -1): #jump the first 2 collumns char = seq[j + 1] #print "char:", char for i in range(1, len(m) - 1): # jump the begin and end states for l in range(len(m) - 2, 0, -1): #print "L:",statesCompl[l],", K:",statesCompl[i] m[i][j] += float(m[l][j + 1]) * float(backwardGraph["A"][ statesCompl[i], statesCompl[l]]) * float( backwardGraph["E"][statesCompl[l], char]) ''' print "partial value: ",float(m[i][j]) print "lines value:", float(m[l][j+1]) print "Alk: ",float(backwardGraph["A"][statesCompl[i],statesCompl[l]]) print "Elc: ", float(backwardGraph["E"][statesCompl[l],char])''' for l in range(1, len(m) - 1): m[0][0] += float(m[l][1]) * float( backwardGraph["A"]["0", statesCompl[l]]) * float( backwardGraph["E"][statesCompl[l], seq[1]]) '''print "psm: ",psm print "lines value:", float(m[l][j+1]) print "Alk: ",float(backwardGraph["A"]["0",statesCompl[l]]) print "Elc: ", float(backwardGraph["E"][statesCompl[l],seq[1]]) print "Char: ", seq[1]''' #matrix.printMatrix(m) return m
def forward(seq, filenameEmission, filenameTransmission): forwardGraph = graph.createGraph(filenameEmission, filenameTransmission) #print forwardGraph char = seq[1] states = forwardGraph["E"]["E", "States"] statesCompl = states[:] statesCompl.insert(0, "0") statesCompl.append("0") statesCompl = ["0", "Y", "N", "0"] print statesCompl m = matrix.createMatrix(len(states) + 2, len(seq), 0) # intialisation part matrix.atualiseValueIntoMatrix(m, 0, 0, 1) # recurrence part # recurrence 1 for i in range(1, len(m) - 1): m[i][1] = float(forwardGraph["A"]["0", statesCompl[i]]) * float( forwardGraph["E"][statesCompl[i], char]) # recurrence 2 for j in range(2, len(m[0]) - 1): #jump the first 2 collumns char = seq[j] for i in range(1, len(m) - 1): # jump the begin and end states for l in range(1, len(m) - 1): #print "L:",statesCompl[l],", K:",statesCompl[i] m[i][j] += float(m[l][j - 1]) * float( forwardGraph["A"][statesCompl[l], statesCompl[i]]) * float( forwardGraph["E"][statesCompl[i], char]) '''print "partial value: ",float(m[i][j]) print "lines value:", float(m[l][j-1]) print "AKL: ",float(forwardGraph["A"][statesCompl[l],statesCompl[i]]) print "Elc: ", float(forwardGraph["E"][statesCompl[i],char])''' for i in range(1, len(m) - 1): m[len(m) - 1][len(m[0]) - 1] += float(m[i][len(m[0]) - 2]) * float( forwardGraph["A"][statesCompl[i], "0"]) matrix.printMatrix(m) return m
def button4(): graph.createFunModuleGraph(lf, listOfFunNames, listOfFunCC) graph.create_function_graph(lf, listOfFunNames, listOfFunCC) graph.createGraph(lf) matplotlib.pyplot.show()
def graphWins(): graph.createGraph(countWins('p1_wins'), countWins('palt_wins'), countWins('d1_wins'), countWins('dalt_wins'))
total_blocking.append(0) else: total_blocking.append(block[i]/reqs[i]) return total_blocking for i in sched_pol: print("Executions of heuristic {}".format(i)) #begin the experiments for j in range(execution_times): print("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++") print("Execution #{} of heuristic {}".format(j,i)) print("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++") #simulation environment env = simpy.Environment() #create the graph gp = g.createGraph() #create the control plane cp = sim.Control_Plane(env, "Graph", gp, i, "fog_first") #traffic generator tg = sim.Traffic_Generator(env,sim.distribution, None, cp) #create the rrhs cp.createRRHs(g.rrhs_amount,env) random.shuffle(g.rrhs) #create fog nodes g.addFogNodes(gp, g.fogs) #add RRHs to the graph g.addRRHs(gp, 0, 64, "0") g.addRRHs(gp, 64, 128, "1") g.addRRHs(gp, 128, 192, "2") g.addRRHs(gp, 192, 256, "3") g.addRRHs(gp, 256, 320, "4")
import graph vertices = [0, 1, 2, 3, 4, 5] edges = ((5, 2), (5, 0), (4, 0), (4, 1), (2, 3), (3, 1)) adj = graph.createGraph(vertices, edges) print "Graph:", adj parent = {} def dfs(u, adj): for v in adj[u]: if v not in parent: parent[v] = u dfs(v, adj) def complete_dfs(vertices, adj): parent = {} for s in vertices: if s not in parent: parent[s] = None dfs(s, adj) return parent # try algorithm dfs(5, adj) print "DFS result (parent dictionary): ", parent
pair = pairs[hashKey] output = pair[0]+' '+pair[1] email = jointEmailsDict[hashKey] sorted_words, stemTokenDict = getImportantWords(email, myIDF, stemmer) sorted_words = [stemTokenDict[x[0]] for x in sorted_words] best_10_words = sorted_words[:10] #get the top 10 words based on frequency and IDF keywords = ' '.join(best_10_words) output += '\t'+keywords+'\n' pairFile.write(output) pairFile.close() if __name__ == '__main__': #get Enron graph [outNodes, sinkNodesSet, inNodes, sendReceiveDict] = graph.createGraph(GRAPH) #PAGERANK and HITS [AuthDict, HubDict] = hits.getHubsAuth(outNodes, inNodes, HUB_FILE, AUTH_FILE, ITERATIONS) pagerankDict = pageRank.getPageRank(outNodes, sinkNodesSet, ITERATIONS, PR_FILE, LAMBDA) #This part is useless unless GraphViz is installed if PRODUCE_GRAPH == True: #Take the union of people tempSet = set(pagerankDict.keys()).union(set(AuthDict.keys())) importantEmployees = tempSet.union(HubDict.keys()) #list of all emails of the important people #Remove useless pete davis importantEmployees.remove('*****@*****.**') #ROLES and EMAILS passed around roleDict = getRoles(ROLES)
def drawModel(model): createGraph(model["name"], model["activation_values"], model["weights"], model["biases"], ["Epoch #" + model["epochs"] + " RMSE", model["RMSE"]])
def main(): #no arguments if (len(sys.argv) == 1): helps() return # with one arguments if (len(sys.argv) == 2): argument = str(sys.argv[1]) if (argument == "ls"): listCurrentDayFood() return elif (argument == "dls"): detailedListCurrentDayFood() return elif (argument == "lsdb"): ListFoodInInventory() return elif (argument == "cal"): if (caloriesConsumed() == -1): print("calorie not set") return if (caloriesConsumed() == 0): print( f"set calorie : %d cal consumed : %d cal balanced : %d cal" % (getLimitCaloriesInDB(), getCalorieOfDay(), caloriesConsumed())) elif (caloriesConsumed() < 0): print( f"set calorie : %d cal consumed : %d cal surplus : +%d cal" % (getLimitCaloriesInDB(), getCalorieOfDay(), caloriesConsumed() * -1)) else: print( f"set calorie : %d cal consumed : %d cal deficit : -%d cal" % (getLimitCaloriesInDB(), getCalorieOfDay(), caloriesConsumed())) elif (argument == "graph"): createGraph() return elif (argument == "help"): helps() return else: print("invalid command") return #with two arguments if (len(sys.argv) == 3): argument = sys.argv[1] if (argument == "setcal"): try: setLimitCaloriesInDB(int(sys.argv[2])) print("calorie set") return except: print("invalid input") return if (argument == "rm"): removeFoodToUserStorage(sys.argv[2]) return if (argument == "rmdb"): removeFoodFromInventory(sys.argv[2]) return else: print("invalid command") return #with three arguments if (len(sys.argv) == 4): argument = sys.argv[1] if (argument == "add"): try: addFoodToUserStorage(sys.argv[2], int(sys.argv[3])) return except: print("invalid command") return else: print("invalid command") return #with five arguments #addFoodToInventory(foodName,carbs,protein,fat) if (len(sys.argv) == 6): argument = sys.argv[1] if (argument == "addtodb"): try: addFoodToInventory(sys.argv[2], int(sys.argv[3]), int(sys.argv[4]), int(sys.argv[5])) return except: print("invalid command") return else: print("invalid command") return #with six arguments if (len(sys.argv) == 7): argument = sys.argv[1] if (argument == "updateindb"): try: newname = sys.argv[3] if (sys.argv[3] != "-1") else -1 updateFoodInInventory(sys.argv[2], newname, int(sys.argv[4]), int(sys.argv[5]), int(sys.argv[6])) return except: print("invalid command") return else: print("invalid command") return else: print("invalid command") return
def button4(): graph.createFunModuleGraph(lf) graph.create_function_graph(lf) graph.createGraph(lf) matplotlib.pyplot.show()
def simulation(numTimeSteps, xSteps, ySteps, occupied, occupiedOld, totNumCells, xPos, yPos, deathTime, pro, proOld, densityScale, lamda, k, fib, vegf, ySubstrate, vegfOld, tolerance, h, xLength, fibOld, xVector, yVector, movement, maxCell, birthTime, divideTime): densityMax = 6 k18 = 0.55555555 k20 = 0.0496031736 k25 = 5736.899771 k26 = .00001859 m1 = 2 # child = 0.25 # 12 hours iteration 5400 child = 0.125 # 6 hours iteration 2700 # child = 0.0625 # 3 hours iteration 1350 fibThreshold = 0.6 workspace = zeros((ySteps, xSteps)) file = open("tracking_backtracks.txt", "w") file2 = open("prolif_death.txt", "w") # Cycle through time steps for time in range(numTimeSteps - 1): # Copy occupied into occupiedOld for x in range(xSteps): for y in range(ySteps): occupiedOld[y][x] = occupied[y][x] # Cycle through cells for cell in range(totNumCells): # At first assume no movement x = xPos[cell][time] y = yPos[cell][time] xPos[cell][time + 1] = x yPos[cell][time + 1] = y # If cell has left the capillary # not including dividing and death right now because it doesn't work with anastomosis #''' # DETERMINE IF CELL HAS DIVIDED OR DIED if deathTime[cell] == numTimeSteps - 1 and y > 0: # add statement to test if dead # cell dies/leaves simulation if it reaches the tumour if y == ySteps - 1: deathTime[cell] = time occupied[y][x] -= 1 # calculate average protease values at time and time-1 # surrounding mesh points usually equals 4 unless it is a boundary condition proMinus0 = 0 proMinus1 = 0 count = 0 #LEFT if x > 0: proMinus0 = proMinus0 + pro[2 * y][x - 1] proMinus1 = proMinus1 + proOld[2 * y][x - 1] count += 1 #RIGHT if x < xSteps - 1: proMinus0 = proMinus0 + pro[2 * y][x] proMinus1 = proMinus1 + proOld[2 * y][x] count += 1 #UP if y > 0: proMinus0 = proMinus0 + pro[2 * y - 1][x] proMinus1 = proMinus1 + proOld[2 * y - 1][x] count += 1 #DOWN if y < ySteps: proMinus0 = proMinus0 + pro[2 * y + 1][x - 1] proMinus1 = proMinus1 + proOld[2 * y + 1][x - 1] count += 1 proMinus0 = proMinus0 / count proMinus1 = proMinus1 / count # logistic term is always 0 becauce denScale times occupied is always greater than densitymax if densityScale * occupied[y][x] > densityMax: logistic = 0 else: logistic = 1 - densityScale * occupied[y][x] / densityMax G = k25 * (exp(-k26 * proMinus0**m1) * (1 - k26 * m1 * proMinus0**m1)) / ( 1 + k25 * proMinus0 * exp(-k26 * proMinus0**m1)) proDependent = G * (proMinus0 - proMinus1) / k if proDependent >= 0: # haven't figured out logistic term yet # divideProb = (k * k18 + G * logistic * (proMinus0 - proMinus1)) * \ # heaviside(time - divideTime[cell] - child * numTimeSteps) divideProb = (k * k18 + G * (proMinus0 - proMinus1)) * \ heaviside(time - divideTime[cell] - child * numTimeSteps) deathProb = k * k20 else: divideProb = k * k18 * heaviside(time - divideTime[cell] - child * numTimeSteps) deathProb = k * k20 - G * (proMinus0 - proMinus1) # not sure if I need this part #if divideProb < 0: # divideProb = 0 #if divideProb > 1 - deathProb: # divideProb = 1 randomNum = random() if randomNum < deathProb: file2.write("\n\nTIME: " + str(time) + "\n") file2.write("CELL: " + str(cell) + "\n") file2.write("cell position: y = " + str(y) + " x = " + str(x) + "\n") file2.write("average protease at time - 1 : " + str(proMinus1) + "\n") file2.write("average protease at time: " + str(proMinus0) + "\n") #file2.write("logistic growth term: " + str(logistic) + "\n") file2.write("Protease dependent term: " + str(proDependent) + "\n") file2.write("Probability of division: " + str(divideProb) + "\n") file2.write("Probability of death: " + str(deathProb) + "\n") file2.write("Probability of doing nothing: " + str(1 - deathProb - divideProb) + "\n") file2.write("random number: " + str(randomNum) + "\n") file2.write("G: " + str(G) + "\n") file2.write("CELL DIED") deathTime[cell] = time occupied[y][x] -= 1 createGraph(ySubstrate, xSteps, vegf, fib, pro, xVector, yVector, workspace, time) elif randomNum < deathProb + divideProb: if totNumCells >= maxCell: print("too many cells. DO NOT DIVIDE") elif totNumCells < maxCell: file2.write("\n\nTIME: " + str(time) + "\n") file2.write("CELL: " + str(cell) + "\n") file2.write("cell position: y = " + str(y) + " x = " + str(x) + "\n") file2.write("average protease at time - 1 : " + str(proMinus1) + "\n") file2.write("average protease at time: " + str(proMinus0) + "\n") #file2.write("logistic growth term: " + str(logistic) + "\n") file2.write("Protease dependent term: " + str(proDependent) + "\n") file2.write("Probability of division: " + str(divideProb) + "\n") file2.write("Probability of death: " + str(deathProb) + "\n") file2.write("Probability of doing nothing: " + str(1 - deathProb - divideProb) + "\n") file2.write("random number: " + str(randomNum) + "\n") file2.write("G: " + str(G) + "\n") file2.write("CELL DIVIDED") xPos[totNumCells][time + 1] = x yPos[totNumCells][time + 1] = y occupied[y][x] += 1 deathTime[totNumCells] = numTimeSteps - 1 birthTime[totNumCells] = time divideTime[cell] = time divideTime[totNumCells] = time totNumCells += 1 createGraph(ySubstrate, xSteps, vegf, fib, pro, xVector, yVector, workspace, time) # DETERMINE IF/WHERE THE CELL MOVES if deathTime[cell] == numTimeSteps - 1: stay = pStay(y, lamda, k) left, T = pMove(x, y, 0, pro, fib, vegf, xSteps, ySteps, lamda, k) right, T = pMove(x, y, 1, pro, fib, vegf, xSteps, ySteps, lamda, k) up, T = pMove(x, y, 2, pro, fib, vegf, xSteps, ySteps, lamda, k) rand = random() # Check if cell can escape the capillary if y == 0: if x == 0: fibcap = fib[0][0] elif x == xSteps - 1: fibcap = fib[0][xSteps - 2] else: fibcap = (fib[0][x - 1] + fib[0][x]) / 2 if fibcap < fibThreshold: rand = 2 file = move(cell, time, stay, left, right, up, rand, yPos, xPos, occupied, fib, vegf, pro, movement, file, T) ''' # ANASTOMOSIS if yPos[cell][time + 1] > 0: if workspace[yPos[cell][time + 1]][xPos[cell][time + 1]] != 0 and \ workspace[yPos[cell][time + 1]][xPos[cell][time + 1]] != cell + 2 and \ workspace[yPos[cell][time + 1]][xPos[cell][time + 1]] != cell + 3.5: print("cell ran into another capillary") deathTime[cell] = time + 1 occupied[yPos[cell][time + 1]][xPos[cell][time + 1]] -= 1 workspace[yPos[cell][time]][xPos[cell][time]] = cell + 2 workspace[yPos[cell][time + 1]][xPos[cell][time + 1]] = cell + 3.5 ''' # workspace without anastomosis workspace[yPos[cell][time]][xPos[cell][time]] = 1 workspace[yPos[cell][time + 1]][xPos[cell][time + 1]] = 5 total = 0 for cell in range(totNumCells): if deathTime[cell] != numTimeSteps - 1: total += 1 if total == totNumCells: print("ALL OF THE CELLS ARE DEAD") break updateVEGF(ySubstrate, xSteps, densityScale, occupiedOld, vegf, vegfOld, k, tolerance, h, xLength) updateFib(ySubstrate, xSteps, densityScale, occupiedOld, fib, fibOld, k, pro, tolerance, h) updatePro(ySubstrate, xSteps, densityScale, occupiedOld, pro, proOld, k, vegfOld) print("time = " + str(time)) if time % 500 == 0: createGraph(ySubstrate, xSteps, vegf, fib, pro, xVector, yVector, workspace, time) return
#!/usr/bin/env python3 import numpy as np import networkx as nx from graph import createGraph from algorithms import * if __name__ == "__main__": G = createGraph() print('###############') print('# DFS_low #####') print('###############') DFS_low(G, 0, 23) print('\n\n') print('#######################') print('# DFS_low_christopher #') print('#######################') DFS_low_CHRISTOPHER(G, 0, 23) print('\n\n') print('###############') print('# DFS_high #') print('###############') DFS_high(G, 0, 23) print('\n\n') print('########################')
def button3(): graph.createGraph(lf) matplotlib.pyplot.show()
def train( data=[[1], [2], [3]], targets=[[3], [2], [1]], layers=[1, 2, 1], output_bias=False, randWeightsLimits=[0, 1], activation_function=ReLU, cost_function=squared_error_CF, epochs=1, learning_rate=0.01, bias_learning_rate=None, pauseEpoch=False, pauseIteration=False, viz=[True, True, False] ): #[plainchart, graph at end of training, graph at start of epoch or iteration] #flexibility to have different learning rates for bias if bias_learning_rate == None: bias_learning_rate = learning_rate #set up neural network architecture weights, biases = cnn(layers, randWeightsLimits, output_bias) RMSEs = [] #run epochs print("Training " + activation_function.__name__ + " nn of layers " + str(layers)) RMSE = 0 for epoch in range(0, epochs): #restart error measurement squared_error_sum = 0 #shuffle the data and corresponding targets c = list(zip(data, targets)) random.shuffle(c) data, targets = zip(*c) #iterate over each data point print("Epoch " + str(epoch + 1) + "/" + str(epochs)) for data_x_targets_index in range(0, len(data)): #collect data points input_set = data[data_x_targets_index] target_set = targets[data_x_targets_index] #forward prop, back prop and update weights activation_values = forwardSingleDataPoint(input_set, weights, biases, activation_function) squared_error, weight_gradients, bias_gradients = backwardSingleDataPoint( activation_values, target_set, weights, activation_function, cost_function) if epoch == 0 and data_x_targets_index == 0 and viz[ 2] or pauseIteration: graph_name = activation_function.__name__ + " - Ep #" + str( epoch) + ", It #" + str( data_x_targets_index) + " @ lr " + str(learning_rate) createGraph(graph_name, activation_values, weights, biases, ["0.5 * error^2", squared_error]) if pauseIteration: print("weight gradients") print(weight_gradients) print("bias gradients") print(bias_gradients) input("Press Enter to start next iteration...") weights, biases = update(weights, biases, weight_gradients, bias_gradients, learning_rate, bias_learning_rate) #add to sum to calculate RMSE at end of epoch squared_error_sum += squared_error RMSE = (squared_error_sum / len(data))**(0.5) #print chart in terminal if epoch > 0: RMSEs.append(RMSE) print("RMSE :" + str(RMSE)) if pauseEpoch: print("weights") print(weights) print("biases") print(biases) print("weight gradients") print(weight_gradients) print("bias gradients") print(bias_gradients) input("Press Enter to start next epoch...") #print RMSE Chart if epochs > 1 and viz[0]: chart = plainchart.PlainChart(RMSEs, style=plainchart.PlainChart.scatter) print(chart.render()) #create nn graph graph_name = activation_function.__name__ + " - Epoch " + str( epochs) + ' @ lr ' + str(learning_rate) if viz[1]: print("Creating NN graph...") graph = createGraph(graph_name, activation_values, weights, biases, ["Epoch #" + str(epochs) + " RMSE", str(RMSE)]) #save model model = { "weights": weights, "biases": biases, "layers": layers, "lr": learning_rate, "af": str(activation_function), "cf": str(cost_function), "RMSE": RMSE, "name": graph_name, "activation_values": activation_values, "epochs": epochs } #notify print("Completed training of " + activation_function.__name__ + " nn of layers " + str(layers)) return model