Upload train_interface.py with huggingface_hub

train_interface.py

@@ -1,194 +1,75 @@
 import gradio as gr
-from huggingface_hub import HfApi, login
-import json
+from train_interface import start_training
 import os
-from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments, Trainer
-from datasets import load_dataset
-import traceback
-import torch
+from huggingface_hub import login
+import json
 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
+import sys
+
+print("=== Démarrage de l'application ===")
+print(f"Python version: {sys.version}")
+print(f"Working directory: {os.getcwd()}")
 
 # Charger la configuration
+print("\nChargement de 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()
+def create_interface():
+    # Configurer Hugging Face
+    print("\nConfiguration de Hugging Face...")
+    if not setup_huggingface():
+        print("Erreur : Impossible de configurer Hugging Face")
     
-    # 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."
-)
+    with gr.Blocks(theme="huggingface") as demo:
+        gr.Markdown("# AUTO Training Space")
+        
+        with gr.Row():
+            with gr.Column():
+                gr.Markdown(f"""
+                ### Configuration actuelle
+                - **Modèle** : {config['model']['name']}
+                - **Dataset** : {config['dataset']['name']}
+                - **Nombre d'époques** : {config['training']['epochs']}
+                
+                ### Format du dataset
+                Le dataset contient des exemples structurés avec :
+                - Une instruction (question utilisateur)
+                - Une entrée (contexte optionnel)
+                - Une sortie (réponse avec recommandations)
+                
+                ### Optimisations
+                - Utilisation de BF16 pour une meilleure performance
+                - Gestion optimisée des données avec pandas
+                """)
+        
+        with gr.Row():
+            with gr.Column():
+                status_output = gr.Textbox(
+                    label="Statut de l'entraînement",
+                    value="En attente de démarrage...",
+                    interactive=False
+                )
+                logs_output = gr.Markdown(
+                    value="### Logs d'entraînement\nLes logs seront affichés ici pendant l'entraînement."
+                )
+                
+                train_button = gr.Button("Démarrer l'entraînement")
+                train_button.click(
+                    fn=start_training,
+                    inputs=[],
+                    outputs=[status_output, logs_output]
+                )
+        
+        return demo
 
 if __name__ == "__main__":
-    demo.launch()
+    print("\nCréation de l'interface...")
+    demo = create_interface()
+
+    print("\nLancement de l'application...")
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        show_api=False
+    )