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