def _insert_country_vectors(self):
session.query(CountryVector).delete()
for country_id, country_vector in self.implicit_mf.country_vectors.vectors.iterrows(
):
session.add(
CountryVector(country_id=int(country_id), **country_vector))
session.commit()
def get_recommended_songs():
country_ids = request.get_json()['country_ids']
operator_ids = request.get_json()['operator_ids']
country_vector_objects = session.query(CountryVector).filter(CountryVector.country_id.in_(country_ids)).all()
operator_objects = session.query(Operator).filter(Operator.id.in_(operator_ids)).all()
recommended_songs = [{'artist': artist, 'title': title, 'url': url} for title, artist, url in RecommendedSongGenerator(country_vector_objects, operator_objects)]
return jsonify({'songs': recommended_songs}), 200
def get_countries():
countries = [{
'id': country.id,
'name': country.name,
'value': country.value
} for country in session.query(Country)]
return jsonify({'countries': countries}), 200
def get_operators():
operators = [{
'id': operator.id,
'name': operator.name,
'value': operator.value
} for operator in session.query(Operator)]
return jsonify({'operators': operators}), 200
def _build_R_ui(self):
top_songs_sorted = session.query(TopSong)\
.order_by(TopSong.date.desc(), TopSong.song_id.desc())\
.limit(self.n_top_songs)\
.subquery('top_songs_sorted')
top_songs = session.query(
top_songs_sorted.c.country_id,
top_songs_sorted.c.song_id,
func.sum(top_songs_sorted.c.streams).label('total_streams'))\
.group_by(top_songs_sorted.c.country_id, top_songs_sorted.c.song_id)\
.all()
ratings_matrix = pd.DataFrame(top_songs).pivot(
'country_id', 'song_id', 'total_streams').fillna(0).astype(float)
return np.log(1 + ratings_matrix / self.eps)
def _top_song_exists(top_song):
return session.query(exists()\
.where(TopSong.song_id==top_song.song_id)\
.where(TopSong.country_id==top_song.country_id)\
.where(TopSong.rank==top_song.rank)\
.where(TopSong.streams==top_song.streams)\
.where(TopSong.date==top_song.date)
).scalar()
def _build_R_ui(self):
top_songs = session.query(
TopSong.country_id,
TopSong.song_id,
func.sum(TopSong.streams).label('total_streams')
).group_by(TopSong.country_id, TopSong.song_id).all()
return pd.DataFrame(top_songs).pivot(
'country_id', 'song_id', 'total_streams').fillna(0).astype(float)
def test_implicit_mf_pipeline_inserts_correct_song_vectors(self):
implicit_mf = ImplicitMF(ratings_matrix=DummyRatingsMatrix(),
f=TestImplicitMF.LATENT_FEATURES,
alpha=TestImplicitMF.ALPHA,
lmbda=TestImplicitMF.LAMBDA,
n_iterations=TestImplicitMF.N_ITERATIONS)
pipeline = ImplicitMFPipeline(implicit_mf=implicit_mf)
pipeline.run()
song_vector_objects = session.query(SongVector).all()
actual_song_vectors = self._extract_numeric_vectors(
vector_objects=song_vector_objects, id_col='song_id')
assert_frame_equal(actual_song_vectors,
TestImplicitMF.EXPECTED_SONG_VECTORS)
def get_recommended_songs():
country_ids = request.get_json()['country_ids']
operator_ids = request.get_json()['operator_ids']
operator_objects = session.query(Operator).filter(
Operator.id.in_(operator_ids)).all()
country_vectors = filter_country_vectors(
country_vectors=COUNTRY_VECTOR_COLLECTION.numeric_vectors,
country_ids=country_ids)
recommended_songs_generator = RecommendedSongGenerator(
operator_objects=operator_objects,
song_vector_objects=SONG_VECTOR_COLLECTION,
country_vectors=country_vectors,
)
recommended_songs = [{
'artist': artist,
'title': title,
'url': url
} for title, artist, url in recommended_songs_generator]
return jsonify({'songs': recommended_songs}), 200
def _insert_country_vectors(self):
session.query(CountryVector).delete()
for country_id, country_vector in self.implicit_mf.country_vectors.vectors.iterrows():
session.add(CountryVector(country_id=int(country_id), **country_vector))
session.commit()
def __iter__(self):
aggregate_vector = self._compute_aggregate_vector()
predicted_preferences = pd.DataFrame(self.song_vectors).apply(lambda vec: np.dot(vec, aggregate_vector), axis=1)
for song_id, vector in predicted_preferences.sort_values(ascending=False).head(self.NUM_SONGS_TO_RECOMMEND).iteritems():
song = session.query(Song).filter(Song.id == int(song_id)).first()
yield (song.title, song.artist, song.url)
def __init__(self, country_vector_objects, operator_objects):
self.country_vector_objects = country_vector_objects
self.operator_objects = operator_objects
self.song_vector_objects = session.query(SongVector).all()
self.country_vectors = self._extract_country_vectors()
self.song_vectors = self._extract_song_vectors()
def get_operators():
operators = [{'id': operator.id, 'name': operator.name, 'value': operator.value} for operator in session.query(Operator)]
return jsonify({'operators': operators}), 200
def _query_all_vectors(self):
return session.query(self._model).all()
def get_countries():
countries = [{'id': country.id, 'name': country.name, 'value': country.value} for country in session.query(Country)]
return jsonify({'countries': countries}), 200
def tearDown(self):
session.query(CountryVector).delete()
session.query(SongVector).delete()
session.query(Song).delete()
session.commit()
def __iter__(self):
predicted_preferences = self._compute_predicted_preferences()
for song_id, vector in predicted_preferences.sort_values(ascending=False).head(self.NUM_SONGS_TO_RECOMMEND).iteritems():
song = session.query(Song).filter(Song.id == int(song_id)).first()
yield (song.title, song.artist, song.url)
def _insert_song_vectors(self):
session.query(SongVector).delete()
for song_id, song_vector in self.implicit_mf.song_vectors.vectors.iterrows(
):
session.add(SongVector(song_id=int(song_id), **song_vector))
session.commit()
def _insert_song_vectors(self):
session.query(SongVector).delete()
for song_id, song_vector in self.implicit_mf.song_vectors.vectors.iterrows():
session.add(SongVector(song_id=int(song_id), **song_vector))
session.commit()