Hugging Face's logo

Spaces:
ModuMLTECH
/
DSI_Final_Reg_Projet
Sleeping

App Files Community
DSI_Final_Reg_Projet
File size: 5,116 Bytes 
57ac546
 
 
 
 
 
 
 
 
 
 
 
 
 
 
7c85b2c
57ac546
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
7ba0af4
 
 
57ac546
7ba0af4
57ac546
 
 
 
 
 
 
 
 
 
 
 
 
 
7ba0af4
57ac546
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
7ba0af4
57ac546
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
ff5a68e
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
 
# -*- coding: utf-8 -*-
"""Final_projet_app.ipynb

Automatically generated by Colab.

Original file is located at
    https://colab.research.google.com/drive/1BlNoqeygGpdcMtxEP-U-wJkAVngPpPUf
"""

#Importer les packages
import numpy as np
import gradio as gr
import pandas as pd

data = pd.read_csv('Telephone_data___.csv')
df = pd.read_csv('data_prep.csv')

# Encoder les variables catégorielles
from sklearn.preprocessing import LabelEncoder
# Créer différents encodeurs pour les variables catégorielles
encoder0 = LabelEncoder()
encoder1 = LabelEncoder()
encoder2 = LabelEncoder()
encoders = [encoder0, encoder1, encoder2]
columns = [col for col in data.columns if data[col].dtype == 'object']
for i in range(len(columns)):
  encoders[i].fit(data[columns[i]]) # le modèle prend le temps de reconnaitre les classes
# Fractionner les données
x= df.drop('etat', axis = 1).values # variables prédicteurs
y = df['etat'].values # variable cible

# importer StandardScaler
from sklearn.preprocessing import StandardScaler, MinMaxScaler, normalize
# Instancier StandardScaler
scaler = StandardScaler()
scaler.fit(x) # calcul de la moyenne et de l'écart type
x = scaler.transform(x) # normalisation


from sklearn.model_selection import train_test_split
# Splitter les données en train, val et test
x_train, x_vt,y_train,y_vt = train_test_split(x,y , test_size = 0.2, random_state = 42)
# Splitter les données en val et test
x_val, x_test, y_val, y_test = train_test_split(x_vt, y_vt, test_size = 0.5, random_state = 42)

from sklearn.ensemble import RandomForestClassifier
# Entrainer Random Forest en utilisant les paramètres optimaux 'criterion': 'entropy', 'max_depth': 14, 'n_estimators': 40
rf = RandomForestClassifier(criterion =  'gini', max_depth =  10, n_estimators = 70)
# Entrainement
rf.fit(x_train, y_train)

# importer gradio
import gradio as gr
# Fonction de prédiction simple
def Pred_func(prix,	adresse,	marque,	dim_ecr,	ram,	stockage):
  # Encoder les valeurs des adresse, marque, etat
  adresse = encoder0.transform([adresse])[0]
  marque = encoder1.transform([marque])[0]
  # vecteur des valeurs numériques
  x_new = np.array([prix,	adresse,	marque,	dim_ecr,	ram,	stockage])
  x_new = x_new.reshape(1,-1) # convert en un 2D array
  # Normaliser les données
  x_new = scaler.transform(x_new)
  # Prédire
  y_pred = rf.predict(x_new)
  # Décoder la valeur prédite pour 'etat'
  y_pred_decoded = encoder2.inverse_transform([y_pred[0]])[0]  # Décoder la valeur encodée
  return str(y_pred_decoded)


# Fonction de prédiction multiple
def Pred_func_csv(file):
  # Lire le fichier csv
  df = pd.read_csv(file)
  # prédictions
  predictions = []
  # Boucle sur les lignes du dataframe
  for row in df.iloc[:, :].values:
    # nouvelle ligne avec les valeurs des Fuel_Type, Seller_Type et Transmission encodées
    new_row = np.array([row[0], encoder0.transform([row[1]])[0], encoder1.transform([row[2]])[0], row[3], row[4],row[5] ])
    new_row = new_row.reshape(1,-1) # convertir en un 2D array
    # Normaliser les données
    new_row = scaler.transform(new_row)
    # Prédire
    y_pred = rf.predict(new_row)
     # Décoder la valeur prédite pour 'etat'
    y_pred_decoded = encoder2.inverse_transform([y_pred[0]])[0]  # Décoder la valeur encodée
    predictions.append(y_pred_decoded) # Ajouter la prédiction à la liste
  df['etat'] = predictions
  df.to_csv('predictions.csv', index = False)
  return 'predictions.csv'


  # définir les blocks afin de pouvoir ajouter plusieurs interfaces
demo = gr.Blocks(theme = gr.themes.Glass())

# autres themes
#gr.themes.Base() gr.themes.Default() gr.themes.Glass() gr.themes.Monochrome() gr.themes.Soft()


# Interface Gradio pour interagir avec la fonction
interface1 = gr.Interface(
    fn=Pred_func,  # Fonction à appeler
    inputs=[
        gr.Number(label="prix"),
        gr.Dropdown(choices= list(np.unique(data.adresse)), label='Adresse'), # on utilise list pour bcp de valeur
        gr.Dropdown(choices= list(np.unique(data.marque)), label='Marque'), # on utilise list pour bcp de valeur
        gr.Number(label="Dimension de l'écran"),
        gr.Number(label="RAM (Go)"),
        gr.Number(label="Stockage (Go)")
    ],
     outputs = gr.Textbox(label='etat'),  # Sortie sous forme de texte
    title="Prédiction de l'état d'un Téléphone portable",  # Titre de l'interface
)
# Créer l'interface 2 permettant de faire une prédiction multiple en partant d'un fichier csv
interface2 = gr.Interface(fn = Pred_func_csv,
                         inputs = gr.File(label='Upload a csv file'),
                          outputs = gr.File(label='Download a csv file'),
                         title="Predict the statut of mobile phone",
                         description = """This machine learning model allows us to predict the statut of mobile phone with his specifications.
                         """)

# faire un tabbing (regrouper en onglet) des interfaces
with demo:
  gr.TabbedInterface([interface1, interface2], ['Simple Prediction', 'Prédiction multiple'])

# lancer l'interface
demo.launch(share = True)