Upload 10 files

presentation.py

@@ -0,0 +1,126 @@
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import importlib
+
+
+from st_on_hover_tabs import on_hover_tabs
+
+import streamlit as st
+
+import streamlit_presentation
+import streamlit_presentation.analyse
+importlib.reload(streamlit_presentation.analyse)
+from streamlit_presentation.analyse import repartition_par_categorie
+from streamlit_presentation.analyse import repartition_longueur_categorie
+
+
+import streamlit_presentation.preprocessing
+importlib.reload(streamlit_presentation.preprocessing)
+from streamlit_presentation.preprocessing import detection_langage_et_traduction
+
+import streamlit_presentation.modele
+importlib.reload(streamlit_presentation.modele)
+from streamlit_presentation.modele import presentation_modele
+from sklearn.metrics import f1_score
+
+plt.rcParams['font.size'] = 12
+plt.rcParams['axes.labelsize'] = 10
+plt.rcParams['axes.titlesize'] = 12
+plt.rcParams['xtick.labelsize'] = 8
+plt.rcParams['ytick.labelsize'] = 8
+plt.rcParams['legend.fontsize'] = 8
+plt.rcParams['lines.linewidth'] = 1
+
+#on charge les donnees utilisees
+data = pd.read_csv( 'data.csv')
+extract_data = pd.read_csv( 'data_tr_extract.csv')
+sum_data = pd.read_csv( 'data_sum_extract.csv')
+test_data = pd.read_pickle( 'data_test.pkl')
+
+from keras.models import load_model
+import tensorflow as tf
+from tensorflow.keras import backend as K
+import ast
+
+
+def f1_weighted(true, pred):  
+
+    # Classes
+    classes = K.arange(0, 27) 
+    true = K.one_hot(K.cast(true, 'int32'), 27)
+    
+    # Calcule les TP, FP, FN pour chaque classe
+    tp = K.dot(K.transpose(true), K.round(pred))
+    fp = K.dot(K.transpose(1-true), K.round(pred))
+    fn = K.dot(K.transpose(true), 1-K.round(pred))
+
+    # Calcule le score F1 pour chaque classe
+    p = tp / (tp + fp + K.epsilon())
+    r = tp / (tp + fn + K.epsilon())
+    f1 = 2*p*r / (p+r+K.epsilon())
+
+    
+    weighted_f1 = K.sum(f1 * K.sum(true, axis=0) / K.sum(true))
+    return weighted_f1
+
+model = load_model("final_model_kfold.h5", custom_objects={'f1_weighted': f1_weighted})
+
+
+
+
+
+from sklearn.preprocessing import LabelEncoder
+encoder =  LabelEncoder()
+print(test_data.columns)
+y_test = encoder.fit_transform(test_data["prdtypecode"])
+class_labels = encoder.classes_
+label_size = 27
+
+
+
+####### Page principale
+st.set_page_config(layout="wide")
+st.markdown('<style>' + open('./style.css').read() + '</style>', unsafe_allow_html=True)
+
+st.title("Mon Application")
+
+with st.sidebar:
+    tabs = on_hover_tabs(tabName=['Introduction', "Analyse", "Preprocessing", "Modèle", "Pistes exploratoires"], 
+                         iconName=['apps', 'bar_chart', "sync", "memory", "topic"], default_choice=0)
+
+st.markdown("""
+<style>
+    .rounded-border-parent {
+        border-radius: 15px !important;
+        border: 1px solid blue !important;
+        background-color: lightgray !important;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+
+if tabs == "Introduction":
+    st.write("# Introduction")
+    st.write("Ici")
+
+elif tabs == "Analyse":
+    st.write("# Analyse")
+    
+    st.dataframe(data.head(30))
+    st.write("")
+    
+    repartition_par_categorie(st, data)
+    repartition_longueur_categorie(st, data)
+
+elif tabs == "Preprocessing":
+    detection_langage_et_traduction(st, extract_data, sum_data)
+
+elif tabs == "Modèle":
+    presentation_modele(st, test_data, model,class_labels,y_test)
+
+elif tabs == "Pistes exploratoires":
+    st.write("# Pistes exploratoires")
+    st.write("Ici")
+
+

streamlit_presentation/analyse.py

@@ -0,0 +1,66 @@
+import pandas as pd
+import numpy as np
+import seaborn as sns
+import matplotlib.pyplot as plt
+
+def repartition_par_categorie(st,data):
+    val_code = data['prdtypecode'].unique()
+
+    target_count = (data["prdtypecode"].value_counts(normalize=True)*100).reset_index()
+    target_count.columns=["prdtypecode","pourcentage"]
+
+    plt.figure(figsize=(10,3))
+    ax = sns.barplot( x="prdtypecode", y="pourcentage", data=target_count)
+
+    ax.axhline(y=100/len(val_code),color="green",linewidth=2, alpha=0.5)
+
+    plt.xticks(rotation=45)
+    plt.xlabel('Code produit')
+    plt.ylabel('Pourcentage')
+    plt.grid()
+    plt.title("Distribution des valeurs de la target")
+
+    # Afficher le graphique avec Streamlit
+    col1, col2,col3 = st.columns([6,1,3])
+    with col1:
+        st.pyplot(plt)
+
+    with col3:
+        st.markdown('<div class="rounded-border"></div>', unsafe_allow_html=True)
+        st.write("\n\n\n\n\n\n")
+        st.write("La catégorie la plus présente représente 12% du corpus.")
+        st.write("Si la base était uniformément répartie:")
+        st.write(f"=> chaque code serait représenté à {100/len(val_code):.2f}% de la base")
+
+
+def repartition_longueur_categorie(st,data):
+    data["designation_length"] = data["designation"].str.len()
+    data["description_length"] = data["description"].str.len()
+    
+    plt.figure(figsize=(10,4))
+    ax = sns.histplot(x='designation_length', data=data,bins=50);
+    ax.axhline(data["designation_length"].mean(),color="r",linewidth=2, alpha=0.5)
+    
+    plt.xticks(rotation=45)
+    plt.xlabel("Longueur de la designation en caractères");
+    plt.ylabel("nb d'occurences");
+    plt.grid()
+    plt.title("Répartition des longueurs des designations");
+    
+    col1, col2,col3 = st.columns([2,6,3])
+    with col1:
+        st.write(data["designation_length"].describe())
+        
+    with col2:
+        st.pyplot(plt)
+
+    with col3:        
+        st.text('')
+        st.text('')
+        st.text('')
+        st.text('')
+        st.text('')
+        st.text('')
+        st.write(f'=> Longueur de la designation est comprise entre {data["designation_length"].min()} et {data["designation_length"].max()} caractères')
+        st.write("on a une majeure partie de la distribution entre 45 et 100 caractères, puis un pic à 250 caractères")
+        

streamlit_presentation/modele.py

@@ -0,0 +1,53 @@
+import matplotlib.pyplot as plt
+import seaborn as sns
+import numpy as np 
+from sklearn.metrics import f1_score
+from sklearn.metrics import confusion_matrix
+
+def presentation_modele(st,data, model,class_labels, y_test):
+    
+    st.write('Notre modèle prend les embeddings de Camembert pour les descriptions et designations (séparemment), les embeddings de FlauBert pour les descriptions, les embeddings VIT pour les images et les tailles des champs de texte.')
+    
+    st.image("model.png",  use_column_width=True)
+    #afficher une image du modele
+    #afficher les embeddings en extrait
+    #ajouter un bouton qui declanche le training
+    if st.button("Prédire"):
+        X1_test = data["embeddings_desi"].values
+        X1_test = np.stack(X1_test).astype(np.float32)
+        X2_test = data["embeddings_desc"].values
+        X2_test = np.stack(X2_test).astype(np.float32)
+        X3_test = data["embedding_vit"].values
+        X3_test = np.stack(X3_test).astype(np.float32)
+        X4_test = data["designation_length_normalized"].values
+        X5_test = data["description_length_normalized"].values
+        X6_test = data["embeddings_desi_Flaubert"].values
+        X6_test = np.stack(X6_test).astype(np.float32)
+        y_pred = model.predict([X1_test, X2_test,X3_test,X4_test,X5_test,X6_test])
+        y_pred_ids = np.argmax(y_pred, axis=-1)
+
+        weighted_f1_score = f1_score(y_test, y_pred_ids, average='weighted')
+        st.write("weighted F1 score:",weighted_f1_score)
+    
+ 
+        conf_matrix = confusion_matrix(y_test, y_pred_ids)
+
+        row_sums = conf_matrix.sum(axis=0)
+        normalized_conf_matrix = conf_matrix / row_sums[ np.newaxis,:]*100
+
+
+        st.title("Matrice de Confusion Normalisée")
+        plt.figure(figsize=(10, 10))
+        sns.heatmap(normalized_conf_matrix, annot=True, cmap='Blues',fmt='.0f',
+                    xticklabels=class_labels,
+                    yticklabels=class_labels,
+                    linewidths=1.5)
+        plt.xlabel('Prédictions')
+        plt.ylabel('Réelles')
+        plt.title('Matrice de Confusion')
+        st.pyplot(plt)
+        
+    #afficher la matrice de conf.
+    st.dataframe(data.head(10))
+    
+    

streamlit_presentation/preprocessing.py

@@ -0,0 +1,35 @@
+import numpy as np
+import seaborn as sns
+import matplotlib.pyplot as plt
+
+
+def detection_langage_et_traduction(st,data, sum_data):
+    
+    data_lang = data[(data["desi_langue"] != "fr") | (data["desc_langue"] != "fr")]
+    data_lang = data_lang[["designation","desi_langue","tr_designation", "description","desc_langue","tr_description"]]
+    st.write('Utilisation de FastText pour détecter la langue: champ "desi_langue", champ "desc_langue"')
+    st.dataframe(data_lang)
+    st.write("Nous remarquons que la langue n'est pas toujours correctement détectée: nous acceptons ce problême, plutôt que de traduire le texte sans fournir la langue d'origine, le résultat étant nettement moins bon.")
+    
+    st.markdown("---")
+    st.write("")
+    st.subheader("Génération de résumés")
+    st.write("")
+    st.write("Certaines descriptions dépassent notre limitation en terme de tokens d'entrée du modèle, aussi, plutôt de couper le texte à l'aveugle, nous choisissons de résumer les descriptions.")
+    st.write("")
+    st.markdown("Le modèle Barthez [moussaKam/barthez-orangesum-abstract](https://huggingface.co/moussaKam/barthez-orangesum-abstract) propose de résumer des textes en francais, il utilise des mots et morceaux de phrases provenant du texte lui-même. Notre objectif est de conserver le sujet du texte et avoir les caractéristiques principales")
+    
+    st.image("summarize.png", use_column_width=False)
+    st.write("Si le nombre de mots est supérieur à 200, nous retournons la description originale, sinon nous la résumons avec un objectif de 200 mots. Notre limite de token est de 250, en prenant 200 nous gardons une marge de 50.")
+    
+    data_sum = sum_data[["description","tr_description_sum"]]
+    st.dataframe(data_sum)  
+    st.write("")
+    st.markdown("---")
+    st.write("")
+    st.write("Nous appliquons un prétraitement aux images, qui détecte la présence de padding dans les images, et le réduit au minimum possible. Ensuite, nous transformons les images en 224x224 pour correspondre au format VGG16 et VIT")
+    st.write("")
+    
+    st.image("resize.png",  use_column_width=True)
+    st.image("samples.png",  use_column_width=True)
+    st.write("Un grand nombre de catégories peuvent ainsi éviter la perte due au downscale des images, sauvant presque toutes les cartes à collectionner, les cartes postales, les revues, etc. Nous allions ainsi une taille idéale pour le modèle (celle sur laquelle il a été pré-entrainé) et une perte d'information minimisée.")