Prédiction du prix des ordinateurs portables avec ML

Dans mon article précédent, j'ai créé un script pour générer un CSV avec des données d'ordinateur portable, en effectuant du web scraping dans PCComponentes.

Cette idée est née en essayant de créer un modèle de Machine Learning qui, en fonction des composants que vous fournissez, prédit le prix de l'appareil. Cependant, lors de mes recherches, j'ai trouvé un DataFrame public qui pouvait être utilisé pour entraîner le modèle, mais il avait un problème : les prix remontaient à 2015, ce qui le rendait peu utile.

Pour cette raison, j'ai décidé de construire un DataFrame directement depuis le site PCComponentes, ce qui me permettrait d'avoir des données mises à jour et fiables. De plus, ce processus pourrait être automatisé à l'avenir (au moins jusqu'à ce que PCComponentes modifie la structure de son site Web).

Allons-y !

---

Traitement des données DataFrame

Avant d'entraîner le modèle, il est nécessaire d'organiser et de nettoyer les données pour les rendre plus faciles à lire et à traiter. Pour cela, nous utiliserons les bibliothèques Numpy, Pandas et Matplotlib, largement utilisées dans l'analyse et le traitement des données.

La première chose est d'importer ces bibliothèques et d'ouvrir le CSV généré :

import pandas as pd  
import numpy as np  
import matplotlib.pyplot as plt  

Ensuite, on supprime les lignes avec des valeurs vides ou nulles :

df = df.dropna()  

---

Analyse et filtrage des données

Commençons par analyser les différents types de processeurs disponibles. Pour les visualiser, nous utiliserons la bibliothèque Seaborn :

import seaborn as sns  
sns.countplot(data=df, x='CPU')

Ici, nous voyons qu'il existe 207 types de processeurs différents. Entraîner un modèle avec toutes ces valeurs pourrait être problématique, car une grande partie des données ne seraient pas pertinentes et généreraient du bruit qui affecterait les performances.

Au lieu de supprimer toute la colonne, nous filtrerons les valeurs les plus pertinentes :

def cpu_type_define(text):
    text = text.split(' ')
    if text[0] == 'intel':
        if 'i' in text[-1]:
            if text[-1].split('-')[0] == 'i3':
                return 'low gamma intel processor'

            return text[0]+' '+text[1]+' '+text[-1].split('-')[0] 

        return 'low gamma intel processor'
    elif text[0] == 'amd':
        if text[1] == 'ryzen':
            if text[2] == '3':
                return 'low gamma amd processor'

            return text[0]+' '+text[1]+' '+text[2]

        return 'low gamma amd processor'
    elif 'm' in text[0]:
        return 'Mac Processor'
    else:
        return 'Other Processor'

data['Cpu'] = data['Cpu'].apply(cpu_type_define)
sns.histplot(data=data,x='Cpu')
data['Cpu'].value_counts()

Résultant en :

---

Filtrage GPU

Nous effectuons un processus similaire avec les cartes graphiques (GPU), en réduisant le nombre de catégories pour éviter le bruit dans les données :

def gpu_type_define(text):    

    if 'rtx' in text:

        num = int(''.join([char for char in text if char.isdigit()]))

        if num == 4080 or num == 4090 or num == 3080:
            return 'Nvidia High gamma'
        elif num == 4070 or num == 3070 or num == 4060 or num == 2080:
            return 'Nivida medium gamma'
        elif num == 3050 or num == 3060 or num == 4050 or num == 2070:
            return 'Nvidia low gamma'
        else:
            return 'Other nvidia grafic card'

    elif 'radeon' in text:

        if 'rx' in text:
            return 'Amd High gamma'
        else:
            return 'Amd low Gamma'

    elif 'gpu' in text:
        return 'Apple integrated graphics'

    return text



data['Gpu'] = data['Gpu'].apply(gpu_type_define)
sns.histplot(data=data,x='Gpu')
data['Gpu'].value_counts()  

Résultat :

---

Traitement du stockage et de la RAM

Pour simplifier le stockage des données, nous combinons l'espace total de tous les disques durs en une seule valeur :

def fitler_ssd(text):
    two_discs = text.split('+')


    if len(two_discs) == 2:
        return int(''.join([char for char in two_discs[0] if char.isdigit()])) + int(''.join([char for char in two_discs[1] if char.isdigit()]))        
    else:
        return int(''.join([char for char in text if char.isdigit()]))

data['SSD'] = data['SSD'].str.replace('tb','000')
data['SSD'] = data['SSD'].str.replace('gb','')
data['SSD'] = data['SSD'].str.replace('emmc','')
data['SSD'] = data['SSD'].str.replace('ssd','')

Enfin, on filtre les valeurs de RAM pour ne garder que les chiffres :

import pandas as pd  
import numpy as np  
import matplotlib.pyplot as plt  

---

Codage de données non numériques

Avant d'entraîner le modèle, il est nécessaire de transformer les colonnes non numériques en données que l'algorithme peut interpréter. Pour cela, nous utilisons le ColumnTransformer et le OneHotEncoder de la bibliothèque sklearn :

df = df.dropna()  

---

Formation sur modèle

J'ai testé plusieurs algorithmes de Machine Learning pour déterminer lequel était le plus efficace selon le coefficient de détermination (R2 Score). Voici les résultats :

Modelo	R2 Score
Logistic Regression	-4086280.26
Random Forest	0.8025
ExtraTreeRegressor	0.7531
GradientBoostingRegressor	0.8025
XGBRegressor	0.7556

Les meilleurs résultats ont été obtenus avec Random Forest et GradientBoostingRegressor, tous deux avec un R2 proche de 1.

Pour m'améliorer encore, j'ai combiné ces algorithmes à l'aide d'un régresseur de vote, obtenant un score R2 de 0,8085 :

import seaborn as sns  
sns.countplot(data=df, x='CPU')

---

Conclusion

Le modèle formé avec le Voting Regressor était le plus efficace. Vous êtes maintenant prêt à l'intégrer dans une application web, ce que j'expliquerai en détail dans le prochain post.

Lien vers le projet

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!