Ett avgörande steg i arbetsflödet för datavetenskap är att mäta vår modells noggrannhet med hjälp av lämpligt mått. I den här handledningen kommer vi att lära oss två metoder för att beräkna källexemplets förutsagda klassnoggrannhet: manuellt och att använda Pythons scikit-learn-bibliotek.

Här är en sammanfattning av de ämnen som vi har diskuterat i den här handledningen.

• Manuell beräkning av precision_score
• Beräkna accuracy_score med hjälp av scikit learning
• Scikit lär dig accuracy_scores exempel
• Hur fungerar scikit learning accuracy_score?

Vad är noggrannhet?

En av de mest använda måtten som beräknar prestandan för klassificeringsmodeller är noggrannhet. Procentandelen etiketter som vår modell framgångsrikt förutspådde representeras av noggrannhet. Till exempel, om vår modell exakt klassificerade 80 av 100 etiketter, skulle dess noggrannhet vara 0,80.

Skapa funktion för att beräkna noggrannhetspoäng

Låt oss skapa en Python-funktion för att beräkna de förutspådda värdenas noggrannhetspoäng, givet att vi redan har provets sanna etiketter och etiketterna förutspådde modellen.

Koda

 # 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 

Ovanstående funktion accepterar värden för klassificeringsmodellens förutsagda etiketter och sanna etiketter för provet som dess argument och beräknar noggrannhetspoängen. Här itererar vi genom varje par av sanna och förutspådda etiketter parallellt för att registrera antalet korrekta förutsägelser. Vi dividerar sedan det antalet med det totala antalet etiketter för att beräkna noggrannhetspoängen.

Vi kommer att tillämpa funktionen på ett prov nu.

Koda

 # 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:

 0.9777777777777777 

Vi får 0,978 som noggrannhetspoäng för Support Vector Classification-modellens förutsägelser.

Observera att användning av numpy-arrayer för att vektorisera likhetsberäkningen kan göra koden som nämns ovan mer effektiv.

Noggrannhet med Sklearns accuracy_score()

Metoden accuracy_score() för sklearn.metrics, accepterar provets sanna etiketter och etiketterna som förutspås av modellen som dess parametrar och beräknar noggrannhetspoängen som ett flytvärde, som likaså kan användas för att erhålla noggrannhetspoängen i Python. Det finns flera användbara funktioner för att beräkna typiska utvärderingsmått i klassen sklearn.metrics. Låt oss använda sklearns accuracy_score() funktion för att beräkna Support Vector Classification-modellens noggrannhetspoäng med samma exempeldatauppsättning som tidigare.

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

Vi använder detta för att beräkna noggrannhetspoängen för klassificering. Denna metod beräknar subgruppsnoggrannhet i multi-label klassificering; en datauppsättnings förutsagda underuppsättning av etiketter måste exakt matcha den faktiska datauppsättningen av etiketter i y_true.

Parametrar

y_true (1d array-liknande, eller array som indikerar etikett/gles matris):Dessa är de riktiga etiketterna för ett givet prov.y_pred (1d array-liknande, eller array som indikerar etikett/gles matris):Förutspådda etiketter som en klassificeringsmodell har returnerat.normalisera (bool, default = True):Den anger antalet framgångsrikt klassificerade förutsagda prov om svaret är falskt. Returnerar andelen korrekt klassificerade predikterade sampel om True.sample_weight (arrayliknande form (n,), standard = Ingen):Provvikter.

Returnerar

poäng (flyta):Det ger förhållandet mellan framgångsrikt klassificerade prover (float) om normalisera == Sant; annars returnerar den antalet framgångsrikt klassificerade förutsagda sampel (int). 1 är 100 % noggrannhet för normalisera == Sant och antalet prover som tillhandahålls med normalisera == Falskt.

Exempel på Accuracy_score

Koda

 # 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 använder binära etikettindikatorer med flera etiketter:

Koda

 # 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:

int sträng

 0.5 

Hur scikit learn accuracy_score fungerar

Metoden accuracy_score i paketet sklearn.metrics tilldelar delmängdsnoggrannhet i fleretikettsklassificering.

Det krävs att etiketterna som modellen har förutspått för det givna provet och de sanna etiketterna för provet matchar exakt.

Noggrannhet beskriver modellens beteende i alla klasser. Om alla klasser är jämförbara betydelsefulla är det till hjälp.

Förhållandet mellan antalet noggranna förutsägelser och det totala antalet prov eller det totala antalet förutsägelser används för att bestämma modellens noggrannhet.

Koda:

2. Koden nedan importerar två bibliotek. Vi importerar sklearn.metrics för att förutsäga modellnoggrannhet och numpy bibliotek.
3. De sanna värdena för provet är y_true = ['1', '1', '0', '0', '1', '1', '0'].
4. ['1', '1', '0', '0', '1', '1', '0'] dessa är modellens förutsagda värden för exempeldata.
5. Noggrannhet = ( matris[0][0] + matris[-1][-1] ) / numpy.sum(matris) används för att få klassificeringsmodellens noggrannhetspoäng.
6. Noggrannhetspoängen visas som utdata med print(precision).

Koda

 # 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 den här handledningen lärde vi oss scikit-learn accuracy_score i Python och undersökte några implementeringsexempel.