Estás leyendo la publicación: Automatización de la clasificación Zero-Shot generando etiquetas de modelo con GPT-3: hacia la IA
Publicado originalmente en Hacia la IA.
El aprendizaje de tiro cero es un método de aprendizaje automático que permite usar un modelo previamente entrenado para clasificar datos de acuerdo con un conjunto de clases o etiquetas que no se han usado para entrenar el modelo. Zero-shot puede ser útil para varias aplicaciones, entre ellas:
- etiquetar datos sin perder tiempo entrenando o ajustando un modelo
- etiquetando datos porque no tenemos un conjunto de entrenamiento para entrenar o ajustar un modelo
Tradicionalmente, la creación de etiquetas para una tarea de clasificación de disparo cero implica definir manualmente un conjunto de clases o etiquetas potenciales que el modelo puede usar para hacer predicciones sobre los datos no vistos. Este proceso puede llevar mucho tiempo y ser propenso a errores, especialmente para grandes conjuntos de datos o dominios complejos.
Al usar GPT-3 de OpenAI para generar etiquetas para modelos de clasificación de disparo cero, ¡podemos reducir significativamente el tiempo y el esfuerzo necesarios para crear este conjunto de etiquetas!
En este artículo, mostraré cómo crear un modelo de clasificación de texto de tiro cero, integrando GPT-3 de OpenAI para la creación de etiquetas (es decir, generar un conjunto de etiquetas relevantes para los datos que queremos categorizar) y HuggingFace zero-shot modelos para la clasificación de texto real (es decir, clasificar los datos de acuerdo con este conjunto de etiquetas).
Para comenzar, necesitaremos instalar transformers y openai e importar todos los módulos necesarios:
!pip instalar transformadores
!pip instalar openai
de oleoducto de importación de transformadores
antorcha de importación
desde tqdm importar tqdm
importar pandas como pd
importar openai
solicitudes de importación
También necesitaremos inicializar el cliente API de OpenAI con nuestra clave API:
openai.api_key = (“su clave”) #replace con su clave
Ahora que tenemos los paquetes necesarios y la clave API, definamos (1) una función para generar etiquetas relevantes para el corpus de textos que queremos clasificar y (2) una función para clasificar el corpus en función del conjunto de etiquetas previamente definido.
(1) Primero, defina una función para generar las etiquetas que alimentaremos a nuestro modelo de clasificación de tiro cero:
def get_zero_shot_labels(dominio, n_labels = Ninguno):
si n_labels es Ninguno:
prompt = ‘Está eligiendo las etiquetas para un modelo de clasificación de tiro cero, genere una lista de temas para el dominio: {}’.formato (dominio)
demás:
prompt = ‘Está eligiendo las etiquetas para un modelo de clasificación de tiro cero, genere una lista con un mínimo de {} temas para el dominio: {}’.format(n_labels, domain)
respuesta = openai.Completion.create(
motor=”texto-davinci-002″,
aviso = aviso,
max_tokens=40,
n=1,
detener = ninguno,
temperatura=0.5,
)
texto = respuesta[“choices”][0][“text”]
etiquetas = [label.strip(‘-‘) for label in text.split(‘\n’)]
volver (etiquetas)
Esta función usa GPT-3 (alternativamente, puede usar GPT-4) para generar un conjunto de etiquetas relevantes para el dominio específico que nos interesa.
get_zero_shot_labels tiene dos entradas:
- dominio es una cadena que contiene la descripción del dominio relevante para los datos que enviaremos al modelo de clasificación de tiro cero (p. ej., reseñas de restaurantes, noticias de fútbol, etc.)
- n_labels es el número mínimo de etiquetas que queremos generar. Si no se especifica n_labels, la función generará un número no especificado de etiquetas para el dominio especificado.
(2) A continuación, definiremos una función para clasificar nuestros datos de entrada según la lista de posibles etiquetas que creamos previamente con get_zero_shot_labels:
def zero_shot_classification(text_lst, etiquetas, modelo, multi_etiqueta = Falso):
dispositivo = antorcha.dispositivo(“cuda” si antorcha.cuda.is_disponible() de lo contrario “cpu”)
classifier_pipeline = pipeline(“clasificación de tiro cero”, modelo = modelo, multi_label = multi_label, dispositivo=dispositivo)
presiones = []
#loop para cada texto en text_list
para input_sequence en tqdm(text_lst, total=len(text_lst)):
pred = classifier_pipeline(entrada_secuencia, etiquetas)
label_scores = dict(zip(pred[‘labels’]presa[‘scores’]))
preds.append(etiqueta_puntuaciones)
#almacenar las probabilidades de las etiquetas en un df
preds_df = pd.DataFrame(preds)
volver (preds_df)
La función tiene 4 entradas:
- text_lst: una lista de cadenas que representan los datos que se clasificarán.
- etiquetas: el conjunto de etiquetas para clasificar los datos en consecuencia.
- modelo: Una cadena que representa el modelo de clasificación de tiro cero a usar.
- multi_label: una bandera booleana que indica si el modelo debe generar varias etiquetas por secuencia de entrada.
Una vez que tenemos nuestra función de generador de etiquetas y la función para clasificar textos, podemos combinar las dos en un clasificador de tiro cero de extremo a extremo con poca intervención humana.
Así que ahora es el momento de juntarlos: end_to_end_zero_shot combina el código de generación de etiquetas con el clasificador de texto para proporcionar una solución integral para la clasificación de texto Zero-shot:
def end_to_end_zero_shot(dominio, text_lst, n_labels =Ninguno, modelo = “valhalla/distilbart-mnli-12-3”, multi_label = False):
etiquetas = get_zero_shot_labels(dominio, n_etiquetas = n_etiquetas)
imprimir (etiquetas)
user_input = input(“continuar con estas etiquetas (sí/no)”).lower()
si entrada_usuario == “sí”:
preds_df = zero_shot_classification(text_lst, etiquetas, modelo, multi_label = multi_label)
volver (preds_df)
demás:
print(‘modifique su solicitud y/o vuelva a intentarlo.’)
volver (etiquetas)
Estoy usando “valhalla/distilbart-mnli-12–3”, que es una versión destilada de bart-large-mnli (funciona más rápido), como mi modelo predeterminado, pero puede probarlo con otros.
En la función, también incluí user_input que solicita al usuario que examine las etiquetas propuestas por GPT antes de proceder a etiquetar el corpus.
Finalmente, aquí hay un ejemplo:
dominio = ‘reseñas de restaurantes’
texto_lst = [ “The food was amazing!”,
“The service was slow and the staff was unfriendly.”,
“The ambiance was perfect for a romantic dinner.”,
“The prices were too high for the quality of the food.”,
“I highly recommend this restaurant!”]
resultados = end_to_end_zero_shot(dominio, text_lst, n_labels =Ninguno, modelo = “valhalla/distilbart-mnli-12-3”, multi_label = False)
[‘Food quality’, ‘Service quality’, ‘Price’, ‘Atmosphere’, ‘Location’, ‘Menu’, ‘Dietary restrictions’]
proceder con estas etiquetas (sí/no)sí
100%|██████████| 5/5 [00:09<00:00, 1.85s/it]
Nota final
En este artículo, discutimos cómo implementar un algoritmo de clasificación de texto Zero-shot que automatiza el proceso de generación de etiquetas usando GPT-3 (o GPT4, ¡aún mejor!). Para esta implementación, asumo que el corpus que estamos etiquetando pertenece a un dominio determinado (por lo tanto, las etiquetas producidas por GPT-3 serán relevantes)
Agradezco cualquier comentario y crítica constructiva! Mi e-mail es [email protected]
Publicado a través de Hacia la IA
