def _compute_preferences(self): """ compute preferred distribution of each human for park, stores, etc.""" for h in self.humans: h.stores_preferences = [ (compute_distance(h.household, s) + 1e-1)**-1 for s in self.stores ] h.parks_preferences = [ (compute_distance(h.household, s) + 1e-1)**-1 for s in self.parks ]
def find_similar_input(collection, _result, r0, threshold=10, display=True): """ find data set within result with similar input waveform to r """ if r0.__class__ == dict: std = np.array(r0.get('input_signal')) elif r0.__class__ == str: (fnhead, fnum) = parse_fname(r0) r0_entry = collection.find_one( {'fnhead' : fnhead, 'fnum' : fnum } ) std = np.array(r0_entry.get('input_signal')) filtered_result = [] result = _result.clone() for r_candidate in result: try: comp = np.array(r_candidate.get('input_signal')) dist = compute_distance(comp, std) print dist if dist < threshold: if display == True: plot(comp) show() print r_candidate.get('fnhead'), r_candidate.get('fnum') print dist filtered_result = filtered_result + [r_candidate] except: print 'input signal not found' return filtered_result
def __get_neighbors(self, X, idx): neighs = [] for i in range(len(X)): d = compute_distance(X[idx], X[i]) if d <= self.eps and i != idx: neighs.append(i) return np.asarray(neighs)
def readJSON(city): gvals = open( '/Users/pranavramkrishnan/Desktop/Research/maps/static/data/' + str(city) + '/green/greenery_compressed.json', 'r') streets = open( '/Users/pranavramkrishnan/Desktop/Research/maps/static/data/' + str(city) + '/green/street_map_compressed.json', 'r') output = open( '/Users/pranavramkrishnan/Desktop/Research/maps/static/data/' + str(city) + '/green/paths/data.csv', 'a+') green_data = json.load(gvals) smap = json.load(streets) rawData = {} seg_greens = [] seg_dists = [] for segment in green_data['segments']: startLat = float(segment[0]) startLng = float(segment[1]) endLat = float(segment[2]) endLng = float(segment[3]) segmentID = str(segment[4]) segmentGreen = smap[segmentID][1] if startLat == endLat and startLng == endLng: segmentDist = 0.0 else: segmentDist = utils.compute_distance([startLat, startLng], [endLat, endLng]) seg_greens.append(segmentGreen) seg_dists.append(segmentDist) output.write( str(startLat) + ',' + str(startLng) + ',' + str(endLat) + ',' + str(endLng) + ',' + str(segmentGreen) + ',' + str(segmentDist) + '\n')
def compute_distance(self, shop1: Shop, shop2: Shop): if (shop1.identifier, shop2.identifier) not in self._costs: self._costs[(shop1.identifier, shop2.identifier)] = compute_distance( shop1.coords, shop2.coords) self._costs[(shop2.identifier, shop1.identifier)] = self._costs[(shop1.identifier, shop2.identifier)] return self._costs[(shop1.identifier, shop2.identifier)]
def predict(self, X): dist = compute_distance(X, self.X) dist = [[tuple(pair) for pair in line] for line in dist.tolist()] dist = [sorted(line, key=lambda pair: pair[0]) for line in dist] neighs = np.matrix([[pair[1] for pair in line] for line in dist]) dists = np.matrix([[pair[0] for pair in line] for line in dist]) k_neighs = neighs[:, :self.K].astype(np.int) total_dist = np.sum(dists[:, :self.K], axis=1) weights = dists[:, :self.K] / total_dist neigh_vals = self.y[k_neighs] return (np.multiply(weights, np.squeeze(neigh_vals))).sum(axis=1)
def findClosestStation(point, city): bestDist = 10000 bestStation = '' stations = origins[city].keys() for i in range(len(stations)): dist = utils.compute_distance(point, origins[city][stations[i]]) if dist < bestDist: bestDist = dist bestStation = stations[i] return origins[city][bestStation], bestStation
def predict(self, X): # dist.shape = (Num test data, num train data, 2) dist = compute_distance(X, self.X, self.dist_type) dist = [[tuple(pair) for pair in line] for line in dist.tolist()] dist = [sorted(line, key=lambda pair: pair[0]) for line in dist] neighs = np.matrix([[pair[1] for pair in line] for line in dist]) k_neighs = neighs[:, :self.K].astype(np.int) neigh_vals = self.y[k_neighs][:, :, 0] counts = np.apply_along_axis(np.bincount, axis=1, arr=neigh_vals, minlength=np.max(neigh_vals) + 1) winner_neigh_idx = np.argmax(counts, axis=1) return winner_neigh_idx
def _select_location(self, location_type, city): """ Preferential exploration treatment to visit places rho, gamma are treated in the paper for normal trips Here gamma is multiplied by a factor to supress exploration for parks, stores. """ if location_type == "park": S = self.visits.n_parks self.adjust_gamma = 1.0 pool_pref = self.parks_preferences locs = city.parks visited_locs = self.visits.parks elif location_type == "stores": S = self.visits.n_stores self.adjust_gamma = 1.0 pool_pref = self.stores_preferences locs = city.stores visited_locs = self.visits.stores elif location_type == "miscs": S = self.visits.n_miscs self.adjust_gamma = 1.0 pool_pref = [(compute_distance(self.location, m) + 1e-1) ** -1 for m in city.miscs if m != self.location] pool_locs = [m for m in city.miscs if m != self.location] locs = city.miscs visited_locs = self.visits.miscs else: raise ValueError(f'Unknown location_type:{location_type}') if S == 0: p_exp = 1.0 else: p_exp = self.rho * S ** (-self.gamma * self.adjust_gamma) if self.rng.random() < p_exp and S != len(locs): # explore cands = [i for i in locs if i not in visited_locs] cands = [(loc, pool_pref[i]) for i, loc in enumerate(cands)] else: # exploit cands = [(i, count) for i, count in visited_locs.items()] cands, scores = zip(*cands) loc = self.rng.choice(cands, p=_normalize_scores(scores)) visited_locs[loc] += 1 return loc
def get_filtered_shops(self, my_coords: Coords, desired_activities: set, max_radius: int = 1000, max_shops=100): """ Aquesta funció retorna totes les botigues de les activitats que s'han triat. Ex: totes les carniseries, peixateries, etc. en el radi indicat :param my_coords: :param desired_activities: :param max_radius: :param max_shops: :return: """ filtered_shops = defaultdict(list) for activity, shops in self.activity2shops.items(): if activity in desired_activities: near_shops = list() for shop in shops: dist = compute_distance(my_coords, shop.coords) if dist <= max_radius: near_shops.append((shop, dist)) filtered_shops[activity] = [shop_dist[0] for shop_dist in sorted(near_shops, key=lambda x: x[1])[:max_shops]] return filtered_shops
def GET(self): c = Criminal() v = Victim() how_many = 3 c_locs = c.get_last_locations("CriminalLocation", how_many) v_locs = v.get_last_locations("VictimLocation", how_many) distances = [] for cl, vl in zip(c_locs, v_locs): #Compute distances lat1 = cl[0] lng1 = cl[1] lat2 = vl[0] lng2 = vl[1] d = utils.compute_distance(lat1, lng1, lat2, lng2) distances.append(d) #print distances return render.distances(distances, how_many)
def __get_neighbors(self, X_new, X): distance = [compute_distance(X_new, data) for data in X] return np.argsort(distance)[:self.K]
def predict(self, X_new): return np.argmin( [compute_distance(X_new, center) for center in self.centroids])
def __get_centroids(self, X, labels): for k in range(self.K): group = X[labels == k] mean = np.mean(group, axis=0) idx = np.argmin([compute_distance(mean, data) for data in X]) self.centroids[k] = X[idx]
def get_user_id(): return str(657476578) @timeit def do_something(): logger.info("main function started") time.sleep(1) if __name__ == "__main__": logging_utils = LoggingUtils(name="FeatureManagementService", log_level="INFO", log_record_factory_func=get_user_id) logger = logging_utils.init_logger_with_attribute("USERID") # logger = logging_utils.init_logger() logger.info('creating new userid') do_something() logger.info('creating an instance of auxiliary_module.Auxiliary') a = auxiliary.Auxiliary() logger.info('created an instance of auxiliary_module.Auxiliary') logger.info('calling auxiliary_module.Auxiliary.do_something') a.do_something() logger.info('finished auxiliary_module.Auxiliary.do_something') logger.info('calling auxiliary_module.some_function()') auxiliary.some_function() logger.info('done with auxiliary_module.some_function()') compute_distance()
def jsonToGeoJSON(): basePath = '/Users/pranavramkrishnan/Desktop/Research/maps/static/data/Cambridge/transportation/' jsonVals = open(basePath + 'buildings_central_final.json', 'r') jsonVals = jsonVals.readlines()[0].split('},') features = [] central = [42.365504, -71.103819] for line in jsonVals: lineElements = line.split(':') center = lineElements[1].split('],')[0].split(',') centerLat = float(center[0][2:]) centerLng = float(center[1]) center = [centerLng, centerLat] # color = str(lineElements[2].split(',')[0]) # color = color[2:len(color)-1] coordinates = processPolygonCoordinate( lineElements[3].split(']],')[0] + ']]') bestMode = lineElements[4].split(',')[0] bestMode = bestMode[2:len(bestMode) - 1] color = colorMapping(bestMode) datavals = lineElements[5].split('],')[0].split(',') datavals = [ float(datavals[0][2:]), float(datavals[1]), float(datavals[2]), float(datavals[3]), float(datavals[4]), float(datavals[5]), float(datavals[6]) ] dist = utils.compute_distance([centerLat, centerLng], central) data_id_str = lineElements[len(lineElements) - 1] if data_id_str[-2] == '}': data_id = int(data_id_str[:-2]) else: data_id = int(data_id_str) relative_order = orderMapping(bestMode) polygon = geojson.Polygon(coordinates) properties = { "color": color, "bestMode": bestMode, "center": center, "distance": dist, "relative_order": relative_order } feature = geojson.Feature(geometry=polygon, properties=properties, id=data_id) features.append(feature) sorted_features = sorted( features, key=lambda k: (k.properties["relative_order"], k.properties["distance"])) featureColleciton = geojson.FeatureCollection(sorted_features) geojson_data = geojson.dumps(featureColleciton) output_file = open(basePath + 'central.geojson', 'w') output_file.write(geojson_data)
def load_datasets(dataset_name, dataset_dir, do_pca, pca_dims, add_bias, remove_mean, density_sigma, interp_sigma, dist_sigma): print(dataset_name) im_files = None explain_files = None class_names = None explain_interp = None # for the explanation 1.0 means easy to interpret and 0.0 means hard if dataset_name == 'iris': iris = datasets.load_iris() X = iris.data Y = iris.target elif dataset_name == 'wine': wine = datasets.load_wine() X = wine.data Y = wine.target elif dataset_name == 'breast_cancer': bc = datasets.load_breast_cancer() X = bc.data Y = bc.target elif dataset_name == '2d_outlier': num_exs = 100 sig = 0.005 pt = 0.3 cls1 = np.random.multivariate_normal([pt, pt], [[sig, 0], [0, sig]], int(num_exs * 0.8)) cls2 = np.random.multivariate_normal([-pt, -pt], [[sig, 0], [0, sig]], int(num_exs * 0.8)) # add "noise" cls1n = np.random.multivariate_normal([pt, pt], [[sig * 10, 0], [0, sig * 10]], int(num_exs * 0.2)) cls2n = np.random.multivariate_normal([-pt, -pt], [[sig * 10, 0], [0, sig * 10]], int(num_exs * 0.2)) X = np.vstack((cls1, cls1n, cls2, cls2n)) Y = np.ones(X.shape[0]).astype(np.int) Y[:int(num_exs * 0.8) + int(num_exs * 0.2)] = 0 elif dataset_name == '3blobs': num_exs = 80 cls1 = np.random.multivariate_normal([1.0, -1.0], [[0.12, 0], [0, 0.12]], num_exs) cls2 = np.random.multivariate_normal([-1.0, -1.0], [[0.12, 0], [0, 0.12]], num_exs) cls3 = np.random.multivariate_normal([-1.0, 1.0], [[0.12, 0], [0, 0.12]], num_exs) X = np.vstack((cls1, cls2, cls3)) Y = np.ones(X.shape[0]).astype(np.int) Y[:num_exs] = 0 elif dataset_name == 'blobs_2_class': X, Y = make_blobs(n_samples=200, centers=2, random_state=0) elif dataset_name == 'blobs_3_class': X, Y = make_blobs(n_samples=300, centers=3, random_state=0) elif dataset_name == 'butterflies_crop_monarch': X, Y, im_files, explain_files, class_names, explain_interp = load_data( dataset_dir, dataset_name, interp_sigma) for i in range(len(class_names)): if class_names[i] != b'Monarch': class_names[i] = 'Not_monarch' else: class_names[i] = 'Monarch' t = i class_names = np.delete(class_names, [2, 3, 4]) Y[Y == t] = 1 Y[Y != 1] = 0 elif dataset_name == 'chinese_chars_binary': X, Y, im_files, explain_files, class_names, explain_interp = load_data( dataset_dir, dataset_name, interp_sigma) for i in range(len(class_names)): if class_names[i] != b'grass': class_names[i] = 'not_grass' else: class_names[i] = 'grass' t = i class_names = np.delete(class_names, [2]) Y[Y == t] = 1 Y[Y != 1] = 0 elif dataset_name == 'woodpecker': X, Y, im_files, explain_files, class_names, explain_interp = load_data( dataset_dir, dataset_name, interp_sigma) for i in range(len(class_names)): if class_names[i] != 'Red_bellied_Woodpecker': class_names[i] = 'Not_red_bellied_Woodpecker' else: class_names[i] = 'Red_bellied_Woodpecker' t = i class_names = np.delete(class_names, [2]) Y[Y == t] = 1 Y[Y != 1] = 0 else: X, Y, im_files, explain_files, class_names, explain_interp = load_data( dataset_dir, dataset_name, interp_sigma) if im_files is None: im_files = np.asarray([''] * X.shape[0]) if explain_files is None: explain_files = np.asarray([''] * X.shape[0]) if class_names is None: class_names = np.asarray([''] * np.unique(Y).shape[0]) if explain_interp is None: explain_interp = np.ones(X.shape[0]) # standardize if remove_mean: X = X - X.mean(0) X = X / X.std(0) # do PCA if do_pca and X.shape[1] > 2: pca = PCA(n_components=2) pca.fit(X) X = pca.transform(X) X = X - X.mean(0) X = X / X.std(0) # add 1 for bias (intercept) term if add_bias: X = np.hstack((X, np.ones(X.shape[0])[..., np.newaxis])) # balance datasets - same number of examples per class X, Y, im_files, explain_files, explain_interp = balance_data( X, Y, im_files, explain_files, explain_interp) # train test split dataset_train, dataset_test = make_train_test_split( X, Y, im_files, explain_files, class_names, explain_interp) # density of points dataset_train['X_density'] = ut.compute_density(dataset_train['X'], dataset_train['Y'], density_sigma, True) #distance of points dataset_train['X_distance'] = ut.compute_distance(dataset_train['X'], dataset_train['Y'], dist_sigma, True) #print dataset_train['X_distance'] print('train split') print(dataset_train['X'].shape[0], 'instances') print(dataset_train['X'].shape[1], 'features') print(np.unique(dataset_train['Y']).shape[0], 'classes') return dataset_train, dataset_test
def RPE(traj_gt, traj_est, param_max_pairs=10000, param_fixed_delta=False, param_delta=1.00, param_delta_unit="m", param_offset=0.00): """ This method computes the Relative Pose Error (RPE) and Drift Per Distance Travelled (DDT) Ref: Sturm et al. (2012), Scona et al. (2017) Input: traj_gt -- the first trajectory (ground truth) traj_est -- the second trajectory (estimated trajectory) param_max_pairs -- number of relative poses to be evaluated param_fixed_delta -- false: evaluate over all possible pairs true: only evaluate over pairs with a given distance (delta) param_delta -- distance between the evaluated pairs param_delta_unit -- unit for comparison: "s": seconds "m": meters "rad": radians "deg": degrees "f": frames param_offset -- time offset between two trajectories (to traj_xyz_gt the delay) param_scale -- scale to be applied to the second trajectory Output: list of compared poses and the resulting translation and rotation error """ stamps_gt = list(traj_gt.keys()) stamps_est = list(traj_est.keys()) stamps_gt.sort() stamps_est.sort() stamps_est_return = [] for t_est in stamps_est: t_gt = stamps_gt[utils.find_closest_index(stamps_gt, t_est + param_offset)] t_est_return = stamps_est[utils.find_closest_index( stamps_est, t_gt - param_offset)] t_gt_return = stamps_gt[utils.find_closest_index( stamps_gt, t_est_return + param_offset)] if not t_est_return in stamps_est_return: stamps_est_return.append(t_est_return) if (len(stamps_est_return) < 2): raise Exception( "Number of overlap in the timestamps is too small. Did you run the evaluation on the right files?" ) if param_delta_unit == "s": index_est = list(traj_est.keys()) index_est.sort() elif param_delta_unit == "m": index_est = utils.distances_along_trajectory(traj_est) elif param_delta_unit == "rad": index_est = utils.rotations_along_trajectory(traj_est, 1) elif param_delta_unit == "deg": index_est = utils.rotations_along_trajectory(traj_est, 180 / np.pi) elif param_delta_unit == "f": index_est = range(len(traj_est)) else: raise Exception("Unknown unit for delta: '%s'" % param_delta_unit) if not param_fixed_delta: if (param_max_pairs == 0 or len(traj_est) < np.sqrt(param_max_pairs)): pairs = [(i, j) for i in range(len(traj_est)) for j in range(len(traj_est))] else: pairs = [(random.randint(0, len(traj_est) - 1), random.randint(0, len(traj_est) - 1)) for i in range(param_max_pairs)] else: pairs = [] for i in range(len(traj_est)): j = utils.find_closest_index(index_est, index_est[i] + param_delta) if j != len(traj_est) - 1: pairs.append((i, j)) if (param_max_pairs != 0 and len(pairs) > param_max_pairs): pairs = random.sample(pairs, param_max_pairs) gt_interval = np.median( [s - t for s, t in zip(stamps_gt[1:], stamps_gt[:-1])]) gt_max_time_difference = 2 * gt_interval result = [] diff_pose = [] for i, j in pairs: stamp_est_0 = stamps_est[i] stamp_est_1 = stamps_est[j] stamp_gt_0 = stamps_gt[utils.find_closest_index( stamps_gt, stamp_est_0 + param_offset)] stamp_gt_1 = stamps_gt[utils.find_closest_index( stamps_gt, stamp_est_1 + param_offset)] if (abs(stamp_gt_0 - (stamp_est_0 + param_offset)) > gt_max_time_difference or abs(stamp_gt_1 - (stamp_est_1 + param_offset)) > gt_max_time_difference): continue gt_delta = utils.transform_diff(traj_gt[stamp_gt_1], traj_gt[stamp_gt_0]) est_delta = utils.transform_diff(traj_est[stamp_est_1], traj_est[stamp_est_0]) error44 = utils.transform_diff(est_delta, gt_delta) gt_distance_travelled = utils.compute_distance(gt_delta) # check if the distance is not nan or inf gt_distance_travelled = gt_distance_travelled if ( not 0) else utils._EPS diff_pose.append(error44) trans = utils.compute_distance(error44) rot = utils.compute_angle(error44) result.append( [stamp_est_0, stamp_est_1, stamp_gt_0, stamp_gt_1, trans, rot]) if len(result) < 2: raise Exception( "Couldn't find matching timestamp pairs between groundtruth and estimated trajectory!" ) stamps = np.array(result)[:, 0] trans_error = np.array(result)[:, 4] rot_error = np.array(result)[:, 5] errors = np.matrix([SE3Lib.TranToVec(dT) for dT in diff_pose]).transpose() return errors, trans_error, rot_error, gt_distance_travelled
def __find_closest_cluster(self, data): dist = [compute_distance(data, c) for c in self.centroids] return np.argmin(dist)
def __init__(self, p=None): """ 构建模型参数,加载数据 把前90%分为8:1用作train和valid,来选择超参数, 不用去管剩下的10%. 把前90%作为train,剩下的是test,把valid时学到的参数拿过来跑程序. valid和test部分,程序是一样的,区别在于送入的数据而已。 :param p: 一个标示符,没啥用 :return: """ # 1. 建立各参数。要调整的地方都在 p 这了,其它函数都给写死。 if not p: t = 't' # 写1就是valid, 写0就是test assert 't' == t or 'v' == t # no other case p = OrderedDict([ ('dataset', 'test.txt'), ('mode', 'test' if 't' == t else 'valid'), ('split', -1 if 't' == t else -2), # test预测最后一个。 ('at_nums', [5, 10, 15, 20]), ('epochs', 10), # 调程序用50,test时用100. ('latent_size', 20), ('alpha', 0.01), ('lambda', 0.001), # dist2pre: 两个数据集都用0.001,并且用SGD。 ('loss_weight', [0.5, 0.5]), # foursquare: 已是最佳值 ('dd', 150 / 1000.0), # 150m ('UD', 5), # 截断距离5km,lambda_s的维度。 # gowalla: 已是最佳值 # ('dd', 100 / 1000.0), # 200m # ('UD', 20), # 截断距离40km,lambda_s的维度。 ('mini_batch', 0), # 0:one_by_one, 1:mini_batch. 全都用逐条。 ('gru', 2), # 0:bpr, 1:gru, 2:dist2pre-linear # 3:dist2pre-nonlinear ('batch_size_train', 1), # ('batch_size_test', 128), # user * item 矩阵太大了,分成多次计算。 768 ('process_data_folder', 'process_data/Foursquare/'), ('percent', 0.7) ]) for i in p.items(): print(i) dist_num = int(p['UD'] / p['dd']) # 1520 = 38*1000/25。idx=[0, 1519+1] print(dist_num) # 2. 加载数据 # 因为train/set里每项的长度不等,无法转换为完全的(n, m)矩阵样式,所以shared会报错. [(user_num, item_num), pois_cordis, (aux_tra_buys, aux_tes_buys),(aux_tra_dist, aux_tes_dist), (tra_buys, tes_buys), (tra_dist, tes_dist)] = \ load_data(os.path.join(PATH, p['dataset']), p['mode'], p['split'], p['dd'], dist_num, p['process_data_folder'], p['percent']) # TODO 修改处 # 加载离线处理好的加噪数据,并计算相应的距离 obfuscated_pois = read_from_pkl( p['process_data_folder'] + 'auxiliary_domain/', 'obfuscated_pois') confidence_matrix = read_from_pkl( p['process_data_folder'] + 'auxiliary_domain/', 'confidence_matrix') # 辅助域训练数据为加噪后的数据,测试数据保留原数据 aux_tra_buys = obfuscated_pois aux_tra_dist = compute_distance(aux_tra_buys, pois_cordis, p['dd'], dist_num) aux_tra_num = len(aux_tra_buys) # 将辅助域的数据与目标域的数据合并一起带入训练 aux_tra_buys.extend(tra_buys) aux_tes_buys.extend(tes_buys) aux_tra_dist.extend(tra_dist) aux_tes_dist.extend(tes_dist) tra_buys = aux_tra_buys tes_buys = aux_tes_buys tra_dist = aux_tra_dist tes_dist = aux_tes_dist # 正样本加masks tra_buys_masks, tra_masks = fun_data_buys_masks(tra_buys, tail=[item_num ]) # 预测时算用户表达用 tes_buys_masks, tes_masks = fun_data_buys_masks(tes_buys, tail=[item_num]) # 预测时用 tra_dist_masks, _ = fun_data_buys_masks(tra_dist, tail=[dist_num]) tes_dist_masks, _ = fun_data_buys_masks(tes_dist, tail=[dist_num]) # 负样本加masks tra_buys_neg_masks = fun_random_neg_masks_tra( item_num, tra_buys_masks) # 训练时用(逐条、mini-batch均可) tes_buys_neg_masks = fun_random_neg_masks_tes(item_num, tra_buys_masks, tes_buys_masks) # 预测时用 # 计算负样本与上一个正样本的距离间隔,并加masks tra_dist_neg_masks = fun_compute_dist_neg(tra_buys_masks, tra_masks, tra_buys_neg_masks, pois_cordis, p['dd'], dist_num) # 每个user训练序列里最后一个poi和all pois的距离落在哪个区间里。 usrs_last_poi_to_all_intervals = fun_compute_distance( tra_buys_masks, tra_masks, pois_cordis, p['dd'], dist_num) # print(tra_dist[0][:5]) # [1520, 274, 0, 428, 142], 38km/25m=1520 # print(tra_dist_masks[1020][:sum(tra_masks[1020])]) # 3. 创建类变量 self.p = p self.user_num, self.item_num, self.dist_num = user_num, item_num, dist_num self.pois_cordis = pois_cordis self.tra_buys_masks, self.tra_masks, self.tra_buys_neg_masks = tra_buys_masks, tra_masks, tra_buys_neg_masks self.tes_buys_masks, self.tes_masks, self.tes_buys_neg_masks = tes_buys_masks, tes_masks, tes_buys_neg_masks self.tra_dist_masks = tra_dist_masks self.tes_dist_masks = tes_dist_masks self.tra_dist_neg_masks = tra_dist_neg_masks self.ulptai = usrs_last_poi_to_all_intervals self.aux_tra_num = aux_tra_num self.confidence_matrix = np.array(confidence_matrix)
def __get_samples_distance_matrix(self): distances = np.zeros((self.n, self.n)) for i in range(self.n): for j in range(self.n): distances[i, j] = compute_distance(self.X[i], self.X[j]) return distances
def test_distance_bad(self): assert compute_distance("ssd", "aaa", 53.339428, -6.257664, "Christina McArdle") == [0, 0]
def test_distance_ok(self): assert compute_distance( 52.986375, -6.043701, 53.339428, -6.257664, "Christina McArdle") == [36.271572836813576, 'Christina McArdle']
def _compute_travel_time(self, pos1, pos2): dis = utils.compute_distance(pos1, pos2) return dis / self._robot_speed
def create_street_segments(city): basePath = '/Users/pranavramkrishnan/Desktop/Research/maps/static/data/' + str( city) + '/' streets = json.load(open(basePath + 'streets2.json', 'r')) features = [] output = open(basePath + 'segs_test.csv', 'w') main_output = open(basePath + 'green/query_points2.csv', 'w') coordinates_list = [] check = {} types = [] types_to_ignore = [ "EXPY", "FWY", "TER", "ALY", "HWY", "I", "KYS", "GRN", "Fwy", "PROMENADE", None ] query_points = [] ds = [] for feature in streets['features']: st_type = feature['properties']['STREETTYPE'] types.append(st_type) if st_type not in types_to_ignore: name = feature['properties']['REGISTERED'] name += ' ' name += str(st_type) street_name = capitalize_name(name) # CNN = str(feature['properties']['CNN']) # F_NODE = float(feature['properties']["F_NODE_CNN"]) # T_NODE = float(feature['properties']["T_NODE_CNN"]) coordinates = feature['geometry']['coordinates'] i = 0 #total_dist = 0 while (i < len(coordinates) - 1): start_coord = (float(coordinates[i][0]), float(coordinates[i][1])) end_coord = (float(coordinates[i + 1][0]), float(coordinates[i + 1][1])) seg_dist = utils.compute_distance( [start_coord[1], start_coord[0]], [end_coord[1], end_coord[0]]) * 5280 ds.append(seg_dist) if seg_dist > 75: query_points.append([ truncate_float(start_coord[1]), truncate_float(start_coord[0]), truncate_float(end_coord[1]), truncate_float(end_coord[0]), street_name ]) i += 1 print set(types) print min(ds), max(ds), sum(ds) / len(ds) for pt in query_points: line = '' for s in pt: line += str(s) line += ',' main_output.write(line + '\n') points = {'segments': query_points, 'streets': []} final_json_data = json.dumps(points) output_file = open(basePath + '/green/greenery_test_test.json', 'w') output_file.write(final_json_data)