def rate_all(user, restaurants, feature_fns): """Return the predicted ratings of restaurants by user using the best predictor based on a function from feature_fns. Arguments: user -- A user restaurants -- A list of restaurants feature_fns -- A sequence of feature functions """ predictor = best_predictor(user, ALL_RESTAURANTS, feature_fns) reviewed = user_reviewed_restaurants(user, restaurants) # BEGIN Question 9 "*** REPLACE THIS LINE ***" pred_rest_name = [ restaurant_name(restaurant) for restaurant in restaurants ] pred_rest_review = [predictor(restaurant) for restaurant in restaurants] pred_rate = { name: rating for name, rating in zip(pred_rest_name, pred_rest_review) } rest_name = [restaurant_name(restaurant) for restaurant in reviewed] rest_review = [user_rating(user, restaurant) for restaurant in rest_name] rate_user = {name: rating for name, rating in zip(rest_name, rest_review)} pred_rate.update(rate_user) return pred_rate
def rate_all(user, restaurants, feature_fns): """Return the predicted ratings of restaurants by user using the best predictor based a function from feature_fns. Arguments: user -- A user restaurants -- A list of restaurants feature_fns -- A sequence of feature functions """ predictor = best_predictor(user, ALL_RESTAURANTS, feature_fns) reviewed = user_reviewed_restaurants(user, restaurants) # BEGIN Question 9 "*** REPLACE THIS LINE ***" #restaurant_ratings={name:reviewed(user,name) for name in reviewed} #user_reviewed=restaurant_ratings.keys() #restaurant_ratings.update({x:predictor(restaurants[x]) for x in restaurants if x not in user_reviewed}) #return restaurant_ratings reviewed_restaurants= [restaurant_name(restaurant) for restaurant in reviewed] user_rest_ratings= [user_rating(user, restaurant) for restaurant in reviewed_restaurants] user_reviewed= {name: rating for name, rating in zip(reviewed_restaurants, user_rest_ratings)} all_restaurants = [restaurant_name(restaurant) for restaurant in restaurants] pred_rest_ratings = [predictor(restaurant) for restaurant in restaurants] all_ratings_dict= {name: rating for name, rating in zip(all_restaurants, pred_rest_ratings)} all_ratings_dict.update(user_reviewed) return all_ratings_dict
def deploy(machine=None): print green("当前机器:" + env.host) #如果指定机器,那就只上着一个 if machine and not machine == env.host: return #关闭slb #print env.host for slb in env.slbList: utils.setSlb(env.slbServer, slb, 0) utils.runCmd("sleep 5") #备份 utils.zip(env.online) utils.download(env.online, env.localPath) #上传 utils.upload(env.source, env.target) #杀掉进程 utils.stopProcess(env.aport) utils.runCmd("sleep 10") #解压缩 utils.unzip(env.online) #开始进程 utils.runCmd(env.start_process) #sleep 多少秒 utils.runCmd("sleep " + env.sleep_time) #监控进程 run(env.monitor_url) #上线slb for slb in env.slbList: utils.setSlb(env.slbServer, slb, 100)
def rate_all(user, restaurants, feature_fns): """Return the predicted ratings of restaurants by user using the best predictor based on a function from feature_fns. Arguments: user -- A user restaurants -- A list of restaurants feature_fns -- A sequence of feature functions """ predictor = best_predictor(user, ALL_RESTAURANTS, feature_fns) reviewed = user_reviewed_restaurants(user, restaurants) # BEGIN Question 9 rest_names = [restaurant_name(x) for x in restaurants] pred_rest_ratings = [predictor(x) for x in restaurants] dict_all = { name: rating for name, rating in zip(rest_names, pred_rest_ratings) } reviewed_names = [restaurant_name(x) for x in reviewed] user_rest_ratings = [ user_rating(user, restaurant) for restaurant in reviewed_names ] dict_user = { name: rating for name, rating in zip(reviewed_names, user_rest_ratings) } dict_all.update(dict_user) return dict_all
def find_centroid(cluster): """Return the centroid of the locations of the restaurants in cluster.""" # BEGIN Question 5 (dont avoid the abstraction barrier) return [ mean(zip(*[restaurant_location(r) for r in cluster])[0]), mean(zip(*[restaurant_location(r) for r in cluster])[1]) ]
def rate_all(user, restaurants, feature_fns): """Return the predicted ratings of restaurants by user using the best predictor based on a function from feature_fns. Arguments: user -- A user restaurants -- A list of restaurants feature_fns -- A sequence of feature functions """ predictor = best_predictor(user, ALL_RESTAURANTS, feature_fns) reviewed = user_reviewed_restaurants(user, restaurants) # BEGIN Question 9 reviewed_rest_names = [restaurant_name(r) for r in reviewed] reviewed_rating = [user_rating(user, restaurant_name(r)) for r in reviewed] reviewed_all = zip(reviewed_rest_names, reviewed_rating) predicted_rest_names = [ restaurant_name(r) for r in restaurants if r not in reviewed ] predicted_rating = [predictor(r) for r in restaurants if r not in reviewed] predicted_all = zip(predicted_rest_names, predicted_rating) combine_pairs = predicted_all + reviewed_all return dict(combine_pairs)
def find_predictor(user, restaurants, feature_fn): """Return a rating predictor (a function from restaurants to ratings), for a user by performing least-squares linear regression using feature_fn on the items in restaurants. Also, return the R^2 value of this model. Arguments: user -- A user restaurants -- A sequence of restaurants feature_fn -- A function that takes a restaurant and returns a number """ reviews_by_user = { review_restaurant_name(review): review_rating(review) for review in user_reviews(user).values() } xs = [feature_fn(r) for r in restaurants] ys = [reviews_by_user[restaurant_name(r)] for r in restaurants] # BEGIN Question 7 sx = [i - mean(xs) for i in xs] sy = [i - mean(ys) for i in ys] sxx = sum([k[0] * k[1] for k in zip(sx, sx)]) syy = sum([k[0] * k[1] for k in zip(sy, sy)]) sxy = sum([k[0] * k[1] for k in zip(sx, sy)]) b = sxy / sxx a = mean(ys) - b * mean(xs) r_squared = sxy * sxy / (sxx * syy) # END Question 7 def predictor(restaurant): return b * feature_fn(restaurant) + a return predictor, r_squared
def main(): url = 'http://jandan.net/ooxx' curPage = getHost.getMainUrl(url) utils.logger.info('please input nums you want catch (0~' + curPage + ') :') maxCatchPage = int(raw_input("")) while maxCatchPage > int(curPage) or maxCatchPage < 0: utils.logger.info('please input nums you want catch (0~' + curPage + ') :') maxCatchPage = int(raw_input("")) utils.logger.info( 'please 10input thread nums you want lanuch (n*5&less20):') threadCount = int(raw_input("")) while threadCount > 20 or threadCount < 0: utils.logger.info( 'please input thread nums you want lanuch (n*5&less20):') threadCount = int(raw_input("")) start = time.clock() if curPage: myThread.createThread(threadCount, maxCatchPage, curPage) utils.zip('Img') else: print 'main() get tilUrls failed.' end = time.clock() utils.logger.info("process used time: %f s" % (end - start))
def zip(online=None, machine=None): if not machine or not online: abort("机器、远程路径不能为空") print green("当前机器:" + env.host) if machine and not machine == env.host: return utils.zip(online)
def find_predictor(user, restaurants, feature_fn): """Return a rating predictor (a function from restaurants to ratings), for a user by performing least-squares linear regression using feature_fn on the items in restaurants. Also, return the R^2 value of this model. Arguments: user -- A user restaurants -- A sequence of restaurants feature_fn -- A function that takes a restaurant and returns a number """ xs = [feature_fn(r) for r in restaurants] ys = [user_rating(user, restaurant_name(r)) for r in restaurants] # BEGIN Question 7 xys = zip(xs, ys) meanx = mean(xs) meany = mean(ys) sxx = reduce(lambda s, x: pow(x - meanx, 2) + s, xs, 0) syy = reduce(lambda s, y: pow(y - meany, 2) + s, ys, 0) sxy = reduce(lambda s, xy: (xy[0] - meanx) * (xy[1] - meany) + s, xys, 0) b = sxy / sxx a = meany - b * meanx r_squared = pow(sxy, 2) / (sxx * syy) # END Question 7 def predictor(restaurant): return b * feature_fn(restaurant) + a return predictor, r_squared
def find_predictor(user, restaurants, feature_fn): """Return a rating predictor (a function from restaurants to ratings), for a user by performing least-squares linear regression using feature_fn on the items in restaurants. Also, return the R^2 value of this model. Arguments: user -- A user restaurants -- A sequence of restaurants feature_fn -- A function that takes a restaurant and returns a number """ reviews_by_user = {review_restaurant_name(review): review_rating(review) for review in user_reviews(user).values()} xs = [feature_fn(r) for r in restaurants] ys = [reviews_by_user[restaurant_name(r)] for r in restaurants] # BEGIN Question 7 Sxx = sum([(x - mean(xs))**2 for x in xs]) Syy = sum([(y - mean(ys))**2 for y in ys]) Sxy = sum([(x - mean(xs)) * (y - mean(ys)) for x, y in zip(xs, ys)]) b = Sxy/Sxx a = mean(ys) - b*mean(xs) r_squared = Sxy**2/(Sxx*Syy) # END Question 7 def predictor(restaurant): return b * feature_fn(restaurant) + a return predictor, r_squared
def find_predictor(user, restaurants, feature_fn): """Return a rating predictor (a function from restaurants to ratings), for a user by performing least-squares linear regression using feature_fn on the items in restaurants. Also, return the R^2 value of this model. Arguments: user -- A user restaurants -- A sequence of restaurants feature_fn -- A function that takes a restaurant and returns a number """ reviews_by_user = {review_restaurant_name(review): review_rating(review) for review in user_reviews(user).values()} xs = [feature_fn(r) for r in restaurants] ys = [reviews_by_user[restaurant_name(r)] for r in restaurants] # BEGIN Question 7 "*** REPLACE THIS LINE ***" # b, a, r_squared = 0, 0, 0 # REPLACE THIS LINE WITH YOUR SOLUTION mean_x = mean(xs) mean_y = mean(ys) xys = zip(xs, ys) sxx = sum([(x-mean_x) * (x-mean_x) for x in xs]) syy = sum([(y-mean_y) * (y-mean_y) for y in ys]) sxy = sum([(x-mean_x) * (y-mean_y) for x, y in xys]) b = sxy / sxx a = mean_y - b * mean_x r_squared = sxy * sxy / (sxx * syy) # END Question 7 def predictor(restaurant): return b * feature_fn(restaurant) + a return predictor, r_squared
def find_predictor(user, restaurants, feature_fn): """Return a rating predictor (a function from restaurants to ratings), for a user by performing least-squares linear regression using feature_fn on the items in restaurants. Also, return the R^2 value of this model. Arguments: user -- A user restaurants -- A sequence of restaurants feature_fn -- A function that takes a restaurant and returns a number """ reviews_by_user = {review_restaurant_name(review): review_rating(review) for review in user_reviews(user).values()} xs = [feature_fn(r) for r in restaurants] ys = [reviews_by_user[restaurant_name(r)] for r in restaurants] # BEGIN Question 7 xx, yy, sxy = [elem - mean(xs) for elem in xs], [elem - mean(ys) for elem in ys], 0 # computes the standard deviations of x and y sxx, syy = sum(x**2 for x in xx), sum(y**2 for y in yy) for a, b in zip(xx, yy): sxy += a*b # finds a and b to solve for predictor function b = sxy/sxx a = mean(ys) - b*mean(xs) r_squared = sxy**2/(sxx*syy) # END Question 7 def predictor(restaurant): return b * feature_fn(restaurant) + a return predictor, r_squared
def find_predictor(user, restaurants, feature_fn): """Return a rating predictor (a function from restaurants to ratings), for a user by performing least-squares linear regression using feature_fn on the items in restaurants. Also, return the R^2 value of this model. Arguments: user -- A user restaurants -- A sequence of restaurants feature_fn -- A function that takes a restaurant and returns a number """ reviews_by_user = {review_restaurant_name(review): review_rating(review) for review in user_reviews(user).values()} xs = [feature_fn(r) for r in restaurants] ys = [reviews_by_user[restaurant_name(r)] for r in restaurants] # BEGIN Question 7 "*** REPLACE THIS LINE ***" mean_x, mean_y = mean(xs), mean(ys) xx_list = [x - mean_x for x in xs] yy_list = [y - mean_y for y in ys] xy_list = zip(xx_list, yy_list) S_xx = sum([xx ** 2 for xx in xx_list]) S_yy = sum([yy ** 2 for yy in yy_list]) S_xy = sum([xx * yy for xx, yy in xy_list]) b = S_xy / S_xx a = mean_y - b * mean_x r_squared = S_xy ** 2 / (S_xx * S_yy) # END Question 7 def predictor(restaurant): return b * feature_fn(restaurant) + a return predictor, r_squared
def find_predictor(user, restaurants, feature_fn): """Return a rating predictor (a function from restaurants to ratings), for USER by performing least-squares linear regression using FEATURE_FN on the items in RESTAURANTS. Also, return the R^2 value of this model. Arguments: user -- A user restaurants -- A sequence of restaurants feature_fn -- A function that takes a restaurant and returns a number """ reviews_by_user = {review_restaurant_name(review): review_rating(review) for review in user_reviews(user).values()} xs = [feature_fn(r) for r in restaurants] ys = [reviews_by_user[restaurant_name(r)] for r in restaurants] "*** YOUR CODE HERE ***" b, a, r_squared = 0, 0, 0 # REPLACE THIS LINE WITH YOUR SOLUTION mean_x = mean(xs) mean_y = mean(ys) s_xx = sum([pow(x-mean_x,2) for x in xs]) s_yy = sum([pow(y-mean_y,2) for y in ys]) xy_pair = zip(xs,ys) s_xy = sum([(pair[0]-mean_x)*(pair[1]-mean_y) for pair in xy_pair]) b = s_xy/s_xx a = mean_y-b*mean_x r_squared = pow(s_xy,2)/(s_xx*s_yy) def predictor(restaurant): return b * feature_fn(restaurant) + a return predictor, r_squared
def find_predictor(user, restaurants, feature_fn): """Return a rating predictor (a function from restaurants to ratings), for USER by performing least-squares linear regression using FEATURE_FN on the items in RESTAURANTS. Also, return the R^2 value of this model. Arguments: user -- A user restaurants -- A sequence of restaurants feature_fn -- A function that takes a restaurant and returns a number """ ## dictionary of (name: rating) pairs for a SINGLE user reviews_by_user = { review_restaurant_name(review): review_rating(review) for review in user_reviews(user).values() } xs = [feature_fn(r) for r in restaurants] ys = [reviews_by_user[restaurant_name(r)] for r in restaurants] Sxx_list = [r - mean(xs) for r in xs] Syy_list = [r - mean(ys) for r in ys] Sxy_list = zip(Sxx_list, Syy_list) Sxx = sum([pow(r, 2) for r in Sxx_list]) Syy = sum([pow(r, 2) for r in Syy_list]) Sxy = sum([r[0] * r[1] for r in Sxy_list]) b = Sxy / Sxx a = mean(ys) - b * mean(xs) r_squared = pow(Sxy, 2) / (Sxx * Syy) def predictor(restaurant): return b * feature_fn(restaurant) + a return predictor, r_squared
def find_predictor(user, restaurants, feature_fn): """Return a rating predictor (a function from restaurants to ratings), for a user by performing least-squares linear regression using feature_fn on the items in restaurants. Also, return the R^2 value of this model. Arguments: user -- A user restaurants -- A sequence of restaurants feature_fn -- A function that takes a restaurant and returns a number """ reviews_by_user = { review_restaurant_name(review): review_rating(review) for review in user_reviews(user).values() } xs = [feature_fn(r) for r in restaurants] ys = [reviews_by_user[restaurant_name(r)] for r in restaurants] # BEGIN Question 7 sum_squares = lambda x, y: sum([p[0] * p[1] for p in zip(x, y)]) x = [x - mean(xs) for x in xs] y = [y - mean(ys) for y in ys] s_xx = sum_squares(x, x) s_yy = sum_squares(y, y) s_xy = sum_squares(x, y) b, r_squared = s_xy / s_xx, s_xy**2 / ( s_xx * s_yy) # REPLACE THIS LINE WITH YOUR SOLUTION a = mean(ys) - b * mean(xs) # END Question 7 def predictor(restaurant): return b * feature_fn(restaurant) + a return predictor, r_squared
def find_predictor(user, restaurants, feature_fn): """Return a rating predictor (a function from restaurants to ratings), for a user by performing least-squares linear regression using feature_fn on the items in restaurants. Also, return the R^2 value of this model. Arguments: user -- A user restaurants -- A sequence of restaurants feature_fn -- A function that takes a restaurant and returns a number """ reviews_by_user = {review_restaurant_name(review): review_rating(review) for review in user_reviews(user).values()} xs = [feature_fn(r) for r in restaurants] ys = [reviews_by_user[restaurant_name(r)] for r in restaurants] S_xx, S_yy, S_xy = 0, 0, 0 mean_x, mean_y = mean(xs), mean(ys) for x in xs: S_xx += (x - mean_x)**2 for y in ys: S_yy += (y - mean_y)**2 xsys = zip(xs, ys) for x, y in xsys: S_xy += (x - mean_x) * (y - mean_y) b, a, r_squared = S_xy / S_xx, mean_y - (S_xy / S_xx) * mean_x, S_xy**2 / (S_xx * S_yy) def predictor(restaurant): return b * feature_fn(restaurant) + a return predictor, r_squared
def find_predictor(user, restaurants, feature_fn): """Return a rating predictor (a function from restaurants to ratings), for a user by performing least-squares linear regression using feature_fn on the items in restaurants. Also, return the R^2 value of this model. Arguments: user -- A user restaurants -- A sequence of restaurants feature_fn -- A function that takes a restaurant and returns a number """ reviews_by_user = { review_restaurant_name(review): review_rating(review) for review in user_reviews(user).values() } xs = [feature_fn(r) for r in restaurants] ys = [reviews_by_user[restaurant_name(r)] for r in restaurants] # BEGIN Question 7 S_xx = sum([(x - mean(xs))**2 for x in xs]) S_yy = sum([(y - mean(ys))**2 for y in ys]) S_xy = sum([(x - mean(xs)) * (y - mean(ys)) for x, y in zip(xs, ys)]) b, a, r_squared = S_xy / S_xx, mean(ys) - (S_xy / S_xx) * mean( xs), S_xy**2 / (S_xx * S_yy) # REPLACE THIS LINE WITH YOUR SOLUTION # END Question 7 def predictor(restaurant): return b * feature_fn(restaurant) + a return predictor, r_squared
def find_predictor(user, restaurants, feature_fn): """Return a rating predictor (a function from restaurants to ratings), for USER by performing least-squares linear regression using FEATURE_FN on the items in RESTAURANTS. Also, return the R^2 value of this model. Arguments: user -- A user restaurants -- A sequence of restaurants feature_fn -- A function that takes a restaurant and returns a number """ reviews_by_user = {review_restaurant_name(review): review_rating(review) for review in user_reviews(user).values()} xs = [feature_fn(r) for r in restaurants] ys = [reviews_by_user[restaurant_name(r)] for r in restaurants] mean_xs = mean(xs) mean_ys = mean(ys) s_xx = sum([pow(x - mean_xs, 2) for x in xs]) s_yy = sum([pow(y - mean_ys, 2) for y in ys]) s_xy = sum([mul(z[0], z[1]) for z in zip([x - mean_xs for x in xs], [y - mean_ys for y in ys])]) b = s_xy / s_xx a = mean_ys - b * mean_xs r_squared = pow(s_xy, 2) / mul(s_xx, s_yy) def predictor(restaurant): return b * feature_fn(restaurant) + a return predictor, r_squared
def find_predictor(user, restaurants, feature_fn): """Return a rating predictor (a function from restaurants to ratings), for `user` by performing least-squares linear regression using `feature_fn` on the items in `restaurants`. Also, return the R^2 value of this model. Arguments: user -- A user restaurants -- A sequence of restaurants feature_fn -- A function that takes a restaurant and returns a number """ reviews_by_user = {review_restaurant_name(review): review_rating(review) for review in user_reviews(user).values()} xs = [feature_fn(r) for r in restaurants] ys = [reviews_by_user[restaurant_name(r)] for r in restaurants] # BEGIN Question 7 "*** REPLACE THIS LINE ***" x_mean = mean(xs) y_mean = mean(ys) s_xx = sum([pow(x-x_mean,2) for x in xs]) s_yy = sum([pow(y-y_mean,2) for y in ys]) s_xy = sum([(x-x_mean)*(y-y_mean) for x,y in zip(xs,ys)]) b, a, r_squared = s_xy/s_xx, y_mean - (s_xy/s_xx)*x_mean, (pow(s_xy,2))/(s_xx*s_yy) # REPLACE THIS LINE WITH YOUR SOLUTION # END Question 7 def predictor(restaurant): return b * feature_fn(restaurant) + a return predictor, r_squared
def find_predictor(user, restaurants, feature_fn): """Return a rating predictor (a function from restaurants to ratings), for a user by performing least-squares linear regression using feature_fn on the items in restaurants. Also, return the R^2 value of this model. Arguments: user -- A user restaurants -- A sequence of restaurants feature_fn -- A function that takes a restaurant and returns a number """ reviews_by_user = {review_restaurant_name(review): review_rating(review) for review in user_reviews(user).values()} #print (reviews_by_user) xs = [feature_fn(r) for r in restaurants] ys = [reviews_by_user[restaurant_name(r)] for r in restaurants] joined_list = zip(xs, ys) # BEGIN Question 7 meanx = mean(xs) meany = mean(ys) sxx = sum([(x-meanx)**2 for x in xs]) syy = sum([(y-meany)**2 for y in ys]) sxy = sum([(xy[0]-meanx)*(xy[1]-meany) for xy in joined_list]) b = sxy/ sxx a = meany - b * meanx r_squared = sxy**2 / (sxx * syy) # END Question 7 def predictor(restaurant): return b * feature_fn(restaurant) + a return predictor, r_squared
def find_predictor(user, restaurants, feature_fn): """Return a rating predictor (a function from restaurants to ratings), for a user by performing least-squares linear regression using feature_fn on the items in restaurants. Also, return the R^2 value of this model. Arguments: user -- A user restaurants -- A sequence of restaurants feature_fn -- A function that takes a restaurant and returns a number """ reviews_by_user = {review_restaurant_name(review): review_rating(review) for review in user_reviews(user).values()} xs = [feature_fn(r) for r in restaurants] ys = [reviews_by_user[restaurant_name(r)] for r in restaurants] x_avg, y_avg = mean(xs), mean(ys) Sxx, Syy = sum([(x-x_avg)**2 for x in xs]), sum([(y-y_avg)**2 for y in ys]) x_y_pairs = zip(xs,ys) Sxy = sum([(pair[0]-x_avg)*(pair[1]-y_avg) for pair in x_y_pairs]) b, r_squared = Sxy/Sxx, Sxy**2/(Sxx*Syy) a = y_avg - b*x_avg def predictor(restaurant): return b * feature_fn(restaurant) + a return predictor, r_squared
def find_predictor(user, restaurants, feature_fn): """Return a rating predictor (a function from restaurants to ratings), for a user by performing least-squares linear regression using feature_fn on the items in restaurants. Also, return the R^2 value of this model. Arguments: user -- A user restaurants -- A sequence of restaurants feature_fn -- A function that takes a restaurant and returns a number """ reviews_by_user = {review_restaurant_name(review): review_rating(review) for review in user_reviews(user).values()} xs = [feature_fn(r) for r in restaurants] ys = [reviews_by_user[restaurant_name(r)] for r in restaurants] # BEGIN Question 7 s_xx, x_mean, s_yy, y_mean, s_xy = 0, mean(xs), 0, mean(ys), 0 for i in xs: s_xx += (i-x_mean)**2 for j in ys: s_yy += (j-y_mean)**2 xy_list = zip(xs, ys) for i, j in xy_list: s_xy += (i-x_mean)*(j-y_mean) b = s_xy/s_xx a = y_mean - b*x_mean r_squared = s_xy**2 / (s_xx*s_yy) # END Question 7 def predictor(restaurant): return b * feature_fn(restaurant) + a return predictor, r_squared
def find_predictor(user, restaurants, feature_fn): """Return a rating predictor (a function from restaurants to ratings), for a user by performing least-squares linear regression using feature_fn on the items in restaurants. Also, return the R^2 value of this model. Arguments: user -- A user restaurants -- A sequence of restaurants feature_fn -- A function that takes a restaurant and returns a number """ reviews_by_user = { review_restaurant_name(review): review_rating(review) for review in user_reviews(user).values() } xs = [feature_fn(r) for r in restaurants] ys = [reviews_by_user[restaurant_name(r)] for r in restaurants] # BEGIN Question 7 mean1 = mean(xs) mean2 = mean(ys) sxx = sum([pow(x - mean1, 2) for x in xs]) syy = sum([pow(y - mean2, 2) for y in ys]) sxy = sum([(x - mean1) * (y - mean2) for x, y in zip(xs, ys)]) b, a, r_squared = sxy / sxx, mean2 - sxy / sxx * mean1, pow( sxy, 2) / (sxx * syy) # END Question 7 def predictor(restaurant): return b * feature_fn(restaurant) + a return predictor, r_squared
def find_predictor(user, restaurants, feature_fn): """Return a rating predictor (a function from restaurants to ratings), for a user by performing least-squares linear regression using feature_fn on the items in restaurants. Also, return the R^2 value of this model. Arguments: user -- A user restaurants -- A sequence of restaurants feature_fn -- A function that takes a restaurant and returns a number """ xs = [feature_fn(r) for r in restaurants] ys = [user_rating(user, restaurant_name(r)) for r in restaurants] # BEGIN Question 7 "*** YOUR CODE HERE ***" mean_x = mean(xs) mean_y = mean(ys) S_xx = sum((x_i - mean_x)**2 for x_i in xs) S_yy = sum((y_i - mean_y)**2 for y_i in ys) S_xy = sum((x_i - mean_x) * (y_i - mean_y) for x_i, y_i in zip(xs, ys)) b = S_xy / S_xx r_squared = S_xy**2 / (S_xx * S_yy) a = mean_y - b * mean_x # END Question 7 def predictor(restaurant): return b * feature_fn(restaurant) + a return predictor, r_squared
def find_predictor(user, restaurants, feature_fn): """Return a rating predictor (a function from restaurants to ratings), for USER by performing least-squares linear regression using FEATURE_FN on the items in RESTAURANTS. Also, return the R^2 value of this model. Arguments: user -- A user restaurants -- A sequence of restaurants feature_fn -- A function that takes a restaurant and returns a number """ reviews_by_user = {review_restaurant_name(review): review_rating(review) for review in user_reviews(user).values()} xs = [feature_fn(r) for r in restaurants] ys = [reviews_by_user[restaurant_name(r)] for r in restaurants] "*** YOUR CODE HERE ***" b, a, r_squared = 0, 0, 0 # REPLACE THIS LINE WITH YOUR SOLUTION xs_mean = mean(xs) xs_minus_mean = [x - xs_mean for x in xs] ys_mean = mean(ys) ys_minus_mean = [y - ys_mean for y in ys] Sxx = sum([pow(x, 2) for x in xs_minus_mean]) Syy = sum([pow(y, 2) for y in ys_minus_mean]) Sxy = sum([x * y for x, y in zip(xs_minus_mean, ys_minus_mean)]) b = Sxy / Sxx a = ys_mean - b * xs_mean r_squared = pow(Sxy, 2) / (Sxx * Syy) def predictor(restaurant): return b * feature_fn(restaurant) + a return predictor, r_squared
def find_predictor(user, restaurants, feature_fn): """Return a rating predictor (a function from restaurants to ratings), for USER by performing least-squares linear regression using FEATURE_FN on the items in RESTAURANTS. Also, return the R^2 value of this model. Arguments: user -- A user restaurants -- A sequence of restaurants feature_fn -- A function that takes a restaurant and returns a number """ reviews_by_user = {review_restaurant_name(review): review_rating(review) for review in user_reviews(user).values()} xs = [feature_fn(r) for r in restaurants] ys = [reviews_by_user[restaurant_name(r)] for r in restaurants] "*** YOUR CODE HERE ***" data_points=zip(xs, ys) S_xx, S_yy, S_xy = 0, 0, 0 for x in xs: S_xx += pow((x - mean(xs)), 2) for y in ys: S_yy += pow((y - mean(ys)), 2) for x, y in data_points: S_xy += (x - mean(xs))*(y - mean(ys)) b = S_xy/S_xx a, r_squared = mean(ys)-b*mean(xs), pow(S_xy, 2)/(S_xx*S_yy) # REPLACE THIS LINE WITH YOUR SOLUTION def predictor(restaurant): return b * feature_fn(restaurant) + a return predictor, r_squared
def find_predictor(user, restaurants, feature_fn): """Return a rating predictor (a function from restaurants to ratings), for a user by performing least-squares linear regression using feature_fn on the items in restaurants. Also, return the R^2 value of this model. Arguments: user -- A user restaurants -- A sequence of restaurants feature_fn -- A function that takes a restaurant and returns a number """ reviews_by_user = {review_restaurant_name(review): review_rating(review) for review in user_reviews(user).values()} xs = [feature_fn(r) for r in restaurants] ys = [reviews_by_user[restaurant_name(r)] for r in restaurants] # BEGIN Question 7 Sxx, Syy, Sxy = 0, 0, 0 for x in xs: Sxx += (x - mean(xs)) ** 2 for y in ys: Syy += (y - mean(ys)) ** 2 for x,y in zip(xs, ys): Sxy += (x - mean(xs)) * (y - mean(ys)) b = Sxy / Sxx a = mean(ys) - b * mean(xs) r_squared = (Sxy **2) / (Sxx * Syy) # END Question 7 def predictor(restaurant): return b * feature_fn(restaurant) + a return predictor, r_squared
def find_predictor(user, restaurants, feature_fn): """Return a rating predictor (a function from restaurants to ratings), for `user` by performing least-squares linear regression using `feature_fn` on the items in `restaurants`. Also, return the R^2 value of this model. Arguments: user -- A user restaurants -- A sequence of restaurants feature_fn -- A function that takes a restaurant and returns a number """ reviews_by_user={review_restaurant_name(review): review_rating(review) for review in user_reviews(user).values()} xs=[feature_fn(r) for r in restaurants] ys=[reviews_by_user[restaurant_name(r)] for r in restaurants] Sxx=sum([(x-mean(xs))**2 for x in xs]) Syy=sum([(y-mean(ys))**2 for y in ys]) xy=zip([(x-mean(xs)) for x in xs], [(y-mean(ys)) for y in ys]) Sxy=sum(r[0]*r[1] for r in xy) b=Sxy/Sxx a=mean(ys)-b*mean(xs) r_squared=(Sxy**2)/(Sxx*Syy) def predictor(restaurant): return b*feature_fn(restaurant)+a return predictor, r_squared
def find_predictor(user, restaurants, feature_fn): """Return a rating predictor (a function from restaurants to ratings), for a user by performing least-squares linear regression using feature_fn on the items in restaurants. Also, return the R^2 value of this model. Arguments: user -- A user restaurants -- A sequence of restaurants feature_fn -- A function that takes a restaurant and returns a number """ reviews_by_user = {review_restaurant_name(review): review_rating(review) for review in user_reviews(user).values()} xs = [feature_fn(r) for r in restaurants] ys = [reviews_by_user[restaurant_name(r)] for r in restaurants] # BEGIN Question 7 "*** REPLACE THIS LINE ***" mean_xs = mean(xs) mean_ys = mean(ys) list_x = [x - mean_xs for x in xs] list_y = [y - mean_ys for y in ys] sxx = sum( map(lambda x: x * x, list_x) ) syy = sum( map(lambda y: y * y, list_y) ) sxy = sum([a * b for a,b in zip (list_x, list_y)]) b = sxy / sxx a = mean_ys - b * mean_xs r_squared = (sxy ** 2) / (sxx * syy) # END Question 7 def predictor(restaurant): return b * feature_fn(restaurant) + a return predictor, r_squared
def find_predictor(user, restaurants, feature_fn): """Return a rating predictor (a function from restaurants to ratings), for a user by performing least-squares linear regression using feature_fn on the items in restaurants. Also, return the R^2 value of this model. Arguments: user -- A user restaurants -- A sequence of restaurants feature_fn -- A function that takes a restaurant and returns a number """ reviews_by_user = { review_restaurant_name(review): review_rating(review) for review in user_reviews(user).values() } xs = [feature_fn(r) for r in restaurants] # xs -- a sequence of feature[3,5,6,7] ys = [reviews_by_user[restaurant_name(r)] for r in restaurants] # ys -- a sequence of reviews [2,3,4,6] # list(zip(ys, xs))-- [[2,3],[3,5],[6,4],[7,6]] # BEGIN Question 7 # b, a, r_squared = 0, 0, 0 pairs = zip(xs, ys) sxx = sum([(x[0] - mean(xs))**2 for x in pairs]) syy = sum([(x[1] - mean(ys))**2 for x in pairs]) sxy = sum([(x[0] - mean(xs)) * (x[1] - mean(ys)) for x in pairs]) b = sxy / sxx a = mean(ys) - b * mean(xs) r_squared = sxy**2 / (sxx * syy) # END Question 7 def predictor(restaurant): return b * feature_fn(restaurant) + a return predictor, r_squared
def find_predictor(user, restaurants, feature_fn): """Return a rating predictor (a function from restaurants to ratings), for USER by performing least-squares linear regression using FEATURE_FN on the items in RESTAURANTS. Also, return the R^2 value of this model. Arguments: user -- A user restaurants -- A sequence of restaurants feature_fn -- A function that takes a restaurant and returns a number """ reviews_by_user = { review_restaurant_name(review): review_rating(review) for review in user_reviews(user).values() } xs = [feature_fn(r) for r in restaurants] ys = [reviews_by_user[restaurant_name(r)] for r in restaurants] "*** YOUR CODE HERE ***" xx = sum([pow(xi - mean(xs), 2) for xi in xs]) yy = sum([pow(yi - mean(ys), 2) for yi in ys]) xy = sum([(xi - mean(xs)) * (yi - mean(ys)) for xi, yi in zip(xs, ys)]) b = xy / xx a, r_squared = mean(ys) - b * mean(xs), pow(xy, 2) / ( xx * yy) # REPLACE THIS LINE WITH YOUR SOLUTION def predictor(restaurant): return b * feature_fn(restaurant) + a return predictor, r_squared
def find_predictor(user, restaurants, feature_fn): """Return a rating predictor (a function from restaurants to ratings), for a user by performing least-squares linear regression using feature_fn on the items in restaurants. Also, return the R^2 value of this model. Arguments: user -- A user restaurants -- A sequence of restaurants feature_fn -- A function that takes a restaurant and returns a number """ xs = [feature_fn(r) for r in restaurants] ys = [user_rating(user, restaurant_name(r)) for r in restaurants] # BEGIN Question 7 mean_x = mean(xs) mean_y = mean(ys) combined = zip(xs,ys) Sxx,Syy,Sxy = 0,0,0 for sx,sy in combined: Sxx += (sx - mean_x) ** 2 Syy += (sy - mean_y) ** 2 Sxy += (sx - mean_x) * (sy - mean_y) b = Sxy / Sxx a = mean_y - b * mean_x r_squared = Sxy ** 2 / (Sxx * Syy) # END Question 7 def predictor(restaurant): return b * feature_fn(restaurant) + a return predictor, r_squared
def find_predictor(user, restaurants, feature_fn): """Return a rating predictor (a function from restaurants to ratings), for a user by performing least-squares linear regression using feature_fn on the items in restaurants. Also, return the R^2 value of this model. Arguments: user -- A user restaurants -- A sequence of restaurants feature_fn -- A function that takes a restaurant and returns a number """ xs = [feature_fn(r) for r in restaurants] ys = [user_rating(user, restaurant_name(r)) for r in restaurants] # BEGIN Question 7 "*** YOUR CODE HERE ***" xs_zip_ys = zip(xs, ys) S_xx, S_yy, S_xy, x_mean, y_mean = 0, 0, 0, mean(xs), mean(ys) S_xx = sum([pow(x - x_mean, 2) for x in xs]) S_yy = sum([pow(y - y_mean, 2) for y in ys]) S_xy = sum([(x - x_mean) * (y - y_mean) for x, y in xs_zip_ys]) b = S_xy / S_xx a = y_mean - b * x_mean r_squared = pow(S_xy, 2) / (S_xx * S_yy) # END Question 7 def predictor(restaurant): return b * feature_fn(restaurant) + a return predictor, r_squared
def find_predictor(user, restaurants, feature_fn): """Return a rating predictor (a function from restaurants to ratings), for a user by performing least-squares linear regression using feature_fn on the items in restaurants. Also, return the R^2 value of this model. Arguments: user -- A user restaurants -- A sequence of restaurants feature_fn -- A function that takes a restaurant and returns a number """ xs = [feature_fn(r) for r in restaurants] ys = [user_rating(user, restaurant_name(r)) for r in restaurants] # BEGIN Question 7 xsandys = zip(xs, ys) sxx = sum([(the_xes - mean(xs))**2 for the_xes in xs]) syy = sum([(the_ys - mean(ys))**2 for the_ys in ys]) sxy = sum([(x - mean(xs)) * (y - mean(ys)) for x, y in xsandys]) b = (sxy / sxx) a = mean(ys) - b * mean(xs) r_squared = (sxy**2 / (sxx * syy)) # END Question 7 def predictor(restaurant): return b * feature_fn(restaurant) + a return predictor, r_squared
def find_predictor(user, restaurants, feature_fn): """Return a rating predictor (a function from restaurants to ratings), for a user by performing least-squares linear regression using feature_fn on the items in restaurants. Also, return the R^2 value of this model. Arguments: user -- A user restaurants -- A sequence of restaurants feature_fn -- A function that takes a restaurant and returns a number """ reviews_by_user = {review_restaurant_name(review): review_rating(review) for review in user_reviews(user).values()} xs = [feature_fn(r) for r in restaurants] ys = [reviews_by_user[restaurant_name(r)] for r in restaurants] # BEGIN Question 7 x_avg = mean(xs) y_avg = mean(ys) s_xx = sum((x - x_avg) * (x - x_avg) for x in xs) s_yy = sum((y - y_avg) *(y - y_avg) for y in ys) s_xy = sum((x - x_avg) * (y - y_avg) for x, y in zip(xs, ys)) b = s_xy / s_xx a = y_avg - b * x_avg r_squared = (s_xy) * (s_xy) / (s_xx * s_yy) # END Question 7 def predictor(restaurant): return b * feature_fn(restaurant) + a return predictor, r_squared
def find_predictor(user, restaurants, feature_fn): """Return a rating predictor (a function from restaurants to ratings), for a user by performing least-squares linear regression using feature_fn on the items in restaurants. Also, return the R^2 value of this model. Arguments: user -- A user restaurants -- A sequence of restaurants feature_fn -- A function that takes a restaurant and returns a number """ reviews_by_user = { review_restaurant_name(review): review_rating(review) for review in user_reviews(user).values() } xs = [feature_fn(r) for r in restaurants] ys = [reviews_by_user[restaurant_name(r)] for r in restaurants] # BEGIN Question 7 mean_x = mean(xs) mean_y = mean(ys) S_xx = sum([(xi - mean_x) * (xi - mean_x) for xi in xs]) S_yy = sum([(yi - mean_y) * (yi - mean_y) for yi in ys]) S_xy = sum([(xi - mean_x) * (yi - mean_y) for xi, yi in zip(xs, ys)]) b = S_xy / S_xx a = mean_y - b * mean_x r_squared = (S_xy * S_xy) / (S_xx * S_yy) # END Question 7 def predictor(restaurant): return b * feature_fn(restaurant) + a return predictor, r_squared
def find_predictor(user, restaurants, feature_fn): """Return a rating predictor (a function from restaurants to ratings), for a user by performing least-squares linear regression using feature_fn on the items in restaurants. Also, return the R^2 value of this model. Arguments: user -- A user restaurants -- A sequence of restaurants feature_fn -- A function that takes a restaurant and returns a number """ xs = [feature_fn(r) for r in restaurants] ys = [user_rating(user, restaurant_name(r)) for r in restaurants] # BEGIN Question 7 "*** YOUR CODE HERE ***" mean_xs = mean(xs) mean_ys = mean(ys) xs_ys = zip(xs, ys) sxx = sum([(x - mean_xs)**2 for x in xs]) syy = sum([(x - mean_ys)**2 for x in ys]) sxy = sum([(x[0] - mean_xs) * (x[1] - mean_ys) for x in xs_ys]) b = sxy / sxx a = mean_ys - b * mean_xs r_squared = (sxy * sxy) / (sxx * syy) # END Question 7 def predictor(restaurant): return b * feature_fn(restaurant) + a return predictor, r_squared
def find_predictor(user, restaurants, feature_fn): """Return a rating predictor (a function from restaurants to ratings), for a user by performing least-squares linear regression using feature_fn on the items in restaurants. Also, return the R^2 value of this model. Arguments: user -- A user restaurants -- A sequence of restaurants feature_fn -- A function that takes a restaurant and returns a number """ xs = [feature_fn(r) for r in restaurants] ys = [user_rating(user, restaurant_name(r)) for r in restaurants] S_xx = sum([(i - mean(xs))**2 for i in xs]) S_yy = sum([(j - mean(ys))**2 for j in ys]) S_xy = sum([(i - mean(xs)) * (j - mean(ys)) for i, j in zip(xs, ys)]) b = S_xy / S_xx a = mean(ys) - b * mean(xs) r_squared = (S_xy**2) / (S_xx * S_yy) def predictor(restaurant): return b * feature_fn(restaurant) + a return predictor, r_squared
def find_predictor(user, restaurants, feature_fn): """Return a rating predictor (a function from restaurants to ratings), for a user by performing least-squares linear regression using feature_fn on the items in restaurants. Also, return the R^2 value of this model. Arguments: user -- A user restaurants -- A sequence of restaurants feature_fn -- A function that takes a restaurant and returns a number """ xs = [feature_fn(r) for r in restaurants] ys = [user_rating(user, restaurant_name(r)) for r in restaurants] # BEGIN Question 7 "*** YOUR CODE HERE ***" sxlist =[x - mean(xs) for x in xs] sylist = [y - mean(ys) for y in ys] sxylist = zip(sxlist,sylist) Sxx = sum(pow(x,2) for x in sxlist) Syy = sum(pow(y,2) for y in sylist) Sxy = sum(a[0] * a[1] for a in sxylist) b= Sxy/Sxx a = mean(ys) - b* mean(xs) r_squared = Sxy**2/(Sxx*Syy) # END Question 7 def predictor(restaurant): return b * feature_fn(restaurant) + a return predictor, r_squared
def find_predictor(user, restaurants, feature_fn): """Return a rating predictor (a function from restaurants to ratings), for a user by performing least-squares linear regression using feature_fn on the items in restaurants. Also, return the R^2 value of this model. Arguments: user -- A user restaurants -- A sequence of restaurants feature_fn -- A function that takes a restaurant and returns a number """ reviews_by_user = {review_restaurant_name(review): review_rating(review) for review in user_reviews(user).values()} xs = [feature_fn(r) for r in restaurants] ys = [reviews_by_user[restaurant_name(r)] for r in restaurants] # BEGIN Question 7 sxx=sum([((x - mean(xs))*(x - mean(xs))) for x in xs]) syy=sum([((y - mean(ys))*(y - mean(ys))) for y in ys]) sx=[(x-mean(xs)) for x in xs] sy=[(y-mean(ys)) for y in ys] sxy=sum(part[0]*part[1] for part in zip(sx,sy)) b, a, r_squared = sxy/sxx, mean(ys)-sxy*mean(xs)/sxx, sxy*sxy/(sxx*syy) # REPLACE THIS LINE WITH YOUR SOLUTION # END Question 7 def predictor(restaurant): return b * feature_fn(restaurant) + a return predictor, r_squared
def find_predictor(user, restaurants, feature_fn): """Return a rating predictor (a function from restaurants to ratings), for a user by performing least-squares linear regression using feature_fn on the items in restaurants. Also, return the R^2 value of this model. Arguments: user -- A user restaurants -- A sequence of restaurants feature_fn -- A function that takes a restaurant and returns a number """ reviews_by_user = {review_restaurant_name(review): review_rating(review) for review in user_reviews(user).values()} xs = [feature_fn(r) for r in restaurants] ys = [reviews_by_user[restaurant_name(r)] for r in restaurants] # BEGIN Question 7 "*** REPLACE THIS LINE ***" #S_xx computes the sum value for xs S_xx = sum([pow(x - mean(xs), 2) for x in xs]) #S_yy computes the sum value for ys S_yy = sum([pow(y - mean(ys), 2) for y in ys]) #S_xy computes the sum value for xy S_xy = sum([ (x - mean(xs)) * (y - mean(ys)) for x,y in zip(xs, ys)]) b = S_xy / S_xx a = mean(ys) - b * mean(xs) r_squared = pow(S_xy, 2)/(S_xx * S_yy) # REPLACE THIS LINE WITH YOUR SOLUTION # END Question 7 def predictor(restaurant): return b * feature_fn(restaurant) + a return predictor, r_squared
def find_predictor(user, restaurants, feature_fn): """Return a rating predictor (a function from restaurants to ratings), for a user by performing least-squares linear regression using feature_fn on the items in restaurants. Also, return the R^2 value of this model. Arguments: user -- A user restaurants -- A sequence of restaurants feature_fn -- A function that takes a restaurant and returns a number """ reviews_by_user = {review_restaurant_name(review): review_rating(review) for review in user_reviews(user).values()} xs = [feature_fn(r) for r in restaurants] ys = [reviews_by_user[restaurant_name(r)] for r in restaurants] # BEGIN Question 7 #b, a, r_squared = 0, 0, 0 # REPLACE THIS LINE WITH YOUR SOLUTION mean_zipped = zip([(x - mean(xs)) for x in xs], [(y - mean(ys)) for y in ys]) sxx = sum([((x - mean(xs)) ** 2) for x in xs]) syy = sum([((y - mean(ys)) ** 2) for y in ys]) sxy = sum((elem[0] * elem[1]) for elem in mean_zipped) b = sxy / sxx a = mean(ys) - ((sxy/sxx) * mean(xs)) r_squared = (sxy * sxy) / (sxx * syy) # END Question 7 def predictor(restaurant): return b * feature_fn(restaurant) + a return predictor, r_squared
def find_predictor(user, restaurants, feature_fn): """Return a rating predictor (a function from restaurants to ratings), for `user` by performing least-squares linear regression using `feature_fn` on the items in `restaurants`. Also, return the R^2 value of this model. Arguments: user -- A user restaurants -- A sequence of restaurants feature_fn -- A function that takes a restaurant and returns a number """ reviews_by_user = {review_restaurant_name(review): review_rating(review) for review in user_reviews(user).values()} xs = [feature_fn(r) for r in restaurants] ys = [reviews_by_user[restaurant_name(r)] for r in restaurants] # BEGIN Question 7 mean_x=mean(xs) mean_y=mean(ys) S_xx, S_xy, S_yy = 0, 0, 0 for elem in xs: S_xx += (elem-mean_x) ** 2 for elem in ys: S_yy += (elem-mean_y) ** 2 for x,y in zip(xs,ys): S_xy+=(x-mean_x) * (y-mean_y) b = S_xy/S_xx a = mean_y-b * mean_x r_squared = S_xy ** 2 / (S_xx * S_yy) # REPLACE THIS LINE WITH YOUR SOLUTION # END Question 7 def predictor(restaurant): return b * feature_fn(restaurant) + a return predictor, r_squared
def find_predictor(user, restaurants, feature_fn): """Return a rating predictor (a function from restaurants to ratings), for a user by performing least-squares linear regression using feature_fn on the items in restaurants. Also, return the R^2 value of this model. Arguments: user -- A user restaurants -- A sequence of restaurants feature_fn -- A function that takes a restaurant and returns a number """ xs = [feature_fn(r) for r in restaurants] ys = [user_rating(user, restaurant_name(r)) for r in restaurants] # BEGIN Question 7 inside_x = [(r - mean(xs)) for r in xs] inside_y = [(r - mean(ys)) for r in ys] combine_xy = zip(inside_x, inside_y) sxx = sum([r ** 2 for r in inside_x]) syy = sum([r ** 2 for r in inside_y]) sxy = sum([r[0] * r[1] for r in combine_xy]) b = sxy / sxx a = mean(ys) - b * mean(xs) r_squared = (sxy ** 2)/(sxx * syy) # END Question 7 def predictor(restaurant): return b * feature_fn(restaurant) + a return predictor, r_squared
def group_by_centroid(restaurants, centroids): """Return a list of lists, where each list contains all restaurants nearest to some item in CENTROIDS. Each item in RESTAURANTS should appear once in the result, along with the other restaurants nearest to the same centroid. No empty lists should appear in the result. """ "*** YOUR CODE HERE ***" cent_list = [find_closest(restaurant_location(restaurant), centroids) for restaurant in restaurants] return group_by_first(zip(cent_list, restaurants))
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 closest_centroid = [find_closest(restaurant_location(x), centroids) for x in restaurants] restaurants_and_their_centroids = zip(closest_centroid, restaurants) return group_by_first(restaurants_and_their_centroids)
def group_by_centroid(events, centroids): """Return a list of lists, where each list contains all restaurants nearest to some item in CENTROIDS. Each item in RESTAURANTS should appear once in the result, along with the other restaurants nearest to the same centroid. No empty lists should appear in the result. """ closestcentroid = [find_closest(event, centroids) for event in events] result = zip(closestcentroid, events) cluster = group_by_first(result) return cluster
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 locations = [restaurant_location(y) for y in restaurants] closestcentroid=[find_closest(x,centroids) for x in locations] result = zip(closestcentroid,restaurants) clusterlist = group_by_first(result) return clusterlist
def find_predictor(user, restaurants, feature_fn): """Return a rating predictor (a function from restaurants to ratings), for a user by performing least-squares linear regression using feature_fn on the items in restaurants. Also, return the R^2 value of this model. Arguments: user -- A user restaurants -- A sequence of restaurants feature_fn -- A function that takes a restaurant and returns a number """ reviews_by_user = {review_restaurant_name(review): review_rating(review) for review in user_reviews(user).values()} xs = [feature_fn(r) for r in restaurants] ys = [reviews_by_user[restaurant_name(r)] for r in restaurants] # print(xs) # print(ys) # BEGIN Question 7 mean_x = mean(xs) mean_y = mean(ys) S_xx = sum([(i - mean_x)**2 for i in xs]) S_yy = sum([(i - mean_y)**2 for i in ys]) # print([(i - mean_x)**2 for i in xs]) # print([(i - mean_y)**2 for i in ys]) zipped_xy = zip(xs, ys) S_xy = sum([(i[0] - mean_x) * (i[1] - mean_y) for i in zipped_xy]) # print(S_xx) # print(S_yy) b = S_xy/S_xx a, r_squared = mean_y - b*mean_x, (S_xy**2) / (S_xx * S_yy) # print(b) # print(a) # print(r_squared)# REPLACE THIS LINE WITH YOUR SOLUTION # END Question 7 def predictor(restaurant): return b * feature_fn(restaurant) + a return predictor, r_squared
def find_predictor(user, restaurants, feature_fn): """Return a rating predictor (a function from restaurants to ratings), for USER by performing least-squares linear regression using FEATURE_FN on the items in RESTAURANTS. Also, return the R^2 value of this model. Arguments: user -- A user restaurants -- A sequence of restaurants feature_fn -- A function that takes a restaurant and returns a number """ reviews_by_user = {review_restaurant_name(review): review_rating(review) for review in user_reviews(user).values()} xs = [feature_fn(r) for r in restaurants] ys = [reviews_by_user[restaurant_name(r)] for r in restaurants] "*** YOUR CODE HERE ***" mean_x = mean(xs) mean_y = mean(ys) xs1 = xs ys1 = ys tempx = [pow(x - mean_x, 2) for x in xs] tempy = [pow(y - mean_y, 2) for y in ys] tempx1 = [(x - mean_x) for x in xs1] tempy1 = [(y - mean_y) for y in ys1] tempx1y1 = [a*b for a,b in zip(tempx1, tempy1)] s_xx = sum(tempx) s_yy = sum(tempy) s_xy = sum(tempx1y1) b, r_squared = (s_xy) / (s_xx), (pow(s_xy, 2))/(s_xx * s_yy) a = (mean(ys) - b * mean(xs)) def predictor(restaurant): return b * feature_fn(restaurant) + a return predictor, r_squared
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 dictionary from restaurant names to restaurants feature_fns -- A sequence of functions that each takes a restaurant """ reviewed = list(user_reviewed_restaurants(user, restaurants).values()) "*** YOUR CODE HERE ***" predicter_list, r_squared_list=[], [] for fn in feature_fns: x, y = find_predictor(user, reviewed, fn) predicter_list.append(x) r_squared_list.append(y) zipped=zip(predicter_list, r_squared_list) return max(zipped, key=lambda x: x[1])[0] """r_squared_list = []
def find_predictor(user, restaurants, feature_fn): """Return a rating predictor (a function from restaurants to ratings), for a user by performing least-squares linear regression using feature_fn on the items in restaurants. Also, return the R^2 value of this model. Arguments: user -- A user restaurants -- A sequence of restaurants feature_fn -- A function that takes a restaurant and returns a number """ #某一位用户的评价信息(字典) 餐馆名字: 餐馆得分 reviews_by_user = {review_restaurant_name(review): review_rating(review) for review in user_reviews(user).values()} #给定餐馆的某个特征值,这个餐馆的集合应当和上述的餐馆是相同的 xs = [feature_fn(r) for r in restaurants] #和某一位用户的评价分数 ys = [reviews_by_user[restaurant_name(r)] for r in restaurants] # BEGIN Question 7 # Sxx = Σi(xi - mean(x))^2 # Syy = Σi(yi - mean(y))^2 # Sxy = Σi(xi - mean(x))(yi - mean(y)) # b = Sxy / Sxx # a = mean(y) - b * mean(x) # R2 = Sxy2 / (Sxx * Syy) s_xx = sum([(x - mean(xs)) * (x - mean(xs)) for x in xs]) s_yy = sum([(y - mean(ys)) * (y - mean(ys)) for y in ys]) s_xy = sum([(x - mean(xs)) * (y - mean(ys)) for x, y in zip(xs, ys)]) b = s_xy / s_xx a = mean(ys) - b * mean(xs) r_squared = s_xy * s_xy / (s_xx * s_yy) # END Question 7 def predictor(restaurant): return b * feature_fn(restaurant) + a #给出一个餐馆,和一个特征值,能够推断分数 return predictor, r_squared
def find_predictor(user, restaurants, feature_fn): """Return a rating predictor (a function from restaurants to ratings), for a user by performing least-squares linear regression using feature_fn on the items in restaurants. Also, return the R^2 value of this model. Arguments: user -- A user restaurants -- A sequence of restaurants feature_fn -- A function that takes a restaurant and returns a number """ import math reviews_by_user = {review_restaurant_name(review): review_rating(review) for review in user_reviews(user).values()} xs = [feature_fn(r) for r in restaurants] ys = [reviews_by_user[restaurant_name(r)] for r in restaurants] # BEGIN Question 7 xy = zip(xs, ys) #print('a', user) print(114, restaurants) #print('b', xs, ys) Sxx = sum([(x - mean(xs)) ** 2 for x in xs]) Syy = sum([(y - mean(ys)) ** 2 for y in ys]) Sxy = sum([(x - mean(xs)) * (y - mean(ys)) for x, y in xy]) #b, a, r_squared = 0, 0, 0 # REPLACE THIS LINE WITH YOUR SOLUTION b = Sxy / Sxx a = mean(ys) - b * mean(xs) r_squared = math.sqrt(Sxy * Sxy / (Sxx * Syy)) # END Question 7 def predictor(restaurant): return b * feature_fn(restaurant) + a return predictor, r_squared
def find_predictor(user, restaurants, feature_fn): """Return a rating predictor (a function from restaurants to ratings), for USER by performing least-squares linear regression using FEATURE_FN on the items in RESTAURANTS. Also, return the R^2 value of this model. Arguments: user -- A user restaurants -- A sequence of restaurants feature_fn -- A function that takes a restaurant and returns a number """ reviews_by_user = {review_restaurant_name(review): review_rating(review) for review in user_reviews(user).values()} xs = [feature_fn(r) for r in restaurants] ys = [reviews_by_user[restaurant_name(r)] for r in restaurants] "*** YOUR CODE HERE ***" mean_x = mean(xs) mean_y = mean(ys) lst = zip(xs, ys) Sxx, Syy, Sxy = 0, 0, 0 for each in lst: x = each[0] y = each[1] Sxx += (x-mean_x)*(x-mean_x) Syy += (y-mean_y)*(y-mean_y) Sxy += (x-mean_x)*(y-mean_y) b = Sxy / Sxx a = mean_y - b*mean_x r_squared = (Sxy*Sxy) /(Sxx*Syy) def predictor(restaurant): return b * feature_fn(restaurant) + a return predictor, r_squared
def find_predictor(user, restaurants, feature_fn): """Return a rating predictor (a function from restaurants to ratings), for a user by performing least-squares linear regression using feature_fn on the items in restaurants. Also, return the R^2 value of this model. Arguments: user -- A user restaurants -- A sequence of restaurants feature_fn -- A function that takes a restaurant and returns a number """ reviews_by_user = {review_restaurant_name(review): review_rating(review) for review in user_reviews(user).values()} xs = [feature_fn(r) for r in restaurants] ys = [reviews_by_user[restaurant_name(r)] for r in restaurants] # BEGIN Question 7 xmean = mean(xs) Sxxvalue = [(x-xmean)**2 for x in xs] Sxx = sum(Sxxvalue) ymean = mean(ys) Syyvalue = [(y-ymean)**2 for y in ys] Syy = sum(Syyvalue) Sxymeanx = [(x-xmean) for x in xs] Sxymeany = [(y-ymean) for y in ys] zipmeans=zip(Sxymeanx,Sxymeany) final = [x*y for (x,y) in zipmeans] Sxy = sum(final) b, r_squared = Sxy/Sxx, Sxy**2/(Sxx*Syy) a = ymean-(b*xmean) # END Question 7 def predictor(restaurant): return b * feature_fn(restaurant) + a return predictor, r_squared
def find_predictor(user, restaurants, feature_fn): """Return a rating predictor (a function from restaurants to ratings), for USER by performing least-squares linear regression using FEATURE_FN on the items in RESTAURANTS. Also, return the R^2 value of this model. Arguments: user -- A user restaurants -- A sequence of restaurants feature_fn -- A function that takes a restaurant and returns a number """ reviews_by_user = {review_restaurant_name(review): review_rating(review) for review in user_reviews(user).values()} xs = [feature_fn(r) for r in restaurants] ys = [reviews_by_user[restaurant_name(r)] for r in restaurants] "*** YOUR CODE HERE ***" mean_x, mean_y = mean(xs), mean(ys) S_xx = 0 S_yy = 0 S_xy = 0 for x, y in zip(xs, ys): S_xx = S_xx + pow(x - mean_x, 2) S_yy = S_yy + pow(y - mean_y, 2) S_xy = S_xy + (x - mean_x)*(y - mean_y) b = S_xy/S_xx a = mean_y - (b*mean_x) r_squared = (S_xy**2)/(S_xx*S_yy) def predictor(restaurant): return b * feature_fn(restaurant) + a return predictor, r_squared
pid = path.join(pt,d) if path.exists(pid) : po = pid.replace(pt,pc) createDirectories(po) copyFiles(pid,po) print ' +> '+pid pid = path.join(pt,'config') if path.exists(pid): po = pid.replace(pt,pc) createDirectories(po) copyFile(options.configFile,po) print '... finally copying ' + options.configFile print '\n... now packaging ' + cfgname zip(cfgname,pc,cfg['ZIPPER']) print '\n... now cleaning ' removeDirectories(pc) if options.archiveName != '': print '\n... now packaging ' + cfgname + ' into ' + archive zip(path.basename(archive),archive,cfg['ZIPPER']) # /!\ use the last cfg value print '\n... now cleaning ' + archive removeDirectories(archive) # <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< # ~~~~ Jenkins' success message ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ print '\n\nMy work is done\n\n'
msg = "Test: runned= %d succes= %d failed= %d <br>" % ( tests_results["tests"], tests_results["success"], tests_results["tests"] - tests_results["success"], ) msg += "Failures: Txt %d Tex %d Image %d <br>" % ( tests_results["txt_failure"], tests_results["tex_failure"], tests_results["img_failure"], ) msg += "<br> Link: %s/%s.html" % (link, gpu) if branch != 0: msg += "<br>Framewok: %s %s" % (branch, revision) utils.call("python", "mail.py", recipients, subject, msg) print print print "*** DAVA AUTOTEST Copy results for artifact storing ***" print "Copy results for storing in TC %s -> %s" % (output, currentDir + "/Artifacts/" + gpu) shutil.copytree(output, currentDir + "/Artifacts/" + gpu) for test in os.listdir(results): shutil.copytree(input + "/" + test, currentDir + "/Artifacts/" + gpu + "/" + test + "/input/") shutil.copytree(results + "/" + test, currentDir + "/Artifacts/" + gpu + "/" + test + "/expected_results/") print "*** DAVA AUTOTEST Zip results for artefacts ***" os.chdir(currentDir + "/Artifacts/") utils.zip(gpu, gpu)