Et afgørende trin i datavidenskabens arbejdsgang er at måle vores models nøjagtighed ved hjælp af den passende metrik. I denne tutorial lærer vi to metoder til at beregne kildeeksemplets forudsagte klassenøjagtighed: manuelt og ved at bruge Pythons scikit-learn-bibliotek.

Her er en oversigt over de emner, vi har diskuteret i denne tutorial.

• Manuel beregning af nøjagtighed_score
• Beregning af accuracy_score ved hjælp af scikit learning
• Scikit lær accuracy_score's eksempler
• Hvordan virker scikit learning accuracy_score?

Hvad er nøjagtighed?

En af de meget anvendte metrics, der beregner klassifikationsmodellers ydeevne, er nøjagtighed. Procentdelen af ​​etiketter, som vores model har forudsagt med succes, er repræsenteret ved nøjagtighed. For eksempel, hvis vores model nøjagtigt klassificerede 80 af 100 etiketter, ville dens nøjagtighed være 0,80.

Oprettelse af funktion til beregning af nøjagtighedsscore

Lad os oprette en Python-funktion til at beregne den forudsagte værdis nøjagtighedsscore, givet at vi allerede har prøvens sande etiketter, og etiketterne forudsagde 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 

Ovenstående funktion accepterer værdier for klassifikationsmodellens forudsagte etiketter og sande etiketter for prøven som dens argumenter og beregner nøjagtighedsscore. Her gentager vi hvert par af sande og forudsagte etiketter parallelt for at registrere antallet af korrekte forudsigelser. Vi dividerer derefter dette tal med det samlede antal etiketter for at beregne nøjagtighedsscoren.

Vi vil anvende funktionen på en prøve nu.

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) 

Produktion:

npm ryd cache

 0.9777777777777777 

Vi får 0,978 som nøjagtighedsscore for Support Vector Classification-modellens forudsigelser.

Bemærk, at brug af numpy-arrays til at vektorisere lighedsberegningen kan gøre koden nævnt ovenfor mere effektiv.

Nøjagtighed ved hjælp af Sklearns accuracy_score()

Accuracy_score()-metoden for sklearn.metrics accepterer prøvens sande etiketter og etiketterne forudsagt af modellen som dens parametre og beregner nøjagtighedsscoren som en flydende værdi, som ligeledes kan bruges til at opnå nøjagtighedsscore i Python. Der er flere nyttige funktioner til at beregne typiske evalueringsmetrikker i klassen sklearn.metrics. Lad os bruge sklearns accuracy_score()-funktion til at beregne Support Vector Classification-modellens nøjagtighedsscore ved hjælp af det samme eksempeldatasæt som tidligere.

sklearn.metrics.accuracy_score(y_true, y_pred, *, normalize=True, sample_weight=Ingen)

Vi bruger dette til at beregne nøjagtighedsscore for klassificering. Denne metode beregner undergruppenøjagtighed i multi-label klassificering; et datasæts forudsagte undersæt af etiketter skal nøjagtigt matche det faktiske datasæt af etiketter i y_true.

tring til int

Parametre

y_true (1d array-lignende eller array-indikerende etiket/sparse matrix):Dette er de rigtige etiketter for en given prøve.y_pred (1d array-lignende eller array-indikerende etiket/sparse matrix):Forudsagte etiketter, som en klassificeringsmodel har returneret.normalisere (bool, standard = Sand):Det giver antallet af vellykket klassificerede forudsagte prøver, hvis svaret er falsk. Returnerer andelen af ​​korrekt klassificerede forudsagte prøver, hvis True.sample_weight (array-lignende form (n,), standard = Ingen):Prøvevægte.

Vender tilbage

score (flydende):Det giver forholdet mellem vellykket klassificerede prøver (float), hvis normalisere == Sand; ellers returnerer den antallet af vellykket klassificerede forudsagte prøver (int). 1 er 100 % nøjagtighed for normalisere == Sand og antallet af prøver leveret med normalisere == Falsk.

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) 

Produktion:

 0.9777777777777777 

Når du bruger binære etiketindikatorer 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))) 

Produktion:

 0.5 

Sådan virker scikit learning accuracy_score

Accuracy_score-metoden i sklearn.metrics-pakken tildeler delmængdenøjagtighed i multi-label-klassificering.

Det kræves, at de etiketter, som modellen har forudsagt for den givne prøve, og de sande etiketter for prøven matcher nøjagtigt.

Nøjagtighed beskriver modellens adfærd på tværs af alle klasser. Hvis alle klasserne er sammenlignelige betydningsfulde, er det nyttigt.

Forholdet mellem antallet af nøjagtige forudsigelser og det samlede antal prøver eller det samlede antal forudsigelser bruges til at bestemme modellens nøjagtighed.

Kode:

2. Koden nedenfor importerer to biblioteker. Vi importerer sklearn.metrics til at forudsige modelnøjagtighed og numpy biblioteker.
3. De sande værdier af prøven er y_true = ['1', '1', '0', '0', '1', '1', '0'].
4. ['1', '1', '0', '0', '1', '1', '0'] dette er modellens forudsagte værdier for prøvedataene.
5. Nøjagtighed = ( matrix[0][0] + matrix[-1][-1] ) / numpy.sum(matrix) bruges til at få klassifikationsmodellens nøjagtighedsscore.
6. Nøjagtighedsscoren vises som output ved hjælp af print(nøjagtighed).

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) 

Produktion:

 Confusion Matrix: [[2 2] [3 0]] 0.2857142857142857 

Så i denne tutorial lærte vi scikit-learn accuracy_score i Python og undersøgte nogle implementeringseksempler.