Cálculo de la precisión promedio para la detección de objetos en redes neuronales convolucionales (CNN) en Python.

Answer

1. 

   davy.ai

   July 16, 2023 at 9:40 pm

   Para calcular la Precisión Promedio (mAP) para el clasificador de detección de objetos, debes seguir estos pasos:

   1. Primero, necesitas determinar los valores de Verdadero Positivo (TP), Falso Positivo (FP) y Falso Negativo (FN) para cada clase en cada imagen. Puedes hacer esto comparando los valores de clase y puntuación obtenidos del clasificador con las etiquetas de verdad para cada imagen.

   2. Después de calcular TP, FP y FN para cada imagen, necesitas calcular los valores de Precisión y Recall para cada clase. La Precisión es la proporción de TP entre la suma de TP y FP, mientras que el Recall es la proporción de TP entre la suma de TP y FN.

   3. Luego, necesitas calcular la Precisión Promedio (AP) para cada clase trazando una curva de Precisión-Recall (PR) para esa clase, y luego calculando el área bajo la curva (AUC). Puedes utilizar la biblioteca scikit-learn en Python para trazar las curvas PR y calcular el AUC.

   4. Finalmente, necesitas calcular el mAP tomando la media de los valores de AP para todas las clases.

   Aquí tienes algunos ejemplos de código que puedes utilizar para calcular el mAP para tu detector de objetos:

   # Define tus etiquetas de clase y puntajes para cada imagen
   class_labels = [[1, 2, 3], [1, 2, 4], [3, 5, 6], ..., [2, 3, 4]]
   class_scores = [[0.99, 0.91, 0.75], [0.69, 0.91, 0.75], [0.99, 0.92, 0.68], ..., [0.95, 0.91, 0.68]]
   
   # Define las etiquetas de verdad y los puntajes para cada imagen
   gt_labels = [[1, 2, 3], [1, 2, 4], [3, 5, 6], ..., [2, 3, 4]]
   gt_scores = [[1, 1, 1], [1, 1, 1], [1, 1, 1], ..., [1, 1, 1]]
   
   # Define tu lista de nombres de clase
   class_names = ['As', 'Jota', 'Diez', 'Reina', 'Nueve', 'Rey']
   
   # Calcula TP, FP y FN para cada clase e imagen
   TP = np.zeros((len(class_names), len(class_labels)))
   FP = np.zeros((len(class_names), len(class_labels)))
   FN = np.zeros((len(class_names), len(class_labels)))
   
   for i, img_classes in enumerate(class_labels):
       for j, class_id in enumerate(img_classes):
           if class_id in gt_labels[i]:
               k = gt_labels[i].index(class_id)
               if class_scores[i][j] >= gt_scores[i][k]:
                   TP[class_id-1][i] = 1
               else:
                   FP[class_id-1][i] = 1
           else:
               FP[class_id-1][i] = 1
   
       for k, gt_class_id in enumerate(gt_labels[i]):
           if gt_class_id not in img_classes:
               FN[gt_class_id-1][i] = 1
   
   # Calcula la Precisión y Recall para cada clase
   precision = np.zeros(len(class_names))
   recall = np.zeros(len(class_names))
   
   for i in range(len(class_names)):
       sum_TP = sum(TP[i])
       sum_FP = sum(FP[i])
       sum_FN = sum(FN[i])
       if sum_TP or sum_FP:
           precision[i] = sum_TP / (sum_TP + sum_FP)
       if sum_TP or sum_FN:
           recall[i] = sum_TP / (sum_TP + sum_FN)
   
   # Calcula AP para cada clase
   AP = np.zeros(len(class_names))
   
   for i in range(len(class_names)):
       precision_i = precision[i]
       recall_i = recall[i]
       AP[i] = auc(recall_i, precision_i)
   
   # Calcula mAP
   mAP = np.mean(AP)
   
   # Trazar curvas PR
   for i in range(len(class_names)):
       plt.plot(recall[i], precision[i], label=class_names[i])
   
   plt.xlabel('Recall')
   plt.ylabel('Precisión')
   plt.title('Curva de Precisión-Recall')
   plt.legend()
   plt.show()
   

   Ten en cuenta que el código anterior asume que tus etiquetas de clase y puntajes se almacenan en una lista de listas, donde cada lista interna corresponde a las etiquetas y puntajes predichos para una imagen. Lo mismo ocurre con las etiquetas y puntajes de verdad. También ten en cuenta que esto es solo un fragmento de código aproximado y es posible que necesites modificarlo para adaptarlo a tus necesidades específicas.

Comments are closed.