Tutoriel Scikit Learn
Procédure
Dans ce tutoriel, nous allons en apprendre davantage sur la bibliothèque Scikit Learn of Python et comment nous pouvons utiliser cette bibliothèque pour développer divers algorithmes d'apprentissage automatique. Ce guide comprendra le contenu suivant qui sera discuté un par un avec une explication détaillée:
- Installation
- Tracé du graphique
- Divers ensembles de données et leurs services publics à Scikit apprennent
- Sélection de fonctionnalité
- Formation d'un modèle d'apprentissage automatique
Étape 01: installation
Avant de démarrer avec The Scikit Learn, nous devons d'abord installer son package à partir des référentiels Python. Pour ce faire, nous devons faire télécharger et installer Python (la dernière version ou tout) sur notre système. Pour télécharger le Python sur votre système, accédez au lien I.e.
«Https: // www. Python .org ". Une fois que vous êtes redirigé vers cette URL, accédez aux téléchargements et cliquez sur le Python avec n'importe quelle version que vous souhaitez télécharger comme ci-dessous:
Une fois le python téléchargé, nous devons maintenant l'installer. Sélectionnez l'option d'installation personnalisée après avoir ajouté le Python au chemin.
Vérifiez toutes les options de la fenêtre popping pour installer les packages de PIP avec Python et continuez et sélectionnez Suivant.
L'étape suivante sera de spécifier l'emplacement des packages Python, de vérifier toutes les options avancées données et de spécifier l'emplacement et de cliquer sur Installer; Cela commencera ensuite le processus d'installation qui se poursuivra pendant un certain temps.
Maintenant, Python est installé sur nos systèmes. Pour ouvrir le type de shell Python, mettez Python sur le menu de recherche et appuyez sur Entrée. La coque Python s'ouvrira ensuite. Maintenant, nous allons avancer pour installer le scikit Learn sur Python. Pour cela, ouvrez l'invite de commande et tapez Python pour vérifier si le Python s'exécute sur le système ou non. Si le système renvoie la version de Python, cela signifie que le Python s'exécute correctement. Ensuite, nous devons vérifier la version de PIP afin de mettre à niveau les packages PIP:
$ python
$ pip --version
Après avoir vérifié les versions Python et PIP, saisissez maintenant la commande suivante sur l'invite de commande pour installer le scikit Learn sur Python.
$ pip install Scikit Learn
Après cela, le Scikit avec tous ses packages commencera à installer.
Maintenant, Scikit Learn a été installé dans notre système, et maintenant nous pouvons utiliser les packages Scikit pour développer n'importe quel algorithme d'apprentissage automatique. Après l'installation réussie de Scikit, nous allons maintenant passer à l'étape suivante, où nous apprendrons comment tracer les graphiques des données à l'aide de Scikit Learn.
Étape 02: tracé du graphique
Les graphiques sont connus comme les outils visuels qui aident à visualiser les informations données si les données des ensembles de données sont trop nombreuses ou compliquées pour décrire. Les graphiques mettent l'accent sur la représentation de la relation entre une ou plusieurs variables. Pour travailler avec les algorithmes d'apprentissage automatique, nous devons connaître la représentation des données pour l'analyse des données pour former et tester les données en conséquence. Scikit Learn fournit de nombreux packages de visualisation (sous forme graphique) pour les différents ensembles de données.
Exemple # 01
La visualisation des données sous la forme d'un graphique peut être obtenue à l'aide du package Matplotlib. Matplotlib est un package Python qui contribue comme base des packages de tracé Sci-Kit Learn. Scikit Learn s'intègre au Matplotlib pour le traçage (représentation visuelle des données ou les résultats obtenus après la formation et les tests des données dans les algorithmes d'apprentissage automatique). Essayons de mettre en œuvre un exemple à l'aide de matplotlib.
Supposons que nous voulons tracer des nombres aléatoires pour visualiser leur relation les uns avec les autres. Nous pouvons prendre ces nombres au hasard, e.g., 0.5, 1.5, 2.5. Pour écrire le code, nous importerons la bibliothèque Matplotlib depuis les packages Python en tant que plt. Après cette étape, nous pouvons maintenant utiliser PLT au lieu d'écrire Matplotlib dans l'ensemble du code. Ensuite, en utilisant ce PLT, nous rédigerons une commande pour tracer les nombres que nous avons déjà sélectionnés au hasard en utilisant la fonction «PLT. tracé («Nombres sélectionnés») ». Pour afficher ces numéros sur le graphique dans la sortie, nous utiliserons la fonction «PLT. montrer()". Le code peut être créé de manière suivante:
$ importer matplotlib. pypllot comme plt
$ plt. Terrain ([0.5, 1.5, 2.5])
$ plt. montrer()
Les nombres seront ensuite affichés dans la sortie sur le graphique:
Exemple # 02
Si nous voulons tracer les données sous la forme d'un tracé de dispersion, alors nous pouvons utiliser la fonction «Scatter. parcelle ()". Le tracé de dispersion représente les données sous la forme des points de données sur les points. Ces parcelles fonctionnent sur deux ou plus deux variables. Chaque point ou point de données sur le graphique représente les deux valeurs différentes (chacune sur l'axe X et l'axe y) correspondant à un point de données dans un ensemble de données.
Dans l'exemple ultérieur, nous allons tracer un tracé de dispersion. Pour ce faire, nous importerons le Matplotlib Pyplot en tant que PLT. Ce PLT peut ensuite être utilisé à la place de Matplotlib. pypllot. Après cela, nous définirons les deux variables x et y comme x = 1, 3, 5, 7 et y = 2, 4, 6, 8. Pour le tracé de dispersion, la dimension de X et Y doit être appariée. Pour tracer les deux variables, nous utiliserons la fonction plt. dispersion («variable 1, variable 2»). Pour afficher ces variables sur le graphique, utilisez la fonction plt. montrer ().
$ importer matplotlib. pypllot comme plt
$ x = [1, 3, 5, 7]
$ y = [2, 4, 6, 8]
$ plt. disperser (x, y)
$ plt. montrer ()
La relation entre les deux variables spécifiées sous la forme d'un tracé dispersé sera ensuite affichée comme:
Les exemples susmentionnés peuvent être utilisés pour tracer les données spécifiques et connaître leur relation entre elles.
Exemple # 03
Supposons maintenant que nous travaillions avec un ensemble de données binaires, et nous devons classer les données comme appartenant à la classe 0 ou à la classe 1. Nous avons développé un classificateur binaire pour ces données à l'aide d'un algorithme d'apprentissage automatique, et maintenant nous voulons savoir à quel point ce classificateur fonctionne bien. À cette fin, nous pouvons utiliser un AUC-Roc_Curve.
Dans la courbe AUC -ruc, l'AUC indique à quel degré le classificateur développé peut prédire correctement les classes, soit 0 ou 1, et ROC représente la probabilité que les classificateurs représentent correctement les classes. La courbe AUC-RUC_ affiche la courbe entre FPR (axe y) et TPR (axe x), qui sont tous deux des arrayons nd. Pour implémenter cette courbe AUC-RUC, premièrement, importez le MatplotlibpyPlot en tant que PLT afin que nous puissions appeler PLT pour tracer.
Ensuite, nous importerons le Numpy en tant que NP pour créer le ND-Arrays. Après cette importation à partir de mesures Sklearn. Nous allons maintenant spécifier les X et Y en utilisant le NP. array () pour créer le nd-arrays. ND-Arrays Utilisez le Numpy pour stocker les nombres séquentiels. Pour spécifier le FPR et le TPR et les seuils, nous utiliserons la méthode «Métriques.roc_curve (x, y) », puis nous utiliserons ces valeurs de FPR et TPR pour stocker dans le ROC_AUC en appelant la fonction« Métriques.AUC () ".
Une fois ces valeurs spécifiées, nous appellerons la fonction en utilisant «les métriques. Roccurvedisplay () ”en passant FPR, TPR et ROC_AUC dans ses arguments et les stocker en variable Afficher tous. Ensuite, nous appellerons la fonction. Plot () et plt. show () Pour afficher la courbe ROC-Auc avec les paramètres spécifiés dans la sortie comme suit:
Après avoir exécuté le code susmentionné, nous obtenons la sortie suivante:
La courbe RUC-Auc a été affichée dans la sortie maintenant, ce qui représente combien notre classificateur développé a prédit les classes comme 1 ou 0 correctement. Roc-AUC Curve fonctionne pour les ensembles de données avec une classification binaire.
Exemple # 04
Une autre méthode de traçage graphique utilisant le Scikit Apprenez la courbe d'étalonnage. La courbe d'étalonnage a un autre nom: le diagramme de fiabilité; Cette courbe trace la moyenne de la probabilité prévue contre la classe positive de l'axe y de la courbe en prenant l'entrée du classificateur de classification binaire. Pour implémenter cette courbe d'étalonnage, résolvons un exemple où nous importerons d'abord l'ensemble de données «Faire de la classification» à partir du package de données Sklearn, puis importez le train et tester la fraction Après cette courbe d'étalonnage d'importation et l'affichage des «étalonnages Sklearn».
Une fois que nous avons importé tous les packages importants et requis, chargez désormais la méthode «Faire de classification» à l'aide de la méthode de chargement «dataset_name ()», après cela, nous diviserons les données à des fins de train et de test à l'aide de la méthode «Train_test__split ()», puis nous nous Construirea le modèle de classification à l'aide de «LogisticRegression ()» et montera ce modèle sur X_Train et Y_Train.
Maintenant en utilisant les étiquettes et les probabilités qui ont été prédites à l'aide de «classificateur. Prédire la probabilité () »en contournant le XTest comme argument d'entrée, appelez la méthode« Curve d'étalonnage () «Pour tracer la courbe d'étalonnage d'abord, puis l'afficher en utilisant« DisplayCurve () ».
La sortie affiche le tracé de la courbe d'étalonnage qui a utilisé les vraies probabilités prévues d'un classificateur binaire.
Étape 03: Divers ensembles de données et leurs services publics à Scikit Learn
Pour travailler avec des algorithmes d'apprentissage automatique, nous devons avoir les ensembles de données que nous pouvons utiliser pour créer les algorithmes spécifiques et réaliser les sorties souhaitées. Scikit Learn est livré avec des packages qui ont des ensembles de données intégrés par défaut stockés par le nom Sklearn. ensembles de données. Pour travailler sur les ensembles de données, nous pouvons les lire à l'aide de référentiels de données par défaut Sklearn ou en les générant.
Les ensembles de données que Sklearn fournit à son utilisateur sont des ensembles de données de jouets relativement petits et d'autres ensembles de données du monde réel qui sont énormes et ont des informations liées aux applications du monde. La taille standard et les petits ensembles de données peuvent être obtenus à l'aide des chargeurs de données, tandis que les ensembles de données du monde réel sont chargés via l'ensemble de données Rensette.
Dans cet exemple, nous importerons d'abord les ensembles de données de jouets à partir de «Sklearn. ensembles de données ». Pour importer l'ensemble de données, nous utiliserons Sklearn.ensembles de données. Sklearn.Les ensembles de données permettent d'importer les ensembles de données à partir de ses ensembles de données par défaut. Différents ensembles de données peuvent être chargés à partir de Sklearn.ensembles de données utilisant cette commande.
$ de Sklearn. Les ensembles de données importent un chargement_digits
Ici, nous avons importé l'ensemble de données des chiffres du sklearn.ensembles de données. Nous pouvons charger tout autre ensemble de données en utilisant la même commande avec la modification simple; c'est-à-dire que nous devons remplacer le «load_digits» par le nom de cet ensemble de données spécifique que nous voulons charger dans la commande mentionnée ci-dessus. Maintenant, à l'étape suivante, nous chargerons l'ensemble de données à l'aide de la méthode «Data Set_name ()», puis la stockerons dans n'importe quelle variable, disons l'ensemble de données, comme nous l'avons fait dans cette commande
$ dataset = load_digits ().
Jusqu'à cette étape, l'ensemble de données a été téléchargé dans les chiffres. Pour afficher les données de cet ensemble de données, nous utiliserons la fonction d'impression et passerons le nom de la variable.Données dans les arguments de la fonction d'impression.
$ print (ensemble de données.données )
Maintenant, nous allons les exécuter toutes les commandes ci-dessus mentionnées explicitement sous la forme d'un code, et elle donnera la sortie comme suit:
Après avoir exécuté le code, nous avons obtenu une sortie qui affiche toutes les données stockées dans l'ensemble de données de chargement _digits.
Si nous voulons connaître la spécification de l'ensemble de données en termes de combien de classes y a-t-il dans l'ensemble de données ou du nombre de fonctionnalités pour l'ensemble de données plus la taille de l'échantillon de l'ensemble de données, c'est-à-dire combien d'exemples ont été donnés pour chaque ensemble de données.
Pour obtenir ces informations, nous pouvons simplement utiliser le nom de la fonction «DataSet_varaable. forme". Pour implémenter cela, importez l'ensemble de données (LOAD_IRIS) à partir de Sklearn.ensembles de données, puis charger cet ensemble de données en appelant la méthode «load_iris ()» et en le stockant dans «Iris. charger". Puis imprimez la spécification de l'ensemble de données à l'aide de l'impression (Lo dansé.forme) de la manière suivante:
Le code ci-dessus aurait la sortie suivante après l'exécution:
La sortie a renvoyé les valeurs (150, 4). Cela signifie que l'ensemble de données a 150 exemples d'échantillons et 4 attributs que nous pouvons utiliser pour créer notre algorithme d'apprentissage automatique en fonction de la demande.
Dans l'exemple suivant, nous apprendrons maintenant à importer des ensembles de données du monde réel et à y travailler. Pour les données réelles, nous récupérons les fichiers à l'aide de la fonction de récupération qui télécharge et extrait l'ensemble de données du cache / archive du site Web spécifique et le charge dans le sklearn. ensembles de données.
Prenons les données du monde réel des ensembles de données du monde réel à l'aide du sklearn.ensembles de données et travailler dessus. Ici, nous aimerions prendre les données de certains sites Web de groupes de discussion, «TV Nomsgroups Sites Web». Nous allons maintenant importer l'ensemble de données pour ce site Web spécifique en récupérant d'abord les fichiers du référentiel du site Web. Ensuite, nous chargerons les données d'entraînement des fichiers récupérés de ces données au sklearn.ensembles de données appelant la méthode de chargement, i.e., "DataSet_name (sous-ensemble =" Testez ou former des données à saisir ")" puis les stockera dans une variable "NewspaperDataload".
Après cela, nous afficherons simplement les noms cibles de l'ensemble de données. Les «noms cibles» sont les fichiers qui contiennent les fichiers de données réels des ensembles de données. Appelons la fonction d'impression pour afficher les noms des fichiers présents dans l'ensemble de données en écrivant les commandes:
$ pprint (List («DataSetName. cible ”_NAMES))
Nous avons importé l'Emprint ici car le nom cible contient la liste du fichier, et nous voulons que cette liste soit affichée telle qu'elle est. Pour afficher cette liste, nous avons d'abord importé le package pprint, puis en l'utilisant, nous avons affiché la liste des noms de fichiers dans l'ensemble de données que nous avons déjà chargé dans «Sklearn.ensembles de données "en récupérant les fichiers du site Web. Nous avons implémenté le code susmentionné dans Python, et sa sortie est devenue ceci:
Maintenant, la liste des ensembles de données a été affichée par le système. Si nous voulons connaître les attributs de cet ensemble de données, E.g., Le nombre d'exemples d'échantillons que contient l'ensemble de données, le nombre total de fonctionnalités dans l'ensemble de données, etc. Nous pouvons simplement utiliser l'impression (DataSet_name. nom de fichier. forme) Depuis, comme nous avons déjà expliqué que toutes les informations de l'ensemble de données sont stockées dans le fichier file_name ou cible_name, et il renverra les informations d'attribut de l'ensemble de données tel qu'il est.
$ print (journal dataload. nom de fichier. forme )
Étape 04: sélection des fonctionnalités
Dans les algorithmes d'apprentissage automatique, l'aspect le plus important qui contrôle la sortie de l'algorithme est les fonctionnalités. Les caractéristiques contribuent principalement à la construction de tout algorithme d'apprentissage automatique. Tout le traitement est effectué sur les ensembles de données basés sur les fonctionnalités. Les fonctionnalités peuvent rendre les algorithmes robustes ou un échec complet en termes de précision (meilleure prédiction ou estimation) pour la limite de décision. S'il existe des caractéristiques redondantes ou un plus grand nombre de fonctionnalités qui sont nécessaires, cela contribue à un sur-ajustement dans la sortie.
Le sur-ajustement est le phénomène dans lequel un modèle formé sur des ensembles de données ayant plus de fonctionnalités que nécessaire et a une erreur de formation la plus proche de zéro, mais lorsqu'elle est formée sur l'ensemble de données de test, le modèle ne fonctionne pas bien sur cet ensemble de données de test et par conséquent ne prend pas les bonnes décisions. Pour éviter que les chances que le modèle formé soit trop élevé, nous laisse tomber certaines des caractéristiques inutiles. Cette réduction de la dimensionnalité peut être effectuée de plusieurs manières en utilisant le Scikit Learn.
Exemple # 01
La première méthode pour supprimer la fonction consiste à un seuil de faible variance; Dans ce type de sélection des fonctionnalités, nous supprimons ces fonctionnalités des ensembles de données ayant une faible variance qui sont inférieurs aux seuils donnés. Les fonctionnalités de faible variance sont celles qui contribuent la même valeur tout au long de l'ensemble de données.
Essayons un exemple de réduction des fonctionnalités. Supposons que nous ayons un ensemble de données qui a trois fonctionnalités dans les données binaires. Dans notre exemple, les ensembles de données de chiffres ont quatre colonnes comme quatre fonctionnalités. Si nous voulons supprimer une fonctionnalité avec tous ses exemples d'échantillons de l'ensemble de données, nous utiliserons la formule de variance et construire un seuil de variance sur cela. Si une fonctionnalité a une faible variance, le seuil sera ensuite supprimé de l'ensemble de données.
Nous importerons d'abord le seuil de variance à partir de la "Sklearn FEAUTH_SELECTION". Une fois le seuil de variance importé, nous définirons ensuite la valeur de ce seuil qui, dans notre cas, nous avons défini comme «0.5 ”. Ainsi, toutes les colonnes de fonctionnalités qui ont une valeur inférieure à ce seuil retireront de cet ensemble de données de chiffres.
Pour ce faire, nous appellerons la méthode «variance threshold ()». Dans les arguments de la fonction, nous passerons la valeur de seuil à 0.5 et stockez-le dans une variable «Threholder». Après cela, nous appellerons la fonction «Threholder. fit_transform () ”et transmettez l'ensemble de données à cette fonction et laissez-la la stocker avec le nom new_dataset. Une fois que nous aurons terminé ces étapes, nous imprimerons l'ensemble de données comme indiqué:
Comme on peut le voir dans la sortie qu'avant d'avoir appliqué le seuil de variance à l'ensemble de données, il avait 4 fonctionnalités, et maintenant après l'application du seuil de variance sur l'ensemble de données, nous avons demandé au système de supprimer toutes les colonnes ayant une variance sous l'ensemble de l'ensemble de l'ensemble de l'ensemble de l'ensemble Valeur de seuil, je.e., 0.5, la sortie affiche trois colonnes dans l'ensemble de données, ce qui signifie que la colonne One a été calculée pour avoir une variance inférieure au seuil, il a donc été supprimé de l'ensemble de données pour éviter la redondance dans l'ensemble de données et pour rendre le modèle formé sur les données Conçu pour être plus précis en termes de précision et éviter le sur-ajustement.
Exemple # 02
La deuxième méthode pour sélectionner les fonctionnalités de l'ensemble de données est donnée par la méthode «SELECT K-Best». Pour la mise en œuvre de cette méthode, l'ensemble de données IRIS sera importé des «sklearndatasets», puis nous chargerons cet ensemble de données et les enregistrerons dans une variable aléatoire telle que IRIS. Ensuite, pour charger l'ensemble de données, nous appellerons "LoadDataset_Name ()".
CHI2 mesure la différence entre les caractéristiques attendues et observées et est utilisé pour les tâches de classification. Après avoir chargé l'ensemble de données dans Iris et importé le SELECT K Best et Chi2, nous allons maintenant les utiliser dans le «Fit. fonction transform () ». Le selectKbest (Chi2, k = 2). adapter.transform (), il correspond d'abord aux données en prenant les données de formation en entrée, puis en les transformant. Ensuite, le K dans la méthode SelectKbest laisse tomber les colonnes et sélectionne les fonctionnalités qui ont noté les fonctionnalités les plus élevées. Dans notre cas, nous sélectionnerons les deux fonctionnalités lorsque nous sélectionnons la valeur k égale à 2.
Dans cet exemple, lorsque nous avons simplement chargé l'ensemble de données, puis l'a affiché, il y avait quatre colonnes comme fonctionnalités dans l'ensemble de données, mais maintenant après avoir appliqué la méthode SelectKbest avec k = 2 sur l'ensemble de données maintenant, le nouvel ensemble de données est sorti avec Deux colonnes en tant que fonctionnalités, ce qui signifie que le SelectKBest a sélectionné les deux meilleures fonctionnalités de l'ensemble de données d'origine.
Exemple # 03
Une autre façon de sélectionner la fonctionnalité importante dans l'ensemble de données est donnée par Scikit Learn à l'aide de «l'élimination des fonctionnalités récursives (RFE)». RFE laisse tomber les fonctionnalités les moins importantes de l'ensemble de données en effectuant la formation récursive de l'ensemble de données. RFE sélectionne le numéro de fonctionnalité pour lui-même en utilisant la médiane du nombre total de fonctionnalités dans l'ensemble de données, et il ne fait qu'une seule fonctionnalité de l'ensemble de données à chaque itération. Pour implémenter RFE, importez d'abord les bibliothèques nécessaires pour créer le code via ces commandes.
Maintenant, nous avons réussi à importer les forfaits de RFE de Sklearn. fonctionnalité. sélection. Pour créer l'ensemble de données, nous avons chargé la fonction «Make_Regression ()», et dans ses arguments, nous avons passé ces paramètres que nous voulons dans l'ensemble de données.
$ X, y = make_regression (n_sample = 10000, n_features = 100, n_informative = 2)
$ print (x.forme)
Ensuite, nous imprimons cet ensemble de données pour connaître la forme ou les attributs exacts de l'ensemble de données. Après avoir affiché l'ensemble de données, nous allons maintenant utiliser l'éliminateur de fonctionnalité récursive. À cette fin, nous ferons un modèle en tant que DecisionTreeeRgressor (). Une fois le modèle terminé maintenant en utilisant le RFECV () que nous avons importé plus tôt, nous passerons le Verbose, le modèle / estimateur, l'étape, le score et le CV comme les paramètres requis dans les arguments de RFECV.
Maintenant, pour supprimer la fonction récursive, nous allons installer et transformer les données. L'ensemble de la procédure expliquée peut être écrit comme le code ci-dessous:
Maintenant, les fonctionnalités seront abandonnées récursivement en fonction de nos besoins après chaque itération, car il peut être clairement montré dans la sortie. Cette élimination récursive des fonctionnalités se poursuivra jusqu'à ce que nous atteignions le point où nous nous retrouvons avec deux fonctionnalités importantes sur le total des 100 fonctionnalités présentes dans l'ensemble de données d'origine.
Exemple # 04
Une autre méthode que nous pouvons utiliser pour supprimer les fonctionnalités supplémentaires, ou nous pouvons simplement les déposer en raison de leur redondance, est le «modèle SELECTFROM» ainsi que les «modèles linéaires». Lorsque les modèles linéaires de thèses sont en quelque sorte pénalisés avec la norme L1, leur solution existe peu car la plupart de leurs coefficients deviennent égaux à zéro.
Dans la réduction de la dimensionnalité ou la sélection des fonctionnalités, ces modèles linéaires, ainsi que le modèle SELECTFROM, aident à sélectionner ce coefficient non nul. Ils travaillent principalement pour le problème de régression. Pour implémenter le modèle SELECTFROM, nous devons d'abord importer le linearsvc à partir de Sklearn.SVM, LinearsVC est le classificateur de vecteur de support linéaire qui trouve la meilleure ligne d'ajustement (hyper-plan) pour diviser et classer les données dans différentes catégories; Une fois que nous aurons l'hyperplan dans le LSVC, nous pouvons ensuite fournir n'importe quelle fonctionnalité à ce modèle le mieux ajusté pour savoir quelle classe appartiendrait à cette fonctionnalité, alors nous importerons l'ensemble de données à partir de Sklearn. ATA sets, et après cela, nous devrons importer le «modèle SELECTFROM» de Sklearn.sélection de fonctionnalité.
Une fois que les packages requis ont été importés, nous chargeons l'ensemble de données d'iris à l'aide de charge_dataset (), puis affichons les attributs de l'ensemble de données de l'iris en termes d'exemples d'échantillons et le nombre de fonctionnalités qu'il a en utilisant le " .Méthode de forme ». Après avoir connu la forme de l'ensemble de données, nous allons maintenant appliquer le «linearsvc ().Fit (_loaded Data Set) ”Modèle avec C = 0.01, une pénalité du linéarsvc = l1 comme argument d'entrée. Créez ensuite le modèle à l'aide de «SelectFrom Model ()», puis transformez le modèle à l'aide de «modèle.transformer()". Affichez maintenant le nouvel ensemble de données de transformation et affichez son attribut à l'aide des données «set_new.forme".
La forme de l'ensemble de données avant d'appliquer le «modèle SELECTFROM» pour la sélection des fonctionnalités était (150, 4), ce qui signifie qu'il avait 150 exemples d'échantillons et quatre attributs, mais une fois que nous avons appliqué la sélection des fonctionnalités sur l'ensemble de données en utilisant «linearsvc »Et le modèle SELECTFROM La forme de l'ensemble de données a été transformée en (150, 3), ce qui signifie que la seule fonctionnalité a été supprimée de l'ensemble de données.
Étape 05: prétraitement des données
Les ensembles de données avec lesquels nous travaillons pour développer et former différents algorithmes d'apprentissage automatique sur eux ne sont pas toujours ceux de leur forme parfaite à utiliser pour construire le modèle. Nous devons modifier ces ensembles de données en fonction de nos exigences. La toute première étape que nous devons faire après le chargement de l'ensemble de données et avant l'entraînement, le modèle est le prétraitement des données. En pré-traitement des données, nous entendons:
- Échelle de fonctionnalité
- Normalisation / normalisation des fonctionnalités
Échelle de fonctionnalité
La tâche la plus importante dans le prétraitement des données est la mise à l'échelle des fonctionnalités. La mise à l'échelle des fonctionnalités est effectuée pour faire que toutes les fonctionnalités de l'ensemble de données ont la même unité; Sinon, l'algorithme ne s'entraînera pas correctement et peut affecter les performances de l'algorithme en ralentissant le processus. La mise à l'échelle peut être effectuée en utilisant le Minmaxscaler ou le maxabscaler. La mise à l'échelle des fonctionnalités définit les valeurs des valeurs de fonction entre zéro et une principalement, et parfois à la demande, il peut limiter la valeur d'une fonctionnalité à sa taille unitaire.
Ici, nous implémenterons un exemple dans lequel nous allons d'abord importer le prétraitement de Sklearn, puis nous importerons Numpy. Numpy est utilisé dans les fonctions où nous devons travailler avec des tableaux. Maintenant, nous allons créer un nd-array en utilisant Numpy. Pour faire la mise à l'échelle des fonctionnalités sur ce tableau que nous avons créé, d'abord, nous utiliserons la méthode «Prétraitement. Minmaxscaler () ». Après cette étape, nous appliquons le Minmaxscaler au tableau en appelant la méthode «Minmaxscaler. fit_transform () ”et passera ce tableau dans ses arguments. Le code peut être réécrit comme:
La sortie après la mise à l'échelle de la fonction a été effectuée sur le «X» donne la valeur d'un tableau entre zéro et un. Le maxaBSScaler fonctionne principalement de la même manière que le Minmaxscaler, mais ce scaleur fait évoluer les valeurs de données entre un (-1) et un positif (+1). Le code du maxabscaler est donné par:
Dans la sortie, les valeurs des données «x» ont été renvoyées sous la forme continue de la plage variant entre -1 et +1.
Normalisation / normalisation des fonctionnalités
Nous découvrirons les techniques de prétraitement des données dans cet exemple. Passons d'abord à partir du prétraitement de Sklearn et après l'importation du prétraitement de Sklearn, puis importe également Numpy car nous allons maintenant travailler avec des tableaux ND. Créez maintenant un ND-Array et stockez-le dans "X". Nous devons maintenant effectuer la normalisation / normalisation moyenne sur ces données. Pour ce faire, nous utiliserons la méthode conventionnelle «prétraitement. standardcaler. ajustement («Tapez ici les données à normaliser») ». La valeur de la fonction sera ensuite enregistrée dans une variable, e.g., écailleur. Effectuez maintenant la normalisation sur les données données X avec la méthode, E.g. "écailleur. transform («data») »et afficher les données nouvellement transformées: alors:
Les données «x» ont été standardisées avec la valeur moyenne la plus proche de zéro. La normalisation / normalisation des données est effectuée pour éviter tout redondant ou doublons dans l'ensemble de données. La normalisation / normalisation moyenne garantit que les données connexes dans les ensembles de données. De plus, il traite également de tout problème causé en raison des modifications, e.g., Suppression de données, ajout de nouvelles données ou toute mise à jour dans les ensembles de données qui pourraient devenir un obstacle à l'avenir.
Maintenant que nous avons le plus appris sur les packages Scikit Learn que nous pouvons utiliser pour construire les algorithmes d'apprentissage automatique. Nous devons tester nos capacités avec le Scikit Apprenez une fonction que nous avons utilisée ci-dessus dans ce guide et développer un algorithme d'apprentissage automatique pour former d'abord un modèle sur l'ensemble de données spécifique, puis tester ce modèle en les exécutant sur l'ensemble de données de test inconnu pour Gagnez une expérience pratique sur cette fonction Scikit Learn Fonctions / Packages. Lancement de la mise en œuvre des fonctions Scikit Learn pour l'algorithme ou modèle d'apprentissage automatique.
Étape 06: Formation du modèle à l'aide de Scikit Learn
Nous allons entraîner le «modèle de régression linéaire» sur l'ensemble de données de tarification de la maison que nous nous créerons dans le code plus tard. La régression linéaire trouve le meilleur ajustement de ligne pour les points de données donnés dans l'ensemble de données. Cette ligne est tracée sur les points de données du graphique. Nous utilisons ensuite cette ligne pour prédire les valeurs que notre modèle de train prédirera lorsqu'elle sera testée sur certaines données de test avec la conviction que les points de données de sortie générés après avoir exécuté les données de test sur le modèle suivraient la ligne comme les données ou la formation d'origine Les données ont suivi.
Pour travailler avec le modèle de régression linéaire, nous devons importer la bibliothèque Matplotlib, puis à partir de Scikit Learn, nous importerons le modèle linéaire, les matrices et toute sélection de modèle pour former le modèle plus tard dans le code. Pour créer l'ensemble de données du prix des logements, nous importerons NP à partir de Numpy et créerons les deux nd-array avec des noms «zonesq_footage_x» et «houseprice_y», respectivement.
Après avoir créé ces deux ND-Arrays, nous tracerons leurs valeurs sur le tracé en utilisant le «dispersion.Plot () ”en étiquetant l'axe x du graphique comme la« zone de la maison »et l'axe y comme le« prix de la maison ». Une fois les points de données tracés, nous entraînerons ensuite le modèle à l'aide du modèle «linéaire ()». Nous élargirons ensuite les dimensions du nd-array «zoneq_footage_x», puis il sera stocké dans la nouvelle variable «x_new». Ensuite, nous utiliserons la "Model_house.fit () "et passera le" x_new "et" houseprice_y "dans ses arguments d'entrée pour s'adapter au modèle pour la meilleure ligne.
Nous créerons l'hypothèse de la meilleure ligne ajustée par «y = theta0 * x + theta1» et tracerons ces sorties attendues vers les données réelles et tracer le graphique. Ce graphique nous fera savoir la meilleure ligne d'ajustement pour les points de données donnés, sur la base desquels nous prédireons la sortie des points de données des données de test prédites comme correctes ou non.
Ceci est le graphique que nous avons obtenu avant d'entraîner le modèle. Tous les points de données ici ont été tracés en suivant les valeurs de l'axe X et de l'axe Y.
Ce graphique est la sortie du modèle formé, et il montre la meilleure ligne d'ajustement pour prédire la sortie des points de données si le modèle formé est évalué sur certaines données de test.
Conclusion
Scikit Learn est une bibliothèque de Python qui utilise le package Sklearn pour fonctionner avec ses différentes fonctions disponibles pour construire n'importe quel algorithme d'apprentissage automatique. Dans ce tutoriel, nous avons appris Scikit Learn des étapes très basiques (l'installation du Scikit Learn on Python à la formation complexe d'un modèle à l'aide des packages Scikit Learn)). Entre les deux du niveau de base au niveau complexe, nous avons discuté du traçage de graphiques, du chargement des ensembles de données, de la sélection des fonctionnalités et du prétraitement des données. Nous espérons que vous trouverez ce tutoriel utile pour développer vos connaissances concernant Sci-Kit Learn.