Upload 8 files

demo-1.py

@@ -0,0 +1,150 @@
+"""
+Démonstration du framework Sitiai
+"""
+
+import numpy as np
+import sitiai
+
+print("=" * 60)
+print("Bienvenue dans Sitiai!")
+print("Framework Python pour créer et entraîner des IA légères")
+print("=" * 60)
+
+# ============================================
+# DEMO 1: IA GÉNÉRATIVE - Générateur de noms
+# ============================================
+
+print("\n\n📝 DÉMO 1: Générateur de Noms")
+print("-" * 60)
+
+# Créer une IA générative pour les noms
+print("\n1. Création d'une IA générative...")
+name_ai = sitiai.create.ai('generative', mode='name_generator')
+print(f"✓ {name_ai}")
+
+# Charger des données d'entraînement
+print("\n2. Chargement des données d'entraînement...")
+noms_francais = [
+    "Clemylia", "Alexandre", "Sophie", "Marie", "Pierre",
+    "Julien", "Camille", "Lucas", "Emma", "Hugo",
+    "Léa", "Thomas", "Chloé", "Nathan", "Manon",
+    "Baptiste", "Clara", "Antoine", "Juliette", "Maxime"
+]
+name_ai.load_data(noms_francais)
+print(f"✓ {len(noms_francais)} noms chargés")
+
+# Entraîner le modèle
+print("\n3. Entraînement du modèle...")
+name_ai.train(epochs=100)
+print("✓ Entraînement terminé!")
+
+# Générer de nouveaux noms
+print("\n4. Génération de nouveaux noms:")
+nouveaux_noms = name_ai.generate_batch(n=8, temperature=0.8)
+for i, nom in enumerate(nouveaux_noms, 1):
+    print(f"   {i}. {nom}")
+
+# ============================================
+# DEMO 2: IA DE PRÉDICTION LINÉAIRE
+# ============================================
+
+print("\n\n" + "=" * 60)
+print("📊 DÉMO 2: Prédiction Linéaire")
+print("-" * 60)
+
+# Créer des données synthétiques pour la régression
+print("\n1. Création de données synthétiques...")
+np.random.seed(42)
+n_samples = 200
+
+# Relation: y = 3*x1 + 2*x2 - x3 + 5 + bruit
+X_train = np.random.randn(n_samples, 3)
+y_train = 3 * X_train[:, 0] + 2 * X_train[:, 1] - X_train[:, 2] + 5
+y_train += np.random.randn(n_samples) * 0.5  # Ajouter du bruit
+
+X_test = np.random.randn(50, 3)
+y_test = 3 * X_test[:, 0] + 2 * X_test[:, 1] - X_test[:, 2] + 5
+y_test += np.random.randn(50) * 0.5
+
+print(f"✓ {n_samples} échantillons d'entraînement, 50 échantillons de test")
+
+# Créer une IA de prédiction linéaire
+print("\n2. Création d'une IA de prédiction linéaire...")
+linear_ai = sitiai.create.ai('linear', input_size=3, output_size=1, hidden_layers=[16, 8])
+print(f"✓ {linear_ai}")
+
+# Entraîner le modèle
+print("\n3. Entraînement du modèle (cela peut prendre quelques secondes)...")
+linear_ai.train(X_train, y_train, epochs=200, learning_rate=0.01, verbose=False)
+print("✓ Entraînement terminé!")
+
+# Évaluer le modèle
+print("\n4. Évaluation sur les données de test...")
+mse, r2 = linear_ai.evaluate(X_test, y_test)
+print(f"   • Erreur quadratique moyenne (MSE): {mse:.4f}")
+print(f"   • Score R² (coefficient de détermination): {r2:.4f}")
+
+# Faire quelques prédictions
+print("\n5. Exemples de prédictions:")
+for i in range(5):
+    x = X_test[i:i+1]
+    pred = linear_ai.predict(x)[0, 0]
+    real = y_test[i]
+    print(f"   Prédiction: {pred:.2f} | Réel: {real:.2f} | Erreur: {abs(pred - real):.2f}")
+
+# ============================================
+# DEMO 3: Utilisation de SitiNEUR directement
+# ============================================
+
+print("\n\n" + "=" * 60)
+print("🧠 DÉMO 3: Utilisation directe de SitiNEUR")
+print("-" * 60)
+
+print("\n1. Création d'une couche de neurones...")
+layer = sitiai.SitiNEUR(input_size=5, output_size=3, activation='relu')
+print(f"✓ {layer}")
+
+print("\n2. Test de propagation avant...")
+input_data = np.random.randn(2, 5)  # 2 exemples, 5 features
+output = layer.forward(input_data)
+print(f"   Entrée shape: {input_data.shape}")
+print(f"   Sortie shape: {output.shape}")
+print(f"   Sortie:\n{output}")
+
+# ============================================
+# DEMO 4: Sauvegarde et Chargement de Modèles
+# ============================================
+
+print("\n\n" + "=" * 60)
+print("💾 DÉMO 4: Sauvegarde et Chargement de Modèles")
+print("-" * 60)
+
+print("\n1. Sauvegarde du modèle linéaire...")
+linear_ai.save_weights('demo_linear_model.npz')
+
+print("\n2. Sauvegarde du générateur de noms...")
+name_ai.save_weights('demo_name_generator.npz')
+
+print("\n3. Test de chargement...")
+loaded_ai = sitiai.create.ai('linear', input_size=3, output_size=1, hidden_layers=[16, 8])
+loaded_ai.load_weights('demo_linear_model.npz')
+
+# Vérifier que ça fonctionne
+test_pred = loaded_ai.predict(X_test[0:1])
+print(f"   Prédiction avec modèle chargé: {test_pred[0, 0]:.2f}")
+
+# ============================================
+# Conclusion
+# ============================================
+
+print("\n\n" + "=" * 60)
+print("✨ Démonstration terminée!")
+print("=" * 60)
+print("\nSitiai vous permet de:")
+print("  • Créer des IA génératives pour générer des noms, textes, etc.")
+print("  • Créer des IA de prédiction linéaire pour la régression")
+print("  • Utiliser des couches de neurones SitiNEUR facilement")
+print("  • Sauvegarder et charger vos modèles (.npz)")
+print("  • Partager vos modèles facilement!")
+print("\nSyntaxe simple inspirée de PyTorch, mais plus accessible!")
+print("=" * 60)

example_save_load-1.py

@@ -0,0 +1,119 @@
+
+"""
+Exemple de sauvegarde et chargement de modèles Sitiai
+"""
+
+import numpy as np
+import sitiai
+
+print("=" * 60)
+print("Exemple: Sauvegarde et Chargement de Modèles")
+print("=" * 60)
+
+# ============================================
+# EXEMPLE 1: Modèle Linéaire
+# ============================================
+
+print("\n📊 EXEMPLE 1: Modèle de Régression Linéaire")
+print("-" * 60)
+
+# Créer des données
+np.random.seed(42)
+X_train = np.random.randn(100, 3)
+y_train = 3 * X_train[:, 0] + 2 * X_train[:, 1] - X_train[:, 2] + 5 + np.random.randn(100) * 0.5
+
+# Créer et entraîner le modèle
+print("\n1. Création et entraînement du modèle...")
+ai = sitiai.create.ai('linear', input_size=3, output_size=1, hidden_layers=[16, 8])
+ai.train(X_train, y_train, epochs=100, verbose=False)
+print(f"✓ Modèle entraîné: {ai}")
+
+# Faire une prédiction avant sauvegarde
+X_test = np.array([[1.0, 2.0, 0.5]])
+pred_before = ai.predict(X_test)
+print(f"\n2. Prédiction avant sauvegarde: {pred_before[0, 0]:.4f}")
+
+# Sauvegarder le modèle
+print("\n3. Sauvegarde du modèle...")
+ai.save_weights('my_linear_model.npz')
+
+# Créer un nouveau modèle et charger les poids
+print("\n4. Création d'un nouveau modèle et chargement des poids...")
+ai_loaded = sitiai.create.ai('linear', input_size=3, output_size=1, hidden_layers=[16, 8])
+ai_loaded.load_weights('my_linear_model.npz')
+
+# Vérifier que les prédictions sont identiques
+pred_after = ai_loaded.predict(X_test)
+print(f"\n5. Prédiction après chargement: {pred_after[0, 0]:.4f}")
+print(f"   Différence: {abs(pred_before[0, 0] - pred_after[0, 0]):.10f}")
+
+# ============================================
+# EXEMPLE 2: Modèle Génératif
+# ============================================
+
+print("\n\n" + "=" * 60)
+print("📝 EXEMPLE 2: Générateur de Noms")
+print("-" * 60)
+
+# Créer et entraîner le modèle
+print("\n1. Création et entraînement du modèle génératif...")
+name_ai = sitiai.create.ai('generative', mode='name_generator')
+noms = ["Alexandre", "Sophie", "Marie", "Pierre", "Julien", "Camille"]
+name_ai.load_data(noms)
+name_ai.train(epochs=100)
+print(f"✓ {name_ai}")
+
+# Générer avant sauvegarde
+print("\n2. Génération avant sauvegarde:")
+names_before = name_ai.generate_batch(n=3, temperature=0.8)
+for i, nom in enumerate(names_before, 1):
+    print(f"   {i}. {nom}")
+
+# Sauvegarder
+print("\n3. Sauvegarde du modèle...")
+name_ai.save_weights('name_generator.npz')
+
+# Charger dans un nouveau modèle
+print("\n4. Chargement dans un nouveau modèle...")
+name_ai_loaded = sitiai.create.ai('generative')
+name_ai_loaded.load_weights('name_generator.npz')
+
+# Générer après chargement
+print("\n5. Génération après chargement:")
+names_after = name_ai_loaded.generate_batch(n=3, temperature=0.8)
+for i, nom in enumerate(names_after, 1):
+    print(f"   {i}. {nom}")
+
+# ============================================
+# EXEMPLE 3: Partage de Modèle
+# ============================================
+
+print("\n\n" + "=" * 60)
+print("🌐 EXEMPLE 3: Partage de Modèle")
+print("-" * 60)
+
+print("""
+Vos modèles peuvent maintenant être partagés facilement!
+
+Exemples d'utilisation:
+1. Sauvegarder localement:
+   ai.save_weights('mon_modele.npz')
+
+2. Partager sur GitHub:
+   - Commitez le fichier .npz dans votre repo
+   - Les utilisateurs peuvent télécharger et charger avec load_weights()
+
+3. Publier sur un service cloud:
+   - Upload le fichier .npz
+   - Partagez le lien de téléchargement
+
+4. Intégrer dans une application:
+   - Incluez le fichier .npz dans votre package
+   - Chargez-le au démarrage de l'application
+
+Le format .npz est compact et compatible avec NumPy!
+""")
+
+print("=" * 60)
+print("✨ Démonstration terminée!")
+print("=" * 60)

generative.py

@@ -0,0 +1,196 @@
+"""
+Module pour les IA génératives légères
+"""
+
+import numpy as np
+from typing import List, Optional
+import random
+
+
+class GenerativeAI:
+    """
+    IA générative légère pour créer des noms et autres contenus
+    
+    Args:
+        mode: Mode de génération ('name_generator', 'text_generator')
+        **kwargs: Paramètres additionnels
+        
+    Example:
+        >>> from sitiai import create
+        >>> ai = create.ai('generative', mode='name_generator')
+        >>> ai.load_data(['Alice', 'Bob', 'Charlie', 'David'])
+        >>> ai.train(epochs=100)
+        >>> new_name = ai.generate()
+    """
+    
+    def __init__(self, mode: str = 'name_generator', **kwargs):
+        self.mode = mode
+        self.data = []
+        self.char_to_idx = {}
+        self.idx_to_char = {}
+        self.transition_matrix = None
+        self.is_trained = False
+        
+    def load_data(self, data: List[str]):
+        """
+        Charge les données d'entraînement
+        
+        Args:
+            data: Liste de chaînes de caractères pour l'entraînement
+        """
+        self.data = [d.lower() for d in data]
+        
+        # Créer le vocabulaire avec tokens spéciaux
+        all_chars = set(''.join(self.data))
+        all_chars.add('^')  # Token START
+        all_chars.add('$')  # Token END
+        
+        self.char_to_idx = {char: idx for idx, char in enumerate(sorted(all_chars))}
+        self.idx_to_char = {idx: char for char, idx in self.char_to_idx.items()}
+        
+    def train(self, epochs: int = 100, ngram_size: int = 2):
+        """
+        Entraîne le modèle génératif
+        
+        Args:
+            epochs: Nombre d'époques (non utilisé pour les n-grammes, mais conservé pour l'API)
+            ngram_size: Taille des n-grammes (par défaut 2 = bigrammes)
+        """
+        if not self.data:
+            raise ValueError("Aucune donnée chargée. Utilisez load_data() d'abord.")
+        
+        vocab_size = len(self.char_to_idx)
+        self.transition_matrix = np.zeros((vocab_size, vocab_size))
+        
+        # Compter les transitions
+        for word in self.data:
+            # Ajouter tokens START (^) et END ($)
+            extended_word = '^' + word + '$'
+            
+            for i in range(len(extended_word) - 1):
+                curr_char = extended_word[i]
+                next_char = extended_word[i + 1]
+                
+                curr_idx = self.char_to_idx[curr_char]
+                next_idx = self.char_to_idx[next_char]
+                
+                self.transition_matrix[curr_idx, next_idx] += 1
+        
+        # Normaliser pour obtenir des probabilités
+        row_sums = self.transition_matrix.sum(axis=1, keepdims=True)
+        row_sums[row_sums == 0] = 1  # Éviter division par zéro
+        self.transition_matrix = self.transition_matrix / row_sums
+        
+        self.is_trained = True
+        
+    def generate(self, max_length: int = 20, temperature: float = 1.0) -> str:
+        """
+        Génère un nouveau nom ou texte
+        
+        Args:
+            max_length: Longueur maximale de la génération
+            temperature: Contrôle la créativité (plus élevé = plus créatif)
+            
+        Returns:
+            Texte généré
+        """
+        if not self.is_trained:
+            raise ValueError("Le modèle n'est pas entraîné. Utilisez train() d'abord.")
+        
+        # Commencer par START (^)
+        current_idx = self.char_to_idx['^']
+        result = []
+        
+        for _ in range(max_length):
+            # Obtenir les probabilités pour le prochain caractère
+            probs = self.transition_matrix[current_idx].copy()
+            
+            # Appliquer la température
+            if temperature != 1.0:
+                probs = np.power(probs, 1.0 / temperature)
+                probs = probs / probs.sum()
+            
+            # Échantillonner le prochain caractère
+            if probs.sum() == 0:
+                break
+                
+            next_idx = np.random.choice(len(probs), p=probs)
+            next_char = self.idx_to_char[next_idx]
+            
+            # Si on atteint END ($), on s'arrête
+            if next_char == '$':
+                break
+                
+            result.append(next_char)
+            current_idx = next_idx
+        
+        return ''.join(result).capitalize()
+    
+    def generate_batch(self, n: int = 5, max_length: int = 20, temperature: float = 1.0) -> List[str]:
+        """
+        Génère plusieurs résultats
+        
+        Args:
+            n: Nombre de générations
+            max_length: Longueur maximale de chaque génération
+            temperature: Contrôle la créativité
+            
+        Returns:
+            Liste de textes générés
+        """
+        return [self.generate(max_length, temperature) for _ in range(n)]
+    
+    def save_weights(self, filepath: str):
+        """
+        Sauvegarde le modèle génératif dans un fichier
+        
+        Args:
+            filepath: Chemin du fichier de sauvegarde (.npz)
+            
+        Example:
+            >>> ai.save_weights('name_generator.npz')
+        """
+        if not filepath.endswith('.npz'):
+            filepath += '.npz'
+        
+        if not self.is_trained:
+            print("⚠️ Attention: Le modèle n'est pas entraîné")
+        
+        save_data = {
+            'transition_matrix': self.transition_matrix,
+            'char_to_idx': np.array(list(self.char_to_idx.items()), dtype=object),
+            'idx_to_char': np.array(list(self.idx_to_char.items()), dtype=object),
+            'mode': np.array([self.mode]),
+            'is_trained': np.array([self.is_trained])
+        }
+        
+        np.savez(filepath, **save_data)
+        print(f"✓ Modèle génératif sauvegardé dans '{filepath}'")
+    
+    def load_weights(self, filepath: str):
+        """
+        Charge un modèle génératif depuis un fichier
+        
+        Args:
+            filepath: Chemin du fichier de sauvegarde (.npz)
+            
+        Example:
+            >>> ai = sitiai.create.ai('generative')
+            >>> ai.load_weights('name_generator.npz')
+        """
+        if not filepath.endswith('.npz'):
+            filepath += '.npz'
+        
+        data = np.load(filepath, allow_pickle=True)
+        
+        self.transition_matrix = data['transition_matrix']
+        self.char_to_idx = dict(data['char_to_idx'])
+        self.idx_to_char = {int(k): v for k, v in data['idx_to_char']}
+        self.mode = str(data['mode'][0])
+        self.is_trained = bool(data['is_trained'][0])
+        
+        print(f"✓ Modèle génératif chargé depuis '{filepath}'")
+    
+    def __repr__(self):
+        status = "entraîné" if self.is_trained else "non entraîné"
+        return f"GenerativeAI(mode='{self.mode}', status='{status}')"

linear.py

@@ -0,0 +1,302 @@
+"""
+Module pour les IA de prédiction linéaire
+"""
+
+import numpy as np
+from typing import List, Tuple, Optional
+from .neuron import SitiNEUR
+
+
+class LinearAI:
+    """
+    IA de prédiction linéaire avec réseau de neurones
+    
+    Args:
+        input_size: Nombre de features en entrée
+        output_size: Nombre de sorties (1 pour régression simple)
+        hidden_layers: Liste des tailles des couches cachées
+        
+    Example:
+        >>> from sitiai import create
+        >>> ai = create.ai('linear', input_size=3, output_size=1, hidden_layers=[10, 5])
+        >>> ai.train(X_train, y_train, epochs=100)
+        >>> predictions = ai.predict(X_test)
+    """
+    
+    def __init__(self, input_size: int, output_size: int = 1, hidden_layers: Optional[List[int]] = None):
+        self.input_size = input_size
+        self.output_size = output_size
+        self.hidden_layers = hidden_layers or [10]
+        
+        # Construire le réseau
+        self.layers: List[SitiNEUR] = []
+        
+        # Première couche
+        layer_sizes = [input_size] + self.hidden_layers + [output_size]
+        
+        for i in range(len(layer_sizes) - 1):
+            # Utiliser 'relu' pour les couches cachées, 'linear' pour la sortie
+            activation = 'relu' if i < len(layer_sizes) - 2 else 'linear'
+            layer = SitiNEUR(
+                input_size=layer_sizes[i],
+                output_size=layer_sizes[i + 1],
+                activation=activation
+            )
+            self.layers.append(layer)
+        
+        self.is_trained = False
+        self.loss_history = []
+        
+        # Paramètres de normalisation
+        self.x_mean = None
+        self.x_std = None
+        self.y_mean = None
+        self.y_std = None
+        
+    def _normalize_X(self, X: np.ndarray, fit: bool = False) -> np.ndarray:
+        """Normalise les entrées"""
+        if fit:
+            self.x_mean = np.mean(X, axis=0)
+            self.x_std = np.std(X, axis=0) + 1e-8  # Éviter division par zéro
+        
+        return (X - self.x_mean) / self.x_std
+    
+    def _normalize_y(self, y: np.ndarray, fit: bool = False) -> np.ndarray:
+        """Normalise les sorties"""
+        if fit:
+            self.y_mean = np.mean(y, axis=0)
+            self.y_std = np.std(y, axis=0) + 1e-8  # Éviter division par zéro
+        
+        return (y - self.y_mean) / self.y_std
+    
+    def _denormalize_y(self, y: np.ndarray) -> np.ndarray:
+        """Dénormalise les prédictions"""
+        if self.y_mean is not None and self.y_std is not None:
+            return y * self.y_std + self.y_mean
+        return y
+    
+    def forward(self, x: np.ndarray) -> np.ndarray:
+        """
+        Propagation avant à travers tout le réseau
+        
+        Args:
+            x: Données d'entrée
+            
+        Returns:
+            Prédictions
+        """
+        output = x
+        for layer in self.layers:
+            output = layer.forward(output)
+        return output
+    
+    def train(self, X: np.ndarray, y: np.ndarray, epochs: int = 100, 
+              learning_rate: float = 0.01, batch_size: Optional[int] = None,
+              verbose: bool = True):
+        """
+        Entraîne le modèle sur les données
+        
+        Args:
+            X: Données d'entrée (shape: [n_samples, input_size])
+            y: Cibles (shape: [n_samples, output_size])
+            epochs: Nombre d'époques d'entraînement
+            learning_rate: Taux d'apprentissage
+            batch_size: Taille des mini-batches (None = batch complet)
+            verbose: Afficher les logs d'entraînement
+        """
+        # Convertir et vérifier les données
+        X = np.array(X, dtype=np.float64)
+        y = np.array(y, dtype=np.float64)
+        
+        # S'assurer que y est 2D
+        if y.ndim == 1:
+            y = y.reshape(-1, 1)
+        
+        # Vérifier qu'il n'y a pas de NaN dans les données
+        if np.any(np.isnan(X)) or np.any(np.isnan(y)):
+            raise ValueError("Les données contiennent des valeurs NaN")
+        
+        # Normaliser les données
+        X_norm = self._normalize_X(X, fit=True)
+        y_norm = self._normalize_y(y, fit=True)
+        
+        n_samples = X_norm.shape[0]
+        batch_size = batch_size or min(32, n_samples)
+        
+        self.loss_history = []
+        
+        for epoch in range(epochs):
+            # Mélanger les données
+            indices = np.random.permutation(n_samples)
+            X_shuffled = X_norm[indices]
+            y_shuffled = y_norm[indices]
+            
+            epoch_loss = 0
+            n_batches = 0
+            
+            # Entraînement par mini-batches
+            for i in range(0, n_samples, batch_size):
+                batch_X = X_shuffled[i:i + batch_size]
+                batch_y = y_shuffled[i:i + batch_size]
+                
+                # Forward pass
+                predictions = self.forward(batch_X)
+                
+                # Vérifier les NaN
+                if np.any(np.isnan(predictions)):
+                    if verbose:
+                        print(f"⚠️ NaN détecté à l'époque {epoch + 1}, arrêt de l'entraînement")
+                    break
+                
+                # Calculer la perte (MSE)
+                loss = np.mean((predictions - batch_y) ** 2)
+                epoch_loss += loss
+                n_batches += 1
+                
+                # Backward pass
+                grad = 2 * (predictions - batch_y) / batch_y.shape[0]
+                
+                for layer in reversed(self.layers):
+                    grad = layer.backward(grad, learning_rate)
+            
+            if n_batches == 0:
+                break
+                
+            avg_loss = epoch_loss / n_batches
+            self.loss_history.append(avg_loss)
+            
+            if verbose and (epoch + 1) % 10 == 0:
+                print(f"Époque {epoch + 1}/{epochs}, Perte: {avg_loss:.6f}")
+        
+        self.is_trained = True
+        
+        if verbose:
+            print(f"\n✓ Entraînement terminé! Perte finale: {self.loss_history[-1]:.6f}")
+    
+    def predict(self, X: np.ndarray) -> np.ndarray:
+        """
+        Fait des prédictions sur de nouvelles données
+        
+        Args:
+            X: Données d'entrée
+            
+        Returns:
+            Prédictions
+        """
+        if not self.is_trained:
+            print("⚠️ Attention: Le modèle n'est pas entraîné.")
+        
+        X = np.array(X, dtype=np.float64)
+        
+        # Normaliser les entrées si le modèle a été entraîné
+        if self.x_mean is not None:
+            X_norm = self._normalize_X(X, fit=False)
+            predictions_norm = self.forward(X_norm)
+            return self._denormalize_y(predictions_norm)
+        
+        return self.forward(X)
+    
+    def evaluate(self, X: np.ndarray, y: np.ndarray) -> Tuple[float, float]:
+        """
+        Évalue le modèle sur des données de test
+        
+        Args:
+            X: Données d'entrée
+            y: Vraies valeurs
+            
+        Returns:
+            (mse, r2_score)
+        """
+        predictions = self.predict(X)
+        y = np.array(y, dtype=np.float32)
+        
+        if y.ndim == 1:
+            y = y.reshape(-1, 1)
+        
+        # MSE
+        mse = np.mean((predictions - y) ** 2)
+        
+        # R² score
+        ss_res = np.sum((y - predictions) ** 2)
+        ss_tot = np.sum((y - np.mean(y)) ** 2)
+        r2 = 1 - (ss_res / ss_tot) if ss_tot != 0 else 0
+        
+        return mse, r2
+    
+    def save_weights(self, filepath: str):
+        """
+        Sauvegarde les poids du modèle dans un fichier
+        
+        Args:
+            filepath: Chemin du fichier de sauvegarde (.npz)
+            
+        Example:
+            >>> ai.save_weights('my_model.npz')
+        """
+        if not filepath.endswith('.npz'):
+            filepath += '.npz'
+        
+        weights_data = {}
+        
+        # Sauvegarder les poids de chaque couche
+        for i, layer in enumerate(self.layers):
+            layer_weights = layer.get_weights()
+            weights_data[f'layer_{i}_weights'] = layer_weights['weights']
+            weights_data[f'layer_{i}_bias'] = layer_weights['bias']
+        
+        # Sauvegarder les paramètres de normalisation
+        if self.x_mean is not None:
+            weights_data['x_mean'] = self.x_mean
+            weights_data['x_std'] = self.x_std
+            weights_data['y_mean'] = self.y_mean
+            weights_data['y_std'] = self.y_std
+        
+        # Sauvegarder la configuration
+        weights_data['input_size'] = np.array([self.input_size])
+        weights_data['output_size'] = np.array([self.output_size])
+        weights_data['hidden_layers'] = np.array(self.hidden_layers)
+        weights_data['is_trained'] = np.array([self.is_trained])
+        
+        np.savez(filepath, **weights_data)
+        print(f"✓ Modèle sauvegardé dans '{filepath}'")
+    
+    def load_weights(self, filepath: str):
+        """
+        Charge les poids du modèle depuis un fichier
+        
+        Args:
+            filepath: Chemin du fichier de sauvegarde (.npz)
+            
+        Example:
+            >>> ai = sitiai.create.ai('linear', input_size=3, output_size=1)
+            >>> ai.load_weights('my_model.npz')
+        """
+        if not filepath.endswith('.npz'):
+            filepath += '.npz'
+        
+        data = np.load(filepath, allow_pickle=True)
+        
+        # Charger les poids de chaque couche
+        for i, layer in enumerate(self.layers):
+            weights_dict = {
+                'weights': data[f'layer_{i}_weights'],
+                'bias': data[f'layer_{i}_bias']
+            }
+            layer.set_weights(weights_dict)
+        
+        # Charger les paramètres de normalisation
+        if 'x_mean' in data:
+            self.x_mean = data['x_mean']
+            self.x_std = data['x_std']
+            self.y_mean = data['y_mean']
+            self.y_std = data['y_std']
+        
+        # Charger le statut
+        if 'is_trained' in data:
+            self.is_trained = bool(data['is_trained'][0])
+        
+        print(f"✓ Modèle chargé depuis '{filepath}'")
+    
+    def __repr__(self):
+        status = "entraîné" if self.is_trained else "non entraîné"
+        return f"LinearAI(architecture={[self.input_size] + self.hidden_layers + [self.output_size]}, status='{status}')"

neuron.py

@@ -0,0 +1,140 @@
+"""
+Module contenant la couche de neurones SitiNEUR
+Syntaxe inspirée de PyTorch mais simplifiée
+"""
+
+import numpy as np
+
+
+class SitiNEUR:
+    """
+    Couche de neurones simplifiée pour Sitiai
+    
+    Args:
+        input_size: Nombre d'entrées
+        output_size: Nombre de sorties
+        activation: Fonction d'activation ('relu', 'sigmoid', 'tanh', 'linear')
+        
+    Example:
+        >>> from sitiai import SitiNEUR
+        >>> layer = SitiNEUR(input_size=10, output_size=5, activation='relu')
+        >>> output = layer.forward(input_data)
+    """
+    
+    def __init__(self, input_size: int, output_size: int, activation: str = 'relu'):
+        self.input_size = input_size
+        self.output_size = output_size
+        self.activation = activation
+        
+        # Initialisation des poids et biais (He initialization pour ReLU, Xavier pour autres)
+        if activation == 'relu':
+            self.weights = np.random.randn(input_size, output_size) * np.sqrt(2.0 / input_size)
+        else:
+            self.weights = np.random.randn(input_size, output_size) * np.sqrt(1.0 / input_size)
+        self.bias = np.zeros(output_size)
+        
+        # Pour la rétropropagation
+        self.last_input = None
+        self.last_output = None
+        self.last_z = None
+        
+    def forward(self, x: np.ndarray) -> np.ndarray:
+        """
+        Propagation avant
+        
+        Args:
+            x: Données d'entrée (shape: [batch_size, input_size])
+            
+        Returns:
+            Sortie de la couche (shape: [batch_size, output_size])
+        """
+        self.last_input = x
+        
+        # Calcul: y = x @ weights + bias
+        self.last_z = np.dot(x, self.weights) + self.bias
+        
+        # Application de la fonction d'activation
+        self.last_output = self._apply_activation(self.last_z)
+        return self.last_output
+    
+    def backward(self, grad_output: np.ndarray, learning_rate: float = 0.01) -> np.ndarray:
+        """
+        Rétropropagation du gradient
+        
+        Args:
+            grad_output: Gradient de la sortie
+            learning_rate: Taux d'apprentissage
+            
+        Returns:
+            Gradient pour la couche précédente
+        """
+        # Clip gradient output to prevent explosion
+        grad_output = np.clip(grad_output, -10, 10)
+        
+        # Gradient de la fonction d'activation
+        if self.activation == 'relu':
+            grad_activation = (self.last_z > 0).astype(float)
+        else:
+            grad_activation = self._activation_gradient(self.last_output)
+        
+        grad_z = grad_output * grad_activation
+        
+        # Clip intermediate gradients
+        grad_z = np.clip(grad_z, -10, 10)
+        
+        # Gradients des poids et biais
+        grad_weights = np.dot(self.last_input.T, grad_z)
+        grad_bias = np.sum(grad_z, axis=0)
+        
+        # Clip parameter gradients
+        grad_weights = np.clip(grad_weights, -1, 1)
+        grad_bias = np.clip(grad_bias, -1, 1)
+        
+        # Mise à jour des paramètres
+        self.weights -= learning_rate * grad_weights
+        self.bias -= learning_rate * grad_bias
+        
+        # Gradient pour la couche précédente
+        grad_input = np.dot(grad_z, self.weights.T)
+        return grad_input
+    
+    def _apply_activation(self, z: np.ndarray) -> np.ndarray:
+        """Applique la fonction d'activation"""
+        if self.activation == 'relu':
+            return np.maximum(0, z)
+        elif self.activation == 'sigmoid':
+            return 1 / (1 + np.exp(-np.clip(z, -500, 500)))
+        elif self.activation == 'tanh':
+            return np.tanh(z)
+        elif self.activation == 'linear':
+            return z
+        else:
+            raise ValueError(f"Activation inconnue: {self.activation}")
+    
+    def _activation_gradient(self, output: np.ndarray) -> np.ndarray:
+        """Calcule le gradient de la fonction d'activation"""
+        if self.activation == 'relu':
+            return (output > 0).astype(float)
+        elif self.activation == 'sigmoid':
+            return output * (1 - output)
+        elif self.activation == 'tanh':
+            return 1 - output ** 2
+        elif self.activation == 'linear':
+            return np.ones_like(output)
+        else:
+            raise ValueError(f"Activation inconnue: {self.activation}")
+    
+    def get_weights(self):
+        """Retourne les poids et biais de la couche"""
+        return {
+            'weights': self.weights.copy(),
+            'bias': self.bias.copy()
+        }
+    
+    def set_weights(self, weights_dict):
+        """Définit les poids et biais de la couche"""
+        self.weights = weights_dict['weights'].copy()
+        self.bias = weights_dict['bias'].copy()
+    
+    def __repr__(self):
+        return f"SitiNEUR(input_size={self.input_size}, output_size={self.output_size}, activation='{self.activation}')"

publish-to-pypi.yml

@@ -0,0 +1,71 @@
+name: Publier Sitiai sur PyPI
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  build:
+    name: Construire le package
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      
+      - name: Installer Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.x"
+      
+      - name: Installer les dépendances de build
+        run: |
+          python -m pip install --upgrade pip
+          pip install build
+      
+      - name: Construire le package
+        run: python -m build
+      
+      - name: Sauvegarder les fichiers de distribution
+        uses: actions/upload-artifact@v4
+        with:
+          name: python-package-distributions
+          path: dist/
+
+  publish-to-testpypi:
+    name: Publier sur TestPyPI
+    needs: [build]
+    runs-on: ubuntu-latest
+    environment:
+      name: testpypi
+      url: https://test.pypi.org/p/sitiai
+    permissions:
+      id-token: write
+    steps:
+      - name: Télécharger les distributions
+        uses: actions/download-artifact@v4
+        with:
+          name: python-package-distributions
+          path: dist/
+      
+      - name: Publier sur TestPyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          repository-url: https://test.pypi.org/legacy/
+
+  publish-to-pypi:
+    name: Publier sur PyPI
+    needs: [build, publish-to-testpypi]
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/sitiai
+    permissions:
+      id-token: write
+    steps:
+      - name: Télécharger les distributions
+        uses: actions/download-artifact@v4
+        with:
+          name: python-package-distributions
+          path: dist/
+      
+      - name: Publier sur PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

pyproject.toml

@@ -0,0 +1,9 @@
+[project]
+name = "sitiai"
+version = "0.1.0"
+description = "Framework Python pour créer et entraîner des IA légères"
+authors = ["Clemylia"]
+requires-python = ">=3.11"
+dependencies = [
+    "numpy>=1.24.0"
+]

requirements-1.txt

@@ -0,0 +1 @@
+numpy>=2.3.3