En este tutorial, aprenderemos a rendir el Adala Entorno para construir una tubería de formación activa modular para la clasificación de síntomas médicos. Comenzamos instalando y verificando a Adala cercano con las dependencias requeridas, luego integramos Google Gemini como un anotador personalizado para clasificar los síntomas en dominios médicos predefinidos. A través de un simple caracolillo de formación activo de tres iteración, priorizando síntomas críticos como el dolor en el pecho, veremos cómo preferir, anotar y visualizar la confianza de la clasificación, obteniendo información praxis sobre el comportamiento del maniquí y la casa desplegable de Adala.
!pip install -q git+https://github.com/HumanSignal/Adala.git
!pip list | grep adalaInstalamos la última interpretación de Adala directamente desde su repositorio de GitHub. Al mismo tiempo, la tira PIP posterior | El comando GREP ADALA escanea la tira de paquetes de su entorno para cualquier entrada que contenga «Adala», proporcionando una confirmación rápida de que la biblioteca se instaló correctamente.
import sys
import os
print("Python path:", sys.path)
print("Checking if adala is in installed packages...")
!find /usr/restringido -name "*adala*" -type d | grep -v "__pycache__"
!git clone https://github.com/HumanSignal/Adala.git
!ls -la AdalaImprimimos sus rutas de búsqueda de módulos Python actuales y luego buscamos el directorio /usr /restringido para cualquier carpeta «adala» instalada (excluyendo __pycache__) para efectuar que el paquete esté apto. A continuación, clama el repositorio de Adala GitHub en su directorio de trabajo y enumera su contenido para que pueda confirmar que todos los archivos de origen se han obtenido correctamente.
import sys
sys.path.append('/content/Adala')Al juntar la carpeta ADALA clonada al sys.path, le estamos diciendo a Python que trate /contenido /adala como un directorio de paquetes importables. Esto asegura que las declaraciones de importación posteriores … las declaraciones se cargarán directamente desde su clon restringido en punto de (o por otra parte de) cualquier interpretación instalada.
!pip install -q google-generativeai pandas matplotlib
import google.generativeai as genai
import pandas as pd
import json
import re
import numpy as np
import matplotlib.pyplot as plt
from getpass import getpassInstalamos el SDK de AI Generativo de Google cercano con el exploración de datos y las bibliotecas de trazado (pandas y matplotlib), luego importar módulos secreto, Genai para interactuar con Gemini, pandas para datos tabulares, JSON y RE para analizar, Numpy para operaciones numéricas, matlotlib.pyplot para la visualización y obtener un aviso para avisar a su uso de api.
try:
from Adala.adala.annotators.almohadilla import BaseAnnotator
from Adala.adala.strategies.random_strategy import RandomStrategy
from Adala.adala.utils.custom_types import TextSample, LabeledSample
print("Successfully imported Adala components")
except Exception as e:
print(f"Error importing: {e}")
print("Falling back to simplified implementation...")Este intento/excepto el agrupación intenta cargar las clases centrales de Adala, BaseAnnotator, Randomstrategy, Textsample y LabeLedSample para que podamos rendir sus anotadores incorporados y estrategias de muestreo. Sobre el éxito, confirma que los componentes ADALA están disponibles; Si alguna importación error, captura el error, imprime el mensaje de excepción y se vuelve a una implementación más simple.
GEMINI_API_KEY = getpass("Enter your Gemini API Key: ")
genai.configure(api_key=GEMINI_API_KEY)Le solicitamos de forma segura que ingrese su secreto de la API Gemini sin hacerla eco de la cuaderno. Luego configuramos el cliente AI Generativo de Google (Genai) con esa secreto para autenticar todas las llamadas posteriores.
CATEGORIES = ("Cardiovascular", "Respiratory", "Gastrointestinal", "Neurological")
class GeminiAnnotator:
def __init__(self, model_name="models/gemini-2.0-flash-lite", categories=None):
self.model = genai.GenerativeModel(model_name=model_name,
generation_config={"temperature": 0.1})
self.categories = categories
def annotate(self, samples):
results = ()
for sample in samples:
prompt = f"""Classify this medical symptom into one of these categories:
{', '.join(self.categories)}.
Return JSON format: {{"category": "selected_category",
"confidence": 0.XX, "explanation": "brief_reason"}}
SYMPTOM: {sample.text}"""
try:
response = self.model.generate_content(prompt).text
json_match = re.search(r'({.*})', response, re.DOTALL)
result = json.loads(json_match.group(1) if json_match else response)
labeled_sample = type('LabeledSample', (), {
'text': sample.text,
'labels': result("category"),
'metadata': {
"confidence": result("confidence"),
"explanation": result("explanation")
}
})
except Exception as e:
labeled_sample = type('LabeledSample', (), {
'text': sample.text,
'labels': "unknown",
'metadata': {"error": str(e)}
})
results.append(labeled_sample)
return resultsDefinimos una tira de categorías médicas e implementamos una clase GeminianNotator que envuelve el maniquí generativo de Google Gemini para la clasificación de síntomas. En su método de anotado, construye una solicitud de retorno de JSON para cada muestra de texto, analiza la respuesta del maniquí en una rótulo estructurada, puntaje de confianza y explicación, y envuelve a los que se encuentran en objetos de muestra etiquetados livianos, recurriendo a una rótulo «desconocida» si se producen errores.
sample_data = (
"Chest pain radiating to left arm during exercise",
"Persistent dry cough with occasional wheezing",
"Severe headache with sensitivity to light",
"Stomach cramps and nausea after eating",
"Numbness in fingers of right hand",
"Shortness of breath when climbing stairs"
)
text_samples = (type('TextSample', (), {'text': text}) for text in sample_data)
annotator = GeminiAnnotator(categories=CATEGORIES)
labeled_samples = ()Definimos una tira de cadenas de síntomas crudos y envolvemos cada una en un objeto de muestra de texto veloz para pasarlas al anotador. Luego instancia su geminiannotator con el conjunto de categorías predefinidos y prepara una tira de etiquetas de rótulo vacía para juntar los resultados de las próximas iteraciones de anotaciones.
print("nRunning Active Learning Loop:")
for i in range(3):
print(f"n--- Iteration {i+1} ---")
remaining = (s for s in text_samples if s not in (getattr(l, '_sample', l) for l in labeled_samples))
if not remaining:
break
scores = np.zeros(len(remaining))
for j, sample in enumerate(remaining):
scores(j) = 0.1
if any(term in sample.text.lower() for term in ("chest", "heart", "pain")):
scores(j) += 0.5
selected_idx = np.argmax(scores)
selected = (remaining(selected_idx))
newly_labeled = annotator.annotate(selected)
for sample in newly_labeled:
sample._sample = selected(0)
labeled_samples.extend(newly_labeled)
latest = labeled_samples(-1)
print(f"Text: {latest.text}")
print(f"Category: {latest.labels}")
print(f"Confidence: {latest.metadata.get('confidence', 0)}")
print(f"Explanation: {latest.metadata.get('explanation', '')(:100)}...")Este caracolillo de formación activo se ejecuta para tres iteraciones, cada vez que se filtran muestras ya marcadas y asigna una puntuación almohadilla de 0.1, impulsada por 0.5 para palabras secreto como «cofre», «corazón» o «dolor», para priorizar los síntomas críticos. Luego selecciona la muestra de anciano rendimiento, invoca el GeminianNotator para suscitar una categoría, confianza y explicación, e imprime esos detalles para la revisión.
categories = (s.labels for s in labeled_samples)
confidence = (s.metadata.get("confidence", 0) for s in labeled_samples)
plt.figure(figsize=(10, 5))
plt.bar(range(len(categories)), confidence, color="skyblue")
plt.xticks(range(len(categories)), categories, rotation=45)
plt.title('Classification Confidence by Category')
plt.tight_layout()
plt.show()Finalmente, extraemos las etiquetas de categoría predichas y sus puntajes de confianza y usamos matplotlib para trazar un descriptivo de barras tieso, donde la consideración de cada mostrador refleja la confianza del maniquí en esa categoría. Los nombres de la categoría se giran para legabilidad, se agrega un título y TITRE_LAYOUT () asegura que los utensilios del descriptivo estén ordenados ayer de la visualización.
En conclusión, al combinar los anotadores plug-and-play de Adala y las estrategias de muestreo con el poder generativo de Google Gemini, hemos construido un flujo de trabajo simplificado que mejoramiento iterativamente la calidad de la anotación en el texto médico. Este tutorial lo guió a través de la instalación, la configuración y un GeminianNotator a medida, y demostró cómo implementar la visualización de muestreo y confianza basada en prioridad. Con esta almohadilla, puede cambiar fácilmente en otros modelos, ampliar su conjunto de categorías o integrar estrategias de formación activo más avanzadas para enfrentarse tareas de anotación más grandes y más complejas.
Probar Cuaderno de colab aquí. Todo el crédito por esta investigación va a los investigadores de este esquema. Encima, siéntete independiente de seguirnos Gorjeo Y no olvides unirte a nuestro 90k+ ml de subreddit.
Aquí hay una breve descripción de lo que estamos construyendo en MarkTechPost:
Asif Razzaq es el CEO de MarktechPost Media Inc .. Como patrón e ingeniero iluminado, ASIF se compromete a rendir el potencial de la inteligencia fabricado para el perfectamente social. Su esfuerzo más flamante es el dispersión de una plataforma de medios de inteligencia fabricado, MarktechPost, que se destaca por su cobertura profunda de informativo de formación espontáneo y de formación profundo que es técnicamente sólido y fácilmente comprensible por una audiencia amplia. La plataforma cuenta con más de 2 millones de vistas mensuales, ilustrando su popularidad entre el conocido.