Et avgjørende stadium i datavitenskapens arbeidsflyt er å måle modellens nøyaktighet ved å bruke riktig beregning. I denne opplæringen lærer vi to metoder for å beregne kildeeksemplets anslåtte klassenøyaktighet: manuelt og ved å bruke Pythons scikit-learn-bibliotek.
Her er en oversikt over emnene vi har diskutert i denne opplæringen.
- Manuell beregning av nøyaktighet_score
- Beregning av nøyaktighet_score ved hjelp av scikit learning
- Scikit lær accuracy_score sine eksempler
- Hvordan fungerer scikit learning accuracy_score?
Hva er nøyaktighet?
En av de mye brukte beregningene som beregner ytelsen til klassifiseringsmodeller er nøyaktighet. Prosentandelen av etiketter som modellen vår forutså, representeres av nøyaktighet. For eksempel, hvis modellen vår nøyaktig klassifiserte 80 av 100 etiketter, ville dens nøyaktighet være 0,80.
Opprette funksjon for å beregne nøyaktighetspoeng
La oss lage en Python-funksjon for å beregne den predikerte verdiens nøyaktighetsscore, gitt at vi allerede har prøvens sanne etiketter og etikettene som spådde modellen.
Kode
# 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
Funksjonen ovenfor aksepterer verdier for klassifiseringsmodellens predikerte etiketter og sanne etiketter for prøven som argumenter og beregner nøyaktighetsskåren. Her itererer vi gjennom hvert par sanne og spådde etiketter parallelt for å registrere antall korrekte spådommer. Vi deler deretter dette tallet på det totale antallet etiketter for å beregne nøyaktighetspoengene.
Vi vil bruke funksjonen på en prøve nå.
Kode
# 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)
Produksjon:
npm tøm cache
0.9777777777777777
Vi får 0,978 som nøyaktighetsscore for Support Vector Classification-modellens spådommer.
Merk at bruk av numpy-matriser for å vektorisere likhetsberegningen kan gjøre koden nevnt ovenfor mer effektiv.
Nøyaktighet ved bruk av Sklearns accuracy_score()
Accuracy_score()-metoden til sklearn.metrics, aksepterer de sanne etikettene til prøven og etikettene forutsagt av modellen som dens parametere og beregner nøyaktighetsskåren som en flyteverdi, som på samme måte kan brukes til å oppnå nøyaktighetsskåren i Python. Det er flere nyttige funksjoner for å beregne typiske evalueringsberegninger i sklearn.metrics-klassen. La oss bruke sklearns accuracy_score()-funksjon for å beregne Support Vector Classification-modellens nøyaktighetsscore ved å bruke det samme eksempeldatasettet som tidligere.
sklearn.metrics.accuracy_score(y_true, y_pred, *, normalize=True, sample_weight=Ingen)
Vi bruker dette for å beregne nøyaktighetsscore for klassifisering. Denne metoden beregner undergruppenøyaktighet i multi-label klassifisering; et datasetts anslåtte delsett av etiketter må samsvare nøyaktig med det faktiske datasettet med etiketter i y_true.
755 chmod
Parametere
Returnerer
Eksempel på Accuracy_score
Kode
# 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)
Produksjon:
0.9777777777777777
Når du bruker binære etikettindikatorer med flere etiketter:
Kode
# 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)))
Produksjon:
0.5
Hvordan scikit learning accuracy_score fungerer
Accuracy_score-metoden til sklearn.metrics-pakken tildeler delsettnøyaktighet i multi-label-klassifisering.
Det kreves at etikettene modellen har forutsagt for den gitte prøven og de sanne etikettene til prøven samsvarer nøyaktig.
Nøyaktighet beskriver modellens oppførsel på tvers av alle klasser. Hvis alle klassene er sammenlignbare betydningsfulle, er det nyttig.
Forholdet mellom antallet nøyaktige spådommer og det totale antallet prøver eller det totale antallet spådommer brukes til å bestemme modellens nøyaktighet.
Kode:
- Koden nedenfor importerer to biblioteker. Vi importerer sklearn.metrics for å forutsi modellnøyaktighet og numpy biblioteker.
- De sanne verdiene for prøven er y_true = ['1', '1', '0', '0', '1', '1', '0'].
- ['1', '1', '0', '0', '1', '1', '0'] dette er modellens anslåtte verdier for eksempeldataene.
- Nøyaktighet = ( matrise[0][0] + matrise[-1][-1] ) / numpy.sum(matrise) brukes for å få klassifiseringsmodellens nøyaktighetsscore.
- Nøyaktighetspoengene vises som utdata ved bruk av utskrift (nøyaktighet).
Kode
# 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)
Produksjon:
Confusion Matrix: [[2 2] [3 0]] 0.2857142857142857
Så i denne opplæringen lærte vi scikit-learn accuracy_score i Python og undersøkte noen implementeringseksempler.