Een cruciale fase in de data science-workflow is het meten van de nauwkeurigheid van ons model met behulp van de juiste metriek. In deze zelfstudie leren we twee methoden voor het berekenen van de voorspelde klassennauwkeurigheid van het bronvoorbeeld: handmatig en met behulp van de scikit-learn-bibliotheek van Python.
Hier volgt een overzicht van de onderwerpen die we in deze tutorial hebben besproken.
- Handmatig nauwkeurigheid_score berekenen
- Accuratesse_score berekenen met behulp van scikit learn
- Scikit leert de voorbeelden van nauwkeurigheid_score
- Hoe leert scikit accurate_score?
Wat is nauwkeurigheid?
Een van de veelgebruikte maatstaven waarmee de prestaties van classificatiemodellen worden berekend, is nauwkeurigheid. Het percentage labels dat ons model met succes heeft voorspeld, wordt weergegeven door nauwkeurigheid. Als ons model bijvoorbeeld 80 van de 100 labels nauwkeurig zou classificeren, zou de nauwkeurigheid 0,80 zijn.
Functie creëren om de nauwkeurigheidsscore te berekenen
Laten we een Python-functie maken om de nauwkeurigheidsscore van de voorspelde waarden te berekenen, aangezien we al over de echte labels van het voorbeeld beschikken en de labels het model voorspelden.
Code
# 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
De bovenstaande functie accepteert waarden voor de voorspelde labels van het classificatiemodel en de echte labels van het monster als argumenten en berekent de nauwkeurigheidsscore. Hier doorlopen we elk paar ware en voorspelde labels parallel om het aantal correcte voorspellingen vast te leggen. Vervolgens delen we dat aantal door het totale aantal labels om de nauwkeurigheidsscore te berekenen.
de cijfers van het alfabet
We zullen de functie nu op een voorbeeld toepassen.
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)
Uitgang:
0.9777777777777777
We krijgen 0,978 als de nauwkeurigheidsscore voor de voorspellingen van het Support Vector Classification-model.
Merk op dat het gebruik van numpy-arrays om de gelijkheidsberekening te vectoriseren de bovengenoemde code efficiënter kan maken.
Nauwkeurigheid met behulp van Sklearn's accuratesse_score()
De nauwkeurigheid_score()-methode van sklearn.metrics accepteert de echte labels van het voorbeeld en de labels voorspeld door het model als parameters en berekent de nauwkeurigheidsscore als een float-waarde, die eveneens kan worden gebruikt om de nauwkeurigheidsscore in Python te verkrijgen. Er zijn verschillende handige functies om typische evaluatiestatistieken te berekenen in de klasse sklearn.metrics. Laten we de functie accuratesse_score() van sklearn gebruiken om de nauwkeurigheidsscore van het Support Vector Classification-model te berekenen met behulp van dezelfde voorbeeldgegevensset als eerder.
sklearn.metrics.accuracy_score(y_true, y_pred, *, normalize=True, sample_weight=None)
We gebruiken dit voor het berekenen van de nauwkeurigheidsscore van de classificatie. Deze methode berekent de nauwkeurigheid van subgroepen bij classificatie met meerdere labels; de voorspelde subset met labels van een dataset moet precies overeenkomen met de daadwerkelijke dataset met labels in y_true.
Parameters
Geeft terug
Voorbeeld van Nauwkeurigheid_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)
Uitgang:
0.9777777777777777
Bij gebruik van binaire labelindicatoren met meerdere labels:
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)))
Uitgang:
0.5
Hoe scikit accuraatheid_score leert werken
De nauwkeurigheid_score-methode van het pakket sklearn.metrics wijst subset-nauwkeurigheid toe in classificatie met meerdere labels.
Het is vereist dat de labels die het model voor het gegeven monster heeft voorspeld en de echte labels van het monster exact overeenkomen.
Nauwkeurigheid beschrijft het gedrag van het model in alle klassen. Als alle klassen vergelijkbaar significant zijn, is dit nuttig.
De verhouding tussen het aantal nauwkeurige voorspellingen en het totale aantal monsters of het totale aantal voorspellingen wordt gebruikt om de nauwkeurigheid van het model te bepalen.
Code:
- De onderstaande code importeert twee bibliotheken. We importeren sklearn.metrics voor het voorspellen van modelnauwkeurigheid en numpy-bibliotheken.
- De werkelijke waarden van de steekproef zijn y_true = ['1', '1', '0', '0', '1', '1', '0'].
- ['1', '1', '0', '0', '1', '1', '0'] dit zijn de voorspelde waarden van het model voor de voorbeeldgegevens.
- Nauwkeurigheid = ( matrix[0][0] + matrix[-1][-1] ) / numpy.sum(matrix) wordt gebruikt om de nauwkeurigheidsscore van het classificatiemodel te verkrijgen.
- De nauwkeurigheidsscore wordt weergegeven als uitvoer met behulp van 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)
Uitgang:
Confusion Matrix: [[2 2] [3 0]] 0.2857142857142857
Daarom hebben we in deze tutorial scikit-learn accuratesse_score in Python geleerd en enkele implementatievoorbeelden onderzocht.