Uma etapa crucial no fluxo de trabalho da ciência de dados é medir a precisão do nosso modelo usando a métrica apropriada. Neste tutorial, aprenderemos dois métodos para calcular a precisão prevista da classe da amostra de origem: manualmente e usando a biblioteca scikit-learn do Python.

Aqui está um resumo dos tópicos que discutimos neste tutorial.

• Calculando manualmente a precisão_score
• Cálculo de precisão_score usando scikit learn
• Scikit aprende exemplos de exactidão_score
• Como funciona o scikit learn exactid_score?

O que é precisão?

Uma das métricas amplamente utilizadas que calcula o desempenho dos modelos de classificação é a precisão. A porcentagem de rótulos que nosso modelo previu com sucesso é representada pela precisão. Por exemplo, se nosso modelo classificasse com precisão 80 de 100 rótulos, sua precisão seria de 0,80.

Criando função para calcular pontuação de precisão

Vamos criar uma função Python para calcular a pontuação de precisão dos valores previstos, visto que já temos os rótulos verdadeiros da amostra e os rótulos previram o modelo.

Código

 # 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 

A função acima aceita valores para os rótulos previstos do modelo de classificação e rótulos verdadeiros da amostra como seus argumentos e calcula a pontuação de precisão. Aqui, iteramos cada par de rótulos verdadeiros e previstos em paralelo para registrar o número de previsões corretas. Em seguida, dividimos esse número pelo número total de rótulos para calcular a pontuação de precisão.

Aplicaremos a função em uma amostra agora.

Código

tratamento de exceções em java

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

Saída:

 0.9777777777777777 

Obtemos 0,978 como pontuação de precisão para as previsões do modelo de classificação de vetores de suporte.

Observe que o uso de matrizes numpy para vetorizar o cálculo da igualdade pode tornar o código mencionado acima mais eficiente.

Precisão usando precisão_score() do Sklearn

O método exactidão_score() de sklearn.metrics aceita os rótulos verdadeiros da amostra e os rótulos previstos pelo modelo como seus parâmetros e calcula a pontuação de precisão como um valor flutuante, que também pode ser usado para obter a pontuação de precisão em Python. Existem várias funções úteis para calcular métricas de avaliação típicas na classe sklearn.metrics. Vamos usar a função exactidão_score() do sklearn para calcular a pontuação de precisão do modelo de classificação de vetores de suporte usando o mesmo conjunto de dados de amostra anterior.

em java

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

Usamos isso para calcular a pontuação de precisão da classificação. Este método calcula a precisão do subgrupo na classificação multirótulo; o subconjunto de rótulos previsto de um conjunto de dados deve corresponder precisamente ao conjunto de dados real de rótulos em y_true.

Parâmetros

y_true (semelhante a uma matriz 1d ou matriz indicando rótulo/matriz esparsa):Estes são os rótulos verdadeiros para uma determinada amostra.y_pred (semelhante a uma matriz 1d ou matriz indicando rótulo/matriz esparsa):Rótulos previstos que um modelo de classificação retornou.normalizar (bool, padrão = True):Fornece o número de amostras previstas classificadas com sucesso se a resposta for Falsa. Retorna a proporção de amostras previstas classificadas corretamente se for True.sample_weight (tipo array de forma (n,), padrão = Nenhum):Pesos amostrais.

Devoluções

pontuação (flutuador):Fornece a proporção de amostras classificadas com sucesso (float) se normalize == True; caso contrário, retorna a contagem de amostras previstas classificadas com sucesso (int). 1 é 100% de precisão para normalizar == Verdadeiro e a contagem de amostras fornecidas com normalizar == Falso.

Exemplo de Accuracy_score

Código

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

Saída:

 0.9777777777777777 

Ao usar indicadores de rótulos binários com vários rótulos:

Código

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

Saída:

 0.5 

Como funciona o scikit learn exactid_score

O método exactidão_score do pacote sklearn.metrics atribui precisão de subconjunto na classificação multi-rótulo.

string jsonjava

É necessário que os rótulos que o modelo previu para a amostra dada e os rótulos verdadeiros da amostra correspondam exatamente.

A precisão descreve o comportamento do modelo em todas as classes. Se todas as classes forem comparativamente significativas, isso será útil.

A proporção entre a contagem de previsões precisas e o número total de amostras ou o número total de previsões é usada para determinar a precisão do modelo.

Código:

2. O código abaixo importa duas bibliotecas. Estamos importando sklearn.metrics para prever a precisão do modelo e bibliotecas numpy.
3. Os valores verdadeiros da amostra são y_true = ['1', '1', '0', '0', '1', '1', '0'].
4. ['1', '1', '0', '0', '1', '1', '0'] estes são os valores previstos do modelo para os dados de amostra.
5. Precisão = ( matriz[0][0] + matriz[-1][-1] ) / numpy.sum(matriz) é usado para obter a pontuação de precisão do modelo de classificação.
6. A pontuação de precisão é exibida como saída usando print(accuracy).

Código

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

Saída:

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

Portanto, neste tutorial, aprendemos scikit-learn exactidão_score em Python e examinamos alguns exemplos de implementação.