def runme(): global q_vector movieid_name_map = DataHandler.movieid_name_map enter_userid = 36 # input("UserID : ") userId = int(enter_userid) times = time.time() DataHandler.vectors() DataHandler.createDictionaries1() loadBase(userId) # runDecomposition(loadPCASemantics) distances = runAllMethods() reco = [nonwatchedList[i] for i in distances][0:5] runAllMethodrelevancefeedback(reco, [1, 1, 1, 0, 0]) new_query = q_vector movies = recommendMovies(new_query) named_movies = [movieid_name_map[i] for i in movies] print('Top 5 movies : ' + str(named_movies)) while True: feedback = input("Relevance (1/0) for each of the 5 movies: ") if feedback == 'exit': print("GoodBye........") break feedback = [int(i) for i in feedback.split(',')] new_query = newQueryFromFeedBack(movies, feedback) print([movieid_name_map[nonwatchedList[i]] for i in new_query][0:5])
def fill_metadata(self): i = 0 for h in range(0, self.tree.max_height + 1): for y in range(0, 2 ** h): for z in range(0, 2 ** h): self.tree.metadata[i] = {} path = DataHandler.get_path(h,y,z) self.tree.metadata[i] = {} if os.path.isfile(path): data = json.load(codecs.open(path, 'r', 'latin-1')) self.tree.metadata[i]["bbox"] = {} self.tree.metadata[i]["bbox"]["min_x"] = data["bbox"][0] self.tree.metadata[i]["bbox"]["min_y"] = data["bbox"][1] self.tree.metadata[i]["bbox"]["max_x"] = data["bbox"][2] self.tree.metadata[i]["bbox"]["max_y"] = data["bbox"][3] self.min_x = min([self.min_x, data["bbox"][0]]) self.min_y = min([self.min_y, data["bbox"][1]]) self.max_x = max([self.max_x, data["bbox"][2]]) self.max_y = max([self.max_y, data["bbox"][3]]) i += 1
def __init__(self): self._db = DataHandler() self._pointspreads = PointSpreads() self._team_idxs = {} self._team_ids = {} self._pagerank = {} self._team_data = {}
def train(self, config): self._cls = self.__parse(config.model.cls) self._dh = DataHandler(config.data, config.db, config.model.features) X, y = self._dh.run() if config.data.balance: X, y = DataBalancer().run(X, y) self._cls.fit(X, y)
class SkinClassifier(): def __init__(self): self._cls = None self._dh = None def train(self, config): self._cls = self.__parse(config.model.cls) self._dh = DataHandler(config.data, config.db, config.model.features) X, y = self._dh.run() if config.data.balance: X, y = DataBalancer().run(X, y) self._cls.fit(X, y) def run(self, img): M, N = img.shape[:-1] X = self._dh.get_features(img) y = self._cls.predict(X) y = self._dh.reshape(y, M, N) return self.__get_skin(img, y) def __get_skin(self, img, p): skin = img.copy() skin[p != 1] = 0 mask = p.copy() mask = mask.astype(np.uint8) mask[p == 1] = 255 mask[mask != 255] = 0 return skin, mask def save(self, fn): joblib.dump((self._cls, self._dh), fn) def load(self, fn): assert exists, '!fn...' self._cls, self._dh = joblib.load(fn) def __parse(self, desc): tmp = makeCallableString(desc) return eval(tmp)
def __init__(self): self.min_x = 100000000000 self.min_y = 100000000000 self.max_x = 0 self.max_y = 0 self.height = 480 self.width = 640 self.graph = Graph() self.graph.load_data("path/path.data") # thread = threading.Thread(target=self.graph.load_data, args=["path/path.data"]) # thread.start() #threads.append(thread) # process = multiprocessing.Process(target = self.graph.load_data, args=["path/path.data"]) # process.start() self.data_handler = DataHandler("data") self.tree = QuadTree(3) self.active_nodes = [] self.zoom_level = 1 self.fill_metadata() self.active_nodes.append(0)
def __init__(self): self._data = None self._db = DataHandler() self._seasons = {}
class PointSpreads: lines = ( "linesage", "linedok", "linepugh", "linesag", "linemoore", "linesagp", "linefox", "linepom", "linepig" ) def __init__(self): self._data = None self._db = DataHandler() self._seasons = {} @property def data(self): if self._data is None: with self._db.connector() as cur: cur.execute("""SELECT * from pointspreads;""") self._data = list(cur)# + CurrentPointspreads().data() return self._data def pred_game(self, season, team_one, team_two, daynum=None): if season < FIRST_SEASON: return 0 model = self.pred_season(season) season_data = [j for j in self.data if j["season"] == season] if daynum is None: games = [j for j in season_data if {j['wteam'], j['lteam']} == {team_one, team_two}] if games: most_recent = max(games, key=lambda j: int(j["daynum"])) if most_recent['wteam'] == team_one: return model.predict(self.get_feature(most_recent)) return model.predict([-j for j in self.get_feature(most_recent)]) else: for row in [j for j in season_data if j["daynum"] == daynum]: if row['wteam'] == team_one and row['lteam'] == team_two: return model.predict(self.get_feature(row)) if row['wteam'] == team_two and row['lteam'] == team_one: return model.predict([-j for j in self.get_feature(row)]) return 0 def get_feature(self, row): feature = [] for line in [row[line] for line in self.lines]: try: feature.append(float(line)) except ValueError: feature.append(0.0) return feature def pred_season(self, season): if season not in self._seasons: features = [] labels = [] print season for row in [j for j in self.data if j["season"] < season]: feature = self.get_feature(row) features.append(feature) labels.append(row["wscore"] - row["lscore"]) features.append([-j for j in feature]) labels.append(-row["wscore"] + row["lscore"]) self._seasons[season] = LassoLarsCV(fit_intercept=False).fit(features, labels) return self._seasons[season]
class Elixer: def __init__(self): self.min_x = 100000000000 self.min_y = 100000000000 self.max_x = 0 self.max_y = 0 self.height = 480 self.width = 640 self.graph = Graph() self.graph.load_data("path/path.data") # thread = threading.Thread(target=self.graph.load_data, args=["path/path.data"]) # thread.start() #threads.append(thread) # process = multiprocessing.Process(target = self.graph.load_data, args=["path/path.data"]) # process.start() self.data_handler = DataHandler("data") self.tree = QuadTree(3) self.active_nodes = [] self.zoom_level = 1 self.fill_metadata() self.active_nodes.append(0) def get_path_with_coordinations(self, source, destination): result = [] for node in self.get_path(source, destination): result.append(self.graph.reverse_nodes_dict[node]) return result def get_path(self, source, destination): if(source.__class__.__name__ == 'tuple'): #path, cost = self.graph.apply_dijkstra(self.graph.nodes_dict[source], self.graph.nodes_dict[destination]) path = self.graph.apply_a_star(self.graph.nodes_dict[source], self.graph.nodes_dict[destination]) return path else: #path, cost = self.graph.apply_dijkstra(source, destination) path = self.graph.apply_a_star(source, destination) return path def fill_metadata(self): i = 0 for h in range(0, self.tree.max_height + 1): for y in range(0, 2 ** h): for z in range(0, 2 ** h): self.tree.metadata[i] = {} path = DataHandler.get_path(h,y,z) self.tree.metadata[i] = {} if os.path.isfile(path): data = json.load(codecs.open(path, 'r', 'latin-1')) self.tree.metadata[i]["bbox"] = {} self.tree.metadata[i]["bbox"]["min_x"] = data["bbox"][0] self.tree.metadata[i]["bbox"]["min_y"] = data["bbox"][1] self.tree.metadata[i]["bbox"]["max_x"] = data["bbox"][2] self.tree.metadata[i]["bbox"]["max_y"] = data["bbox"][3] self.min_x = min([self.min_x, data["bbox"][0]]) self.min_y = min([self.min_y, data["bbox"][1]]) self.max_x = max([self.max_x, data["bbox"][2]]) self.max_y = max([self.max_y, data["bbox"][3]]) i += 1 @classmethod def scale(self, level, x, y, max_x, min_x, max_y, min_y): new_x = (((x - min_x) / (max_x - min_x)) * (640 * level)) new_y = (((y - min_y) / (max_y - min_y)) * (480 * level)) return new_x, new_y @classmethod def reverse_scale(self, level, new_x, new_y, max_x, min_x, max_y, min_y): old_x = (float(new_x) / (640 * level)) * (max_x - min_x) + min_x old_y = (float(new_y) / (480 * level)) * (max_y - min_y) + min_y return old_x, old_y def get_current_coordinates(self): coordinates = [] for node in self.active_nodes: value = self.tree.value(node) coordinates += self.data_handler.load_data(value[0], value[1], value[2]) return coordinates def push_siblings_with_collision(self, camera_x_offset, camera_y_offset, zoom_level = None): if(zoom_level == None): zoom_level = self.zoom_level if(self.active_nodes == [0]): return parents = set() for node in self.active_nodes: parents.add(self.tree.parent(node)) self.active_nodes = [] for parent in parents: self.active_nodes += self.get_children_with_collision(parent, camera_x_offset, camera_y_offset, zoom_level+1) print(">>> just pushed these nodes with collision: ", self.active_nodes) def push_parents_with_collision(self, camera_x_offset, camera_y_offset, zoom_level = None): if(zoom_level == None): zoom_level = self.zoom_level if(self.active_nodes == [0]): return self.active_nodes = [] for node in self.active_nodes: if(has_collision(node, camera_x_offset, camera_y_offset, zoom_level + 1)): self.active_nodes.push(node) def push_children_with_collision(self, camera_x_offset, camera_y_offset, zoom_level = None): if(zoom_level == None): zoom_level = self.zoom_level result = [] for node in self.active_nodes: result += self.get_children_with_collision(node, camera_x_offset, camera_y_offset, zoom_level + 1) print("children: ", result) self.active_nodes = result def has_collision(self, node, camera_x_offset, camera_y_offset, scale_level): min_x = self.tree.metadata[node]["bbox"]["min_x"] min_y = self.tree.metadata[node]["bbox"]["min_y"] max_x = self.tree.metadata[node]["bbox"]["max_x"] max_y = self.tree.metadata[node]["bbox"]["max_y"] min_x, min_y = self.scale(scale_level, min_x, min_y, self.max_x, self.min_x, self.max_y, self.min_y) max_x, max_y = self.scale(scale_level, max_x, max_y, self.max_x, self.min_x, self.max_y, self.min_y) min_x += camera_x_offset max_x += camera_x_offset min_y += camera_y_offset max_y += camera_y_offset if(min_x < 640 and max_x > 0 and min_y < 480 and max_y > 0): return True return False def get_children_with_collision(self, current_node, camera_x_offset, camera_y_offset, scale_level = None): if(scale_level == None): scale_level = self.zoom_level + 1 nodes = [] for node in self.tree.get_children(current_node): if(node >= self.tree.storage_size): continue if(self.tree.metadata[node] == {}): continue if(self.has_collision(node, camera_x_offset, camera_y_offset, scale_level)): nodes.append(node) print("collision nodes: ", nodes) return nodes
class League: def __init__(self): self._db = DataHandler() self._pointspreads = PointSpreads() self._team_idxs = {} self._team_ids = {} self._pagerank = {} self._team_data = {} def data(self, team_id): if team_id not in self._team_data: self._team_data[team_id] = Team(team_id) return self._team_data[team_id] def _lookups(self, season): self._team_idxs[season] = {} self._team_ids[season] = {} with self._db.connector() as cur: cur.execute("""SELECT wteam, lteam FROM RegularSeasonCompactResults where season = ?""", (season,)) for row in cur: if row["wteam"] not in self._team_idxs[season]: idx = len(self._team_idxs[season]) self._team_idxs[season][row["wteam"]] = idx self._team_ids[season][idx] = row["wteam"] if row["lteam"] not in self._team_idxs[season]: idx = len(self._team_idxs[season]) self._team_idxs[season][row["lteam"]] = idx self._team_ids[season][idx] = row["lteam"] def team_ids(self, season): if season not in self._team_ids: self._lookups(season) return self._team_ids[season] def team_idxs(self, season): if season not in self._team_idxs: self._lookups(season) return self._team_idxs[season] def strength(self, team_id, season, daynum=None): return self.pagerank(season, daynum)[self.team_idxs(season)[team_id]] def pointspread(self, season, team_one, team_two, daynum=None): return self._pointspreads.pred_game(season, team_one, team_two, daynum) def pagerank(self, season, daynum=None): if daynum is None: daynum = 1000 if daynum not in self._pagerank.get(season, {}): idxs = self.team_idxs(season) A = numpy.zeros((len(idxs) + 1, len(idxs) + 1)) A[-1, :] = 1 A[:, -1] = 1 with self._db.connector() as cur: cur.execute("""SELECT wteam, lteam, wscore - lscore AS spread FROM RegularSeasonCompactResults WHERE season = ? and daynum < ?""", (season, daynum)) for row in cur: # A[idxs[row['wteam']], idxs[row['lteam']]] += row['spread'] A[idxs[row['wteam']], idxs[row['lteam']]] = 1 # normalize col_sums = A.sum(1) col_sums[col_sums == 0] = 1 A /= col_sums new_x = numpy.zeros((A.shape[0],)) new_y = numpy.ones((A.shape[0],)) while norm(new_x - new_y) > 0.0001: new_x = new_y new_y = numpy.dot(A, new_y) new_y /= norm(new_y) if season not in self._pagerank: self._pagerank[season] = {} self._pagerank[season][daynum] = new_y return self._pagerank[season][daynum]