def forward(self, x, bc, f): ''' x: size (batch_size x image_size x image_size) return: same size ''' batch_size = x.size(0) x = x.unsqueeze(1) r = - F.conv2d(x, self.fd_loss_kernel) if f is not None: r = f + r p = r.clone() rTr = utils.dot_product(r, r) for i in range(self.n_iters): p_pad = utils.pad_boundary(p.squeeze(1), torch.zeros(1, 4)).unsqueeze(1) Ap = F.conv2d(p_pad, self.fd_loss_kernel) pAp = utils.dot_product(p, Ap) alpha = (rTr / pAp).view(batch_size, 1, 1, 1) # Update x = x + alpha * p_pad r_new = r - alpha * Ap rTr_new = utils.dot_product(r_new, r_new) beta = (rTr_new / rTr).view(batch_size, 1, 1, 1) p_new = r_new + beta * p p = p_new r = r_new rTr = rTr_new return x.squeeze(1)
def closest_point(self, f_x, f_y, s_x, s_y, obs_bearing): ''' Calculate the closest point on the line to the feature The feature is the point (probably not on the line) The line is defined by a point (state x and y) and direction (heading) This probably won't return a point that is behind the x-y-bearing. Input: f_x float (feature's x coordinate) f_y float (feature's y coordinate) s_x float (robot state's x) s_y float (robot state's y) obs_bearing float (robot state's heading) ''' origin_to_feature = ( f_x - s_x, f_y - s_y, 0.0, ) line_parallel = unit((cos(obs_bearing), sin(obs_bearing), 0.0)) # origin_to_feature dot line_parallel = magnitude of otf along line magmag = dot_product(origin_to_feature, line_parallel) if magmag < 0: return (s_x, s_y) scaled_line = scale(line_parallel, magmag) scaled_x = scaled_line[0] scaled_y = scaled_line[1] return (float(s_x + scaled_x), float(s_y + scaled_y))
def distance_q(source_type, target_type, embs, e_size): # if pmode=COS, then using cossim to evaluate the distance # if pmode=DOT, then using dot product to evaluate the distance target_pool = copy.copy(embs[target_type]) # if mode == 'Het': # target_pool = {} # for n_type in ntypes: # target_pool.update(embs[n_type]) while 1: n_name = raw_input("Enter your node: ") if n_name in embs[source_type]: print 'looking for ' + n_name + '...' t_emb = embs[source_type][n_name] sim_map = {} for key in target_pool: if pmode == 'COS': sim_map[key] = utils.cossim(t_emb, target_pool[key]) if pmode == 'DOT': sim_map[key] = utils.dot_product(t_emb, target_pool[key]) sim_map = sorted(sim_map.items(), key=operator.itemgetter(1), reverse=True) print sim_map[:10] else: print 'name ' + n_name + ' is not fould in ' + source_type
def closest_point(self, f_x, f_y, s_x, s_y, obs_bearing): ''' Calculate the closest point on the line to the feature The feature is the point (probably not on the line) The line is defined by a point (state x and y) and direction (heading) This probably won't return a point that is behind the x-y-bearing. Input: f_x float (feature's x coordinate) f_y float (feature's y coordinate) s_x float (robot state's x) s_y float (robot state's y) obs_bearing float (robot state's heading) ''' origin_to_feature = (f_x - s_x, f_y - s_y, 0.0,) line_parallel = unit((cos(obs_bearing), sin(obs_bearing), 0.0)) # origin_to_feature dot line_parallel = magnitude of otf along line magmag = dot_product(origin_to_feature, line_parallel) if magmag < 0: return (s_x, s_y) scaled_line = scale(line_parallel, magmag) scaled_x = scaled_line[0] scaled_y = scaled_line[1] return (float(s_x + scaled_x), float(s_y + scaled_y))
def attack(self): r = self.r rm = self.public_key is_dual_code = self.m <= 2 * self.r if is_dual_code: r = self.m - 1 - r rm = rm.orthogonal d, rm = gcd_step(rm, r, self.m) if d != 1: logger.info('performing Minder-Shokrollahi attack...') rm_minus_1 = MinderShokrollahi(d, self.m).attack(rm) rm = dot_product(rm.orthogonal, rm_minus_1).orthogonal else: logger.info('skipping Minder-Shokrollahi step...') logger.debug('solving P and M matrices...') P = find_permutation(rm, self.m) if is_dual_code: r = self.m - 1 - r permuted_rm = rm_code.generator(r, self.m) * P M = find_nonsingular(self.public_key, permuted_rm) return M, P
def TM(filename, k, weights, testset=None): _weights = {'fwd':weights['fwd'], 'bwd':weights['bwd'], 'fwd_lex':weights['fwd_lex'], 'bwd_lex':weights['bwd_lex']} # if a test set is provided, load all src tirgrams in it NGRAM_FILTERING_THRESHOLD = 6 testset_ngrams = set() if testset != None: sys.stderr.write("phrase table will be filtered for test set {0}...".format(testset)) for line in io.open(testset, encoding='utf8', mode='r'): tokens = line.strip().split() for phrase_len in range(1, NGRAM_FILTERING_THRESHOLD+1): for start_index in range(0, len(tokens)-phrase_len): _phrase = ' '.join(tokens[start_index:start_index+phrase_len]) testset_ngrams.add(_phrase) sys.stderr.write("done. ngrams count = {0}\n".format(len(testset_ngrams))) sys.stderr.write("Reading translation model from %s...\n" % (filename,)) tm = {} tm_size=0 for line in io.open(filename, encoding='utf8'): (f, e, logprobs) = line.strip().split(" ||| ") f_tokens = f.strip().split() # filter out irrelevant phrase pairs # assert(testset != None) # sys.stderr.write(u'this thing is weird: {0}'.format(' '.join(f_tokens[0:NGRAM_FILTERING_THRESHOLD]))) if ' '.join(f_tokens[0:NGRAM_FILTERING_THRESHOLD]) not in testset_ngrams: #sys.stderr.write(u'this phrase was eliminated: {0}\n'.format(f)) continue if tm_size > 0 and tm_size % 100000 == 0: sys.stderr.write('tm_size={0}\n'.format(tm_size)) logprobs = logprobs.strip().split() bwd = log(float(logprobs[0])) bwd_lex = log(float(logprobs[1])) fwd = log(float(logprobs[2])) fwd_lex = log(float(logprobs[3])) p = phrase(e, fwd, bwd, fwd_lex, bwd_lex) f_tuple = tuple(f_tokens) if f_tuple in tm: tm[f_tuple].append(p) else: tm[f_tuple] = [p] tm_size += 1 for f in tm: # prune all but top k translations tm_size -= len(tm[f]) tm[f].sort(key=lambda x: dot_product({'fwd':x.fwd, 'bwd':x.bwd, 'fwd_lex':x.fwd_lex, 'bwd_lex':x.bwd_lex}, _weights)) del tm[f][k:] tm_size += len(tm[f]) sys.stderr.write('final tm_size={0}\n'.format(tm_size)) return tm
def classify_doc_real(t_emb, target_embs, pmode): # if not hierarchical sim_map = {} for key in target_embs: if pmode == 'COS': sim_map[key] = utils.cossim(t_emb, target_embs[key]) if pmode == 'DOT': sim_map[key] = utils.dot_product(t_emb, target_embs[key]) sim_map = sorted(sim_map.items(), key=operator.itemgetter(1), reverse=True) return sim_map
def predict(example): o_nodes = learned_net[1] # forward pass for node in o_nodes: in_val = dot_product(example, node.weights) node.value = node.activation(in_val) # hypothesis return find_max_node(o_nodes)
def LogisticLinearLeaner(dataset, learning_rate=0.01, epochs=100): """ [Section 18.6.4] Linear classifier with logistic regression. """ idx_i = dataset.inputs idx_t = dataset.target examples = dataset.examples num_examples = len(examples) # X transpose X_col = [dataset.values[i] for i in idx_i] # vertical columns of X # add dummy ones = [1 for _ in range(len(examples))] X_col = [ones] + X_col # initialize random weights num_weights = len(idx_i) + 1 w = random_weights(min_value=-0.5, max_value=0.5, num_weights=num_weights) for epoch in range(epochs): err = [] h = [] # pass over all examples for example in examples: x = [1] + example y = sigmoid(dot_product(w, x)) h.append(sigmoid_derivative(y)) t = example[idx_t] err.append(t - y) # update weights for i in range(len(w)): buffer = [x * y for x, y in zip(err, h)] w[i] = w[i] + learning_rate * (dot_product(buffer, X_col[i]) / num_examples) def predict(example): x = [1] + example return sigmoid(dot_product(w, x)) return predict
def LinearLearner(dataset, learning_rate=0.01, epochs=100): """ [Section 18.6.3] Linear classifier with hard threshold. """ idx_i = dataset.inputs idx_t = dataset.target examples = dataset.examples num_examples = len(examples) # X transpose X_col = [dataset.values[i] for i in idx_i] # vertical columns of X # add dummy ones = [1 for _ in range(len(examples))] X_col = [ones] + X_col # initialize random weights num_weights = len(idx_i) + 1 w = random_weights(min_value=-0.5, max_value=0.5, num_weights=num_weights) for epoch in range(epochs): err = [] # pass over all examples for example in examples: x = [1] + example y = dot_product(w, x) t = example[idx_t] err.append(t - y) # update weights for i in range(len(w)): w[i] = w[i] + learning_rate * (dot_product(err, X_col[i]) / num_examples) def predict(example): x = [1] + example return dot_product(w, x) return predict
def calculate_score(self, doc_ids_to_scores): """Returns a list of (score, doc_id). Calculates the dot product between each document's score for each feature and the respective feature weights.""" results = [] for doc_id, score in doc_ids_to_scores.iteritems(): doc_score_vector = [score.get(key, 0) for key in self.features_vector_key] doc_score = utils.dot_product( doc_score_vector, self.features_weights) results.append((doc_score, doc_score_vector, doc_id)) return results
def predict(example): # input nodes i_nodes = learned_net[0] # activate input layer for v, n in zip(example, i_nodes): n.value = v # forward pass for layer in learned_net[1:]: for node in layer: inc = [n.value for n in node.inputs] in_val = dot_product(inc, node.weights) node.value = node.activation(in_val) # hypothesis o_nodes = learned_net[-1] prediction = find_max_node(o_nodes) return prediction
def score_one(self, rest, avg_number_of_ratings): """ Calculates the overall score for a single restaurant, out of 10 :param rest: Obj representing the restaurant to calculate a score for :param avg_number_of_ratings: The average number of ratings received by restaurants in this batch :return: The overall score of the restaurant, out of 10 """ scores = [ self.calc_location_score(rest), self.calc_rating_score(rest, avg_number_of_ratings), self.calc_price_score(rest) ] print( f"Restaurant: {rest.name}\nRatings (score, num): {[rest.rating, rest.num_ratings]}\nScores (loc, rating, price): {scores}\n\n" ) final_score = dot_product(self.weights, scores) * self.MAX_SCORE / sum( self.weights) return final_score
def build_actor_actor_matrix(actors_tag_vector): """ Build actor similarity matrix based on the actors_tag_vector. :param actors_tag_vector: actors in tags vector space :return: actor_matrix, 2D matrix describes the actor similarity actors, sorted_actor_list, you can get (index in matrix)->(actor id) actors_index, actor_index_dict, you can get (actor id)->(index in matrix) """ actors = sorted(actors_tag_vector.keys()) actors_index = {} for i, v in enumerate(actors): actors_index[v] = i actor_matrix = zeros((len(actors), len(actors))) for i, _actor in enumerate(actors): for j, actor in enumerate(actors): actor_matrix[i][j] = dot_product(actors_tag_vector[_actor], actors_tag_vector[actor])[0] return actor_matrix, actors, actors_index
def build_movie_movie_matrix(movies_tag_vector): """ Build movie similarity matrix based on the movies_tag_vector. :param movies_tag_vector: movies in tags vector space :return: movie_matrix, 2D matrix describes the movie similarity movies, sorted_movie_list, you can get (index in matrix)->(movie id) movies_index, movie_index_dict, you can get (movie id)->(index in matrix) """ movies = sorted(movies_tag_vector.keys()) movies_index = {} for i, v in enumerate(movies): movies_index[v] = i movie_matrix = zeros((len(movies), len(movies))) for i, _movie in enumerate(movies): for j, movie in enumerate(movies): movie_matrix[i][j] = dot_product(movies_tag_vector[_movie], movies_tag_vector[movie])[0] return movie_matrix, movies, movies_index
def along_axis_error(self, location, goal): """ calc error along the axis defined by the goal position and direction input: two nav_msgs.msg.Odometry, current best location estimate + goal output: double distance along the axis axis is defined by a vector from the unit circle aligned with the goal heading relative position is the vector from the goal x, y to the location x, y distance is defined by the dot product example use: see calc_errors above """ relative_position_x = (goal.pose.pose.position.x - location.pose.pose.position.x) relative_position_y = (goal.pose.pose.position.y - location.pose.pose.position.y) # relative position of the best estimate position and the goal # vector points from the goal to the location relative_position = (relative_position_x, relative_position_y, 0.0) goal_heading = quaternion_to_heading(goal.pose.pose.orientation) goal_vector_x = math.cos(goal_heading) goal_vector_y = math.sin(goal_heading) # vector in the direction of the goal heading, axis of desired motion goal_vector = (goal_vector_x, goal_vector_y, 0.0) val = dot_product(relative_position, goal_vector) if abs(val) < .0001: return 0.0 return -val
def find_related_actors_of_a_movie(movie_id, movie_actor_list, movie_tfidf_tags, movie_tags, actor_tfidf_tags, actor_tags, mode): """ Task 1d, given a movie, finding the top10 most related actors who have not acted in the movie, leveraging the given movie's TF-IDF tag vectors, top 5 latent semantics in the space of tags. :param movie_id: Movie id given by user :param movie_actor_list: A list contains the actors acted in this movie :param movie_tfidf_tags: Movie mapped into tf-idf tags vector :param movie_tags: Movie mapped into raw tags vector :param actor_tfidf_tags: Actors mapped into tf-idf tags vector :param actor_tags: Actors mapped into raw tags vector :return: """ if movie_id not in movie_tags: print('invalid movieid') return if mode == 'TF-IDF': result = {} for actor in actor_tfidf_tags: if actor in movie_actor_list[movie_id]: continue dot_product, cosine = lib.dot_product(actor_tfidf_tags[actor], movie_tfidf_tags[movie_id]) # print(math.acos(cosine)/math.pi * 180) result[actor] = dot_product for r in sorted(result.items(), key=lambda x: x[1], reverse=True)[:10]: print('actor_id: ', r[0], 'dot_product: ', r[1]) # sort cosine output top-10 elif mode == 'SVD': # construct a matrix from movie_id, actors tags a, row_name, column_name = dict_to_matrix(movie_tfidf_tags[movie_id], actor_tfidf_tags) # SVD u, s, v = np.linalg.svd(a, full_matrices=False) result = {} # select top-5 latent semantics indies # print(np.allclose(a[0], np.dot(u[0], np.dot(np.diag(s), v)))) for i, actor in enumerate(row_name): if actor in movie_actor_list[movie_id]: continue result[actor] = np.dot(u[0][:5], u[i + 1][:5]) for r in sorted(result.items(), key=lambda x: x[1], reverse=True)[:10]: print('actor_id: ', r[0], 'dot_product: ', r[1]) elif mode == 'PCA': # construct a matrix from movie_id, actors tags a, row_name, column_name = dict_to_matrix(movie_tfidf_tags[movie_id], actor_tfidf_tags) # PCA pca = PCA() u = pca.fit_transform(a) result = {} # select top-5 latent semantics indies for i, actor in enumerate(row_name): if actor in movie_actor_list[movie_id]: continue result[actor] = np.dot(u[0][:5], u[i + 1][:5]) for r in sorted(result.items(), key=lambda x: x[1], reverse=True)[:10]: print('actor_id: ', r[0], 'dot_product: ', r[1]) elif mode == 'LDA': movie = movie_tags[movie_id] for actor in actor_tags: for tag in actor_tags[actor]: if tag not in movie: movie[tag] = 0 model, topic_terms = generate_model(movie) latent_semantics = get_top_10_using_LDA_model( movie_actor_list[movie_id], model, topic_terms, actor_tags) for actor in sorted(latent_semantics.items(), key=lambda x: x[1], reverse=True)[:10]: print('actor_id: ', actor[0], ' dot_product: ', actor[1]) else: print('unsupported mode')
def BackPropagationLearner(dataset, net, learning_rate, epochs, activation=sigmoid): """ [Figure 18.23] The back-propagation algorithm for multilayer networks. """ # initialise weights for layer in net: for node in layer: node.weights = random_weights(min_value=-0.5, max_value=0.5, num_weights=len(node.weights)) examples = dataset.examples # As of now dataset.target gives an int instead of list, # Changing dataset class will have effect on all the learners. # Will be taken care of later. o_nodes = net[-1] i_nodes = net[0] o_units = len(o_nodes) idx_t = dataset.target idx_i = dataset.inputs n_layers = len(net) inputs, targets = init_examples(examples, idx_i, idx_t, o_units) for epoch in range(epochs): # iterate over each example for e in range(len(examples)): i_val = inputs[e] t_val = targets[e] # activate input layer for v, n in zip(i_val, i_nodes): n.value = v # forward pass for layer in net[1:]: for node in layer: inc = [n.value for n in node.inputs] in_val = dot_product(inc, node.weights) node.value = node.activation(in_val) # initialize delta delta = [[] for _ in range(n_layers)] # compute outer layer delta # error for the MSE cost function err = [t_val[i] - o_nodes[i].value for i in range(o_units)] # calculate delta at output if node.activation == sigmoid: delta[-1] = [ sigmoid_derivative(o_nodes[i].value) * err[i] for i in range(o_units) ] elif node.activation == relu: delta[-1] = [ relu_derivative(o_nodes[i].value) * err[i] for i in range(o_units) ] elif node.activation == tanh: delta[-1] = [ tanh_derivative(o_nodes[i].value) * err[i] for i in range(o_units) ] elif node.activation == elu: delta[-1] = [ elu_derivative(o_nodes[i].value) * err[i] for i in range(o_units) ] else: delta[-1] = [ leaky_relu_derivative(o_nodes[i].value) * err[i] for i in range(o_units) ] # backward pass h_layers = n_layers - 2 for i in range(h_layers, 0, -1): layer = net[i] h_units = len(layer) nx_layer = net[i + 1] # weights from each ith layer node to each i + 1th layer node w = [[node.weights[k] for node in nx_layer] for k in range(h_units)] if activation == sigmoid: delta[i] = [ sigmoid_derivative(layer[j].value) * dot_product(w[j], delta[i + 1]) for j in range(h_units) ] elif activation == relu: delta[i] = [ relu_derivative(layer[j].value) * dot_product(w[j], delta[i + 1]) for j in range(h_units) ] elif activation == tanh: delta[i] = [ tanh_derivative(layer[j].value) * dot_product(w[j], delta[i + 1]) for j in range(h_units) ] elif activation == elu: delta[i] = [ elu_derivative(layer[j].value) * dot_product(w[j], delta[i + 1]) for j in range(h_units) ] else: delta[i] = [ leaky_relu_derivative(layer[j].value) * dot_product(w[j], delta[i + 1]) for j in range(h_units) ] # update weights for i in range(1, n_layers): layer = net[i] inc = [node.value for node in net[i - 1]] units = len(layer) for j in range(units): layer[j].weights = vector_add( layer[j].weights, scalar_vector_product(learning_rate * delta[i][j], inc)) return net
def predict(example): x = [1] + example return sigmoid(dot_product(w, x))
def predict(example): x = [1] + example return dot_product(w, x)
def dot_and_cosine(v1, v2): return utils.dot_product(v1, v2)[0]