pygame.display.set_caption("Game") # Create player player = bird.Bird(SCREEN_HEIGHT, DISPLAYSURF, WHITE) # Create pipe array pipes = [] pipes.append(pipe.Pipe(SCREEN_HEIGHT, SCREEN_WIDTH, DISPLAYSURF, WHITE)) # Pipe spawner pipe_delay = 2000 # 2 seconds new_pipe = pygame.USEREVENT + 1 pygame.time.set_timer(new_pipe, pipe_delay) # Create brain brain = brain.Brain() # Sprite groups # all_sprites = pygame.sprit # Game Loop while True: # Refresh background DISPLAYSURF.fill(BLACK) # Cycles through all occurring events for event in pygame.event.get(): if event.type == QUIT: pygame.quit() sys.exit() if event.type == pygame.KEYDOWN:
#maybe make a phrase class? #get rid of the r in front of the MEMORY_PATH home = r'C:\Users\Brandon\Documents\Personal Projects\chatbot\memoryTEST2.csv' work = r'C:\Users\valleba\Documents\personal\chatbot\memoryTEST5.csv' startUpPacket = { 'MEMORY_PATH': work,#C:\Users\valleba\Documents\personal\chatbot\memoryTEST.csv 'COMMAND_LIST': ['print memory','backup memory', 'end', 'test'],#belong here???????????? 'PUNC_LIST': ['.','?','!'], 'PRE_CB_UI_STR': ' ', #befor chatbot response 'POST_CB_UI_STR': ' :', #after chatbot response #rename!!!!!!!!!!!!!! 'POST_SENT_SPACE': ' ', #num spaces after sentance 'OG_GREETINGS': ['Hi!', 'Howdy Partner!', 'Well hello there.'] } #make chatbot chatbot = brain.Brain(startUpPacket) # chatbot.buildNewMem()#!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #greet user and get first response #greeting = chatbot.getGreeting() #inPhrase = input(greeting + chatbot.POST_CB_UI_STR) contConvo = True #start loop while chatbot.endProgram == False: #form outPhrase if contConvo == True: if chatbot.numResponses == 0: outPhrase = chatbot.getGreeting() else:
x2, y2 = (l+1)*SCALE_X, w*SCALE_Y circle = pyplot.Circle((x2, y2), radius=RAD, fill=False) pyplot.gca().add_patch(circle) line = pyplot.Line2D((x, x2), (y, y2), linewidth=abs(weight), color="r" if weight < 0 else "g") pyplot.gca().add_line(line) pyplot.axis('scaled') pyplot.axis('off') pyplot.title('Neural Network architecture', fontsize=15) pyplot.show() if os.path.exists(SAVE_FP): print("Loading brain from save file...") grid = snake.Grid() creatures = [main.Creature(brain.Brain(load=SAVE_FP), grid) for c in range(2)] while True: for i,c in enumerate(creatures): if not c.dead: c.step() else: c.snake.clear() creatures[i] = main.Creature(brain.Brain(load=SAVE_FP), grid) main.draw(grid) time.sleep(0.06)
def init(self, images): for im in images: self.images.append(br.Brain(im))
import brain import time import datetime from dapai import restart, restartJingYing from subprocess import call def screencap(): cmd = r"adb shell screencap | perl -pe 's/\x0D\x0A/\x0A/g' > data/screenshot.raw;" p1 = call(cmd, shell=True) screencap() e = env.Env() b = brain.Brain() print '-------------Begin working---------------' my_turn_round = 0 empty_operation = 0 # restartJingYing() # fn = 'record/' + str(datetime.datetime.now())[:-7] + '.png' # e.im.rotate(90).crop((800,230,1300,650)).save(fn) while True: print '-----------------------------------------' screencap() try: e.getImage() if e.canChupai() == 0: print 'empty_operation: ', empty_operation
#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ @author: yanickdupuisbinette """ import brain parameters = {'batch_size': [32], 'epochs': [100], 'optimizer': ['adam']} onehot_encoder = ['Geography', 'Gender'] standard_scaler = [ 'CreditScore', 'Age', 'Tenure', 'Balance', 'NumOfProducts', 'HasCrCard', 'IsActiveMember', 'EstimatedSalary' ] delete_data = [0, 3] layer_and_units = [6, 8] new_brain = brain.Brain(parameters=parameters, dataset='data/Churn_Modelling.csv', delete_data=delete_data, layer_and_units=layer_and_units, onehot_encoder=onehot_encoder, standard_scaler=standard_scaler) best_parameters, best_accuracy, cm = new_brain.search()
import json from flask import Flask, url_for from flask import request from flask import render_template from flask import jsonify import brain app = Flask(__name__, static_url_path='/static') brain_ai = brain.Brain() @app.route("/", methods=['GET']) def page(): return render_template('index.html') @app.route('/send', methods=["POST"]) def send(): request.get_data() inmsg = request.form['user_input'] out = {"message": str(inmsg)} return jsonify(out) @app.route('/respond', methods=['POST']) def process(): request.get_data() message = request.form['user_input']
# default xavier init for m in policy_net.modules(): if isinstance(m, (nn.Conv2d, nn.Linear)): nn.init.xavier_uniform(m.weight, gain=nn.init.calculate_gain('relu')) # if the model file exists, load it if os.path.isfile("vrep_arm_model.pt") and CONTINUE_TRAINING: policy_net.load_state_dict(torch.load('vrep_arm_model.pt')) target_net1.load_state_dict(torch.load('vrep_arm_model_target1.pt')) target_net2.load_state_dict(torch.load('vrep_arm_model_target2.pt')) print("loaded existing model file") br = brain.Brain(simulator=None, policy_net=policy_net, target_net1=target_net1, target_net2=target_net2, memory_size=MEMORY_SIZE, value_net_trainer=value_net_trainer, state_is_image=STATE_IS_IMAGE, use_value_net=USE_VALUE_NET) N_EPISODES = 20000 TIMESTEP_PER_EPISODE = 20 FILE_PREFIX = "dataset/replay_" N_WORKERS = 3 EPSILON = 0.0 USE_SCRIPTED_POLICY = True workers = [None] * N_WORKERS for i in range(N_WORKERS): # launch a thread to collect online data workers[i] = datacollection_thread.DataCollectionThread(
def overlap_grand_sim(n=100000, k=317, p=0.01, beta=0.05, min_iter=10, max_iter=30): b = brain.Brain(p, save_winners=True) b.add_stimulus("stimA", k) b.add_area("A", n, k, beta) b.add_stimulus("stimB", k) b.add_area("B", n, k, beta) b.add_area("C", n, k, beta) b.add_area("D", n, k, 0) b.project({"stimA": ["A"], "stimB": ["B"]}, {}) # Create assemblies A and B to stability for i in xrange(10): b.project({"stimA": ["A"], "stimB": ["B"]}, {"A": ["A"], "B": ["B"]}) b.project({"stimA": ["A"]}, {"A": ["A", "C"]}) # Project A->C for i in xrange(10): b.project({"stimA": ["A"]}, {"A": ["A", "C"], "C": ["C"]}) # Project B->C b.project({"stimB": ["B"]}, {"B": ["B", "C"]}) for i in xrange(10): b.project({"stimB": ["B"]}, {"B": ["B", "C"], "C": ["C"]}) # Project both A,B to C b.project({ "stimA": ["A"], "stimB": ["B"] }, { "A": ["A", "C"], "B": ["B", "C"] }) for i in xrange(min_iter - 2): b.project({ "stimA": ["A"], "stimB": ["B"] }, { "A": ["A", "C"], "B": ["B", "C"], "C": ["C"] }) results = {} for i in xrange(min_iter, max_iter + 1): b.project({ "stimA": ["A"], "stimB": ["B"] }, { "A": ["A", "C"], "B": ["B", "C"], "C": ["C"] }) b_copy1 = copy.deepcopy(b) b_copy2 = copy.deepcopy(b) # in copy 1, project just A b_copy1.project({"stimA": ["A"]}, {}) b_copy1.project({}, {"A": ["C"]}) # in copy 2, project just B b_copy2.project({"stimB": ["B"]}, {}) b_copy2.project({}, {"B": ["C"]}) intersection = bu.overlap(b_copy1.areas["C"].winners, b_copy2.areas["C"].winners) assembly_overlap = float(intersection) / float(k) # projecting into D b_copy1.project({}, {"C": ["D"]}) b_copy1.project({"stimB": ["B"]}, {}) b_copy1.project({}, {"B": ["C"]}) b_copy1.project({}, {"C": ["D"]}) D_saved_winners = b_copy1.areas["D"].saved_winners proj_intersection = bu.overlap(D_saved_winners[0], D_saved_winners[1]) proj_overlap = float(proj_intersection) / float(k) print "t=" + str(i) + " : " + str(assembly_overlap) + " -> " + str( proj_overlap) + "\n" results[assembly_overlap] = proj_overlap return results
print(s) if __name__ == '__main__': if not is_power_of(NUM_PAIRS, PER_PAIR): raise Exception("Population {}, must be power of {}".format( NUM_PAIRS, PER_PAIR)) pairs = [Pair() for p in range(NUM_PAIRS)] seed = time.time() if os.path.exists(SAVE_FP): print("Loading brain from save file...") for p in pairs: for c in range(PER_PAIR): p.add_creature(brain.Brain(load=SAVE_FP).mutated()) else: print("Initializing population...") for p in pairs: for c in range(PER_PAIR): p.add_creature(brain.Brain()) idx = 0 while True: rnd = 0 while True: step = 0 while True: best = None finished = 0 for p in pairs:
def _emptyBrain(): mic = test_mic.Mic([]) profile = DEFAULT_PROFILE return brain.Brain(mic, profile)
# "tka015" #2 # tka018 #3 # tka021 #x modelo_file = sys.argv[1] model = load_model(modelo_file) nombre = modelo_file.split("/")[-1].split(".")[0] result_path = "../results/" + brain_id + "_with_" + nombre + ".nii.gz" inp_dim_2d = 35 inp_dim_3d = 11 img_types = ["flair", "FA", "anatomica"] brain = br.Brain(brain_id) brain.createSlices(step=1) #brain.split(1) final = brain.result.shape[0] inicio = 0 fin = int(final * 0.01) step = fin np.random.shuffle(brain.result) #print(fin*100/float(final),"% ",fin," / ", final, end="\r", flush=True) print(fin * 100 / float(final), "% ", fin, " / ", final) new_im = np.zeros(brain.mask.shape, dtype="float32") while True: brain.train = brain.result[inicio:fin] brain.test = brain.result[0:0] total = brain.getData(img_types, "2dx", inp_dim_2d)
# Update SMA calcs for imported data d.update_sma(ma_1) d.update_sma(ma_2) # Update EMA calcs for imported data d.update_ema(ma_1) d.update_ema(ma_2) # Loop for x minutes # for mins in range(720): # d.refresh_ohlc() # print('Refreshing OHLC data. Last ID: ' + str(d.ohlc_last_id)) # time.sleep(60) # Set up brain object with data and trade vol b = brain.Brain(d) # Backtest - pass data and brain object parameters bt = backtest.Backtest(d, b) # Monte carlo simulation from min to max MA bt.run_ma_sim(type, 1, 50) # Simulate single MA combo and export simulated trades # bt.ma_sim(type, ma_1, ma_2) # bt.export_trades() # Save data # d.export_ohlc() # d.export_ohlc_csv()
def __init__(self): self.name = "Elora" import brain self.brain = brain.Brain([81, 6, 9])
def __init__(self): self.win = py.display.set_mode( (config.screen_width, config.screen_height)) py.font.init() py.display.set_caption("EscapeVector") #----------Menusystem--------- self.menu_system = menu.Menu() ############ self.mouse_clicked = False self.quit = False self.mouse_pos = (0, 0) self.pressed_escape = False self.turn_right = False self.turn_left = False self.turbo = False self.throttle_down = True self.throttle_up = False self.slowtime = False self.slowduration = 10 self.clock = py.time.Clock() self.hud_base = py.transform.scale(py.image.load("../images/hud.png"), (200, 200)) self.explode = explosion.Explosion() self.minimap = minimap.Minimap() self.missiles_exploded = [] self.close_time = 0 self.fighters = py.sprite.Group() self.missiles = py.sprite.Group() self.emps = py.sprite.Group() self.turn_screen_red = False self.slowvalue = 1 self.bullets = bullet.BulletsSystem() self.enemiesbullets = bullet.BulletsSystem() self.shoot = False self.ai = brain.Brain() self.ai.fighters = self.fighters.sprites() self.sparkSystem = particle.SparkSystem() self.explosions_size = 10 self.initial_explosion = [] self.clouds = clouds.Clouds() self.explosions = [] self.camoffs = [] for i in range(20): self.camoffs.append( [random.randint(-10, 10), random.randint(-10, 10)]) self.camoffx = 0 self.camoffy = 0 self.shake = False self.shakecount = 0 self.screen_r = 0x8c self.screen_g = 0xbe self.screen_b = 0xd6 self.turn_screen_normal = True self.dirty_rects = [] self.game_exists = False #######sounds##### self.sounds = sound.Sound() self.playerhit = False self.fighterhit = False self.ticklowspeed = 0.5 self.tickhighspeed = 0.1 self.tickspeedrate = 0.05 self.tickspeed = 0.1
def _emptyBrain(): mic = test_mic.Mic([]) profile = yaml.safe_load(open("profile.yml", "r")) return brain.Brain(mic, profile)
def association_grand_sim(n=100000, k=317, p=0.01, beta=0.05, min_iter=10, max_iter=20): b = brain.Brain(p) b.add_stimulus("stimA", k) b.add_area("A", n, k, beta) b.add_stimulus("stimB", k) b.add_area("B", n, k, beta) b.add_area("C", n, k, beta) b.project({"stimA": ["A"], "stimB": ["B"]}, {}) # Create assemblies A and B to stability for i in range(9): b.project({"stimA": ["A"], "stimB": ["B"]}, {"A": ["A"], "B": ["B"]}) b.project({"stimA": ["A"]}, {"A": ["A", "C"]}) # Project A->C for i in range(9): b.project({"stimA": ["A"]}, {"A": ["A", "C"], "C": ["C"]}) # Project B->C b.project({"stimB": ["B"]}, {"B": ["B", "C"]}) for i in range(9): b.project({"stimB": ["B"]}, {"B": ["B", "C"], "C": ["C"]}) # Project both A,B to C b.project({ "stimA": ["A"], "stimB": ["B"] }, { "A": ["A", "C"], "B": ["B", "C"] }) for i in range(min_iter - 2): b.project({ "stimA": ["A"], "stimB": ["B"] }, { "A": ["A", "C"], "B": ["B", "C"], "C": ["C"] }) results = {} for i in range(min_iter, max_iter + 1): b.project({ "stimA": ["A"], "stimB": ["B"] }, { "A": ["A", "C"], "B": ["B", "C"], "C": ["C"] }) b_copy1 = copy.deepcopy(b) b_copy2 = copy.deepcopy(b) # in copy 1, project just A b_copy1.project({"stimA": ["A"]}, {}) b_copy1.project({}, {"A": ["C"]}) # in copy 2, project just B b_copy2.project({"stimB": ["B"]}, {}) b_copy2.project({}, {"B": ["C"]}) o = bu.overlap(b_copy1.areas["C"].winners, b_copy2.areas["C"].winners) results[i] = float(o) / float(k) return results
def add_agent(self, coords): #todo add new brain if self.grid[coords[1]][coords[0]] != int(Object_type.AGENT): self.info[Object_type.AGENT] += 1 self.grid[coords[1]][coords[0]] = int(Object_type.AGENT) brain_instance = brain.Brain() self.agents[coords] = Agent(brain_instance)
#Valor central de las acciones, donde la IA no hace nada direction_boundary = (number_actions -1)/2 number_epochs = 100 #Maximo tamaño de la memoria max_memory = 3000 batch_size = 512 #Diferencia de tempertaura entre dos indices consecutivos # -3, 1.5, 0, 1.5, 3 la diferencia es de 1.5 grados temperature_step = 1.5 #CONSTRUCCIÓN DEL ENTORNO CREANDO UN OBJETO DE LA CLASE ENVIRONMENT env = enviroment.Environtment(optimal_temperature = (18.0, 24.0), initial_month = 0, initial_number_users = 20, initial_rate_data = 30) #CONSTRUCCIÓN DEL CEREBRO CREANDO UN OBJETO DE LA CLASE BRAIN brain = brain.Brain(learning_rate = 0.00001, number_actions = number_actions) #CONSTRUCCIÓN DEL MODELO CREANDO UN OBJETO DE LA CLASE DQN dqn = dqn.DQN(max_memory = max_memory, discount_factor = 0.9) #ELECCIÓN DEL MODO DE ENTRENAMIENTO train = True # ENTRENAR LA IA env.train = train #Para acceder mas rápido al modelo model = brain.model
def __init__(self, name, memory, maxtime=20, dt=0.05, port=19991, visualize=False, use_scripted_policy=False, epsilon=0.0, vrep_file_name='ik_sawyer.ttt'): print("> DCThread: launching thread") threading.Thread.__init__(self) self.printer = logger.Printer("DCThread") self.r = vrep_sawyer.VrepSawyer(dt, headless_mode=True, port_num=port, vrep_file_name=vrep_file_name) self.s = simulator.Simulator(self.r, dt, target_x=0, target_y=0, target_z=0, visualize=False) if torch.cuda.is_available(): self.printer.print_to_screen("> DCThread: cuda is available :D") self.device = torch.device( "cuda" if torch.cuda.is_available() else "cpu") self.name = name self.memory = memory self.use_scripted_policy = use_scripted_policy self.epsilon = epsilon USE_VALUE_NET = False STATE_IS_IMAGE = True MEMORY_SIZE = 1000000 self.s.set_visualize(visualize) policy_net = None target_net1 = None target_net2 = None value_net = None value_net_trainer = None # create the target and policy networks policy_net = dqn.DQN().to(self.device) policy_net.load_state_dict(torch.load('vrep_arm_model.pt')) self.printer.print_to_screen("> DCThread: loaded existing model file") target_net1 = dqn.DQN().to(self.device) target_net2 = dqn.DQN().to(self.device) value_net = valuenet.ValueNet().to(self.device) value_net_trainer = valuenet.ValueNetTrainer(value_net) print_string = "> DCThread: number of parameters: ", sum( p.numel() for p in policy_net.parameters() if p.requires_grad) self.printer.print_to_screen(print_string) target_net1.load_state_dict(policy_net.state_dict()) target_net1.eval() target_net2.load_state_dict(policy_net.state_dict()) target_net2.eval() self.br = brain.Brain( simulator=self.s, #only to access scripted policy policy_net=policy_net, target_net1=target_net1, target_net2=target_net2, memory_size=MEMORY_SIZE, value_net_trainer=value_net_trainer, state_is_image=STATE_IS_IMAGE, use_value_net=USE_VALUE_NET) self.MAX_TIME = maxtime self.FRAME_SKIP = 1 # attach the current memory to the brain self.br.memory = self.memory self.current_success_rate = None self.current_reward = None