def compare_brains_in_regions(brain_regions, regions_to_voxels): for region_name, voxels in regions_to_voxels[i].items(): if region_name in best_brain_regions: if region_name not in brain_regions: brain_regions[region_name] = [] voxels = [v for v in voxels if v in brain_fs[i].get_selected_indexes()] brain_regions[region_name].append(brains[-1][:, voxels]) for region_name in brain_regions: if min(map(len, brain_regions[region_name])) > 0: x_brain, C_brain = get_dists(brain_regions[region_name]) klz_brain, labels_brain = compute_dist_of_dists(x_brain, C_brain, brain_labels) print(region_name, '\t', np.mean(klz_brain), '\t', np.std(klz_brain)) plot(klz_brain, labels_brain)
all_embeddings = [] all_labels = [] for key in embeddings.keys(): all_embeddings += embeddings[key][1:] all_labels += labels[key][1:] #x, C = get_dists(brains + all_embeddings) #klz, prz, labels_ = compute_dist_of_dists(x, C, brain_labels + all_labels) #plot(prz, brain_regions_labels) #klz = np.asarray(klz) #print(klz.shape) #print(brain_regions_labels) import csv x, C = get_dists(all_embeddings) klz, prz, labels_ = compute_dist_of_dists(x, C, all_labels) with open('bert_com_sim_prz_' + '.csv', 'w') as f: writer = csv.writer(f) writer.writerow(all_labels) writer.writerows(prz) print(all_labels) plot(prz, all_labels) half = int(len(all_labels) / 2) for i in np.arange(half): print(all_labels[i].split("_")[-1], all_labels[i + half].split("_")[-1], prz[i][i + half])
str(i) + '_Brain'), 'rb')) for b in blocks: brains[-1].extend(a['brain_activations'][b][11 + delay:-3]) brains[-1] = np.asarray(brains[-1]) brain_fs[i].fit(brains[-1]) original_selected_voxels = brain_fs[i].get_selected_indexes() print(len(original_selected_voxels)) brains[-1] = brains[-1][:, original_selected_voxels] brain_labels.append('brain_' + str(i)) print(brains[-1].shape) print('avg brain shape:', ) x, C = get_dists(brains + all_embeddings) klz, prz, labels_ = compute_dist_of_dists(x, C, brain_labels + all_labels) plot(prz, labels_) klz = np.asarray(klz) print(klz.shape) import csv with open('klz_' + str(delay) + '.csv', "w") as f: writer = csv.writer(f) writer.writerows(klz) with open('prz_' + str(delay) + '.csv', "w") as f: writer = csv.writer(f) writer.writerows(prz) #Get brain regions: for l in labels_:
labels[embedding_key].append(embedding_key + '_context_' + str(context_size)) print("####################################") all_embeddings_per_context_length = {} all_labels_per_context_length = {} for context_size in np.arange(7): all_embeddings_per_context_length[context_size] = [] all_labels_per_context_length[context_size] = [] for key in embeddings.keys(): all_embeddings_per_context_length[context_size] += [ embeddings[key][context_size] ] all_labels_per_context_length[context_size] += [ labels[key][context_size] ] import csv for context_size in np.arange(7): x, C = get_dists(all_embeddings_per_context_length[context_size]) klz, prz, labels_ = compute_dist_of_dists( x, C, all_labels_per_context_length[context_size]) print(context_size, ':', np.mean(prz)) with open('com_sim_prz_' + str(context_size) + '.csv', 'w') as f: writer = csv.writer(f) writer.writerow(all_labels_per_context_length[context_size]) writer.writerows(prz) plot(prz, all_labels_per_context_length[context_size])
def train(self, episodes=-1): # Hacky... if episodes < 0: episodes = self.max_episodes episode = 0 all_rewards = [] try: # Set this to "while True" for genuine convergence for e in range(episodes): # Start episode episode_reward = 0 self.episode_count = e t = 0 state = self.env.reset() state = np.reshape(state, [1, self.n_features]) while True: # self.env.render() # Select action action = self._select_action(state) # Execute transition next_state, reward, done, info = self.env.step(action) episode_reward += reward next_state = np.reshape(next_state, [1, self.n_features]) # Store experience tuple in memory self.memory.append( (state, action, reward, next_state, done)) state = next_state # Replay using mini batch self._update_Q() # Copy learned Q function into target network if t % self.net_replacement_freq == 0: self.Q_ = clone_model(self.Q) self.Q_.set_weights(self.Q.get_weights()) t += 1 if done: break all_rewards.append(episode_reward) sma = np.mean(all_rewards[-SMA_WINDOW:]) logger.info('{},{},{},{}'.format(episode, episode_reward, self.epsilon, sma)) episode += 1 # Uncomment for episodic epsilon decay if not self.epsilon_special: if self.epsilon > self.epsilon_min: self.epsilon *= self.epsilon_decay_rate # Special case: stepwise epsilon decay else: if episode < 150: self.epsilon = 1.0 elif episode < 250: self.epsilon = 0.5 else: self.epsilon = 0.0 # Convergence if sma >= 200: self.solved = True break except KeyboardInterrupt: logger.info('KeyboardInterrupt: halting training') finally: plot(all_rewards) self._save_model() return all_rewards
randoms = [ uniform_random_300, normal_random_300, uniform_random_100, normal_random_100, uniform_random_1000, normal_random_1000 ] random_labels = [ 'uniform_random_300', 'normal_ransom_300', 'uniform_random_100', 'normal_random_100', 'uniform_random_1000', 'normal_random_1000' ] print("brain shapes:", brain_regions[0].shape) x, C = get_dists(brain_regions + all_embeddings + randoms) klz, prz, labels_, p_vals = compute_dist_of_dists( x, C, brain_regions_labels + all_labels + random_labels) plot(prz, labels_) plot(p_vals, labels_) klz = np.asarray(klz) print(klz.shape) dic2save = {"klz": klz, "prz": prz, "labels_": labels_, "p_vals": p_vals} np.save( '_'.join(list(map(str, FLAGS.blocks))) + "rsa_results_all_brain_regions_" + str(delay) + "_" + selecting_feature, dic2save) x, C = get_dists(brains + all_embeddings + randoms) klz, prz, labels_, p_vals = compute_dist_of_dists( x, C, brain_labels + all_labels + random_labels) plot(prz, labels_)
voxels = [v for v in voxels if v in original_selected_voxels] brain_regions.append(brains[-1][:, voxels]) brain_regions_labels.append( ['subject_' + str(i) + region_name]) selected_voxels = [ v for v in original_selected_voxels if voxel_to_regions[i][v] in best_brain_regions ] brains[-1] = brains[-1][:, selected_voxels] brain_labels.append('brain_' + str(i)) print(brains[-1].shape) x, C = get_dists(brains + all_embeddings) klz, prz, labels_ = compute_dist_of_dists(x, C, brain_labels + all_labels) plot(prz, brain_regions_labels + all_labels) klz = np.asarray(klz) print(klz.shape) #print(brain_regions_labels) print(brain_regions_labels) for context_size in [1]: print('context_size:', context_size) for bi in np.arange(len(brain_regions_labels)): print(brain_regions_labels[bi]) output = brain_regions_labels[bi][0] + ' ' for key in embeddings: print(key, embeddings[key][context_size].shape) embedding_key = key + '_' + str(context_size) x, C = get_dists([brain_regions[bi]] +
def train(self, env): # Track rewards all_rewards = [] try: while True: state = env.reset() state = [ round(s, PRECISION) for s in state[:CONTINUOUS_OBSERVATIONS] ] action = self._query_initial( state, env.discrete_obs_space ) # set the state and get first action episode_return = 0 steps = 0 total_Q_update = 0 while True: new_state, reward, done, details = env.step(action) new_state = [ round(s, PRECISION) for s in new_state[:CONTINUOUS_OBSERVATIONS] ] # env.render() episode_return += reward # if steps % 10 == 0: # print([x for x in new_state]) # print("step {} total_reward {:+0.2f}".format(steps, episode_return)) steps += 1 if done: break action, delta_Q = self._query(state, action, new_state, reward, env.discrete_obs_space) total_Q_update += delta_Q all_rewards.append(episode_return) sma = np.mean(all_rewards[-SMA_WINDOW:]) if self.episodes % 10 == 0: if self.episodes >= SMA_WINDOW: logger.info( 'Episode {} | Reward = {} | SMA = {}'.format( self.episodes, episode_return, sma)) else: logger.info('Episode {} | Reward = {}'.format( self.episodes, episode_return)) # Convergence if self.episodes > SMA_WINDOW and sma >= SOLUTION_THRESHOLD: break self.episodes += 1 except KeyboardInterrupt: logger.warn('KeyboardInterrupt - halting training') plot(all_rewards, title='Rewards per episode', xlab='Episode', ylab='Reward') logger.info('{}% of actions were random'.format( round(100. * self.random_actions / self.total_actions, 2)))