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]
