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
