last files for commit

app.py

@@ -0,0 +1,82 @@
+import streamlit as st
+from ranker import SparseTfIdfRanker, BertRanker, SparseDenseMoviesRanker
+import pandas as pd
+import torch
+from utils import get_image_from_url
+
+st.set_page_config(layout="wide")
+
+@st.cache(allow_output_mutation = True)
+def get_ranker(modele):
+    df = pd.read_pickle('films.pkl')
+    
+    if modele=="sparse-dense":
+        modelpath = "sentence-transformers/multi-qa-MiniLM-L6-cos-v1"
+        bert_index = torch.load('multi-qa-MiniLM-L6-cos-v1_embeddings.pth')
+        sparse_index = torch.load('sparsefake.pth')
+        ranker = SparseDenseMoviesRanker(df, modelpath=modelpath, bert_index = bert_index, sparse_index = sparse_index, vectorizer_path='my_v.pkl')
+    elif modele=="sparse":
+        sparse_index = torch.load('sparsefake.pth')
+        ranker = SparseTfIdfRanker(df, vectorizer_path = 'my_v.pkl', index_matrix = sparse_index)
+    elif modele=="dense":
+        modelpath = "sentence-transformers/multi-qa-MiniLM-L6-cos-v1"
+        bert_index = torch.load('multi-qa-MiniLM-L6-cos-v1_embeddings.pth')
+        ranker = BertRanker(df, index_matrix = bert_index, modelpath=modelpath)
+    else:
+        return NotImplementedError
+    return ranker
+
+
+def main():
+
+    st.title("Canap' _is all you need_ 🎥 ") 
+    st.header("Prototype simple de recommandation de contenus basée sur des description de films")
+    st.write("Jeunes parents, je m'adresse en particulier à vous. Pendant que vos jeunes chérubins 👶 tentent de trouver le sommeil,  la plupart de vos soirées se terminent dans les tréfonds d'un canapé, emportés par algorithme de recommandation de contenu qui se base sur moult critères. D'un autre côté, les choix proposés par les sites francophones vous font rentrer dans un vortex sans fin qui allégera vos espoirs d'une soirée cinéma réussie.")
+    st.write("Je vous propose, avec cette maquette, de comprendre un tout petit peu ce qui se passe derrière le capot.") 
+    st.write("⚠️  Il s'agit bien évidemment d'un prototype; je rejette toute responsabilité quant au potentiel ratage d'un dîner pour cause de promesse cinématographique non tenue ⚠️ . Après tout, je ne suis qu'un ingénieur. Si j'étais critique ciné, je ne connaîtrais probablement pas [Hugging Face](https://huggingface.co/) 🤗, ce qui serait bien dommage - et je connais déjà Martin Scorsese, ce qui suffit amplement à me pavaner en soirée (même si, en tant que jeune parent, je n'ai plus de soirée, souvenez-vous).")
+    st.subheader("Principe et objectifs")
+    st.write("On propose ici de comparer trois modèles de recommandation sur une base de films.")
+    st.write("Plus sérieusement, l'objectif est ici triple")
+    st.write("* Montrer que l'on peut rapidement prototyper un modèle de recommandation sur base de contenus") 
+    st.write("* Prouver qu'il est également possible de le faire en langue française. Et, plus généralement, encourager les avancées remarquables du NLP francophone")
+    st.write("* Avec la mise à disposition des modèles pré-entraînés, la période actuelle de l'intelligence artificielle est similaire à l'avènement de l'open source. Il s'agit juste de dépasser rapidement la phase de prototypage !")
+    st.write("Pour les curieux, je suis en train d'élaborer [un post explicatif, plus technique](https://mnemlaghi.github.io/simsearch)")
+
+    st.subheader("La donnée")
+    st.write("La donnée indexée est issue de la collecte de descriptifs d'environ 8000 films. Les métadonnées telles que l'image du film sont récupérées en temps réel lors de la requête")
+
+    st.subheader("Expérimentons !")
+    modele = st.selectbox("Choisissez votre modèle de recommandation", ['sparse-dense', 'sparse', 'dense'])
+    ranker = get_ranker(modele)
+    query = st.text_input("Quelle histoire voulez-vous regarder ce soir ?", "Une histoire de pirates à la recherche d'un trésor")
+    topn = st.number_input("Combien de films souhaitez-vous afficher ?", min_value = 1, max_value = 20, value = 5)
+
+
+    with st.spinner("Canap' vous recherche des films appropriés sur une base de plus de 8000 films..."):
+        if modele=='sparse-dense':
+            user_firstranking = st.number_input("Filtre isssu du premier ranking (vous pouvez le laisser par défaut à 100) ?", min_value = 10, max_value = 1000, value=1000)
+            df = ranker.run_query(query, topn, first_ranking=user_firstranking)
+        else:
+            df = ranker.run_query(query, topn)
+    
+    score_key = 'tfidf-score' if modele=='sparse' else 'bert-score'
+    if st.button("Qu'est-ce qu'on regarde, ce soir ?"):
+        for i,v in df.iterrows():
+            url, desc, score, title = v['url'], v['desc'], v[score_key], v['title']
+            st.header(title)
+            col1, col2, col3 = st.columns([3,5,2])
+            with col1:
+                st.image(get_image_from_url(url))
+                st.write(f"[Lien]({url})")
+
+            with col2:
+                desc_low = desc[:50]
+                with st.expander(desc_low+'...'):
+                    st.write(desc)
+            
+            with col3:
+                percent = str(round(score*100, 1)) +"%"
+                st.metric('similarité', percent)
+
+if __name__=='__main__':
+    main()

ranker.py

@@ -0,0 +1,122 @@
+from transformers import  AutoModel, AutoTokenizer
+import pandas as pd
+import torch
+from torch.utils.data import Dataset
+import logging
+from tqdm import tqdm
+from torch.utils.data import DataLoader
+import torch.nn.functional as F
+import pickle
+import string
+from abc import abstractmethod
+import json
+
+
+class AbstractMoviesRanker:
+    """Abstract class for ranking items"""
+    def __init__(self, df, index_matrix, score_name = "score"):
+        self.df = df
+        self.ids = self.df.index.values
+        self.index_matrix = index_matrix
+        self.score_name = score_name
+
+    @abstractmethod
+    def encode_query(self, query):
+        pass
+    
+    def get_scores(self, encoded_query):
+        return torch.mm(encoded_query, self.index_matrix.transpose(0,1))[0].tolist()
+    
+    def get_top_ids(self, scores, topn=6):
+        ids_scores_pairs = list(zip(self.ids.tolist(), scores))
+        ids_scores_pairs = sorted(ids_scores_pairs, key = lambda x:x[1], reverse = True)
+        sorted_ids = [v[0] for v in ids_scores_pairs]
+        sorted_scores = [v[1] for v in ids_scores_pairs]
+        sorted_df = self.df.loc[sorted_ids[:topn], :]
+        sorted_df.loc[:,self.score_name] = sorted_scores[:topn]
+        return sorted_df
+
+    def run_query(self, query, topn=6):
+        encoded_query = self.encode_query(query)
+        scores = self.get_scores(encoded_query)
+        return self.get_top_ids(scores, topn)
+
+    depunctuate = staticmethod(lambda x: x.translate(str.maketrans('','',string.punctuation)))
+
+class SparseTfIdfRanker(AbstractMoviesRanker):
+    """Sparse Ranking via TF iDF"""
+    def __init__(self, df, index_matrix, vectorizer_path):
+        super(SparseTfIdfRanker, self).__init__(df, index_matrix, score_name = 'tfidf-score')
+        self.vectorizer = pickle.load(open(vectorizer_path, 'rb'))
+        self.index_matrix = self.index_matrix.to_dense() ##For dot products
+
+    def encode_query(self, query):
+        encoded_query = torch.tensor(self.vectorizer.transform([self.depunctuate(query)]).todense(), dtype = torch.float32)
+        return F.normalize(encoded_query, p=2)
+
+
+class BertRanker(AbstractMoviesRanker):
+    """Dense Ranking with embedding matrix"""
+    def __init__(self, df, index_matrix, modelpath):
+        super(BertRanker, self).__init__(df, index_matrix, score_name = "bert-score")
+        self.tokenizer = AutoTokenizer.from_pretrained(modelpath)
+        self.model = AutoModel.from_pretrained(modelpath)
+
+    def encode_query(self, query):
+        tok_q = self.tokenizer(query, return_tensors="pt", padding="max_length", max_length = 128, truncation=True)
+        o = self.model(**tok_q)
+        encoded_query = self.mean_pooling(o, tok_q['attention_mask'])
+        return F.normalize(encoded_query, p=2)
+
+    @staticmethod
+    def mean_pooling(model_output, attention_mask):
+        token_embeddings = model_output.last_hidden_state #First element of model_output contains all token embeddings
+        input_mask_expanded = attention_mask.unsqueeze(-1).expand(token_embeddings.size()).float()
+        return torch.sum(token_embeddings * input_mask_expanded, 1) / torch.clamp(input_mask_expanded.sum(1), min=1e-9)
+
+
+
+class SparseDenseMoviesRanker():
+    """Sparse Ranking via TF iDF, filtering a first rank, then dense ranking on these items"""
+    def __init__(self, df, modelpath, bert_index, sparse_index, vectorizer_path):
+        self.df =df 
+        self.ids = self.df.index.values
+        self.tfidf_engine = SparseTfIdfRanker(df, sparse_index, vectorizer_path)
+        self.modelpath = modelpath
+        self.bert_index = bert_index
+
+    def run_query(self, query, topn=6, first_ranking=1000):
+        tfidf_sorted_frame = self.tfidf_engine.run_query(query, topn=first_ranking)
+        firstranking_index = self.bert_index[tfidf_sorted_frame.index.values]
+        self.bert_engine = BertRanker(tfidf_sorted_frame, firstranking_index, self.modelpath)
+        bert_sorted_frame = self.bert_engine.run_query(query, topn=topn)
+        return bert_sorted_frame
+
+    @classmethod
+    def from_json_config(cls, jsonfile):
+        with open(jsonfile) as fp:
+            conf = json.loads(fp.read())
+
+        ##Load data for ranking
+        df = pd.read_pickle(conf['dataframe'])
+
+        ##Load indices, e.g. embeddings and encoding utilities
+        bert_index = torch.load(conf['bert_index'])
+        sparse_index = torch.load(conf['sparse_index'])
+        vectorizer_path = conf['vectorizer_path']
+        modelpath = conf['modelpath']
+
+        ##Conf for first ranking
+        firstranking = conf.get('firstranking', 100)
+        ranker = cls(df, modelpath, bert_index, sparse_index, vectorizer_path)
+        return ranker 
+
+
+if __name__=='__main__':
+    
+    engine = SparseDenseMoviesRanker.from_json_config('conf.json')
+
+    for query in ["une histoire de pirates et de chasse au trésor", "une histoire de gangsters avec de l'argent"]:
+        print(query)
+        final_df = engine.run_query(query)
+        print(final_df.head())

requirements.txt

@@ -0,0 +1,4 @@
+torch
+scikit-learn
+pandas
+transformers