Como visualizar a matriz de confusão para um modelo

Uma matriz de confusão permite que você veja os rótulos que seu modelo confunde com outros rótulos em seu modelo. Ao usar uma matriz de confusão, é possível focar suas melhorias no modelo.

Durante a avaliação do modelo, o Amazon Rekognition Custom Labels cria uma matriz de confusão usando as imagens de teste para identificar rótulos mal identificados (confusos). O Amazon Rekognition Custom Labels só criam uma matriz de confusão para modelos de classificação. A matriz de classificação pode ser acessada a partir do arquivo de resumo que o Amazon Rekognition Custom Labels cria durante o treinamento do modelo. Não é possível visualizar a matriz de confusão no console do Amazon Rekognition Custom Labels.

Como usar uma matriz de confusão

A tabela a seguir é a matriz de confusão do projeto de exemplo classificação de imagens de Cômodos. Os cabeçalhos das colunas são os rótulos (rótulos de "verdade fundamental") atribuídos às imagens de teste. Os cabeçalhos das linhas são os rótulos que o modelo prevê para as imagens de teste. Cada célula é a porcentagem de previsões de um rótulo (linha) que deve ser o rótulo de "verdade fundamental" (coluna). Por exemplo, 67% das previsões para banheiros foram rotuladas corretamente como banheiros. 33% por cento dos banheiros foram rotulados incorretamente como cozinhas. Um modelo de alto desempenho tem altos valores de células quando o rótulo previsto corresponde ao rótulo de "verdade fundamental". É possível vê-los como uma linha diagonal do primeiro ao último rótulo previsto e os rótulos de "verdade fundamental". Se o valor de uma célula for 0, nenhuma previsão foi feita para o rótulo previsto da célula, que deveria ser o rótulo de "verdade fundamental" da célula.

nota

Como os modelos não são determinísticos, os valores das células da matriz de confusão que você obtém ao treinar o projeto Cômodos podem ser diferentes da tabela a seguir.

A matriz de confusão identifica áreas nas quais focar. Por exemplo, a matriz de confusão mostra que 50% das vezes o modelo confundiu armários com quartos. Nesta situação, devem ser adicionadas mais imagens de armários e quartos ao seu conjunto de dados de treinamento. Verifique também se as imagens existentes do armário e do quarto estão corretamente rotuladas. Isto deve ajudar o modelo a distinguir melhor os dois rótulos. Para adicionar mais imagens a um conjunto de dados, consulte Como adicionar mais imagens a um conjunto de dados.

Embora a matriz de confusão seja útil, é importante saber outras métricas. Por exemplo, 100% das previsões encontraram corretamente o rótulo floor_plan, que indica um excelente desempenho. No entanto, o conjunto de dados de teste tem apenas duas imagens com o rótulo floor_plan. Ele também tem 11 imagens com o rótulo sala_de_estar. Este desequilíbrio também está no conjunto de dados de treinamento (13 imagens sala_de_estar e duas imagens de armário). Para obter uma avaliação mais precisa, equilibre os conjuntos de dados de treinamento e teste adicionando mais imagens de rótulos sub-representados (plantas baixas neste exemplo). Para obter o número de imagens de teste por rótulo, consulte Como acessar as métricas de avaliação (console).

	Rótulo do Ground Truth
Rótulo previsto	quintal	banheiro	quarto	closet	entry_way	floor_plan	front_yard	kitchen	sala_de_estar	patio
quintal	75%	0%	0%	0%	0%	0%	33%	0%	0%	0%
banheiro	0%	67%	0%	0%	0%	0%	0%	0%	0%	0%
quarto	0%	0%	82%	50%	0%	0%	0%	0%	9%	0%
closet	0%	0%	0%	50%	0%	0%	0%	0%	0%	0%
entry_way	0%	0%	0%	0%	33%	0%	0%	0%	0%	0%
floor_plan	0%	0%	0%	0%	0%	100%	0%	0%	0%	0%
front_yard	25%	0%	0%	0%	0%	0%	67%	0%	0%	0%
kitchen	0%	33%	0%	0%	0%	0%	0%	88%	0%	0%
sala_de_estar	0%	0%	18%	0%	67%	0%	0%	12%	91%	33%
patio	0%	0%	0%	0%	0%	0%	0%	0%	0%	67%

Como obter a matriz de confusão para um modelo

O código a seguir usa as operações DescribeProjectse DescribeProjectVersions para obter o arquivo de resumo de um modelo. Em seguida, ele usa o arquivo de resumo para exibir a matriz de confusão do modelo.

Para exibir a matriz de confusão de um modelo (SDK)

1. Se você ainda não tiver feito isso, instale e configure o AWS CLI e os AWS SDKs. Para ter mais informações, consulte Etapa 4: configurar os AWS SDKs AWS CLI e.

2. Use o código a seguir para exibir a matriz de confusão de um modelo. Forneça os seguintes argumentos de linha de comando:

   • project_name: o nome do projeto que você deseja usar. É possível obter o nome do projeto na página de projetos no console do Amazon Rekognition Custom Labels.

   • version_name: a versão do modelo que você deseja usar. É possível obter o nome da versão na página de detalhes do projeto no console do Amazon Rekognition Custom Labels.

   # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
   # SPDX-License-Identifier: Apache-2.0
   
   """
   Purpose
   
   Shows how to display the confusion matrix for an Amazon Rekognition Custom labels image
   classification model.
   """
   
   
   import json
   import argparse
   import logging
   import boto3
   import pandas as pd
   from botocore.exceptions import ClientError
   
   
   logger = logging.getLogger(__name__)
   
   
   def get_model_summary_location(rek_client, project_name, version_name):
       """
       Get the summary file location for a model.
   
       :param rek_client: A Boto3 Rekognition client.
       :param project_arn: The Amazon Resource Name (ARN) of the project that contains the model.
       :param model_arn: The Amazon Resource Name (ARN) of the model.
       :return: The location of the model summary file.
       """
   
       try:
           logger.info(
               "Getting summary file for model %s in project %s.", version_name, project_name)
   
           summary_location = ""
   
           # Get the project ARN from the project name.
           response = rek_client.describe_projects(ProjectNames=[project_name])
   
           assert len(response['ProjectDescriptions']) > 0, \
               f"Project {project_name} not found."
   
           project_arn = response['ProjectDescriptions'][0]['ProjectArn']
   
           # Get the summary file location for the model.
           describe_response = rek_client.describe_project_versions(ProjectArn=project_arn,
                                                                    VersionNames=[version_name])
           assert len(describe_response['ProjectVersionDescriptions']) > 0, \
               f"Model {version_name} not found."
   
           model=describe_response['ProjectVersionDescriptions'][0]
   
           evaluation_results=model['EvaluationResult']
   
           summary_location=(f"s3://{evaluation_results['Summary']['S3Object']['Bucket']}"
                               f"/{evaluation_results['Summary']['S3Object']['Name']}")
   
           return summary_location
   
       except ClientError as err:
           logger.exception(
               "Couldn't get summary file location: %s", err.response['Error']['Message'])
           raise
   
   
   def show_confusion_matrix(summary):
       """
       Shows the confusion matrix for an Amazon Rekognition Custom Labels
       image classification model.
       :param summary: The summary file JSON object.
       """
       pd.options.display.float_format = '{:.0%}'.format
   
       # Load the model summary JSON into a DataFrame.
   
       summary_df = pd.DataFrame(
           summary['AggregatedEvaluationResults']['ConfusionMatrix'])
   
       # Get the confusion matrix.
       confusion_matrix = summary_df.pivot_table(index='PredictedLabel',
                                                 columns='GroundTruthLabel',
                                                 fill_value=0.0).astype(float)
   
       # Display the confusion matrix.
       print(confusion_matrix)
   
   
   def get_summary(s3_resource, summary):
       """
       Gets the summary file.
       : return: The summary file in bytes.
       """
       try:
           summary_bucket, summary_key = summary.replace(
               "s3://", "").split("/", 1)
   
           bucket = s3_resource.Bucket(summary_bucket)
           obj = bucket.Object(summary_key)
           body = obj.get()['Body'].read()
           logger.info(
               "Got summary file '%s' from bucket '%s'.",
               obj.key, obj.bucket_name)
       except ClientError:
           logger.exception(
               "Couldn't get summary file '%s' from bucket '%s'.",
               obj.key, obj.bucket_name)
           raise
       else:
           return body
   
   
   def add_arguments(parser):
       """
       Adds command line arguments to the parser.
       : param parser: The command line parser.
       """
   
       parser.add_argument(
           "project_name", help="The ARN of the project in which the model resides."
       )
       parser.add_argument(
           "version_name", help="The version of the model that you want to describe."
       )
   
   
   def main():
       """
       Entry point for script.
       """
   
       logging.basicConfig(level=logging.INFO,
                           format="%(levelname)s: %(message)s")
   
       try:
   
           # Get the command line arguments.
           parser = argparse.ArgumentParser(usage=argparse.SUPPRESS)
           add_arguments(parser)
           args = parser.parse_args()
   
           print(
               f"Showing confusion matrix for: {args.version_name} for project {args.project_name}.")
   
           session = boto3.Session(profile_name='custom-labels-access')
           rekognition_client = session.client("rekognition")
           s3_resource = session.resource('s3')
   
           # Get the summary file for the model.
           summary_location = get_model_summary_location(rekognition_client, args.project_name,
                                                         args.version_name
                                                         )
           summary = json.loads(get_summary(s3_resource, summary_location))
   
           # Check that the confusion matrix is available.
           assert 'ConfusionMatrix' in summary['AggregatedEvaluationResults'], \
               "Confusion matrix not found in summary. Is the model a classification model?"
   
           # Show the confusion matrix.
           show_confusion_matrix(summary)
           print("Done")
   
       except ClientError as err:
           logger.exception("Problem showing confusion matrix: %s", err)
           print(f"Problem describing model: {err}")
   
       except AssertionError as err:
           logger.exception(
               "Error: %s.\n", err)
           print(
               f"Error: {err}\n")
   
   
   if __name__ == "__main__":
       main()