Upload train_interface.py with huggingface_hub

train_interface.py

@@ -0,0 +1,194 @@
+import gradio as gr
+from huggingface_hub import HfApi, login
+import json
+import os
+from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments, Trainer
+from datasets import load_dataset
+import traceback
+import torch
+from connect_huggingface import setup_huggingface
+from accelerate import Accelerator
+from accelerate.utils import set_seed
+from transformers import DataCollatorForLanguageModeling
+import pandas as pd
+from datetime import datetime
+
+# Charger la configuration
+with open('config.json', 'r') as f:
+    config = json.load(f)
+
+class TrainingCallback:
+    def __init__(self, status_box, log_box):
+        self.status_box = status_box
+        self.log_box = log_box
+        self.logs = []
+        
+    def on_log(self, args, state, control, logs=None):
+        if logs:
+            timestamp = datetime.now().strftime("%H:%M:%S")
+            log_entry = f"[{timestamp}] Loss: {logs.get('loss', 'N/A'):.4f}"
+            if 'eval_loss' in logs:
+                log_entry += f", Eval Loss: {logs['eval_loss']:.4f}"
+            self.logs.append(log_entry)
+            self.log_box.update(value="\n".join(self.logs[-20:]))  # Keep last 20 logs
+            
+    def on_step_end(self, args, state, control):
+        self.status_box.update(value=f"Étape {state.global_step}/{state.max_steps}")
+
+def format_prompt(instruction, input_text, output):
+    """Formate le prompt pour l'entraînement"""
+    if input_text and input_text.strip():
+        return f"### Instruction:\n{instruction}\n\n### Input:\n{input_text}\n\n### Response:\n{output}"
+    return f"### Instruction:\n{instruction}\n\n### Response:\n{output}"
+
+def preprocess_function(examples, tokenizer):
+    """Prétraite les données pour l'entraînement"""
+    # Créer les prompts
+    prompts = [
+        format_prompt(instruction, input_text, output)
+        for instruction, input_text, output in zip(
+            examples['instruction'], 
+            examples['input'], 
+            examples['output']
+        )
+    ]
+    
+    # Tokenizer les prompts avec padding
+    model_inputs = tokenizer(
+        prompts,
+        padding=True,
+        truncation=True,
+        max_length=512,
+        return_tensors=None
+    )
+    
+    # Créer les labels (décalés de 1 pour l'entraînement causal)
+    labels = model_inputs["input_ids"].copy()
+    
+    # Mettre -100 sur le padding pour l'ignorer dans la loss
+    for i, label in enumerate(labels):
+        labels[i] = [-100 if token == tokenizer.pad_token_id else token for token in label]
+    
+    model_inputs["labels"] = labels
+    return model_inputs
+
+def compute_metrics(eval_pred):
+    """Calcule les métriques d'évaluation"""
+    predictions, labels = eval_pred
+    # Convertir en tenseurs PyTorch
+    predictions = torch.tensor(predictions)
+    labels = torch.tensor(labels)
+    
+    # Calculer la loss
+    loss = torch.nn.functional.cross_entropy(
+        predictions.view(-1, predictions.size(-1)),
+        labels.view(-1),
+        ignore_index=-100
+    )
+    
+    return {
+        "loss": loss.item()
+    }
+
+def start_training(status_box=gr.Textbox(), log_box=gr.Markdown()):
+    """Lance l'entraînement du modèle"""
+    try:
+        # Configuration de Hugging Face
+        if not setup_huggingface():
+            return "Erreur : Impossible de configurer Hugging Face"
+        
+        status_box.update(value="Configuration de l'environnement...")
+        
+        # Charger le modèle et le tokenizer
+        tokenizer = AutoTokenizer.from_pretrained(
+            config['model']['name'],
+            trust_remote_code=True
+        )
+        model = AutoModelForCausalLM.from_pretrained(
+            config['model']['name'],
+            trust_remote_code=True,
+            torch_dtype=torch.bfloat16 if torch.cuda.is_available() else torch.float32
+        )
+        
+        # Configurer le tokenizer
+        tokenizer.pad_token = tokenizer.eos_token
+        
+        status_box.update(value="Chargement du dataset...")
+        
+        # Charger le dataset
+        dataset = load_dataset(config['dataset']['name'])
+        
+        # Prétraiter le dataset
+        tokenized_dataset = dataset.map(
+            lambda x: preprocess_function(x, tokenizer),
+            batched=True,
+            remove_columns=dataset["train"].column_names
+        )
+        
+        # Créer le data collator
+        data_collator = DataCollatorForLanguageModeling(
+            tokenizer=tokenizer,
+            mlm=False
+        )
+        
+        status_box.update(value="Configuration de l'entraînement...")
+        
+        # Configuration de l'entraînement
+        training_args = TrainingArguments(
+            output_dir=config['training']['output_dir'],
+            num_train_epochs=config['training']['epochs'],
+            per_device_train_batch_size=config['training']['batch_size'],
+            gradient_accumulation_steps=config['training']['gradient_accumulation_steps'],
+            learning_rate=float(config['training']['learning_rate']),
+            bf16=config['training'].get('bf16', True),
+            logging_steps=10,
+            evaluation_strategy="steps",
+            eval_steps=100,
+            save_strategy="steps",
+            save_steps=100,
+            save_total_limit=1,
+            load_best_model_at_end=True,
+        )
+        
+        # Créer le callback
+        callback = TrainingCallback(status_box, log_box)
+        
+        # Créer le trainer
+        trainer = Trainer(
+            model=model,
+            args=training_args,
+            train_dataset=tokenized_dataset["train"],
+            eval_dataset=tokenized_dataset["validation"] if "validation" in tokenized_dataset else None,
+            tokenizer=tokenizer,
+            data_collator=data_collator,
+            compute_metrics=compute_metrics,
+            callbacks=[callback]
+        )
+        
+        status_box.update(value="Démarrage de l'entraînement...")
+        
+        # Lancer l'entraînement
+        trainer.train()
+        
+        # Sauvegarder le modèle final
+        trainer.save_model()
+        
+        status_box.update(value="Entraînement terminé !")
+        return "Entraînement terminé avec succès !"
+        
+    except Exception as e:
+        error_msg = f"Erreur pendant l'entraînement : {str(e)}\n{traceback.format_exc()}"
+        print(error_msg)
+        return error_msg
+
+# Interface Gradio
+demo = gr.Interface(
+    fn=start_training,
+    inputs=[gr.Textbox(label="Statut de l'entraînement"), gr.Markdown(label="Logs de l'entraînement")],
+    outputs=[gr.Textbox(label="Statut de l'entraînement"), gr.Markdown(label="Logs de l'entraînement")],
+    title="AUTO Training Space",
+    description="Cliquez sur le bouton pour lancer l'entraînement du modèle."
+)
+
+if __name__ == "__main__":
+    demo.launch()