⚖️LexiMini: Comment j'ai construit un assistant juridique IA pour l'Inde - à partir de zéro, sur un TPU pour Windows 7,8,10,11

Affiner Gemma 3 4B sur les données de la loi indienne · MaxText · Distillation Tunix · HuggingFace

Ce blog documente l'approche derrière un pipeline LLM basé sur TPU que je suis en train de construire.

L’accent ici n’est pas seulement mis sur les résultats, mais sur la conception complète du système — comportement du modèle, stratégie de distillation, et les défis pratiques liés au travail avec les TPU dans une configuration réelle.

Au lieu de présenter un état final raffiné, Je décompose le processus réel: comment le système est structuré, quelles décisions ont été prises, et comment les différents composants ont évolué au fil du temps.

Vous trouverez tout ici — de la configuration à l'expérimentation — d'une manière qui reflète la construction du monde réel, pas seulement des scénarios idéaux.

Pourquoi LexiMini?

L'Inde a fini 1.4 milliards de personnes.

Pensez à une femme dans un village de l’Inde rurale. Son propriétaire menace de la expulser. Elle ne sait pas ce que signifie légalement un contrat de location. Elle ne sait pas qu'elle a des droits. Il n'y a pas d'avocat dans son village. Le tribunal de district le plus proche est à deux heures. Et même si elle y arrive — elle ne peut pas se permettre de payer quelqu'un pour expliquer ce qui est écrit dans ce contrat..

Ou pensez à une femme qui a contracté un petit prêt auprès d'un prêteur local.. Elle ne sait pas quel taux d'intérêt est légalement autorisé. Elle ne sait pas ce qu'elle peut faire lorsque les conditions changent du jour au lendemain.. Elle ne sait pas à qui s'adresser.

Ce ne sont pas des cas rares. C'est la vie quotidienne de millions de femmes dans les zones rurales de l'Inde — où l'éducation et l'accès à Internet sont encore limités., où les connaissances juridiques sont presque nulles, et où l'écart entre connaître ses droits et tout perdre n'est qu'un morceau de papier que tu ne peux pas comprendre.

Les gens normaux sont confrontés à ces situations tous les jours — contrats de locataire qu’ils ne peuvent pas lire, des prêts avec des conditions qu'ils ne comprenaient pas, le harcèlement au travail dont ils ne savent pas qu'il est illégal, conflits de propriété qu'ils ne savent pas comment combattre. Ce sont des problèmes ordinaires. Mais sans connaissances juridiques, les problèmes ordinaires deviennent des problèmes qui changent la vie.

Quand ils vont en ligne pour chercher des réponses, ils trouvent l'une des deux choses suivantes:

Un texte juridique dense qui a été écrit par des avocats, pour les avocats.

Ou réponses génériques de l'IA à partir de modèles qui n'ont jamais été formés au droit indien et qui donnent en toute confiance des informations erronées — qui, dans une situation juridique, peut causer un réel préjudice.

Je voulais construire quelque chose de différent. Un petit, une IA ciblée qui en fait sait Loi indienne — droits des locataires, accords de prêt, protections juridiques des femmes, Sections CIB, procédures de libération sous caution, procédures judiciaires. Pas un modèle général qui prétend savoir. Un spécialisé, construit pour les personnes qui en ont le plus besoin.

C'est LexiMini.

Le pipeline complet

Avant d'entrer dans les étapes, voici l'image complète de ce que j'ai construit:

Compartiment GitHub Repo TPU VM GCS
(Données sur la loi indienne) →  (Formation MaxText) → (Points de contrôle)
                                               ↓
                                     Modèle de visage câlin
                                     (Gemme 3 4B Affiné)
                                               ↓
                                     Distillation Tunisie
                                     (4Enseignant B → Étudiant 1B)
                                               ↓
                                     LexiMini Finale
                                     (Léger, Déployable)

Il y a quatre phases:

Phase 1 — Configurez la VM TPU et installez tout
Phase 2 — Préparer et télécharger l'ensemble de données sur la loi indienne
Phase 3 — Affiner Gemma 3 4B en utilisant MaxText
Phase 4 — Distiller le modèle 4B jusqu'à 1B en utilisant Tunix

Laissez-moi parcourir chacun d'eux.

Outils que j'ai utilisés

Outil Ce qu'il fait Google TPU VM (v6e) Puces matérielles TPU pour une formation rapide MaxText Cadre de formation LLM open source basé sur JAX de Google Tunix Post-formation de Google DeepMind + cadre de distillation, construit sur le stockage et le déploiement du modèle JAX HuggingFace Hub Google Cloud Storage (CGC) Stocke les données, poids, et points de contrôle pendant l'entraînement

Une remarque importante: Tout dans ce guide s'exécute directement sur le terminal TPU VM. Après vous être connecté en SSH, vous n'avez jamais besoin de revenir à votre machine locale.

Phase 1: Configuration de la machine virtuelle TPU

Le flux de configuration

Créer une machine virtuelle TPU → SSH dans → Installer des packages → Cloner MaxText → Installer JAX

Étape 1 — Créer la VM TPU

Laissez-moi être honnête sur quelque chose avant d'exécuter cette commande.

Un TPU v6 coûte environ $12–15$ par heure sur Google Cloud. Affiner un modèle 4B pour 5000 les étapes prennent plusieurs heures. La distillation ajoute encore plus. Le coût total de calcul de ce projet, payé de sa poche, serait complètement hors de portée pour la plupart des chercheurs ou étudiants indépendants.

J'ai pu le faire parce que j'ai reçu Crédits Google Cloud via le programme TPUSprint en tant qu'expert développeur Google (OÙ) en IA/ML.

Des crédits Google Cloud sont fournis pour ce projet. #TPUSprint

J'ai commencé par tout configurer à partir de zéro sur Google Cloud.

D'abord, J'ai créé un nouveau projet dans Google Cloud Platform. Une fois le projet prêt, J'ai atterri sur le tableau de bord principal.

De là, J'ai navigué vers Compute Engine → TPU. C'est ici que toutes les ressources TPU sont gérées.

Puisqu'aucun TPU n'a encore été créé, la page était vide. j'ai cliqué sur Créer un TPU pour démarrer la configuration.

Sur l'écran de création du TPU:

J'ai donné un nom au TPU (nœud-1)
Sélectionné le zone (nous-central1-a) — c'est important car la disponibilité du TPU dépend de la zone
Choisissez le Type de TPU (v5litepod-1 dans ce cas, en fonction de la disponibilité)
Sélectionné le Version du logiciel TPU (v2-alpha-tpuv5-lite)

J'ai gardé le reste des paramètres par défaut et j'ai cliqué sur Créer.

Une fois le nœud TPU créé, il apparaissait dans la liste TPU et était prêt à être utilisé.

Cliquez maintenant sur ssh pour ouvrir le terminal:

Pour référence, la même configuration peut également être effectuée à l'aide de CLI:

gcloud calcule tpus tpu-vm créer leximini-tpu \
  --zone=us-central2-b \
  --type d'accélérateur = v4-8 \
  --version=tpu-ubuntu2204-base

Un apprentissage clé ici: La configuration du TPU dépend fortement de la disponibilité. Vous devrez peut-être essayer différentes zones ou types de TPU avant d'en trouver un qui fonctionne..

Toutes les commandes présentées ci-dessous ont été exécutées directement à l'intérieur du terminal TPU VM après la connexion via SSH..

Étape 3 — Installer les packages système

sudo apt-get mise à jour && sudo apt-get install -y git python3-pip wget curl

Étape 4 — Clonez MaxText et installez JAX

MaxText est le cadre de formation de Google pour les grands modèles de langage. Il est construit sur JAX et conçu pour fonctionner nativement sur TPU — ce qui est exactement ce dont nous avons besoin ici.

CD ~
git clone https://github.com/google/maxtext.git
cd maxtext
pip install -r exigences.txt
pip installer jax[TPU] -f https://storage.googleapis.com/jax-releases/libtpu_releases.html

L'installation de JAX TPU prend le temps 5 minutes. Laissez-le finir complètement avant de continuer.

Phase 2: Préparation de l'ensemble de données sur le droit indien

Le flux de données

Texte juridique brut → Script Python → Seau GCS
(.SMS / .fichiers csv)      (convertir en JSONL)     (prêt pour MaxText)

Cette phase m'a pris plus de temps que prévu — pas à cause du code, mais à cause des données elles-mêmes.

J'ai organisé des textes juridiques indiens dans plusieurs catégories: Sections CIB, Procédures CrPC, articles constitutionnels, et extraits de jugements de justice. La curation compte. MaxText s'entraînera exactement sur ce que vous lui donnez. Déchets dans, garbage out — cela est particulièrement vrai pour les textes juridiques où la précision est primordiale.

Étape 5 — Clonez votre référentiel d'ensemble de données sur la VM TPU

CD ~
git clone https://github.com/YOUR_USERNAME/YOUR_REPO.git
cd VOTRE_REPO
ls

Étape 6 — Convertir les données au format JSONL

MaxText a besoin de données d'entraînement au format JSONL — un objet JSON par ligne, chacun avec une touche de texte. Voici le script de conversion:

Le système a été développé à partir de véritables ensembles de données juridiques. Cependant, pour des raisons de confidentialité, J'ai inclus uniquement des données synthétiques dans le référentiel public.

chat > préparer_data.py << 'EOF'
importer json

chat > préparer_data.py << 'EOF'
importer json

input_file  = 'indian_law.txt'   # changer au besoin
output_file = 'train_data.jsonl'

compter = 0

avec ouvert(fichier_entrée, 'r', encoding='utf-8') comme f_in, \
     ouvrir(fichier_sortie, 'w', encoding='utf-8') comme f_out:

pour la ligne dans f_in:
        ligne = ligne.strip()

# sauter les lignes vides ou très courtes
        sinon ligne ou objectif(doubler) < 20:
            continuer

enregistrement = {"text": doubler}
        f_out.écrire(json.dumps(enregistrer, assurer_ascii=Faux) + "\n")
        compter += 1

imprimer(f"Total records written: {compter}")
EOF

python3 préparer_data.py

Il s'agit d'une version simplifiée de l'étape de prétraitement. En pratique, une structuration et un formatage supplémentaires ont été appliqués pour améliorer la qualité de la formation.

Étape 7 — Créer un compartiment GCS et télécharger des données

MaxText ne lit pas le disque local pendant l'entraînement. Il lit à partir de Google Cloud Storage. Donc tout va d'abord à GCS:

# Créer le compartiment (choisissez un nom unique au monde)
gsutil mb -l us-central2 gs://VOTRE-NOM-SEAU

# Télécharger des données d'entraînement
gsutil cp ~/YOUR_REPO/data/train_data.jsonl gs://VOTRE-NOM-BUCKET/data/train_data.jsonl

# Vérifier
gsutil lsgs://VOTRE-NOM-BUCKET/data/

Phase 3: Gemma de réglage fin 3 4B avec MaxText

Le flux de formation

HF Weights GCS Télécharger le point de contrôle du train MaxText
(Gemme 3 4B)   →  (stocker les poids) →  (5000 mesures)    →  (enregistré dans GCS)

C'est le cœur du projet. Nous prenons Gemma 3 4B — Le modèle open source de Google — et lui enseigne tout sur le droit indien.

J'ai exécuté cette étape de formation deux fois. La première fois que j'ai mal configuré le chemin du point de contrôle et perdu des heures de calcul. Les petites erreurs coûtent cher sur le TPU. Vérifiez vos chemins GCS avant d'appuyer sur Entrée.

Étape 8 — Télécharger Gemma 3 4Poids B de HuggingFace

Vous avez besoin d'un compte HuggingFace et d'un jeton d'accès. Obtenez-le de: Huggingface.co → Paramètres → Jetons d'accès → Nouveau jeton.

pip installer huggingface_hub

python3 << 'EOF'
depuis huggingface_hub importer snapshot_download

téléchargement_instantané(
    repo_id='google/gemma3-4b-it',
    local_dir='/home/USER/gemma3-weights',   # remplacez USER par votre nom d'utilisateur (courir: whoami)
    token='hf_YOUR_TOKEN_HERE'
)
imprimer('Download complete!')
EOF

Étape 9 — Télécharger les poids sur GCS

# L'option -m permet le téléchargement parallèle - ne l'ignorez pas pour les fichiers volumineux
gsutil -m cp -r ~/gemma3-weights gs://VOTRE-NOM-SEAU/poids/gemma3-4b/

# Vérifier
gsutil lsgs://VOTRE-NOM-SEAU/poids/gemma3-4b/

Étape 10 — Exécuter le réglage fin

Tout se réunit ici. Une commande, et MaxText prend le relais:

cd ~/maxtext

cd ~/maxtext

python3 MaxText/train.py MaxText/configs/base.yml \
  base_output_directory=gs://VOTRE-NOM-BUCKET/sortie/ \
  load_parameters_path=gs://VOTRE-NOM-SEAU/poids/gemma3-4b/ \
  dataset_path=gs://VOTRE-NOM-BUCKET/data/ \
  nom_modèle = gemma3-4b \
  pas = 5000 \
  run_name=leximini-finetune

Paramètres de formation clés tels que le taux d'apprentissage, taille du lot, et la stratégie d'échauffement ont été ajustées de manière conservatrice pour préserver les connaissances pré-entraînées lors du réglage fin. De petits changements dans ces valeurs ont eu un impact notable sur la stabilité et la qualité de sortie.

Les points de contrôle sont enregistrés automatiquement tous les 500 étapes pour GS://VOTRE-NOM-BUCKET/output/leximini-finetune/checkpoints/

Regardez la valeur de la perte lors de son impression. Quand ça commence à baisser — ce moment est vraiment satisfaisant. Le modèle apprend le droit indien en temps réel.

Étape 11 — Convertir le point de contrôle au format HuggingFace

Après la formation, le point de contrôle est au format natif de MaxText. Nous devons le convertir au format HuggingFace pour qu'il puisse être utilisé avec la bibliothèque Transformers.:

cd ~/maxtext

python3 MaxText/convert_gpt_maxtext_to_hf.py \
  --base_model_path gs://VOTRE-NOM-SEAU/poids/gemma3-4b/ \
  --maxtext_model_path gs://VOTRE-NOM-BUCKET/output/leximini-finetune/checkpoints/5000/ \
  --chemin_sortie ~/leximini-4b-hf \
  --modèle_taille 4b

ls ~/leximini-4b-hf/

Étape 12 — Poussez le modèle 4B affiné vers HuggingFace

python3 << 'EOF'
à partir de huggingface_hub importer HfApi

feu = HfFire()

api.create_repo(
    repo_id='YOUR_HF_USERNAME/leximini-4b',
    token='hf_YOUR_TOKEN_HERE',
    privé=Faux
)

api.upload_folder(
    folder_path='/home/USER/leximini-4b-hf',
    repo_id='YOUR_HF_USERNAME/leximini-4b',
    repo_type='model',
    token='hf_YOUR_TOKEN_HERE'
)
imprimer('4B model uploaded!')
EOF

Phase 4: Distiller 4B → 1B avec Tunix

Le flux de distillation

LexiMini 4B Tunix Framework Gemma 3 1B
(Modèle d'enseignant)  →  (Distillation)      →  (Modèle étudiant)
                                               ↓
                                        LexiMini 1B
                                     (4x plus petit, presque
                                      aussi bien informé)

La mise au point est terminée. Mais un modèle paramétrique 4B est lourd. Son service est lent et coûteux à exploiter à grande échelle. Je voulais quelque chose de plus simple — quelque chose qui pourrait réellement toucher plus de personnes, y compris sur du matériel limité.

C'est là qu'intervient Tunix.

Qu'est-ce que la distillation des connaissances?

Pensez-y de cette façon. Imaginez un avocat chevronné qui pratique le droit indien depuis 20 années. Au lieu de demander à un jeune avocat de lire chaque dossier à partir de zéro, l'aîné s'assoit avec eux et leur explique le raisonnement — le pourquoi derrière chaque jugement, pas seulement le quoi.

Le jeune avocat apprend plus vite, et finit par devenir presque aussi capable — en une fraction du temps.

C'est de la distillation. Le modèle 4B (professeur) guide le modèle 1B (étudiant) reproduire la même compréhension juridique — mais dans un package beaucoup plus petit.

L'idée clé est la suivante: l'élève n'apprend pas seulement à partir d'étiquettes de texte brut. Il apprend de l’enseignant distribution de probabilité de sortie — qui est bien plus riche. Lorsque l'enseignant dit « Section 302 concerne le meurtre », cela ne se contente pas d'afficher cela sous forme de oui/non. Il génère une distribution sur des milliers de jetons — et cette distribution contient des informations nuancées sur les concepts associés., formulations alternatives, niveaux de confiance. L’étudiant absorbe tout ça.

Qu'est-ce que Tunis?

Tunix est un framework de post-formation open source construit par Google DeepMind sur JAX. Il gère des choses comme la distillation des connaissances, RLHF, et l'alignement du modèle — le travail qui se produit après préformation initiale. Il fonctionne nativement sur TPU et s'intègre parfaitement aux points de contrôle JAX.

Étape 13 — Installer Tunix

CD ~
git clone https://github.com/google-deepmind/tunix.git
CD-Tunix
pip installer -e .

Étape 14 — Télécharger Gemma 3 1Poids de base B

Le modèle étudiant part de Gemma 3 1Poids de base B:

python3 << 'EOF'
depuis huggingface_hub importer snapshot_download

téléchargement_instantané(
    repo_id='google/gemma-3-1b',
    local_dir='/home/USER/gemma3-1b-weights',
    token='hf_YOUR_TOKEN_HERE'
)
imprimer('1B base weights ready!')
EOF

# Télécharger sur GCS
gsutil -m cp -r ~/gemma3-1b-weights gs://VOTRE-NOM-SEAU/poids/gemma3-1b/

Étape 15 — Créer la configuration de distillation

chat > ~/tunix/configs/leximini_distill.py << 'EOF'
teacher_model_path  = 'gs://VOTRE-NOM-BUCKET/output/leximini-finetune/checkpoints/5000/'
student_model_path  = 'gs://VOTRE-NOM-SEAU/poids/gemma3-1b/'
output_path         = 'gs://VOTRE-NOM-SEAU/distillé/leximini-1b/'

chat > ~/tunix/configs/leximini_distill.py << 'EOF'

teacher_model_path  = 'gs://VOTRE-NOM-BUCKET/output/leximini-finetune/checkpoints/5000/'
student_model_path  = 'gs://VOTRE-NOM-SEAU/poids/gemma3-1b/'
output_path         = 'gs://VOTRE-NOM-SEAU/distillé/leximini-1b/'

teacher_model_name  = 'gemma3-4b'
student_model_name  = 'gemma3-1b'

train_data_path     = 'gs://VOTRE-NOM-BUCKET/data/train_data.jsonl'

# paramètres d'entraînement (simplifié pour plus de clarté)
étapes = 3000
max_target_length = 1024
température = 3.0 
alpha = 0.7

dtype               = 'bfloat16'

EOF

Deux paramètres qui comptent le plus:

température = 2.0 — Cela adoucit la répartition des résultats de l'enseignant. À température 1.0, le professeur donne des coups vifs, prédictions confiantes. À 2.0, la probabilité s'étend sur plus de jetons — donnant à l'étudiant plus riche, des signaux plus nuancés dont il faut tirer des leçons. Il s’agit de l’une des principales idées de l’article original sur la distillation des connaissances rédigé par Hinton et al..

alpha = 0.7–70% de la perte vient du jumelage avec l’enseignant. 30% provient des données brutes d'entraînement. Cet équilibre maintient l’étudiant ancré dans un véritable texte juridique tout en absorbant le raisonnement de l’enseignant..

En pratique, trouver le bon équilibre entre ces facteurs a nécessité des expérimentations, car différents paramètres peuvent avoir un impact significatif sur la façon dont le modèle d'étudiant conserve la précision.

Étape 16 — Exécuter la distillation

cd ~/tunix

python3 tunix/distillation/distill.py \
  --configconfigs/leximini_distill.py \
  --student_model_path gs://VOTRE-NOM-BUCKET/output/leximini-finetune/checkpoints/5000/ \
  --student_model_path gs://VOTRE-NOM-SEAU/poids/gemma3-1b/ \
  --chemin_sortie gs://VOTRE-NOM-SEAU/distillé/leximini-1b/ \
  --train_data gs://VOTRE-NOM-BUCKET/data/train_data.jsonl \
  --mesures 3000 \
  --taux_d'apprentissage 5e-5 \
  --par_device_batch_size 4 \
  --température 2.0 \
  --alpha 0.7 \
  --type bfloat16 \
  --run_name leximini-distillé

Étape 17 — Convertir le point de contrôle distillé et pousser vers HuggingFace

cd ~/maxtext

python3 MaxText/convert_gpt_maxtext_to_hf.py \
  --base_model_path gs://VOTRE-NOM-SEAU/poids/gemma3-1b/ \
  --maxtext_model_path gs://VOTRE-NOM-SEAU/distilled/leximini-1b/checkpoints/3000/ \
  --chemin_sortie ~/leximini-1b-hf \
  --modèle_taille 1b

ls ~/leximini-1b-hf/

python3 << 'EOF'
à partir de huggingface_hub importer HfApi

feu = HfFire()

api.create_repo(
    repo_id='YOUR_HF_USERNAME/leximini-1b-final',
    token='hf_YOUR_TOKEN_HERE',
    privé=Faux
)

api.upload_folder(
    folder_path='/home/USER/leximini-1b-hf',
    repo_id='YOUR_HF_USERNAME/leximini-1b-final',
    repo_type='model',
    token='hf_YOUR_TOKEN_HERE'
)
imprimer('LexiMini is live!')
EOF

Ce sur quoi je travaille encore

Je veux être transparent sur la situation actuelle de ce projet.

Le modèle affiné existe et fonctionne. Mais cela continue d’halluciner — surtout sur les sections juridiques les moins courantes. Il génère parfois des sections IPC plausibles qui n'existent pas. Il s'agit d'un problème connu avec les modèles de langage formés sur des données de domaine limitées, et j'y travaille activement.

Les domaines sur lesquels je me concentre en ce moment:

Plus de données — L'ensemble de données actuel couvre bien le cœur de la CIB et le droit constitutionnel. Protection des consommateurs, droit de la famille, droit de la propriété, et les lois spécifiques aux États doivent être plus couvertes.
Meilleur formatage des données — Passer des vidages de paragraphes bruts à des paires questions-réponses structurées, ce qui donne au modèle un signal d'apprentissage plus clair.
Réglage de la distillation — Le pipeline 4B → 1B est implémenté mais est toujours en cours de perfectionnement. L’élève de 1B a besoin de plus d’itérations pour assimiler pleinement le raisonnement juridique de l’enseignant.

Les liens GitHub et le modèle final seront ajoutés ici lorsque le projet atteindra une version stable., état fiable. Je préfère partager quelque chose qui fonctionne correctement plutôt que quelque chose qui a l'air impressionnant mais qui induit les gens en erreur sur leurs droits légaux..

Ce que j'ai appris en construisant ceci

Ce n'était pas la première fois que je travaillais avec le réglage fin. J'ai déjà utilisé des approches comme LoRA, QLoRA, et PEFT — ils sont fiables et produisent des résultats solides. Mais ils prennent aussi beaucoup de temps, surtout lorsque vous travaillez avec des ensembles de données plus volumineux et plusieurs itérations.

Ce qui m'a marqué dans ce projet, c'est le passage à une formation basée sur JAX utilisant MaxText.. La différence de vitesse était significative. Les charges de travail qui prendraient généralement des heures pourraient être exécutées en quelques minutes. Les performances du TPU sont évidemment un facteur important ici, mais l'outillage lui-même joue aussi un rôle majeur.

En même temps, cela est venu avec ses propres défis.

MaxText ne dispose pas du type d'écosystème ou de didacticiels adaptés aux débutants comme de nombreux flux de travail basés sur PyTorch.. Il n’y a pas un seul endroit où tout est expliqué clairement. J'ai dû me fier à la documentation, expérimentation, et exploration assistée par l'IA pour comprendre comment les choses fonctionnent réellement sous le capot.

La distillation était un autre domaine où les choses n'étaient pas simples. Pendant que le pipeline fonctionne, maintenir la précision reste un défi. J'expérimente activement pour trouver le bon équilibre entre compression et performances, surtout pour un domaine comme le texte juridique où la précision compte.

Un autre changement important dans ma façon de penser: Je ne veux pas seulement former des modèles — Je veux évoluer vers une formation centrée sur le raisonnement. C'est encore un travail en cours, et je continue d'explorer comment l'intégrer efficacement dans ce pipeline.

Dans l'ensemble, ce projet ne visait pas à apprendre les bases. Il s'agissait de combler les lacunes — documentation manquante, flux de travail peu clairs, et prendre des décisions pratiques dans un système en constante évolution.

Vue d'ensemble

Ce projet ne consiste pas à créer pour les développeurs — il s'agit de créer pour de vrais utilisateurs.

Une personne confrontée à un litige de locataire ou à un contrat de prêt déroutant n'utilisera pas de bloc-notes ni n'appellera une API.. Ils ont besoin de quelque chose de simple, accessible, et fiable — quelque chose qui fonctionne sur un Internet limité, parle un langage simple, et comprend le droit indien au-delà de la maîtrise superficielle.

C'est pourquoi la distillation est importante. Un modèle 4B est puissant, mais un modèle 1B bien optimisé peut fonctionner sur du matériel abordable, charger plus rapidement, et toucher beaucoup plus de personnes. L'objectif n'a jamais été l'échelle en soi – c'était la convivialité.

LexiMini continue d'évoluer. L'hallucination est un véritable défi, et je travaille activement à l'amélioration de la fiabilité. L'ensemble de données s'agrandit également, en particulier dans les domaines qui ont un impact sur la vie quotidienne — droit des locataires, microfinance, les droits des femmes, protection contre la violence domestique, héritage, et gouvernance locale.

Ce n'est pas fini — mais c'est réel, ça tourne, et il est construit avec un objectif clair: rendre le droit indien accessible à ceux qui en ont le plus besoin.

Cet article sera mis à jour au fur et à mesure de l'avancement du projet. Les liens vers le modèle et GitHub seront ajoutés lors de la version stable.

Construit avec MaxText · Tunix · JAX · HuggingFace

Reconnaissance: Des crédits Google Cloud sont fournis pour ce projet. #TPUSprint

⚖️LexiMini: Comment j'ai construit un assistant juridique IA pour l'Inde - à partir de zéro, sur un TPU a été initialement publié dans Google Developer Experts sur Medium, où les gens poursuivent la conversation en soulignant et en répondant à cette histoire.