Apply for AI Grants India

Indian weather advisories are a strong fine-tuning use case—but only if you define the task precisely. A model that classifies cyclone warnings, extracts rainfall thresholds, translates alerts, or drafts farmer-facing messages needs a different dataset and training setup from a model that predicts temperature or rainfall. Hugging Face is well suited to the language layer of this work; it is not a substitute for a numerical forecasting system.

This guide shows how to build a responsible prototype using advisory text and structured labels, with examples relevant to IMD-style warnings, district-level communication, and multilingual delivery.

Choose the right modelling task

Start with one measurable outcome. Common options include:

• Classification: assign hazard, severity, crop impact, or recommended action labels.
• Information extraction: identify locations, dates, rainfall ranges, wind speeds, warning colours, and affected sectors.
• Summarisation: convert a technical bulletin into a short public advisory.
• Controlled generation: draft messages in English or an Indian language using verified inputs.
• Translation: adapt an advisory while preserving units, place names, times, and warning levels.

Do not use a text model to make unsupported weather predictions. For forecasting, combine meteorological observations and numerical weather prediction outputs with a time-series model, then use a language model only to explain verified results. Teams exploring broader model development can also review these best practices for fine-tuning LLMs on custom data.

Build a trustworthy Indian advisory dataset

Use authoritative sources such as published India Meteorological Department bulletins, state disaster-management notices, and clearly licensed historical datasets. Record provenance for every row: source URL, publication time, issuing agency, language, geography, and licence or access conditions.

A practical JSONL record for classification might look like this:

{"text":"Heavy to very heavy rainfall likely at isolated places over Konkan and Goa on 18 July.","label":"heavy_rain","state":"Goa","language":"en","issued_at":"2025-07-17T12:00:00+05:30","source":"official_bulletin_url"}

For instruction tuning, use a structured format that makes the desired behaviour explicit:

{"messages":[{"role":"system","content":"Rewrite advisories clearly. Do not add facts."},{"role":"user","content":"Summarise this bulletin for farmers in Marathi: ..."},{"role":"assistant","content":"..."}]}

Before training:

• Remove duplicate bulletins and boilerplate that appears across every split.
• Normalise district, state, and place names, but retain the original text.
• Preserve Indian date formats, IST timestamps, millimetres, kilometres per hour, and warning colours.
• Separate languages rather than silently mixing scripts or transliterations.
• Mask phone numbers, personal data, and accidental credentials.
• Check licences and redistribution rights before uploading data to a public Hub repository.

Random row-level splitting can inflate results because successive advisories often repeat the same wording. Split by date, event, geography, or bulletin series so validation reflects future and unseen conditions.

Select a model and prepare the environment

For a small classification or extraction task, start with a compact multilingual encoder that supports the scripts in your dataset. For generation, use a small instruction-tuned causal model and parameter-efficient fine-tuning such as LoRA or QLoRA. Evaluate English, Hindi, and any additional target language independently; a single aggregate score can hide poor performance in one language.

Create an isolated environment and install current libraries:

python -m venv .venv
source .venv/bin/activate
pip install -U transformers datasets evaluate accelerate peft torch
huggingface-cli login

Load a local dataset with the datasets library:

from datasets import load_dataset

data = load_dataset("json", data_files={
    "train": "data/train.jsonl",
    "validation": "data/validation.jsonl",
    "test": "data/test.jsonl",
})

For classification, tokenise the advisory text and map labels to integer IDs. For generation, mask the loss where appropriate so the model learns from the assistant response rather than reproducing the prompt. Keep a small, untouched test set for final reporting.

Fine-tune with reproducible settings

A classification run using Trainer can be configured like this:

from transformers import AutoTokenizer, AutoModelForSequenceClassification
from transformers import TrainingArguments, Trainer

checkpoint = "your-compatible-multilingual-checkpoint"
tokenizer = AutoTokenizer.from_pretrained(checkpoint)

encoded = data.map(
    lambda batch: tokenizer(batch["text"], truncation=True, max_length=256),
    batched=True,
)
model = AutoModelForSequenceClassification.from_pretrained(
    checkpoint, num_labels=len(label_names),
)

args = TrainingArguments(
    output_dir="weather-advisory-model",
    learning_rate=2e-5,
    num_train_epochs=3,
    per_device_train_batch_size=16,
    per_device_eval_batch_size=32,
    eval_strategy="epoch",
    save_strategy="epoch",
    load_best_model_at_end=True,
    metric_for_best_model="f1",
    report_to="none",
)

trainer = Trainer(
    model=model,
    args=args,
    train_dataset=encoded["train"],
    eval_dataset=encoded["validation"],
    processing_class=tokenizer,
)
trainer.train()

Treat these values as a starting point, not a recipe. Tune sequence length, learning rate, batch size, class weights, and LoRA rank against a fixed validation set. Track the base checkpoint, dataset version, random seed, hardware, and training configuration in a model card.

Evaluate safety and usefulness—not just accuracy

Report macro-F1, per-class precision and recall, and a confusion matrix for imbalanced hazards. For extraction, measure entity-level precision, recall, and exactness of critical fields. For summarisation or translation, combine automatic metrics with review by speakers familiar with the target language and weather terminology.

Create targeted test slices for:

• Rare cyclones, floods, heatwaves, and lightning events.
• Similar district and village names.
• Mixed English-Hindi text and regional scripts.
• Conflicting or revised bulletins.
• Missing values, abbreviations, and unusual units.
• Advisories containing “no warning” or conditional language.

A useful production rule is to return the source bulletin, extracted facts, confidence, and timestamp alongside generated text. Require human approval for evacuation, health, school-closure, or agricultural actions. The model should abstain when the source is stale, ambiguous, or outside its supported geography.

Publish and deploy on Hugging Face

Push the model, tokenizer, label mapping, evaluation results, and a concise model card to a private or public repository only after checking data rights. Document intended use, prohibited use, languages, geographic coverage, known failure modes, and the date range of training data.

Use the Hugging Face Hub for versioning and a controlled inference service for production. Add authentication, rate limits, audit logs, caching, and a rollback path. Do not expose unrestricted generation if users may interpret drafts as official warnings. For multilingual product interfaces, pair the model with tested translation and voice layers; related open-source vision-language models for Indian languages may help when advisories include maps, symbols, or image-based bulletins.

A practical launch checklist

• Define one task and its failure tolerance.
• Verify source permissions and retain provenance.
• Split by time or weather event, not only randomly.
• Benchmark the base model before fine-tuning.
• Evaluate each language, hazard, and region separately.
• Test abstention, stale data, and bulletin revisions.
• Keep official source links and timestamps visible to users.
• Pilot with meteorologists, disaster managers, or domain experts.
• Monitor drift as terminology, districts, and communication formats change.

For an India-focused AI product, technical quality is only one part of readiness. If you are building a weather, climate, agriculture, or public-safety system, explore Indian open-source AI developer projects for implementation patterns and consider support through AI Grants India.