def __init__(self, inputs, labels, featureName, featureNames, featureTypes, subset=[], boundary=None, operator=''): #Find the actual feature array based on the feature name colIndex = np.where(featureName == featureNames)[0][0] features = inputs[:, colIndex] #The key feature of noonterminal nodes is that they have a decision if featureTypes[colIndex] == 'string': #then the feature is of type categorical and the decision must be categorical self.decision = Decision.Categorical(featureName, subset) else: #else the feature is of type numerical and decision must be numerical self.decision = Decision.Numerical(featureName, operator, boundary) #create the true and false nodes, both unexplored, by filtering the #data to each node based on the decision trueIndices = np.vectorize(self.decision.function)(features) falseIndices = np.logical_not(trueIndices) self.trueNode = Node(inputs[trueIndices], labels[trueIndices], '') self.falseNode = Node(inputs[falseIndices], labels[falseIndices], '') #the node will never use its input field again, but the labels field #is needed for tree pruning Node.__init__(self, [], labels, self.decision.__str__(), 'decision')
def new_generate_agents(num_new_agent, agents): """ new agents generate in Move section """ #num_new_agent = rnd.randrange(num_new_generate) new_agents = [Agent_man() for new_agent_id in range(num_new_agent)] Move.state_task_for_new_agents(new_agents) Decision.initial_strategy(new_agents) for id, agent in enumerate(new_agents): print( f'new_agents No.{id}, state:{agent.state}, next_state:{agent.next_state}, strategy:{agent.strategy}, next_strategy:{agent.next_strategy}, task:{agent.task}' ) agents.extend(new_agents)
def __init__(self): self.loading = LoadingScreen(self) self.camera = Camera(self) self.lighting = Lighting(self) self.balltable = BallTable(self) self.menu = Menu(self) self.decision = Decision(self) self.mousekey = MouseKey(self) self.shotStrength = ShotStrength(self) self.state = GameState.START self.mode = GameMode.TUTORIAL self.balls = [Ball(self)] * 16 self.ballinHole = [None] * 16 self.LastFrameTimePoint = 0
def get_fitness(population): def mean_square_error(x,y): return np.sqrt(((x - y) ** 2).mean(axis=0)) fitness = [] for ind in population: ind = get_phenotype(ind,units_by_layer) aux_mean_error = 0 for (x,y) in S: aux_mean_error += mean_square_error(y,Decision.get_output_vector(units_by_layer,x,ind,factivation)) fitness.append(aux_mean_error) return fitness
def mainAI(self): """Run AI mode""" start = time.time() mainGrid = Grid() mainGrid.computerAddTile() aiPlayer = Decision() while not self.checkGameOver(mainGrid): print("\nCOMPUTER TURN:") mainGrid.computerAddTile() mainGrid.displayGrid() if not self.checkGameOver(mainGrid): move = aiPlayer.getMove(mainGrid) mainGrid.move(move) print("\nPLAYER TURN:") mainGrid.displayGrid() print("\nFINAL GRID:") mainGrid.displayGrid() end = time.time() scores = mainGrid.scores() print("Max score: ", mainGrid.getMaxTile()) print("Total time: ", end - start) return scores, end - start
def weaponMenuSelectWeapon(num, menu, char, wmenu): decision = Decision() panel = menu.panels[0] panel.clearOptions() panel.addOptions([Option("Yes", panel.osize, promptMenuYes, [decision]),\ Option("No", panel.osize, promptMenuNo, [decision])]) menu.addText("Equip?", 0, 0) try: menu.run() except SystemExit: pass if decision.bool: char.equipWeapon(num) wpanel = wmenu.panels[0] sel = wpanel.selected weapon = char.weapons[sel] weaponMenuPrintWeapon(weapon, wmenu, char)
def armorMenuSelectArmor(num, menu, char, amenu): decision = Decision() panel = menu.panels[0] panel.clearOptions() panel.addOptions([Option("Yes", panel.osize, promptMenuYes, [decision]),\ Option("No", panel.osize, promptMenuNo, [decision])]) menu.addText("Equip?", 0, 0) try: menu.run() except SystemExit: pass if decision.bool: char.equipArmor(num) apanel = amenu.panels[0] sel = apanel.selected armor = char.armors[sel] armorMenuPrintArmor(armor, amenu, char)
######## # Aprender vector theta # rho = 0.5 nu = 0.5 l = 1 theta1 = MLPLearning.back_propagation_batch(S,rho,units_by_layer,factivation,850,50) theta2 = MLPLearning.back_propagation_online(S,rho,units_by_layer,factivation,850,50) theta3 = MLPLearning.back_propagation_batch_momentum(S,rho,nu,units_by_layer,factivation,850,50) theta4 = MLPLearning.back_propagation_batch_buffer(S,rho,l,units_by_layer,factivation,850,50) theta5 = MLPLearning.back_propagation_online_buffer(S,rho,l,units_by_layer,factivation,850,50) theta6 = MLPLearning.back_propagation_online_momentum(S,rho,nu,units_by_layer,factivation,850,50) theta7,fitness = MLPLearning.evolutional(S,units_by_layer,factivation,200,500,-2,2,1.1,0.9) ############################## # Clasificacion # logging.info("Clase con theta1: (Backprop batch): "+str(Decision.classify(units_by_layer,[1.0,-6.3,1.0],theta1,factivation))) logging.info("Clase con theta2: (Backprop online): "+str(Decision.classify(units_by_layer,[1.0,-6.3,1.0],theta2,factivation))) logging.info("Clase con theta3: (Backprop batch con momentum): "+str(Decision.classify(units_by_layer,[1.0,-6.3,1.0],theta3,factivation))) logging.info("Clase con theta4: (Backprop batch con amortiguamiento): "+str(Decision.classify(units_by_layer,[1.0,-6.3,1.0],theta4,factivation))) logging.info("Clase con theta5: (Backprop online con amortiguamiento): "+str(Decision.classify(units_by_layer,[1.0,-6.3,1.0],theta5,factivation))) logging.info("Clase con theta6: (Backprop online con momentum): "+str(Decision.classify(units_by_layer,[1.0,-6.3,1.0],theta6,factivation))) logging.info("Clase con theta7: (Algoritmo genetico): "+str(Decision.classify(units_by_layer,[1.0,-5.0,1.0],theta7,factivation))+" fitness: "+str(fitness)) ################# # Regresion # logging.info("Regresion con theta1: (Backprop batch): "+str(Decision.regression(units_by_layer,[1.0,-6.3,1.0],theta1,factivation))) logging.info("Regresion con theta2: (Backprop online): "+str(Decision.regression(units_by_layer,[1.0,-6.3,1.0],theta2,factivation))) logging.info("Regresion con theta3: (Backprop batch con momentum): "+str(Decision.regression(units_by_layer,[1.0,-6.3,1.0],theta3,factivation))) logging.info("Regresion con theta4: (Backprop batch con amortiguamiento): "+str(Decision.regression(units_by_layer,[1.0,-6.3,1.0],theta4,factivation))) logging.info("Regresion con theta5: (Backprop online con amortiguamiento): "+str(Decision.regression(units_by_layer,[1.0,-6.3,1.0],theta5,factivation))) logging.info("Regresion con theta6: (Backprop online con momentum): "+str(Decision.regression(units_by_layer,[1.0,-6.3,1.0],theta6,factivation)))
class Game: ''' ''' def __init__(self): self.loading = LoadingScreen(self) self.camera = Camera(self) self.lighting = Lighting(self) self.balltable = BallTable(self) self.menu = Menu(self) self.decision = Decision(self) self.mousekey = MouseKey(self) self.shotStrength = ShotStrength(self) self.state = GameState.START self.mode = GameMode.TUTORIAL self.balls = [Ball(self)] * 16 self.ballinHole = [None] * 16 self.LastFrameTimePoint = 0 def Load(self): glutInit(sys.argv) glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH) glutInitWindowSize(ParamDef.ScreenResolution[0], ParamDef.ScreenResolution[1]) glutInitWindowPosition(0, 0) glutCreateWindow(APP_NAME) glClearColor(0, 0, 0, 0) glutIdleFunc(self.loading.Idle) glutDisplayFunc(self.loading.UpdateGL) self.currentWindow = glutGetWindow() glutMainLoop() def Run(self): ParamDef.DelayCompensation = 1 glutIgnoreKeyRepeat(1) glEnable(GL_DEPTH_TEST) glEnable(GL_CULL_FACE) glEnable(GL_NORMALIZE) glEnable(GL_BLEND) glShadeModel(GL_SMOOTH) glHint(GL_POLYGON_SMOOTH_HINT, GL_NICEST) glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST) glutMouseFunc(self.mousekey.MouseClick) glutMotionFunc(self.mousekey.MouseMove) glutKeyboardFunc(self.mousekey.KeyPress) glutKeyboardUpFunc(self.mousekey.KeyRelease) glutSpecialFunc(self.mousekey.SpecialKeyPress) glutSpecialUpFunc(self.mousekey.SpecialKeyRelease) glutVisibilityFunc(self.Visible) glutIdleFunc(self.timerEvent) glutDisplayFunc(self.updateGL) def timerEvent(self): #print "timerEvent" ParamDef.FrameTimePoint = glutGet(GLUT_ELAPSED_TIME) / 10 ParamDef.Factor = ParamDef.FrameTimePoint - self.LastFrameTimePoint if (ParamDef.DelayCompensation != 0): ParamDef.Factor = 1 ParamDef.DelayCompensation = 0 if (ParamDef.Factor != 0): if (ParamDef.ShowFPS): if ((ParamDef.FrameTimePoint % 200) < (self.LastFrameTimePoint % 200)): self.menu.SetFPS(Frames / 2) ParamDef.Frames = 0 else: ParamDef.Frames += 1 self.menu.Update(ParamDef.Factor) if self.state == GameState.START: self.StartHandling() elif self.state == GameState.VIEWING: self.ViewingHandling() elif self.state == GameState.AIMING: self.AimHandling() elif self.state == GameState.SWING: self.BackswingHandling() elif self.state == GameState.SHOT: self.ShotHandling() elif self.state == GameState.NEW_WHITE: self.NewWhiteHandling() elif self.state == GameState.JUDGEING: self.JudgeHandling() self.camera.Ride(ParamDef.Factor) self.LastFrameTimePoint = ParamDef.FrameTimePoint glutPostWindowRedisplay(self.currentWindow) def updateGL(self): ''' ''' #print "updateGL" if ParamDef.ZBufferDelete != 0: glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) self.camera.draw() self.lighting.draw() self.balltable.drawSurface() glDisable(GL_DEPTH_TEST) self.balltable.drawLine() for ball in self.balls: ball.drawShadow() glEnable(GL_DEPTH_TEST) self.balltable.drawBorder() distance = 0 #distance resolution = 1 #Display resolution for ball in self.balls: x = ball.Pos_xCM() - self.camera.Pos_x y = ball.Pos_yCM() - self.camera.Pos_y z = self.camera.Pos_z distance = sqrt(x * x + y * y + z * z) resolution = (400 / distance) if (resolution < 3): resolution = 3 resolution = (resolution / 2) * 2 + 1 if (resolution > ParamDef.BallResolution): resolution = ParamDef.BallResolution ball.draw(resolution) glDisable(GL_DEPTH_TEST) glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) glDisable(GL_LIGHTING) self.menu.draw() if (self.state != GameState.START): self.shotStrength.draw() glEnable(GL_DEPTH_TEST) glutSwapBuffers() def Visible(self, visible): print "Visible" if (visible == GLUT_VISIBLE): glutIdleFunc(self.timerEvent) def StartHandling(self): self.camera.ScenicFlight(ParamDef.Factor) self.menu.Update(ParamDef.Factor) def ViewingHandling(self): self.menu.Update(ParamDef.Factor) if (KEY_UP): self.camera.Move_Front(ParamDef.Factor) if (KEY_DOWN): self.camera.Move_Back(ParamDef.Factor) if (KEY_RIGHT): self.camera.Move_Right(ParamDef.Factor) if (KEY_LEFT): self.camera.Move_Left(ParamDef.Factor) if (KEY_SHIFT): self.camera.Move_Up(ParamDef.Factor) if (KEY_CTRL): self.camera.Move_Down(ParamDef.Factor) if (KEY_PAGE_UP): self.camera.Move_In(ParamDef.Factor) if (KEY_PAGE_DOWN): self.camera.Move_Out(ParamDef.Factor) if (KEY_HOME): self.camera.Zoom_In(ParamDef.Factor) if (KEY_END): self.camera.Zoom_Out(ParamDef.Factor) ''' * Aim Handling ''' def AimHandling(self): if (KEY_UP): self.camera.Move_In(ParamDef.Factor) if (KEY_DOWN): self.camera.Move_Out(ParamDef.Factor) if (KEY_RIGHT): self.camera.SwingRight(2 * ParamDef.Factor, self.balls[0].Pos_xCM(), self.balls[0].Pos_yCM()) if (KEY_LEFT): self.camera.SwingLeft(2 * ParamDef.Factor, self.balls[0].Pos_xCM(), self.balls[0].Pos_yCM()) if (KEY_SHIFT): self.camera.SwingDown(ParamDef.Factor, self.balls[0].Pos_xCM(), self.balls[0].Pos_yCM()) if (KEY_CTRL): self.camera.SwingUp(ParamDef.Factor, self.balls[0].Pos_xCM(), self.balls[0].Pos_yCM()) if (KEY_PAGE_UP): self.camera.Move_In(ParamDef.Factor) if (KEY_PAGE_DOWN): self.camera.Move_Out(ParamDef.Factor) if (KEY_HOME): self.camera.Vertigo_In(ParamDef.Factor) if (KEY_END): self.camera.Vertigo_Out(ParamDef.Factor) def BackswingHandling(self): ''' ''' if (KEY_UP): self.camera.Move_In(ParamDef.Factor) if (KEY_DOWN): self.camera.Move_Out(ParamDef.Factor) if (KEY_RIGHT): self.camera.SwingRight(2 * ParamDef.Factor, self.balls[0].Pos_xCM(), self.balls[0].Pos_yCM()) if (KEY_LEFT): self.camera.SwingLeft(2 * ParamDef.Factor, self.balls[0].Pos_xCM(), self.balls[0].Pos_yCM()) if (KEY_SHIFT): self.camera.SwingDown(ParamDef.Factor, self.balls[0].Pos_xCM(), self.balls[0].Pos_yCM()) if (KEY_CTRL): self.camera.SwingUp(ParamDef.Factor, self.balls[0].Pos_xCM(), self.balls[0].Pos_yCM()) if (KEY_PAGE_UP): self.camera.Move_In(ParamDef.Factor) if (KEY_PAGE_DOWN): self.camera.Move_Out(ParamDef.Factor) if (KEY_HOME): self.camera.Zoom_In(ParamDef.Factor) if (KEY_END): self.camera.Zoom_Out(ParamDef.Factor) shotStrength = MaxAusholStaerke * (1 - exp( (-ParamDef.FrameTimePoint + ParamDef.ShotStartTime) / 400.0)) self.ShotStrength.setShockStrength(shotStrength / 3.333) ''' * 击球处理 * ''' def ShotHandling(self): FirstShot = 0 #WeisseVersetzbar=0; if (KEY_UP): self.camera.Move_Front(ParamDef.Factor) if (KEY_DOWN): self.camera.Move_Back(ParamDef.Factor) if (KEY_RIGHT): self.camera.Move_Right(ParamDef.Factor) if (KEY_LEFT): self.camera.Move_Left(ParamDef.Factor) if (KEY_SHIFT): self.camera.Move_Up(ParamDef.Factor) if (KEY_CTRL): self.camera.Move_Down(ParamDef.Factor) if (KEY_PAGE_UP): self.camera.Move_In(ParamDef.Factor) if (KEY_PAGE_DOWN): self.camera.Move_Out(ParamDef.Factor) if (KEY_HOME): self.camera.Zoom_In(ParamDef.Factor) if (KEY_END): self.camera.Zoom_Out(ParamDef.Factor) #Frames++; # F"ur die Frames/sec-Anzeige # Zeit seit Stossbeginn time = ParamDef.FrameTimePoint - ParamDef.StartTime #time # Letzten Zustand noch zeichnen, wenn Stoss if (time > ParamDef.ShotTime): time = ParamDef.ShotTime # eigentlich schon vorbei #printf("%i-%i=%i: ",FrameZeitpunkt,Startzeit,Zeit); for i in range(16): # Alle Kugeln neu positionieren if (LightingList[time][i][2] <= 0): self.balls[i].newPositionD(LightingList[Zeit][i]) self.ShotStrength.setShockStrength(shotStrength / 3.333 - Zeit / 3.0) if (not (time & 31)): neu = 0 for i in range(16): if (self.ballsInGame[i] and self.ballsInHole[i] != 0 and (self.balls[i].Pos_x() == 3000)): self.ballsInHole[i] = 1 neu = 1 if (neu): self.menu.NewMenuState() if (time == ParamDef.ShotTime and not (self.mode == GameMode.TUTORIAL and ParamDef.FrameTimePoint - ParamDef.StartTime < 1900)): # Animation schon fertig? ##ifndef _WIN32 #printf(" %f Frames/sec\n",(Frames*100.0)/(Stossdauer+1.0)); ##endif for i in range(16): if (self.ballssInGame[i] and not self.ballssInHole[i] and (self.balls[i].Pos_x() == 3000)): self.ballssInHole[i] = 1 if (self.mode == GameMode.TRAINING or self.mode == GameMode.TUTORIAL): if (self.balls[0].Pos_x() == 3000): self.state = GameState.NEW_WHITE ShotStrength.setShockStrength(0.0) ParamDef.LageVerbesserung = 1 ParamDef.LageVerbesserungKopffeld = 1 WhiteChosen() self.menu.NewMenuState() else: self.state = GameState.VIEWING ShotStrength.setShockStrength(0.0) self.menu.NewMenuState() elif self.decision.Decisioning() == 0: self.state = GameState.JUDGEING ShotStrength.setShockStrength(0.0) else: self.state = GameState.VIEWING self.shotStrength.setShockStrength(0.0) self.menu.NewMenuState() ''' * 放置白球 ''' def NewWhiteHandling(self): if (self.mode == GameMode.TRAINING): #ParamDef. LageVerbesserungKopffeld = 0 #Location improving header LageVerbesserung = 1 x = self.balls[0].Pos_xCM() y = self.balls[0].Pos_yCM() self.Factor2 = sqrt((self.balls[0].Pos_xCM() - self.camera.Pos_xCM()) * (self.balls[0].Pos_xCM() - self.camera.Pos_xCM()) + (self.balls[0].Pos_yCM() - self.camera.Pos_yCM()) * (self.balls[0].Pos_yCM() - self.camera.Pos_yCM()) + self.camera.Pos_zCM() * self.camera.Pos_zCM()) self.Factor2 *= .005 if (KEY_UP): x += .3 * Factor * Faktor2 * sin(self.camera.Beta * M_PI / 180.0) y += .3 * Factor * Faktor2 * cos(self.camera.Beta * M_PI / 180.0) if (KEY_DOWN): x -= .3 * Factor * Faktor2 * sin(self.camera.Beta * M_PI / 180.0) y -= .3 * Factor * Faktor2 * cos(self.camera.Beta * M_PI / 180.0) if (KEY_LEFT): x -= .3 * Factor * Faktor2 * cos(self.camera.Beta * M_PI / 180.0) y += .3 * Factor * Faktor2 * sin(self.camera.Beta * M_PI / 180.0) if (KEY_RIGHT): x += .3 * Factor * Faktor2 * cos(self.camera.Beta * M_PI / 180.0) y -= .3 * Factor * Faktor2 * sin(self.camera.Beta * M_PI / 180.0) invalid = 0 if (x < -124 or x > 124 or (x > -63.5 and LageVerbesserungKopffeld)): x = self.balls[0].Pos_xCM() if (y < -60.5 or y > 60.5): y = self.balls[0].Pos_yCM() for i in range(16): if ((self.balls[i].Pos_xCM() - x) * (self.balls[i].Pos_xCM() - x) + (self.balls[i].Pos_yCM() - y) * (self.balls[i].Pos_yCM() - y) < 32.7): invalid = 1 #与其他球太近,无效 #invalid if (not invalid): self.self.balls[0].newPositionCM(x, y) if (KEY_SHIFT): self.camera.Move_Up(Factor) if (KEY_CTRL): self.camera.Move_Down(Factor) if (KEY_PAGE_UP): self.camera.Move_In(Factor) if (KEY_PAGE_DOWN): self.camera.Move_Out(Factor) if (KEY_HOME): self.camera.Zoom_In(Factor) if (KEY_END): self.camera.Zoom_Out(Factor) def JudgeHandling(self): if (ParamDef.JudgeDecision == -1): ParamDef.JudgeDecision = Judge.Decisioning() ParamDef.RecodingChanges = ParamDef.JudgeDecision & 1 ParamDef.Foul = ParamDef.JudgeDecision & 2 ParamDef.LageVerbesserungKopffeld = ParamDef.JudgeDecision & 4 ParamDef.LageVerbesserung = ParamDef.JudgeDecision & 8 ParamDef.NeuAufbauenOderWeiterspielen = ParamDef.JudgeDecision & 16 ParamDef.NeuAufbauenOderAchtEinsetzen = ParamDef.JudgeDecision & 32 ParamDef.Player1Win = ParamDef.JudgeDecision & 64 ParamDef.Player2Win = ParamDef.JudgeDecision & 128 self.menu.NewMenuState()
def back_propagation_online_momentum(S,rho,nu,units_by_layer,factivation,max_it=250,report_it=50): k = 0 # it delta = [] # Errores # Inicializar pesos a 0 # theta = [] for l in xrange(1,len(units_by_layer)): theta.append([]) if l-1==0: sm = units_by_layer[l-1] else: sm = units_by_layer[l-1]+1 for i in xrange(units_by_layer[l]): theta[-1].append(np.zeros(sm)) # Inicializar incr_theta_ant # incr_theta_ant = [] for l in xrange(1,len(units_by_layer)): incr_theta_ant.append([]) if l-1==0: sm = units_by_layer[l-1] else: sm = units_by_layer[l-1]+1 for i in xrange(units_by_layer[l]): incr_theta_ant [-1].append(np.zeros(sm)) # Plot # if Config.VERBOSE: color_classes = [Config.COLORS[c%len(Config.COLORS)]+Config.STYLE[c%len(Config.STYLE)] for c in xrange(len(S[0][1]))] # Mientras no converja # while k<max_it: # Inicializar delta # delta = [] for l in xrange(1,len(units_by_layer)): delta.append([]) for i in xrange(units_by_layer[l]): delta[-1].append(0) # Para cada muestra # m = 0 # N muestra for (xk,tk) in S: # Inicializar incr_theta a cada muestra # incr_theta = [] for l in xrange(1,len(units_by_layer)): incr_theta.append([]) if l-1==0: sm = units_by_layer[l-1] else: sm = units_by_layer[l-1]+1 for i in xrange(units_by_layer[l]): incr_theta[-1].append(np.zeros(sm)) ########################## phi,s = forward_propagation(units_by_layer,xk,theta,factivation) # Desde la salida a la entrada # for l in xrange(len(units_by_layer)-1,0,-1): # Para cada nodo # for i in xrange(units_by_layer[l]): ########## Calcular delta ########### if l==len(units_by_layer)-1: delta[l-1][i] = (factivation[l-1][i][1](phi[l-1][i])*(tk[i]-s[l][i])) else: delta[l-1][i] += factivation[l-1][i][1](phi[l-1][i])*sum([delta[l][r]*theta[l][r][i+1] for r in xrange(units_by_layer[l+1])]) ##################################### if l==len(units_by_layer)-1: # Calcular incr_theta (capa salida) # incr_theta[l-1][i][0] += delta[l-1][i] for j in xrange(units_by_layer[l-1]): incr_theta[l-1][i][j+1] += delta[l-1][i]*s[l-1][j] ##################################### else: # Calcular incr_theta (capas ocultas) # for j in xrange(units_by_layer[l-1]): if j==0: incr_theta[l-1][i][j] += delta[l-1][i] else: incr_theta[l-1][i][j] += delta[l-1][i]*s[l-1][j] ##################################### # Actualizaciones # for l in xrange(len(theta)): for i in xrange(len(theta[l])): # Actualizar los pesos # theta[l][i] += (rho*incr_theta[l][i]) + (nu*incr_theta_ant[l][i]) # Actualizar incr_theta_ant # incr_theta_ant[l][i] = (rho*incr_theta[l][i]) + (nu*incr_theta_ant[l][i]) m += 1 # Plot de las muestras # if Config.VERBOSE: if k%report_it==0: plt.clf() plt.ylabel("Y") plt.xlabel("X") maxX = float("-inf") maxY = float("-inf") plt.title("Iteracion backprop online con momentum: "+str(k)) for (xk,tk) in S: predicted_tk = Decision.classify(units_by_layer,xk,theta,factivation) plt.plot(xk[1],xk[2],color_classes[predicted_tk]) if xk[1]>maxX: maxX = xk[1] if xk[2]>maxY: maxY = xk[2] plt.axis([-maxX,2*maxX,-maxY,2*maxY]) plt.show(block=False) print "Siguientes ",report_it," iteraciones [Enter]" raw_input() plt.close() k += 1 return theta
theta3 = MLPLearning.back_propagation_batch_momentum( S, rho, nu, units_by_layer, factivation, 850, 50) theta4 = MLPLearning.back_propagation_batch_buffer(S, rho, l, units_by_layer, factivation, 850, 50) theta5 = MLPLearning.back_propagation_online_buffer( S, rho, l, units_by_layer, factivation, 850, 50) theta6 = MLPLearning.back_propagation_online_momentum( S, rho, nu, units_by_layer, factivation, 850, 50) theta7, fitness = MLPLearning.evolutional(S, units_by_layer, factivation, 200, 500, -2, 2, 1.1, 0.9) ############################## # Clasificacion # logging.info("Clase con theta1: (Backprop batch): " + str( Decision.classify(units_by_layer, [1.0, -6.3, 1.0], theta1, factivation))) logging.info("Clase con theta2: (Backprop online): " + str( Decision.classify(units_by_layer, [1.0, -6.3, 1.0], theta2, factivation))) logging.info("Clase con theta3: (Backprop batch con momentum): " + str( Decision.classify(units_by_layer, [1.0, -6.3, 1.0], theta3, factivation))) logging.info("Clase con theta4: (Backprop batch con amortiguamiento): " + str( Decision.classify(units_by_layer, [1.0, -6.3, 1.0], theta4, factivation))) logging.info("Clase con theta5: (Backprop online con amortiguamiento): " + str( Decision.classify(units_by_layer, [1.0, -6.3, 1.0], theta5, factivation))) logging.info("Clase con theta6: (Backprop online con momentum): " + str(
import numpy as np import Perception import Decision import Memory import random import gym import Learning import math import naoenvSimulation import matplotlib.pyplot as plt camera = Perception.Camera() memory = Memory.Memory(camera) Perc = Perception.Ball(memory) learning = Learning.Learning(memory) Dec = Decision.Decision(memory, learning) def createEnvironment(numberOfPossibleBalls, environment, center): #create some balls ball = [0, 0] gaze = [0, 0] while gaze[0] == 0 or gaze[1] == 0: ball[0] = random.randrange(environment[0], environment[1], 1) ball[1] = random.randrange(environment[2], environment[3], 1) #create the gaze gaze = [ball[0] - center[0], ball[1] - center[1]] #find the direction of the gaze directionx = 1 directiony = 1
def selectBestFeature(inputs, labels, impurityCat, impurityNum, featuresToConsider, featureNames, featureTypes, numIntervals, seed=0): random.seed(seed) if featuresToConsider > inputs.shape[1] or featuresToConsider < 0: Exception('featuresToConsider must be between 0 and {maxx}'.format( maxx=featuresToConsider)) possibleFeatures = np.random.choice(featureNames, featuresToConsider, False) bestImpurity = np.inf bestSplit = ('', '', '' ) #in the form (featureName, isCategorical, arguements) for name in possibleFeatures: colIndex = np.where(name == featureNames)[0][0] vals = inputs[:, colIndex] isCategorical = False if featureTypes[colIndex] == 'string': isCategorical = True if isCategorical: #if the feature is categorical, compute a split for each possible #value and pick the maximum one subset = [] splitImpurity = bestImpurity for cat in np.unique(vals): dec = Decision.Categorical(name, [cat]) trueIndices = np.vectorize(dec.function)(vals) falseIndices = np.logical_not(trueIndices) trueNodeImpurity = impurityResubLabel( labels[trueIndices], impurityCat, impurityNum, sum(trueIndices) / len(labels)) falseNodeImpurity = impurityResubLabel( labels[falseIndices], impurityCat, impurityNum, sum(falseIndices) / len(labels)) if splitImpurity > trueNodeImpurity + falseNodeImpurity: subset = [cat] splitImpurity = trueNodeImpurity + falseNodeImpurity split = (name, True, subset) else: #else the feature is numerical. In that case I discretize the #continuous features into "numIntervals" bins or #however many intervals are possible. def findReImpurityGivenBoundary(bound): lessBound = labels[vals <= bound] moreBound = labels[vals > bound] trueNodeReImpurity = impurityResubLabel( lessBound, impurityCat, impurityNum, len(lessBound) / len(labels)) falseNodeReImpurity = impurityResubLabel( moreBound, impurityCat, impurityNum, len(moreBound) / len(labels)) return trueNodeReImpurity + falseNodeReImpurity numIntervalsForContinuousFeat = min(numIntervals, inputs.shape[0]) possibleBounds = [ max(i) for i in np.array_split(np.sort(vals), numIntervalsForContinuousFeat) ] possibleBounds = np.array(possibleBounds) splitImpurity = np.inf bestBoundary = 0 for bound in possibleBounds: imp = findReImpurityGivenBoundary(bound) if splitImpurity > imp: splitImpurity = imp bestBoundary = bound split = (name, False, ('less', bestBoundary)) if bestImpurity > splitImpurity: bestImpurity = splitImpurity bestSplit = split return bestSplit
print "error was ", e sys.exit(1) # disable ALAutonomousMoves bug am = ALProxy("ALAutonomousMoves", ip, port) am.setExpressiveListeningEnabled(False) am.setBackgroundStrategy("none") #######Global classes####### camera = Perc.Camera() memory = memo.Memory(camera) facePerception = Perc.Face(memory) gazeFollowing = Perc.Gaze(memory) ballPerception = Perc.Ball(memory) learning = Learn.Learning(memory) decision = Deci.Decision(memory, learning) motivation = Moti.Motivation(memory) motorControl = MC.MotorControl(motionProxy, memory, facePerception, tts) ################################################################ # Main functions ################################################################ def setup(): say("Setting up") postureProxy.goToPosture("Crouch", 0.6667) def say(text): tts.say(text)
def main(): ###Calcualtion setting ### #low:100, 30 #medium:130, 60 #high: 160, 100 num_agent = 160 """ average_range beta gamma param_ramge """ max_season = 37 list_state = [] list_task = [] result_list_state = [] result_list_task = [] state_to_nextstate = [] list_Gr = [] list_Cl = [] list_Rt = [] list_Cf = [] list_Mg = [] info = pd.DataFrame({ 'Gr': [], 'Cl': [], 'Rt': [], 'Cf': [], 'Mg': [], 'New': [], 's0': [], 'Sa': [], 'sA': [], 'sB': [], 'sC': [] }) #initialization of ramdom int num_new_agent = 0 #Prepare agents & initialize state & task &strategy agents = Agent_man.generate_agents(num_agent) agents_store = Agent_store.generate_agent_store(5) Agent_store.init_agent_store(agents_store) Agent_store.show_store_info(agents_store) Move.initialize_state_task(agents) Decision.initial_strategy(agents) #Agent_man.show_agent_info(agents) for season in range(1, max_season): print('###########################') print(f'simulate season:{season}') if season != 1 and season != max_season - 1: num_new_agent = rnd.randint(1, 100) #generate new agents print('==== generate new agents ====') Agent_man.new_generate_agents(num_new_agent, agents) #move next_state print('===== agent move =====') Move.agents_moves(agents, season) #divide visitor per stores list_Gr, list_Cl, list_Rt, list_Cf, list_Mg = Manage_store.divide_visitor( agents) if season == 1: #manage instore & waiting for 1st season Manage_store.manage_instore_waiting_first(agents, agents_store, list_Gr, 'Gr') Manage_store.manage_instore_waiting_first(agents, agents_store, list_Cl, 'Cl') Manage_store.manage_instore_waiting_first(agents, agents_store, list_Rt, 'Rt') Manage_store.manage_instore_waiting_first(agents, agents_store, list_Cf, 'Cf') Manage_store.manage_instore_waiting_first(agents, agents_store, list_Mg, 'Mg') if season != 1: Manage_store.manage_instore_waiting_second(agents, agents_store, list_Gr, 'Gr') Manage_store.manage_instore_waiting_second(agents, agents_store, list_Cl, 'Cl') Manage_store.manage_instore_waiting_second(agents, agents_store, list_Rt, 'Rt') Manage_store.manage_instore_waiting_second(agents, agents_store, list_Cf, 'Cf') Manage_store.manage_instore_waiting_second(agents, agents_store, list_Mg, 'Mg') #Agent_man.show_agent_info(agents) #strategy determine next_state print('==== decide next state ====') Decision.strategy_determine_state(agents, agents_store) #agents determine next_strategy print('==== decide next strategy ====') Decision.decide_next_strategy(agents) print('==== insert next strategy into strategy ====') Decision.insert_strategy(agents) Gr, Cl, Rt, Cf, Mg, s0 = Move.count_state_num(agents) Sa = Move.count_store_all(agents) sA, sB, sC = Decision.count_strategy(agents) new_info = pd.DataFrame( [[Gr, Cl, Rt, Cf, Mg, num_new_agent, s0, Sa, sA, sB, sC]], columns=[ 'Gr', 'Cl', 'Rt', 'Cf', 'Mg', 'New', 's0', 'Sa', 'sA', 'sB', 'sC' ]) #new_info = pd.DataFrame([[format(Gr, '.4'),format(Cl,'.4'),format(Rt,'.4'),format(Cf,'.4'),format(Mg,'.4'),num_new_agent,format(s0,'.4'),Sa,sA,sB,sC]],columns=['Gr','Cl','Rt','Cf','Mg','New','s0','Sa','sA','sB','sC']) info = info.append(new_info) #print(f'info:{info}') #infomation of state store result_list_state for id, agent in enumerate(agents): list_state.append(agent.state + '_' + agent.status) list_task.append(agent.task) #print(f'list_state:{list_state}') #print(f'result_list_state:{result_list_state}') result_list_state.append(list_state) result_list_task.append(list_task) #print(f'result_list_state:{result_list_state}') list_state = [] list_task = [] list_Gr = [] list_Cl = [] list_Rt = [] list_Cf = [] list_Mg = [] #print(f'list_state:{list_state}') state = pd.DataFrame(result_list_state) task = pd.DataFrame(result_list_task) print(f'result:{state}') #ディレクトリの変更必須!!! state.to_csv(f'result/high/result_list_state_high.csv') task.to_csv(f'result/high/result_list_task_high.csv') info.to_csv(f'result/high/result_info_high.csv')