def statespace(t, parameterDP): '''the set of states''' inventory = [] limit = parameterDP.MaxInventory partial = np.zeros(parameterDP.N) utils.enumerate(inventory, limit, partial, 0) result = [] for elem in inventory: result.append(utils.State(t, elem)) return result
def __init__(self, model_name, env): super(DQNAgent, self).__init__(model_name, env) self.episode = self.configs.episode self.batch_size = self.configs.batch_size self.gamma = self.configs.gamma self.eps_start = self.configs.eps_start self.eps_end = self.configs.eps_end self.eps_decay = self.configs.eps_decay self.target_update_episode = self.configs.target_update_episode self.model_path = self.configs.save_path self.save_episode = self.configs.save_episode self.plot_episode = self.configs.plot_episode self.policy_net = models.DQN(self.configs, env).to(self.device) self.target_net = models.DQN(self.configs, env).to(self.device) self.load_model(self.model_path) self.optimizer = optim.Adam( self.policy_net.parameters(), lr=self.configs.optimizer_lr, betas=(self.configs.optimizer_beta1, self.configs.optimizer_beta2), eps=self.configs.optimizer_eps, weight_decay=self.configs.optimizer_weight_decay) self.memory = utils.ReplayMemory(10000) self.num_random_choose = 0 self.num_choice_per_dim = self.configs.num_choice_per_dim self.action_dim = env.action_spec().shape self.action_min = env.action_spec().minimum self.action_max = env.action_spec().maximum self.action_space = utils.enumerate(self.num_choice_per_dim, self.action_min, self.action_max)
def find_closest(location, centroids): """Return the centroid in centroids that is closest to location. If multiple centroids are equally close, return the first one. >>> find_closest([3.0, 4.0], [[0.0, 0.0], [2.0, 3.0], [4.0, 3.0], [5.0, 5.0]]) [2.0, 3.0] """ # BEGIN Question 3 d = {i : distance(location, c) for (i, c) in enumerate(centroids)} return centroids[min(d, key=lambda k: d[k])]
def find_closest(location, centroids): """Return the centroid in centroids that is closest to location. If multiple centroids are equally close, return the first one. >>> find_closest([3.0, 4.0], [[0.0, 0.0], [2.0, 3.0], [4.0, 3.0], [5.0, 5.0]]) [2.0, 3.0] """ # BEGIN Question 3 min_key = key_of_min_value( dict(enumerate([distance(location, c) for c in centroids]))) return centroids[min_key]
def find_closest(location, centroids): """Return the centroid in centroids that is closest to location. If multiple centroids are equally close, return the first one. >>> find_closest([3.0, 4.0], [[0.0, 0.0], [2.0, 3.0], [4.0, 3.0], [5.0, 5.0]]) [2.0, 3.0] """ # BEGIN Question 3 "*** YOUR CODE HERE ***" return centroids[min(enumerate( [distance(location, centroid) for centroid in centroids]), key=lambda x: x[1])[0]]
def best_predictor(user, restaurants, feature_fns): """Find the feature within feature_fns that gives the highest R^2 value for predicting ratings by the user; return a predictor using that feature. Arguments: user -- A user restaurants -- A list of restaurants feature_fns -- A sequence of functions that each takes a restaurant """ reviewed = user_reviewed_restaurants(user, restaurants) # BEGIN Question 8 return max(enumerate([find_predictor(user, reviewed, fn) for fn in feature_fns]), key=lambda e: e[1][1])[1][0]
def setofaction(t, parameterDP, current_state): '''return the set of actions which can be adopted according to capacity and the current state current_state''' try: if current_state.period != t - 1: raise Exception except: utils.printErrorAndExit('setofaction') temp = np.array(parameterDP.MaxInventory) - np.array( current_state.inventory) limit = utils.minElementwise(parameterDP.MaxOrder, temp.tolist()) order = [] partial = np.zeros(len(limit)) utils.enumerate(order, limit, partial, 0) result = [] for elem in order: result.append(utils.Action(t, elem)) return result
def find_closest(location, centroids): """Return the centroid in centroids that is closest to location. If multiple centroids are equally close, return the first one. >>> find_closest([3.0, 4.0], [[0.0, 0.0], [2.0, 3.0], [4.0, 3.0], [5.0, 5.0]]) [2.0, 3.0] """ # BEGIN Question 3 # so this beautiful list comprehension takes the distances between the given location and the centroids, enumerates them, # finds the lowest distance, accesses the index of the said distance, and uses that for accessing the closest centroid # yes, it's complicated, but it's too beautiful to delete it return centroids[min(enumerate( [distance(location, centroid) for centroid in centroids]), key=lambda x: x[1])[0]]
def k_means(restaurants, k, max_updates=100): """Use k-means to group restaurants by location into k clusters.""" assert len(restaurants) >= k, 'Not enough restaurants to cluster' old_centroids, n = [], 0 # Select initial centroids randomly by choosing k different restaurants centroids = [restaurant_location(r) for r in sample(restaurants, k)] while old_centroids != centroids and n < max_updates: old_centroids = centroids # BEGIN Question 6 clusterslist = group_by_centroid(restaurants, centroids) for i, cluster in enumerate(group_by_centroid(restaurants, centroids)): centroids[i] = find_centroid(cluster) # END Question 6 n += 1 return centroids
def GetHierarchy(self, bases): '''Parses the string "bases" from the xml into a list of tuples of Base instances. The first tuple is the most direct inheritance, and then it goes up in the hierarchy. ''' if bases is None: return [] base_names = bases.split() this_level = [] next_levels = [] for base in base_names: # get the visibility split = base.split(':') if len(split) == 2: visib = split[0] base = split[1] else: visib = Scope.public decl = self.GetDecl(base) if not isinstance(decl, Class): # on windows, there are some classes which "bases" points to an # "Unimplemented" tag, but we are not interested in this classes # anyway continue base = Base(decl.FullName(), visib) this_level.append(base) # normalize with the other levels for index, level in enumerate(decl.hierarchy): if index < len(next_levels): next_levels[index] = next_levels[index] + level else: next_levels.append(level) hierarchy = [] if this_level: hierarchy.append(tuple(this_level)) if next_levels: hierarchy.extend(next_levels) return hierarchy
def group_by_centroid(restaurants, centroids): """Return a list of clusters, where each cluster contains all restaurants nearest to a corresponding centroid in centroids. Each item in restaurants should appear once in the result, along with the other restaurants closest to the same centroid. """ # BEGIN Question 4 #enumerate for later binding centList = enumerate(centroids) #find correct centroid for each restaurant, return ordered list of centroids centForRestaurant = [find_closest(restaurant_location(restaurants[i]), centroids) for i in range(0, len(restaurants))] #swap centroid for key of centroid in centList centroidIndex = [centroids.index(n) for n in centForRestaurant] #associate restaurant with key of closest centroid restMapping = zip(centroidIndex, restaurants) #return cluster using group_by_first return group_by_first(restMapping)