from dqn import DQN
from brain import Brain
import gym
import numpy as np
import matplotlib.pyplot as plt
learning_rate = 0.001
memory_max = 50000
gamma = 0.9
batch_size = 32
epsilon = 1.
epsilon_decay = 0.995
env = gym.make('MountainCar-v0')
brain = Brain(2, 3, learning_rate=learning_rate)
model = brain.model
dqn = DQN(max_memory=memory_max, discount_factor=gamma)
epoch = 0
currentState = np.zeros((1, 2))
nextState = currentState
total_reward = 0
rewards = list()
while True:
epoch += 1
env.reset()
currentState = np.zeros((1, 2))
nextState = currentState
game_over = False
while not game_over:
def __init__(self, persona, mic, profile):
self._logger = logging.getLogger(__name__)
self.persona = persona
self.mic = mic
self.profile = profile
self.brain = Brain(mic, profile)
# Defining the parameters
memSize = 60000
batchSize = 32
learningRate = 0.0001
gamma = 0.9
nLastStates = 4
epsilon = 1.
epsilonDecayRate = 0.0002
minEpsilon = 0.05
filepathToSave = 'model2.h5'
# Creating the Environment, the Brain and the Experience Replay Memory
env = Environment(0)
brain = Brain((env.nRows, env.nColumns, nLastStates), learningRate)
model = brain.model
dqn = Dqn(memSize, gamma)
# Making a function that will initialize game states
def resetStates():
currentState = np.zeros((1, env.nRows, env.nColumns, nLastStates))
for i in range(nLastStates):
currentState[:, :, :, i] = env.screenMap
return currentState, currentState
# Starting the main loop
# AI for Snake using Deep Q-Learning and Convolutional Neural Networks: Testing the AI
from environment import Environment
from brain import Brain
import numpy as np
nLastStates = 4
filepathToOpen = 'model.h5'
slowdown = 75
env = Environment(slowdown)
brain = Brain((env.nRows, env.nColumns, nLastStates))
model = brain.loadModel(filepathToOpen)
def resetStates():
currentState = np.zeros((1, env.nRows, env.nColumns, nLastStates))
for i in range(nLastStates):
currentState[:,:,:,i] = env.screenMap
return currentState, currentState
while True:
env.reset()
currentState, nextState = resetStates()
gameOver = False
while not gameOver:
qvalues = model.predict(currentState)[0]
action = np.argmax(qvalues)
def __init__(self, persona, mic, profile):
self.persona = persona
self.mic = mic
self.profile = profile
self.brain = Brain(mic, profile)
self.notifier = Notifier(profile)
def __init__(self, h, w, num_actions):
self.device = torch.device(
"cuda" if torch.cuda.is_available() else "cpu")
print(self.device)
self.brain = Brain(h, w, num_actions, self.device)
# -*- coding: utf-8 -*-
from screen import Screen
from snake import (Snake, Fruit)
from brain import Brain
import time
#import numpy as np
sc = Screen([10, 10])
sn = Snake([5, 5])
sn.setDir([0, 0, 0, 1])
fruit = Fruit(10, 10)
b = Brain(12 * 12 + 4)
while sn.valid:
reward = 0.0
move, maks = b.processActions(
sc.arena, [[0, 0, 0, 1], [0, 0, 1, 0], [0, 1, 0, 0], [1, 0, 0, 0]])
sn.setDir(move)
sc = sn.update(sc)
sc = fruit.show(sc)
print sc
print "Predicted reward:", maks
if not sn.valid:
reward = -1.0
if sn.pos == fruit.pos:
sn.addSegment()
fruit.randomize(10, 20)
reward = 1.0
err = b.computeCorrected(sc.arena, maks, reward)
print "Reward error:", err
e.close()
return config
def add_brain_config(config, brain):
config['decision_func'] = brain.decide
config['push_to_brain'] = brain.push_to_queue
config['get_epsilon'] = brain.get_epsilon
return config
if __name__ == "__main__":
# Configs
args = get_args()
config = get_config(args)
brain = Brain(config)
config = add_brain_config(config, brain)
# File structure
checkpoint_path = os.path.join('sessions', config['ENV_NAME'], 'ckpt/')
if not os.path.isdir(checkpoint_path):
os.makedirs(checkpoint_path)
config['NEW_SESSION'] = True
if tf.train.checkpoint_exists(checkpoint_path) and not config['NEW_SESSION']:
brain.load_session(checkpoint_path)
else:
print('INFO: No existing sessons.')
print('------- Configuration -------')
for k in config:
print('{}: {}'.format(k, config[k]))
id='MountainCar-v1',
entry_point='gym.envs.classic_control:MountainCarEnv',
tags={'wrapper_config.TimeLimit.max_episode_steps': 190},
reward_threshold=190,
)
env = Environment('MountainCar-v1',
run_name=None,
repeat_steps=5,
gamma=0.99)
brain = Brain(env,
layer1_size=32,
layer2_size=32,
opt_name='Adam',
opt_lr=1e-3,
target_freq=10000,
train_freq=32,
use_replay=True,
ddqn=True)
agent = Agent(env,
brain,
min_epsilon=0.1,
epsilon_decay=1 / 5e5,
train_nsteps=4)
env.run(agent, train=True, explore=True)
env.run(agent, train=True, explore=True)
env.run(agent, train=True, explore=True)
update = group_maps[which_group]
for key in data_map.keys():
if not update.has_key(key):
update[key] = []
update[key].append(float(data_map[key]))
if __name__ == "__main__":
data_file, subject_id, group_by, variables = parse_xml('config.xml')
brain_regions = variables
csv_to_map(data_file, subject_id, group_by)
b = Brain(group_maps['F'], group_maps['M'])
b.setEndPercentage(1.0 / 4.0)
# Calculate log likelihood ratios and export in excel file
ratio_data = []
column_names = ['SubjectId', 'Gender'] + sorted(group_maps['F'].keys())
ratio_data.append(column_names)
patient_ids = patient_map.keys()
patient_map[patient_ids[1]].plotProbDensity(group_maps['F'],
group_maps['M'])
for patient_id in patient_ids:
def __init__(self, num_states, num_actions):
# 課題の状態と行動の数を設定
self.num_states = num_states # CartPoleは状態数4を取得
self.num_actions = num_actions # CartPoleの行動（右に左に押す）の2を取得
self.brain = Brain(num_states, num_actions) # エージェントが行動を決定するための脳を生成
if __name__ == '__main__':
pool_size = 128
iterations = 1280
new_brain_percent = .1
brains = []
iter = 0
stats_per_iteration = []
evolver = Evolver()
while len(brains) < pool_size:
brains.append(Brain())
for loop in range(iterations):
plot(stats_per_iteration)
iter += 1
mutants = []
while (len(brains) + len(mutants)) < pool_size:
if random() < new_brain_percent:
mutants.append(Brain())
else:
parent_brain = sample(brains, 1)[0]
mutant = parent_brain.getNewMutant(mutation_chance=.2,
max_mutation=.5)
mutants.append(mutant)
brains = brains + mutants
shuffle(
def train(self):
self.NUM_AGENTS = 1
# self.NUM_AGENTS = len(dict_model)
# print("train", dict_model)
# actor_critics = []
# local_brains = []
# rollouts = []
if DEBUG: print(self.config)
actor_critic = ActorCritic(self.n_in, self.n_out)
global_brain = Brain(actor_critic, self.config)
rollout = RolloutStorage(self.NUM_ADVANCED_STEP, self.NUM_PARALLEL,
self.obs_shape, self.device)
current_obs = torch.zeros(self.NUM_PARALLEL,
self.obs_shape).to(self.device)
episode_rewards = torch.zeros([self.NUM_PARALLEL, 1])
final_rewards = torch.zeros([self.NUM_PARALLEL, 1])
episode = np.zeros(self.NUM_PARALLEL)
obs = self.envs.reset()
obs = np.array(obs)
obs = torch.from_numpy(obs).float()
current_obs = obs
rollout.observations[0].copy_(current_obs)
while True:
# for step in range(self.NUM_ADVANCED_STEP):
for step in range(self.max_step):
print("step", step)
with torch.no_grad():
# action = actor_critic.act(rollouts.observations[step]) # ここでアクション決めて
action = torch.zeros(self.NUM_PARALLEL,
self.NUM_AGENTS).long().to(
self.device) # 各観測に対する，各エージェントの行動
if DEBUG:
print("actionサイズ", self.NUM_PARALLEL, self.NUM_AGENTS)
# for i, (k,v) in enumerate( dict_model.items() ):
# if k == training_target:
# tmp_action = v.act(current_obs)
# target_action = copy.deepcopy(tmp_action)
# else:
# tmp_action = v.act_greedy(current_obs)
# action[:,i] = tmp_action.squeeze()
action = actor_critic.act(obs)
if DEBUG: print("action", action)
if DEBUG: print("step前のここ？", action.shape)
obs, reward, done, infos = self.envs.step(action) # これで時間を進める
print("reward(train)", reward)
episode_rewards += reward
# if done then clean the history of observation
masks = torch.FloatTensor([[0.0] if done_ else [1.0]
for done_ in done])
if DEBUG: print("done.shape", done.shape)
if DEBUG: print("masks.shape", masks.shape)
if DEBUG: print("obs.shape", obs.shape)
with open(self.resdir + "/episode_reward.txt", "a") as f:
for i, info in enumerate(infos):
if 'episode' in info:
f.write("{:}\t{:}\t{:}\n".format(
episode[i], info['env_id'],
info['episode']['r']))
print(episode[i], info['env_id'],
info['episode']['r'])
episode[i] += 1
final_rewards *= masks
final_rewards += (1 - masks) * episode_rewards
episode_rewards *= masks
current_obs *= masks
current_obs = obs # ここで観測を更新している
rollout.insert(current_obs, action.data, reward, masks,
self.NUM_ADVANCED_STEP)
with open(self.resdir + "/reward_log.txt",
"a") as f: # このログはエピソードが終わったときだけでいい->要修正
f.write("{:}\t{:}\t{:}\t{:}\t{:}\t{:}\t{:}\t{:}\n".format(
episode.mean(), step,
reward.max().numpy(),
reward.min().numpy(),
reward.mean().numpy(),
episode_rewards.max().numpy(),
episode_rewards.min().numpy(),
episode_rewards.mean().numpy()))
print(episode.mean(), step,
reward.mean().numpy(),
episode_rewards.mean().numpy())
with torch.no_grad():
next_value = actor_critic.get_value(
rollout.observations[-1]).detach()
rollout.compute_returns(next_value, self.gamma)
value_loss, action_loss, total_loss, entropy = global_brain.update(
rollout)
with open(self.resdir + "/loss_log.txt", "a") as f:
f.write("{:}\t{:}\t{:}\t{:}\t{:}\n".format(
episode.mean(), value_loss, action_loss, entropy,
total_loss))
print(
"value_loss {:.4f}\taction_loss {:.4f}\tentropy {:.4f}\ttotal_loss {:.4f}"
.format(value_loss, action_loss, entropy, total_loss))
rollout.after_update()
if int(episode.mean()) + 1 > self.NUM_EPISODES:
# print("ループ抜ける")
break
obs = self.envs.reset()
if self.args.save:
save_model(actor_critic, self.resdir + "/model")
# ここでベストなモデルを保存していた（備忘）
# print("%s番目のエージェントのtrain終了"%training_target)
# dict_model[training_target] = actor_critic # {}
return actor_critic
from brain import Brain
#Initializing the parameters
memory_size = 5000
batch_size = 25
learning_rate = 0.01
epsilion = .9
epsilion_delta = 0.002
min_epsilion = 0.7
gamma = 0.8
n_last_states = 6
#Initializing environment, brain, model and dqn algorithm
env = gym.make('Acrobot-v1')
shapeOfState = env.observation_space.shape[0]
brain = Brain((shapeOfState, n_last_states), learning_rate)
Dqn = DQN(memory_size, gamma)
filepathToSave = 'acrobat2.h5'
ModelImgSave = 'arajin.png'
model = brain.model
#model = brain.load_model(filepathToSave)
callbacks = brain.callbacks(15)
#Reset function for states and environment
def resetStates():
currentState = np.zeros((1, shapeOfState, n_last_states))
for i in range(n_last_states):
if ifile.endswith('.b'):
with open(ifile) as incode:
code = ''
for line in incode:
code += line.strip()
codes.append([code, None])
elif ifile.endswith('.png'):
conv.loadPNG(ifile)
codes.append([conv.toBrainFuck(), conv.getPNG()])
else:
sys.stderr.write('PNGWrongHeaderError\n')
sys.exit(4)
else:
codes.append([ifile, None])
else:
print('Please write down brainfuck program. Confirm with enter.:')
codes.append([input().strip(), None])
for code, png in codes:
brain = Brain(code)
brain.setMemory(args.memory)
brain.setPtr(args.memory_pointer)
brain.setPNG(png)
if start:
brain.start()
if args.test:
brain.writeLog(args.pnm or args.pbm)
sys.exit(0)
def __init__(self, persona, ear):
self._logger = logging.getLogger(__name__)
self.persona = persona
self.mic = ear
self.profile = cmInstance.getRootConfig()
self.brain = Brain()
# -*- coding: utf-8-*-
import logging
import pkgutil
import os
from brain import Brain
brain = Brain()
brain.query("what time is it")
hpc = {'train': zeroObj, 'validation': zeroObj, 'test': zeroObj}
feats = meta.index
costs = meta[config.META_COSTS]
data_trn[feats] = (data_trn[feats] -
meta[config.META_AVG]) / meta[config.META_STD] # normalize
data_val[feats] = (data_val[feats] -
meta[config.META_AVG]) / meta[config.META_STD] # normalize
data_tst[feats] = (data_tst[feats] -
meta[config.META_AVG]) / meta[config.META_STD] # normalize
#==============================
print("Evaluating dataset:", config.dataset)
brain = Brain(None)
brain._load(file='model')
print("Performance on the last model:")
if 'trn' in args.set:
log_trn = Log(data_trn, hpc['train'], costs, brain, "trn_best")
log_trn.log_perf()
if 'val' in args.set:
log_val = Log(data_val, hpc['validation'], costs, brain, "val_best")
log_val.log_perf()
if 'tst' in args.set:
log_tst = Log(data_tst, hpc['test'], costs, brain, "tst_best")
log_tst.log_perf(histogram=True, verbose=True)
def main_(Load=True):
np.set_printoptions(threshold=np.inf)
np.random.seed(SEED)
random.seed(SEED)
torch.manual_seed(SEED)
torch.cuda.manual_seed(SEED)
#self.DATA_FILE = DATA_FILE
DATA_FILE = './data/mb-train'
DATA_VAL_FILE = './data/mb-val'
META_FILE = './data/mb-meta'
data = pd.read_pickle(DATA_FILE)
data_val = pd.read_pickle(DATA_VAL_FILE)
meta = pd.read_pickle(META_FILE)
feats = meta.index
costs = meta[META_COSTS]
for col in COLUMN_DROP:
if col in data.columns:
data.drop(col, axis=1, inplace=True)
data_val.drop(col, axis=1, inplace=True)
#data[feats] = (data[feats] - meta[META_AVG]) / meta[META_STD] # normalize
#data_val[feats] = (data_val[feats] - meta[META_AVG]) / meta[META_STD] # normalize
#np.save('chck_train_data',data)
print("Using", DATA_FILE, "with", len(data), "samples.")
pool = Pool(POOL_SIZE)
env = Environment(data, costs, FEATURE_FACTOR)
brain = Brain(pool)
print(" brain : ")
agent = Agent(env, pool, brain)
#log = Log(data_val, costs, FEATURE_FACTOR, brain)
epoch_start = 0
#epoch_start = 0
if not BLANK_INIT:
print("Loading progress..")
brain._load()
with open('run.state', 'r') as file:
save_data = json.load(file)
epoch_start = save_data['epoch']
brain.update_lr(epoch_start)
agent.update_epsilon(epoch_start)
#==============================
print("Initializing pool..")
for i in range(POOL_SIZE // AGENTS):
utils.print_progress(i, POOL_SIZE // AGENTS)
agent.step()
pool.cuda()
#%%
print("Starting..")
#info = list()
for epoch in range(epoch_start + 1, TRAINING_EPOCHS + 1):
# SAVE
if is_time(epoch, SAVE_EPOCHS):
brain._save()
save_data = {}
save_data['epoch'] = epoch
#info.append(test.test_action())
with open('run.state', 'w') as file:
json.dump(save_data, file)
eval_.test_action()
# SET VALUES
if is_time(epoch, EPSILON_UPDATE_EPOCHS):
agent.update_epsilon(epoch)
if is_time(epoch, LR_SC_EPOCHS):
brain.update_lr(epoch)
# LOG
if is_time(epoch, LOG_EPOCHS):
print("Epoch: {}/{}".format(epoch, TRAINING_EPOCHS))
#log.log()
#log.print_speed()
if is_time(epoch, LOG_PERF_EPOCHS): pass
#slog.log_perf()
# TRAIN
brain.train()
for i in range(EPOCH_STEPS):
agent.step()
hpc = pd.read_pickle(config.HPC_FILE)
feats = meta.index
costs = meta[config.META_COSTS]
data_trn[feats] = (data_trn[feats] -
meta[config.META_AVG]) / meta[config.META_STD] # normalize
data_val[feats] = (data_val[feats] -
meta[config.META_AVG]) / meta[config.META_STD] # normalize
print("Using", config.DATA_FILE, "with", len(data_trn), "samples.")
#==============================
pool = Pool(config.POOL_SIZE)
env = Environment(data_trn, hpc['train'], costs)
brain = Brain(pool)
agent = Agent(env, pool, brain)
log_val = Log(data_val, hpc['validation'], costs, brain, "val")
log_trn = Log(data_trn, hpc['train'], costs, brain, "trn")
#==============================
epoch_start = 0
lr_start = config.OPT_LR
avg_r = types.SimpleNamespace()
avg_r.trn_avg = []
avg_r.trn_run = []
avg_r.val_avg = []
avg_r.val_run = []
avg_r.trn_best = -999.0
avg_r.val_best = -999.0
def __init__(self, text, brain_path=None, file_name=None):
self.file_name = file_name
# Problem text
self.text = text
# Problem brain
self.brain = Brain(brain_path)
# Digest
self.sentences = None
self.sentence_tags = None
self.all_tags = None
self.all_words = None
self.longest_word = None
self.involves_acting = False
self.units_acting_as_context = {}
self.context_subordinates = {}
self.context_actions = {}
self.descriptive_units = []
self.refined_units = {}
self.unit_subtypes = {}
self.units = []
self.running_units = []
self.exestential = False
self.adaptive_context = {}
self.last_contexts = {
"plurality": {
"singular": None,
"plural": None,
"self": None,
"regular": None
},
"gender": {
"masculine": None,
"feminine": None,
"neutral": None,
"mixed": None,
"self": None,
"ambiguous": None
},
"last": None
}
self.subordinate_adaptive_contexts = []
self.previous_contexts = {
"plurality": {
"singular": None,
"plural": None,
"self": None,
"regular": None
},
"gender": {
"masculine": None,
"feminine": None,
"neutral": None,
"mixed": None,
"self": None,
"ambiguous": None
},
"last": None
}
self.all_targets = {
"plurality": {
"singular": {},
"plural": {},
"self": {},
"regular": {}
},
"gender": {
"masculine": {},
"feminine": {},
"neutral": {},
"mixed": {},
"self": {},
"ambiguous": {}
},
"last": None
}
self.contexts = []
self.all_contexts = {
"plurality": {
"singular": {},
"plural": {},
"self": {},
"regular": {}
},
"gender": {
"self": {},
"masculine": {},
"feminine": {},
"neutral": {},
"mixed": {},
"ambiguous": {}
},
"last": None
}
# Engines
self.inference = None
self.question = None
self.solution = None
from brain import Brain
if __name__ == "__main__":
b = Brain()
b.find_answers()
memSize: tf.uint32 = 60_000
batchSize: tf.uint32 = 32
learningRate: tf.float32 = 0.0001
gamma: tf.float32 = 0.9
nLastStates: int = 4
epsilon: float = 1.0
epsilonDecayRate: float = 0.0002
minEpsilon: float = 0.05
randomGenerator = np.random.default_rng()
filepathToSave: str = "model.h5"
# Creating the Environment, the Brain and the Experience Replay Memory
env = Environment(0)
brain = Brain(input_shape=(env.nRows, env.nColumns, nLastStates),
learning_rate=learningRate)
model = brain.model
dqn = Dqn(max_memory=memSize, discount_factor=gamma)
# Making a function that will initialize game states
def resetStates():
currentState = np.zeros((1, env.nRows, env.nColumns, nLastStates))
for i in range(nLastStates):
currentState[:, :, :, i] = env.screenMap
# Return two 'currentState'; one to represent board before taking action & another after taking action
return currentState, currentState
from brain import Brain
hisui = Brain()
print('Login: '******'')
name = input()
hisui.remember_person(name)
while True:
print(name + '$ ', end = '')
input_text = input()
if input_text == 'exit': break
print(hisui.listen(input_text))
# d.sort(key=lambda p: p[1], reverse=True)
# d[0][0].save(f"saved_brains_25/gen_{i}")
# print(f"{i} | {d[0][1]} | {sum(list(map(lambda p: p[1], d))[:sqrt_num])/sqrt_num} | {sum(list(map(lambda p: p[1], d)))/len(d)}")
# print(f"{d[0][1]} | {sum(list(map(lambda p: p[1], d))[:sqrt_num])/sqrt_num} | {sum(list(map(lambda p: p[1], d)))/len(d)}", flush=True, file=f)
# brains = [b.pso(d[0][0], 0.729, 2.05, 2.05, r) for b,r in d]
sqrt_num = 20
print(f"no | best | best {sqrt_num} | generation")
f = open("logs_30.txt", "w+")
brains = [Brain() for i in range(sqrt_num**2)]
for i in range(100):
d = [(brain, Map.calculte_expected_result(brain, probe=10))
for brain in brains]
d.sort(key=lambda p: p[1], reverse=True)
d[0][0].save(f"saved_brains_30/gen_{i}")
print(
f"{i} | {d[0][1]} | {sum(list(map(lambda p: p[1], d))[:sqrt_num])/sqrt_num} | {sum(list(map(lambda p: p[1], d)))/len(d)}"
)
print(
f"{d[0][1]} | {sum(list(map(lambda p: p[1], d))[:sqrt_num])/sqrt_num} | {sum(list(map(lambda p: p[1], d)))/len(d)}",
from Dqn import DQN
from brain import Brain
#Initializing the parameters
memory_size = 1000
batch_size = 25
#learning_rate = 0.0001
epsilion = .4
epsilion_delta = 0.0005
min_epsilion = 0.02
gamma = 0.9
n_last_states = 5
#Initializing environment, brain, model and dqn algorithm
env = gym.make('Acrobot-v1')
brain = Brain((6, n_last_states))
Dqn = DQN(memory_size, gamma)
filepathToLoad = 'acrobat.h5'
model = brain.load_model(filepathToLoad)
#Reset function for states and environment
def resetStates():
currentState = np.zeros((1, 6, n_last_states))
for i in range(n_last_states):
currentState[:, :, i] = env.reset()
return currentState, currentState
def assemblies_simulation(n=1000000, k=1000, p=0.1, beta=0.05, t=100) -> Brain:
logging.basicConfig(level=logging.INFO)
brain: Brain = Brain(p)
brain.add_stimulus("stimulus1", k)
brain.add_stimulus("stimulus2", k)
area_names: List[str] = [
"A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N",
"O", "P"
]
for name in area_names:
brain.add_area(name, n, k, beta)
for _ in range(t):
brain.project({"stimulus1": [area_names[0]]}, {})
brain.project({"stimulus2": [area_names[1]]}, {})
assemblies: List[Assembly] = [
Assembly([NamedStimulus("stimulus1", brain.stimuli["stimulus1"])],
area_names[0], "assembly1"),
Assembly([NamedStimulus("stimulus2", brain.stimuli["stimulus2"])],
area_names[1], "assembly2")
]
assemblies.append(assemblies[0].project(brain, area_names[2]))
assemblies.append(assemblies[1].project(brain, area_names[3]))
for _ in range(t):
assemblies[0].project(brain, area_names[2])
assemblies[1].project(brain, area_names[3])
winners_after_stabilization: set = set()
for _ in range(t // 10):
assemblies[0].project(brain, area_names[2])
assemblies[1].project(brain, area_names[3])
winners_after_stabilization = winners_after_stabilization.union(
brain.areas[area_names[2]].winners)
print(
f"Assembly winners has stabilized to a set of size {len(winners_after_stabilization) / k} * k"
)
assemblies.append(
Assembly.merge(brain, assemblies[0], assemblies[1], area_names[4]))
for _ in range(t):
Assembly.merge(brain, assemblies[0], assemblies[1], area_names[4])
try:
print(
f"Assembly in area of merged area is {Assembly.read(brain, assemblies, area_names[4]).name}"
)
except Exception:
print("Read is unimplemented!")
for _ in range(t):
brain.project({"stimulus2": [area_names[0]]}, {})
assemblies.append(
Assembly([NamedStimulus("stimulus2", brain.stimuli["stimulus2"])],
area_names[0], "assembly3"))
Assembly.associate(brain, assemblies[0], assemblies[5])
for _ in range(t):
Assembly.associate(brain, assemblies[0], assemblies[5])
try:
print(
f"Reads in area {area_names[0]} are {Assembly.get_reads(brain, assemblies, area_names[0])}"
)
except Exception:
print("Read is unimplemented!")
return brain
LEARNING_RATE = 0.001
REGULARIZATION = 0.05
BRAIN_TOPOLOGY = (
(18, None),
(64, LeakyReLU),
(96, LeakyReLU),
(48, LeakyReLU),
(9, Softmax),
)
BRAIN_FILEPATH = "brain/saved/tictactoe-brain.pickle"
print("\nSTART TICTACTOE GAME TRAINING SESSION\n")
learner_brain = Brain(BRAIN_TOPOLOGY, learning_rate=LEARNING_RATE, regularization=REGULARIZATION)
print("Created brain from scratch for the player robot")
adaptive_trainer_brain = Brain(BRAIN_TOPOLOGY, learning_rate=LEARNING_RATE, regularization=REGULARIZATION)
print("Created brain from scratch for the adaptive trainer robot")
try:
static_trainer_brain = pickle.load(open(BRAIN_FILEPATH, "rb"))
print("Loaded previously best brain for the static trainer robot")
except Exception:
static_trainer_brain = Brain(
BRAIN_TOPOLOGY, learning_rate=LEARNING_RATE, regularization=REGULARIZATION
)
print("Created brain from scratch for the static trainer robot")
# The robots
learner_robot = PolicyGradientPlayer(
learner_brain,
cfg = ConfigParser()
cfg.read(f"{os.path.dirname(os.path.realpath(__file__))}/config.ini")
consumer_key = cfg["twitter"]["consumer_key"]
consumer_secret = cfg["twitter"]["consumer_secret"]
access_token = cfg["twitter"]["access_token"]
access_token_secret = cfg["twitter"]["access_token_secret"]
TAGS = [htag.strip() for htag in cfg["twitter"]["hashtags"].split(",")]
auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_token_secret)
API = tweepy.API(auth)
LAST_TWEET_FILE = (
f"{os.path.dirname(os.path.realpath(__file__))}/last_known_retweet.txt")
BRAIN = Brain(LAST_TWEET_FILE)
FORMAT = "%(asctime)-15s:%(levelname)s:%(pathname)s:%(funcName)s:%(lineno)d: %(message)s"
logging.basicConfig(format=FORMAT, datefmt="%Y-%m-%d:%H:%M:%S")
logger = logging.getLogger(__name__)
def _is_tweet_toplevel(tweet):
"""is_tweet_toplevel detects if a tweet is a top level tweet.
Top level tweets are identified by not being a response to another tweet,
or being a retweet of another tweet.
Args:
tweet ([Status]): A tweepy Status object
Returns:
from brain import Brain
brain = Brain(6)
charsets = [
"0ODGCQ",
"1IJ3B8",
"2Z5SEF",
"AHTKXW",
"MNVUY7",
"469LPR"
]
brain.load("../data/brains/Central.p")
characterLines = open('../data/characters.txt', 'r').readlines()
print("Loading samples")
for line in characterLines:
line = line.strip().split("\t")
inputPixelString = line[1]
outputLetter = line[0]
brainIndex = 0
for charset in charsets:
if outputLetter in charset:
break
brainIndex += 1
