version 1 de mon apli

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+data.pkl filter=lfs diff=lfs merge=lfs -text

app.py

@@ -0,0 +1,143 @@
+import streamlit as st
+import pandas as pd
+from fonction import prediction, prediction_embe
+from dotenv import load_dotenv
+import os
+import config
+
+from donnees import data_parfum, data_binaire
+
+
+
+model = config.model
+st.set_page_config(layout="wide")
+
+st.title('Bienvenue sur AKIA PARFUM !') 
+
+##################################################################################################
+# Barre latérale pour les entrées
+with st.sidebar:
+    st.markdown("<h1>SAISISSEZ VOS INFORMATIONS</h1>", unsafe_allow_html=True)
+    
+    nombre = st.number_input(label='Nombre de parfums souhaités :', step=1, format='%d')
+    nombre = int(nombre)
+    
+    
+    parfums_prefere = st.multiselect(
+        "Sélectionnez vos parfums préférés.",
+        list(data_binaire.index)
+    )
+    
+    
+    details_rechercher = st.text_input("Décrivez le parfum de vos rêves.")
+    
+    parfums_detestes = st.multiselect(
+        "Sélectionnez des parfums que vous n'aimez pas.",
+        list(data_binaire.index)
+    )
+    
+
+    
+    if parfums_detestes:
+        liste_deteste = list(prediction(parfums_detestes, data_binaire)[0:10].index) 
+        liste_deteste.extend(parfums_detestes)
+######################################################################################################
+# Diviser la page en deux colonnes
+col1, col2 = st.columns([1, 4])  
+
+# Dans la colonne (col2), afficher les résultats
+with col2:
+    st.markdown("<h3>NOS SUGGESTIONS</h3>", unsafe_allow_html=True)
+    parfums_suggeres = None
+    p = 0  #la variable p sera utiliser dans la suite du code, elle permet de pouvoir noter les parfums apres les recommandation
+    
+    ####################################################################
+    #EVALUATION DES DEUX MODELS ET PREDICTIONS
+    
+    if parfums_prefere:
+        prediction_caracteristique = prediction(parfums_prefere, data_binaire)
+        
+    if details_rechercher:
+        prediction_desciption = prediction_embe(details_rechercher, data_parfum, model)
+        
+    
+       
+        
+    #################################################################### 
+    #ELEMENTS A AFFICHES
+    
+    #####CAS 1 : Liste de parfums favoris et description du parfum de reve
+    if parfums_prefere and details_rechercher:
+        data = pd.concat([prediction_caracteristique, prediction_desciption])
+        predictions = data.groupby(level=0)['probabilite'].mean()
+        predictions = predictions.drop(parfums_prefere)
+        
+        if parfums_detestes:
+            liste_deteste = list(prediction(parfums_detestes, data_binaire)[0:10].index)
+            liste_deteste.extend(parfums_detestes)
+            predictions = predictions.drop(liste_deteste)
+            
+        predictions = predictions.sort_values(ascending=False)
+        parfums_suggeres = predictions[0:nombre]
+        p = 1
+        st.write(parfums_suggeres)
+       
+        
+     ##### CAS 2 : description du parfum de reve    
+    if not parfums_prefere and details_rechercher:
+        if parfums_detestes:
+            prediction_desciption = prediction_desciption.drop(liste_deteste)
+        parfums_suggeres = prediction_desciption[0:nombre]
+        p = 1
+        st.write(parfums_suggeres)
+        
+        
+    ##### CAS 3 : Liste de parfums favoris 
+    if not details_rechercher and parfums_prefere:
+        if parfums_detestes:
+            prediction_caracteristique = prediction_caracteristique.drop(liste_deteste)
+        parfums_suggeres = prediction_caracteristique[0:nombre]
+        p = 1
+        st.write(parfums_suggeres)
+    if not details_rechercher and not parfums_prefere:
+        st.write('Bienvenue ! Veuillez choisir les parfums que vous aimez ou décrire le parfum de vos rêves.')
+        
+    
+    #############################################################################################
+
+### NOTEZ NOS SUGGESTIONS 
+liste = []
+description_ = ''
+
+with st.sidebar:
+    st.markdown("<h1>Notez nos suggestions sur 10</h1>", unsafe_allow_html=True)
+    if p == 1:
+        form_counter = 0
+        form_counter += 1
+        with st.form(key=f'rating_form_{form_counter}'):
+            parfum = st.selectbox("Choisir un parfum :", list(parfums_suggeres.index))
+            note = st.number_input("Entrez une note :", min_value=1, max_value=10)
+            nom = st.text_input("Entrer votre nom.")
+            if parfum:
+                if parfums_prefere :
+                    liste = parfums_prefere
+                    if not details_rechercher:
+                        proba = parfums_suggeres.loc[parfum].values[0]
+                        
+                if details_rechercher:
+                    description_ = details_rechercher
+                    if not parfums_prefere:
+                        proba = parfums_suggeres.loc[parfum].values[0]
+                    
+                #proba = parfums_suggeres.loc[parfum].values[0]
+                
+                if details_rechercher and  parfums_prefere:
+                    proba = parfums_suggeres.loc[parfum]
+                
+            submitted = st.form_submit_button("Enregistrer la note")
+            if submitted:
+                with open("notes.txt", "a") as file:
+                    file.write(f"{nom},{liste},{description_},{parfum},{proba},{note}\n")
+                st.success("Note enregistrée avec succès !")
+    else:
+        st.write('En notant nos recommandations, vous contribuez à améliorer la qualité des suggestions qui vous sont proposées.')

config.py

@@ -0,0 +1 @@
+model = 'models/embedding-001'

data.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7b93fd6100ccde27a1e140293dede6b22b24694fc2cffbdc42348ec4e576ba9a
+size 19730237

donnees.py

@@ -0,0 +1,7 @@
+import pandas as pd
+
+data_parfum = pd.read_pickle("data.pkl")  #Donner des description et des vecteurs de embedding
+
+data_binaire = pd.read_csv('donnee_binaire.csv', index_col='nom_parfum')  ## donnee des carracteristiques avec des 0 et 1
+
+

fonction.py

@@ -0,0 +1,140 @@
+import pandas as pd
+import numpy as np
+from scipy.spatial.distance import pdist, squareform
+from sklearn.metrics.pairwise import cosine_similarity
+import os
+import google.generativeai as genai
+import config
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+
+def prediction(liste_parfums, df):
+    
+    """
+    Cette fonction effectue une prédiction de recommandation de parfums basée sur la similarité de Jaccard.
+
+    Elle prend en entrée une liste de parfums aimés par un utilisateur,
+    calcule un nouveau profil utilisateur en agrégeant les embeddings correspondants à ces parfums,
+    puis calcule la similarité de Jaccard entre ce nouveau profil utilisateur et les autres profils de parfums.
+    Enfin, elle retourne les parfums recommandés triés par ordre décroissant de similarité de Jaccard.
+
+    Args:
+        liste_parfums (list): La liste des parfums aimés par l'utilisateur.
+        df (pandas.DataFrame): Le DataFrame contenant les embeddings des parfums.
+
+    Returns:
+        pandas.DataFrame: Un DataFrame contenant les parfums recommandés et leur probabilité de similarité.
+
+    Raises:
+        ValueError: Si la liste des parfums est vide ou si le DataFrame des embeddings est vide.
+        KeyError: Si la colonne 'Embeddings' n'est pas présente dans le DataFrame.
+    """
+
+    new_user = np.zeros(df.shape[1])  # Initialisation d'une série de zéros pour un nouveau profil utilisateur
+
+    # Calcul du nouveau profil utilisateur
+    for parfum in liste_parfums:
+        new_user += df.loc[parfum]
+    new_user[new_user > 1] = 1 
+    df.loc['new_user'] = new_user
+    
+    
+    # Calcul de la similarité de Jaccard
+    jaccard_distances = pdist(df.values, metric='jaccard')
+    jaccard_similarity_array = 1 - squareform(jaccard_distances)
+    jaccard_similarity_df = pd.DataFrame(jaccard_similarity_array, index=df.index, columns=df.index)
+    
+    # Récupération des similarités pour le nouvel utilisateur
+    jaccard_similarity_series = jaccard_similarity_df.loc['new_user']
+    
+    # Suppression des parfums d'entrée
+    jaccard_similarity_series = jaccard_similarity_series.drop(list(liste_parfums))
+    
+    # Trier les valeurs de similarité de la plus élevée à la plus basse
+    ordered_similarities = jaccard_similarity_series.sort_values(ascending=False)
+    
+    # Supprimer le profil utilisateur après la prédiction
+    df = df.drop(index='new_user')
+    
+    dict_of_dicts = ordered_similarities.to_dict()
+    data = pd.DataFrame(list(dict_of_dicts.values()), index=list(dict_of_dicts.keys()), columns=['probabilite'])
+    return data.iloc[1:]
+
+
+
+
+ 
+
+
+ma_cle = os.getenv('gemini_key')
+genai.configure(api_key=ma_cle)
+model = config.model
+
+def calcul_emb(description_utilisateur, model):
+    """
+    Calcule l'embedding d'une description utilisateur en utilisant un modèle spécifié.
+    Args:
+        description_utilisateur (str): La description de l'utilisateur pour laquelle l'embedding doit être calculé.
+        model (str): Le modèle utilisé pour calculer l'embedding.
+    Returns:
+        numpy.ndarray: L'embedding de la description utilisateur, représenté sous forme de tableau NumPy.
+        
+    Raises:
+        ValueError: Si le modèle spécifié n'est pas valide ou si la description utilisateur est vide.
+    """
+
+    embedding = genai.embed_content(model=model,
+                                    content=description_utilisateur,
+                                    task_type="retrieval_document")
+    return np.array(embedding["embedding"]).reshape(1, -1)
+
+
+
+
+def calcul_similarite(embedding_utilisateur, embedding):
+    """
+    Calcule la similarité cosinus entre deux vecteurs d'embeddings.
+    Args:
+        embedding_utilisateur (numpy.ndarray): L'embedding de la desciption de l'utilisateur, représenté sous forme de tableau NumPy.
+        embedding (numpy.ndarray): L'embedding à comparer avec l'embedding de l'utilisateur, représenté sous forme de tableau NumPy.
+    Returns:
+        float: La similarité cosinus entre les deux embeddings.
+        
+    Raises:
+        ValueError: Si l'une des embeddings n'est pas valide ou si elles n'ont pas la même dimension.
+    """
+    embedding = np.array(embedding).reshape(1, -1)  # Convertir en tableau NumPy avant de remodeler
+    return cosine_similarity(embedding, np.array(embedding_utilisateur).reshape(1, -1))[0][0]
+
+
+
+def prediction_embe(description_utilisateur, df, model):
+    """
+    Cette fonction effectue une prédiction basée sur l'embedding de la description utilisateur.
+
+    Elle calcule l'embedding de la description utilisateur en utilisant le modèle spécifié,
+    puis calcule la similarité cosinus entre cet embedding et les embeddings stockés dans le DataFrame.
+    Enfin, elle classe les résultats par ordre décroissant de similarité.
+
+    Args:
+        description_utilisateur (str): La description de l'utilisateur pour laquelle la prédiction doit être effectuée.
+        df (pandas.DataFrame): Le DataFrame contenant les embeddings des parfums et d'autres informations.
+        model (str): Le modèle utilisé pour calculer l'embedding de la description utilisateur.
+
+    Returns:
+        pandas.DataFrame: Un DataFrame contenant les noms des parfums et les probabilités de similarité, classés par ordre décroissant de similarité.
+
+    Raises:
+        ValueError: Si le modèle spécifié n'est pas valide ou si la description utilisateur est vide.
+        KeyError: Si la colonne 'Embeddings' n'est pas présente dans le DataFrame.
+    """
+    vecteur_utilisateur = calcul_emb(description_utilisateur, model)
+    df['probabilite'] = df['Embeddings'].map(lambda emb: calcul_similarite(emb, vecteur_utilisateur))
+    data = df[['nom_parfum', 'probabilite']]
+    data.set_index('nom_parfum', inplace=True)
+    data = data.sort_values(by='probabilite', ascending=False)
+    return data  
+

notes.txt

@@ -0,0 +1 @@
+

requirements.txt

@@ -0,0 +1,66 @@
+altair==5.3.0
+annotated-types==0.6.0
+attrs==23.2.0
+blinker==1.8.2
+cachetools==5.3.3
+certifi==2024.2.2
+charset-normalizer==3.3.2
+click==8.1.7
+gitdb==4.0.11
+GitPython==3.1.43
+google-ai-generativelanguage==0.6.3
+google-api-core==2.19.0
+google-api-python-client==2.129.0
+google-auth==2.29.0
+google-auth-httplib2==0.2.0
+google-generativeai==0.5.3
+googleapis-common-protos==1.63.0
+grpcio==1.63.0
+grpcio-status==1.62.2
+httplib2==0.22.0
+idna==3.7
+Jinja2==3.1.4
+joblib==1.4.2
+jsonschema==4.22.0
+jsonschema-specifications==2023.12.1
+markdown-it-py==3.0.0
+MarkupSafe==2.1.5
+mdurl==0.1.2
+numpy==1.26.4
+packaging==24.0
+pandas==2.2.2
+pillow==10.3.0
+proto-plus==1.23.0
+protobuf==4.25.3
+pyarrow==16.1.0
+pyasn1==0.6.0
+pyasn1_modules==0.4.0
+pydantic==2.7.1
+pydantic_core==2.18.2
+pydeck==0.9.1
+Pygments==2.18.0
+pyparsing==3.1.2
+python-dateutil==2.9.0.post0
+python-dotenv==1.0.1
+pytz==2024.1
+referencing==0.35.1
+requests==2.31.0
+rich==13.7.1
+rpds-py==0.18.1
+rsa==4.9
+scikit-learn==1.4.2
+scipy==1.13.0
+six==1.16.0
+smmap==5.0.1
+streamlit==1.34.0
+tenacity==8.3.0
+threadpoolctl==3.5.0
+toml==0.10.2
+toolz==0.12.1
+tornado==6.4
+tqdm==4.66.4
+typing_extensions==4.11.0
+tzdata==2024.1
+uritemplate==4.1.1
+urllib3==2.2.1
+watchdog==4.0.0