A Coding Implementation of Accelerating Active Learning Annotation with Adala and Google Gemini

In this tutorial, we will learn how to take advantage of the Adala framework to build a standard active educational pipeline to classify medical symptoms. We start installing Adala and verifying it along with the required dependencies, then combining Google Gemini as a suspension dedicated to classifying symptoms in pre -determined medical fields. Through the active learning ring consisting of three indicators, giving priority to critical symptoms such as chest pain, we will see how to choose classification confidence and perception of it, and gain practical visions in the typical behavior and architecture of Adala.

!pip install -q git+https://github.com/HumanSignal/Adala.git
!pip list | grep adala

We install the latest Adala version directly from its GitHub warehouse. At the same time, the subsequent PIP menu Grep Adala Command wipes your environmental package menu for any “Adala” entries, providing a quick confirmation that the library has been successfully installed.

import sys
import os
print("Python path:", sys.path)
print("Checking if adala is in installed packages...")
!find /usr/local -name "*adala*" -type d | grep -v "__pycache__"




!git clone https://github.com/HumanSignal/Adala.git
!ls -la Adala

We print the current search paths of the Python stereotype and then look at the guide /local /local for any installed “Adala” folders (except __Pycache__) to check that the package is available. Next, the Adala Github warehouse in your business guide and lists its contents so that you can confirm that all source files have been properly brought.

import sys
sys.path.append('/content/Adala')

By attaching the cloned Adala folder to SYS.Path, we ask Python treatment /content /Adala as an imported package. This ensures that the subsequent import phrases adala … will be downloaded directly from your local cloning instead of (or in addition to) any fixed version.

!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 getpass

We install Google Generative AI SDK along with data analysis and library planning (Pandas and Matplotlib), then importing key units, Genai to interact with Gemini, Pandas for schedule, JSON and R for specifications, and Numby numerical operations, Matplotlib.plot for photography.

try:
    from Adala.adala.annotators.base 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...")

This attempt/except for the loading of the basic chapters of Adala, Baseannotatur, Randomstrategy, TextSAMPLE, and SignedSample so that we can benefit from its compact conditions and sampling strategies. Upon success, it confirms that Adala’s ingredients are available; If any import fails, it holds the error, prints the exclusion message, and returns to the simplest application.

GEMINI_API_KEY = getpass("Enter your Gemini API Key: ")
genai.configure(api_key=GEMINI_API_KEY)

We ask you safely to enter the API Gemini key without echo into the notebook. Then we create a Google Generative Ai (Genai) client with this key to ratify all subsequent calls.

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 results

We define a list of medical groups and implement the Geminiannotator category that wraps the Google Gemini generation model to classify symptoms. In the explanatory comments method, it creates a directive that belongs to JSON for each text sample, distributes the form of the form in an organized poster, a degree of confidence, interpretation, and wraps these in objects with lightweight signs, and retreat to a “unknown” label in the event of any errors.

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 = []

We define a list of raw symptom chains and turn each of them in a lightweight text object to pass to the teacher. Then it installs Geminiannotator with the pre -defined category set and prepares an empty menu called _ Samples to store the results of the upcoming explanatory comments.

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]}...")

This active learning loop works for three repetitions, each time you filter the already allowed samples and set a basic degree of 0.1 – moved by 0.5 for the main words such as “chest”, “heart” or “pain” – to determine the priorities of critical symptoms. Then he chooses the highest sample, and he calls Geminianotator to create a category, confidence and explanation, and print these details for the review.

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()

Finally, we extract the expected category stickers and dozens of confidence and use Matplotlib to draw a vertical strip chart, as it reflects the height of each of the model’s confidence in that category. The names of the categories are rotated for reading, and the title is added, and Trittle_Layout () ensures that the chart elements are arranged accurately before the view.

In conclusion, by combining the terms of delivery and operation in Adala, the Google Gemini sampling and the gynecology strategies, we have built a simplified workflow that repeatedly improves the quality of the comment on the medical text. This tutorial has walked through installation, preparation, and a dedicated geminiannotator, and showed how to implement priority -based samples and photograph confidence. With this basis, you can easily switch in other models, expand your categories set, or merge the most advanced active learning strategies to address the tasks of the largest and most complicated illustrations.

Payment Clap notebook here. All the credit for this research goes to researchers in this project. Also, do not hesitate to follow us twitter And do not forget to join 90k+ ml subreddit.

Here is a brief overview of what we build in Marktechpost: