Escribir el manejo personalizado de excepciones en un proyecto de aprendizaje automático usando python

Como desarrollador de aprendizaje automático, puede encontrar varios errores mientras trabaja en su proyecto. Manejar estos errores de una manera estructurada y organizada es esencial para mantener la calidad del código y garantizar que su proyecto se ejecute sin problemas. El manejo personalizado de excepciones es una herramienta poderosa que puede ayudarlo a lograr este objetivo.

El manejo de errores es una parte crucial del desarrollo de software y los proyectos de aprendizaje automático no son una excepción. En el aprendizaje automático, los errores pueden ocurrir debido a varias razones, como problemas de calidad de datos, problemas de entrenamiento de modelos o errores de entrada/salida. Para manejar estos errores de manera efectiva, es esencial usar el manejo personalizado de excepciones en su código. El manejo personalizado de excepciones le permite detectar y manejar errores específicos de su proyecto, lo que facilita la identificación y solución de problemas.

En este blog, lo guiaremos a través de cómo escribir un manejo personalizado de excepciones en un proyecto de aprendizaje automático en Python usando un ejemplo.

Ejemplo

Supongamos que tiene una secuencia de comandos de Python que carga un conjunto de datos desde un archivo y lo procesa con fines de aprendizaje automático. Desea definir una excepción personalizada que se genera cuando se produce un error durante el proceso de carga del conjunto de datos. Aquí está el código para la excepción personalizada:

¿Qué es la clasificación en el contexto del aprendizaje automático y la ciencia de datos?

Código de ejemplo

import sys
import logging
def error_message_detail(error, error_detail:sys):
_, _, exc_tb = error_detail.exc_info()
file_name = exc_tb.tb_frame.f_code.co_filename
error_message = "Error occured in Python Script name [{0}] Line No. [{1}] Error Message [{2}]".format(file_name, exc_tb.tb_lineno, str(error))
También te puede interesar8 responsabilidades laborales clave de un analista de IA
return error_message
class customException(Exception):
def __init__(self, error_message, error_detail:sys):
super().__init__(self, error_message)
self.error_message = error_message_detail(error_message, error_detail=error_detail)
def __str__(self):
return self.error_message

El código anterior incluye una función llamada error_message_detail, que genera un mensaje de error detallado. Se necesitan dos argumentos: errorque es el mensaje de error, y error_detailel cual es un sys objeto que contiene información sobre el error. La función extrae el nombre del archivo y el número de línea donde ocurrió el error y los combina con el mensaje de error para crear un mensaje de error detallado.

Analizando Testimonios de Clientes con ChatGPT: Refinando Nuestra Propuesta de Valor

El código también incluye una excepción personalizada llamada customException. Se necesitan dos argumentos: error_messageque es el mensaje de error, y error_detailel cual es un sys objeto que contiene información sobre el error. El __init__ método de la clase llama al super() funcion para inicializar la base Exception clase con el mensaje de error. Luego usa el error_message_detail función para crear un mensaje de error detallado y lo almacena en el error_message atributo. El __str__ El método de la clase devuelve el mensaje de error cuando se genera la excepción.

Ahora que hemos definido nuestra excepción personalizada, veamos cómo podemos usarla en nuestro proyecto de aprendizaje automático.

Supongamos que tenemos una función llamada load_dataset que carga un conjunto de datos desde un archivo. Así es como podemos usar la excepción personalizada para manejar los errores que ocurren durante el proceso de carga del conjunto de datos:

import pandas as pd
def load_dataset(file_name):
try:
# load the dataset from file_name
df = pd.read_csv(file_name)
También te puede interesar12 Ways to Test Your Forecasts like A Pro
except FileNotFoundError as e:
raise customException('File not found', error_detail=sys)
except ValueError as e:
raise customException('Invalid file format', error_detail=sys)

En este ejemplo, detectamos dos tipos de excepciones: FileNotFoundError y ValueError – que puede ocurrir durante el proceso de carga del conjunto de datos. Cuando ocurre alguna de estas excepciones, elevamos el customException excepción y pasar el mensaje de error y sys.exc_info() objeto como argumentos. El sys.exc_info() El objeto proporciona información adicional sobre el error, como el número de línea y el nombre del archivo donde ocurrió el error.

Entonces podemos atrapar el customException excepción e imprima el mensaje de error:

try:
load_dataset('dataset.csv')
except customException as e:
print(e)

Aquí, atrapamos el customException excepción e imprima el mensaje de error usando el __str__ metodo de la customException clase.

El código para este tutorial se muestra a continuación en la esencia de Github y está disponible aquí.

import sys
import logging
import pandas as pd
def error_message_detail(error, error_detail:sys):
_, _, exc_tb = error_detail.exc_info()
file_name = exc_tb.tb_frame.f_code.co_filename
error_message = "Error occured in Python Script name [{0}] Line No. [{1}] Error Message [{2}]".format(file_name, exc_tb.tb_lineno, str(error))
return error_message
class customException(Exception):
# Constructor or Initializer
def __init__(self, error_message, error_detail:sys):
super().__init__(self, error_message)
self.error_message = error_message_detail(error_message, error_detail=error_detail)
# __str__ is to print() the value
def __str__(self):
return self.error_message
def load_dataset(file_name):
try:
# load the dataset from file_name
df = pd.read_csv(file_name)
except FileNotFoundError as e:
raise customException('File not found', error_detail=sys)
except ValueError as e:
raise customException('Invalid file format', error_detail=sys)
if __name__ == "__main__":
try:
load_dataset('dataset.csv')
except customException as e:
print(e)

Conclusión

El manejo personalizado de excepciones es un aspecto importante de los proyectos de aprendizaje automático. Al definir tipos de error específicos y manejarlos de manera estructurada y organizada, puede hacer que su código sea más legible, fácil de mantener y más fácil de depurar.