Une étape cruciale du flux de travail de la science des données consiste à mesurer la précision de notre modèle à l'aide de la métrique appropriée. Dans ce didacticiel, nous allons apprendre deux méthodes pour calculer la précision de classe prévue de l'échantillon source : manuellement et à l'aide de la bibliothèque scikit-learn de Python.
Voici un aperçu des sujets que nous avons abordés dans ce tutoriel.
- Calcul manuel de l'exactitude_score
- Calcul de l'exactitude_score à l'aide de scikit learn
- Scikit apprend les exemples de précision_score
- Comment scikit apprend-il precision_score ?
Qu’est-ce que la précision ?
L’exactitude est l’une des mesures largement utilisées pour calculer les performances des modèles de classification. Le pourcentage d'étiquettes que notre modèle a prédit avec succès est représenté par l'exactitude. Par exemple, si notre modèle classifiait avec précision 80 étiquettes sur 100, sa précision serait de 0,80.
Création d'une fonction pour calculer le score de précision
Créons une fonction Python pour calculer le score de précision des valeurs prédites, étant donné que nous disposons déjà des véritables étiquettes de l'échantillon et que les étiquettes ont prédit le modèle.
Code
remplacer tout Java
# Python program to define a function to compute accuracy score of model's predicted class # Defining a function which takes true values of the sample and values predicted by the model def compute_accuracy(Y_true, Y_pred): correctly_predicted = 0 # iterating over every label and checking it with the true sample for true_label, predicted in zip(Y_true, Y_pred): if true_label == predicted: correctly_predicted += 1 # computing the accuracy score accuracy_score = correctly_predicted / len(Y_true) return accuracy_score
La fonction ci-dessus accepte les valeurs des étiquettes prédites du modèle de classification et des véritables étiquettes de l'échantillon comme arguments et calcule le score de précision. Ici, nous parcourons chaque paire d'étiquettes vraies et prédites en parallèle pour enregistrer le nombre de prédictions correctes. Nous divisons ensuite ce nombre par le nombre total d'étiquettes pour calculer le score de précision.
Nous allons maintenant appliquer la fonction sur un échantillon.
programmation r en c
Code
# Python program to compute accuracy score using the function compute_accuracy # Importing the required libraries import numpy as np from sklearn.model_selection import train_test_split from sklearn.svm import SVC from sklearn.datasets import load_iris # Loading the dataset X, Y = load_iris(return_X_y = True) # Splitting the dataset in training and test data X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size = 0.3, random_state = 0) # Training the model using the Support Vector Classification class of sklearn svc = SVC() svc.fit(X_train, Y_train) # Computing the accuracy score of the model Y_pred = svc.predict(X_test) score = compute_accuracy(Y_test, Y_pred) print(score)
Sortir:
0.9777777777777777
Nous obtenons 0,978 comme score de précision pour les prédictions du modèle de classification des vecteurs de support.
Notez que l'utilisation de tableaux numpy pour vectoriser le calcul d'égalité peut rendre le code mentionné ci-dessus plus efficace.
Précision à l'aide de l'exactitude_score() de Sklearn
La méthode precision_score() de sklearn.metrics accepte les véritables étiquettes de l'échantillon et les étiquettes prédites par le modèle comme paramètres et calcule le score de précision sous forme de valeur flottante, qui peut également être utilisée pour obtenir le score de précision en Python. Il existe plusieurs fonctions utiles pour calculer les métriques d'évaluation typiques dans la classe sklearn.metrics. Utilisons la fonction precision_score() de sklearn pour calculer le score de précision du modèle de classification des vecteurs de support en utilisant le même échantillon de données que précédemment.
sklearn.metrics.accuracy_score (y_true, y_pred, *, normalize=True, sample_weight=Aucun)
numpy signifie
Nous l'utilisons pour calculer le score de précision de la classification. Cette méthode calcule la précision des sous-groupes dans la classification multi-étiquettes ; le sous-ensemble d'étiquettes prévu d'un ensemble de données doit correspondre précisément à l'ensemble de données réel d'étiquettes dans y_true.
Paramètres
Retour
Exemple de Accuracy_score
Code
# Python program to compute accuracy score using the function accuracy_score # Importing the required libraries import numpy as np from sklearn.model_selection import train_test_split from sklearn.metrics import accuracy_score from sklearn.svm import SVC from sklearn.datasets import load_iris # Loading the dataset X, Y = load_iris(return_X_y = True) # Splitting the dataset in training and test data X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size = 0.3, random_state = 0) # Training the model using the Support Vector Classification class of sklearn svc = SVC() svc.fit(X_train, Y_train) # Computing the accuracy_score of the model Y_pred = svc.predict(X_test) score = accuracy_score(Y_test, Y_pred) print(score)
Sortir:
0.9777777777777777
Lors de l'utilisation d'indicateurs d'étiquettes binaires avec plusieurs étiquettes :
Code
# Python program to show how to calculate accuracy score for multi-label data import numpy as np accuracy_score(np.array([[1, 1], [2, 1]]), np.ones((2, 2)))
Sortir:
0.5
Comment fonctionne Scikit Learn Precision_score
La méthode Accuracy_score du package sklearn.metrics attribue une précision de sous-ensemble dans la classification multi-étiquettes.
couverture du relevé
Il est nécessaire que les étiquettes prédites par le modèle pour l’échantillon donné et les véritables étiquettes de l’échantillon correspondent exactement.
La précision décrit le comportement du modèle dans toutes les classes. Si toutes les classes sont d’importance comparable, cela est utile.
Le rapport entre le nombre de prédictions précises et le nombre total d'échantillons ou le nombre total de prédictions est utilisé pour déterminer l'exactitude du modèle.
lire le fichier csv en java
Code:
- Le code ci-dessous importe deux bibliothèques. Nous importons sklearn.metrics pour prédire la précision du modèle et les bibliothèques numpy.
- Les vraies valeurs de l'échantillon sont y_true = ['1', '1', '0', '0', '1', '1', '0'].
- ['1', '1', '0', '0', '1', '1', '0'] ce sont les valeurs prédites par le modèle pour les exemples de données.
- Accuracy = ( Matrix[0][0] + Matrix[-1][-1] ) / numpy.sum(matrix) est utilisé pour obtenir le score de précision du modèle de classification.
- Le score de précision est affiché comme sortie à l’aide de print(accuracy).
Code
# Pythpn program to show how accuracy_score works # import libraries import numpy as np import sklearn.metrics # Creating a true and predicted sample Y_true = ['1', '1', '0', '0', '1', '1', '0'] Y_pred = ['1', '0', '1', '1', '0', '1', '1'] # finding a confusion matrix matrix = sklearn.metrics.confusion_matrix(Y_true, Y_pred) matrix = np.flip(matrix) print('Confusion Matrix: ', matrix) accuracy = (matrix[0][0] + matrix[-1][-1]) / np.sum(matrix) print(accuracy)
Sortir:
Confusion Matrix: [[2 2] [3 0]] 0.2857142857142857
Ainsi, dans ce didacticiel, nous avons appris scikit-learn Precision_score en Python et examiné quelques exemples d'implémentation.