Spaces:
Sleeping
Sleeping
Download src/data_preprocessing.py from ClementGERARD/Polyfit: direct link, hf CLI and curl.
- Browser
- Download file 12 kB
-
https://huggingface.co/spaces/ClementGERARD/Polyfit/resolve/refs%2Fpr%2F4/src/data_preprocessing.py
- Command line
-
hf download hf://spaces/ClementGERARD/Polyfit@refs/pr/4/src/data_preprocessing.py
-
curl -L -o data_preprocessing.py https://huggingface.co/spaces/ClementGERARD/Polyfit/resolve/refs%2Fpr%2F4/src/data_preprocessing.py
12 kB
| #!/usr/bin/env python3 | |
| # -*- coding: utf-8 -*- | |
| """ | |
| Module de prétraitement des données pour le projet d'IA solaire. | |
| Ce module permet de charger les fichiers CSV contenant les courbes I-V, | |
| d'extraire les caractéristiques et les paramètres cibles, et de préparer | |
| les données pour l'entraînement du modèle. | |
| """ | |
| import joblib | |
| import os | |
| import glob | |
| import numpy as np | |
| import pandas as pd | |
| from sklearn.model_selection import train_test_split | |
| from sklearn.preprocessing import StandardScaler | |
| import matplotlib.pyplot as plt | |
| import logging | |
| # Configuration du logging | |
| logging.basicConfig(level=logging.INFO, | |
| format='%(asctime)s - %(name)s - %(levelname)s - %(message)s') | |
| logger = logging.getLogger(__name__) | |
| class SolarDataProcessor: | |
| """ | |
| Classe pour le prétraitement des données de cellules solaires. | |
| """ | |
| def __init__(self,model_dir, data_dir, n_points=230): | |
| """ | |
| Initialise le processeur de données. | |
| Args: | |
| data_dir (str): Chemin vers le répertoire contenant les fichiers CSV. | |
| n_points (int): Nombre de points à utiliser pour l'interpolation des courbes I-V. | |
| """ | |
| self.data_dir = data_dir | |
| self.model_dir = os.path.join(os.getcwd(), "models") | |
| self.n_points = n_points | |
| self.input_scaler = StandardScaler() | |
| self.output_scaler = StandardScaler() | |
| self.X_train = None | |
| self.X_val = None | |
| self.X_test = None | |
| self.y_train = None | |
| self.y_val = None | |
| self.y_test = None | |
| self.X_user = None | |
| self.y_user = None | |
| def find_csv_files(self): | |
| """ | |
| Trouve tous les fichiers CSV dans le répertoire de données. | |
| Returns: | |
| list: Liste des chemins vers les fichiers CSV. | |
| """ | |
| csv_pattern = os.path.join(self.data_dir, "*.csv") | |
| csv_files = glob.glob(csv_pattern) | |
| logger.info(f"Trouvé {len(csv_files)} fichiers CSV dans {self.data_dir}") | |
| return csv_files | |
| def load_and_process_file(self, file_path): | |
| """ | |
| Charge et prétraite un fichier CSV. | |
| Args: | |
| file_path (str): Chemin vers le fichier CSV. | |
| Returns: | |
| tuple: (X, y) où X est la courbe I-V et y sont les paramètres cibles. | |
| """ | |
| try: | |
| # Charger le fichier CSV | |
| df = pd.read_csv(file_path) | |
| # Vérifier que les colonnes attendues sont présentes | |
| required_cols = ['V', 'I', 'Rsh', 'Rs', 'n', 'J0', 'Jph'] | |
| if not all(col in df.columns for col in required_cols): | |
| logger.warning(f"Colonnes manquantes dans {file_path}, fichier ignoré") | |
| return None, None | |
| # Extraire les colonnes V et I comme entrées | |
| X = df[['V', 'I']].values | |
| # Extraire les paramètres cibles (utiliser la première ligne car ils sont répétés) | |
| y = df[['Rsh', 'Rs', 'n', 'J0', 'Jph']].iloc[0].values | |
| return X, y | |
| except Exception as e: | |
| logger.error(f"Erreur lors du chargement du fichier {file_path}: {e}") | |
| return None, None | |
| def interpolation(self, X): | |
| """ | |
| interpole une courbe I-V pour avoir un nombre fixe de points. | |
| Args: | |
| X (numpy.ndarray): Courbe I-V d'origine. | |
| Returns: | |
| numpy.ndarray: Courbe I-V normalisée. | |
| """ | |
| # Interpolation pour avoir n_points | |
| v_min, v_max = X[0, 0], X[-1, 0] | |
| v_new = np.linspace(v_min, v_max, self.n_points) | |
| # Interpolation linéaire pour le courant | |
| i_new = np.interp(v_new, X[:, 0], X[:, 1]) | |
| # Retourner la courbe normalisée | |
| return np.column_stack((v_new, i_new)) | |
| def preprocess_data(self, post_train=False): | |
| """ | |
| Prétraite toutes les données et les divise en ensembles d'entraînement, validation et test. | |
| """ | |
| csv_files = self.find_csv_files() | |
| if not csv_files: | |
| logger.error("Aucun fichier CSV trouvé. Vérifiez le chemin du répertoire.") | |
| return False | |
| X_list = [] | |
| y_list = [] | |
| # Charger et prétraiter tous les fichiers | |
| for file_path in csv_files: | |
| X, y = self.load_and_process_file(file_path) | |
| if X is not None and y is not None: | |
| # interpoler la courbe I-V | |
| X_norm = self.interpolation(X) | |
| X_list.append(X_norm) | |
| y_list.append(y) | |
| if not X_list: | |
| logger.error("Aucune donnée valide n'a été chargée.") | |
| return False | |
| # Convertir en tableaux numpy | |
| X_array = np.array(X_list) | |
| y_array = np.array(y_list) | |
| # Appliquer une transformation logarithmique à J0 et Jph | |
| log_indices = [3, 4] # Indices de J0 et Jph | |
| y_transformed = y_array.copy() | |
| y_transformed[:, log_indices] = np.log10(np.abs(y_array[:, log_indices]) + 1e-10) | |
| # Aplatir les courbes I-V pour l'entrée du modèle | |
| X_flat = X_array.reshape(X_array.shape[0], -1) | |
| # Normaliser les entrées et sorties | |
| X_scaled = self.input_scaler.fit_transform(X_flat) | |
| y_scaled = self.output_scaler.fit_transform(y_transformed) | |
| #en cas de modèle déjà fini | |
| if post_train: | |
| # Si post_train est True, ne pas diviser les données | |
| self.X_user = X_scaled | |
| self.y_user = y_scaled | |
| input_path = os.path.join(self.model_dir, 'input_scaler.pkl') | |
| output_path = os.path.join(self.model_dir, 'output_scaler.pkl') | |
| self.output_scaler = joblib.load(output_path) | |
| self.input_scaler = joblib.load(input_path) | |
| return True | |
| else: | |
| input_path = os.path.join(self.model_dir, 'input_scaler.pkl') | |
| output_path = os.path.join(self.model_dir, 'output_scaler.pkl') | |
| joblib.dump(self.input_scaler, input_path) | |
| joblib.dump(self.output_scaler, output_path) | |
| # Diviser les données: 70% entraînement, 15% validation, 15% test | |
| X_train_val, X_test, y_train_val, y_test = train_test_split( | |
| X_scaled, y_scaled, test_size=0.15, random_state=42) | |
| X_train, X_val, y_train, y_val = train_test_split( | |
| X_train_val, y_train_val, test_size=0.15/0.85, random_state=42) | |
| # Stocker les données | |
| self.X_train = X_train | |
| self.X_val = X_val | |
| self.X_test = X_test | |
| self.y_train = y_train | |
| self.y_val = y_val | |
| self.y_test = y_test | |
| logger.info(f"Prétraitement terminé: {len(X_train)} échantillons d'entraînement, " | |
| f"{len(X_val)} de validation, {len(X_test)} de test") | |
| return True | |
| def preprocess_input(self, csv_files, path, in_the_dark = False): | |
| X_list = [] | |
| I_list = [] | |
| V_list = [] | |
| for file_path in csv_files: | |
| df = pd.read_csv(path + "/" + file_path) | |
| print(df.head()) | |
| if not in_the_dark: | |
| df["I"] = df["I"]*1e-3 | |
| df["I"] = df["I"]-df["I"].iloc[0] # A/m² | |
| X = df[['V', 'I']].values | |
| X_norm = self.interpolation(X) | |
| X_list.append(X_norm) | |
| V_list.append(X[:, 0]) | |
| I_list.append(X[:, 1]) | |
| X_array = np.array(X_list) | |
| X_flat = X_array.reshape(X_array.shape[0], -1) | |
| input_path = os.path.join(self.model_dir, 'input_scaler.pkl') | |
| output_path = os.path.join(self.model_dir, 'output_scaler.pkl') | |
| self.output_scaler = joblib.load(output_path) | |
| self.input_scaler = joblib.load(input_path) | |
| X_scaled = self.input_scaler.fit_transform(X_flat) | |
| return X_scaled, I_list, V_list | |
| def get_data(self): | |
| """ | |
| Récupère les données prétraitées. | |
| Returns: | |
| tuple: (X_train, X_val, X_test, y_train, y_val, y_test) | |
| """ | |
| return self.X_train, self.X_val, self.X_test, self.y_train, self.y_val, self.y_test | |
| def get_user_data(self): | |
| """ | |
| Récupère les données prétraitées. | |
| Returns: | |
| tuple: (X_user, y_user) | |
| """ | |
| return self.X_user, self.y_user | |
| def inverse_transform_params(self, y_scaled): | |
| """ | |
| Inverse la normalisation des paramètres prédits. | |
| Args: | |
| y_scaled (numpy.ndarray): Paramètres normalisés. | |
| Returns: | |
| numpy.ndarray: Paramètres dans leur échelle d'origine. | |
| """ | |
| y_orig = self.output_scaler.inverse_transform(y_scaled) | |
| # Inverser la transformation logarithmique pour J0 et Jph | |
| log_indices = [3, 4] # Indices de J0 et Jph | |
| y_final = y_orig.copy() | |
| y_final[:, log_indices] = 10 ** y_orig[:, log_indices] | |
| return y_final | |
| def reshape_for_model(self, X_flat, model_type='mlp'): | |
| """ | |
| Reshape les données pour le modèle spécifié. | |
| Args: | |
| X_flat (numpy.ndarray): Données aplaties. | |
| model_type (str): Type de modèle ('mlp' ou 'cnn1d'). | |
| Returns: | |
| numpy.ndarray: Données reshapées pour le modèle. | |
| """ | |
| if model_type.lower() == 'mlp': | |
| return X_flat # Pas besoin de reshape pour MLP | |
| elif model_type.lower() == 'cnn1d': | |
| # Reshape pour CNN 1D: [batch_size, sequence_length, features] | |
| return X_flat.reshape(X_flat.shape[0], self.n_points, 2) | |
| else: | |
| logger.warning(f"Type de modèle inconnu: {model_type}, utilisation de MLP par défaut") | |
| return X_flat | |
| def visualize_sample(self, index=0, dataset='train'): | |
| """ | |
| Visualise un échantillon des données. | |
| Args: | |
| index (int): Index de l'échantillon à visualiser. | |
| dataset (str): Ensemble de données ('train', 'val', ou 'test'). | |
| """ | |
| if dataset == 'train': | |
| X, y = self.X_train, self.y_train | |
| elif dataset == 'val': | |
| X, y = self.X_val, self.y_val | |
| elif dataset == 'test': | |
| X, y = self.X_test, self.y_test | |
| else: | |
| logger.error(f"Ensemble de données inconnu: {dataset}") | |
| return | |
| if X is None or y is None: | |
| logger.error("Les données n'ont pas encore été prétraitées.") | |
| return | |
| if index >= len(X): | |
| logger.error(f"Index {index} hors limites pour l'ensemble {dataset} de taille {len(X)}") | |
| return | |
| # Récupérer l'échantillon | |
| X_sample = X[index] | |
| y_sample = y[index] | |
| # Inverser la normalisation | |
| X_orig = self.input_scaler.inverse_transform(X_sample.reshape(1, -1)).reshape(-1, 2) | |
| y_orig = self.inverse_transform_params(y_sample.reshape(1, -1))[0] | |
| # Tracer la courbe I-V | |
| plt.figure(figsize=(10, 6)) | |
| plt.plot(X_orig[:, 0], X_orig[:, 1], 'o-', label='Courbe I-V') | |
| plt.xlabel('Tension (V)') | |
| plt.ylabel('Courant (I)') | |
| plt.title('Courbe I-V') | |
| plt.grid(True) | |
| plt.legend() | |
| # Afficher les paramètres | |
| param_names = ['Rsh', 'Rs', 'n', 'J0', 'Jph'] | |
| param_values = [f"{param}: {value:.4e}" for param, value in zip(param_names, y_orig)] | |
| param_text = '\n'.join(param_values) | |
| plt.figtext(0.02, 0.02, param_text, fontsize=10, bbox=dict(facecolor='white', alpha=0.8)) | |
| plt.tight_layout() | |
| plt.show() | |