Spaces:
Sleeping
Sleeping
Download src/data_preprocessing.py from ClementGERARD/Polyfit: direct link, hf CLI and curl.
- Browser
- Download file 12.2 kB
-
https://huggingface.co/spaces/ClementGERARD/Polyfit/resolve/refs%2Fpr%2F64/src/data_preprocessing.py
- Command line
-
hf download hf://spaces/ClementGERARD/Polyfit@refs/pr/64/src/data_preprocessing.py
-
curl -L -o data_preprocessing.py https://huggingface.co/spaces/ClementGERARD/Polyfit/resolve/refs%2Fpr%2F64/src/data_preprocessing.py
12.2 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 | |
| from scipy.interpolate import interp1d | |
| # 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)) | |
| if post_train: | |
| # Si post_train est True, ne pas diviser les données | |
| input_path = os.path.join(self.model_dir, 'input_scaler.pkl') | |
| self.input_scaler = joblib.load(input_path) | |
| X_scaled = self.input_scaler.transform(X_flat) | |
| self.output_scalers = [] | |
| y_scaled_list = [] | |
| for i in range(5): | |
| scaler_path = os.path.join(self.model_dir, f'output_scaler_{i}.pkl') | |
| scaler = joblib.load(scaler_path) | |
| self.output_scalers.append(scaler) | |
| y_scaled = scaler.transform(y_split[i]) | |
| y_scaled_list.append(y_scaled) | |
| self.X_user = X_scaled | |
| self.y_user = y_scaled_list | |
| return True | |
| else: | |
| input_path = os.path.join(self.model_dir, 'input_scaler.pkl') | |
| X_scaled = self.input_scaler.fit_transform(X_flat) | |
| joblib.dump(self.input_scaler, input_path) | |
| self.output_scalers = [] | |
| y_scaled_list = [] | |
| for i in range(5): | |
| scaler = StandardScaler() | |
| y_scaled = scaler.fit_transform(y_split[i]) | |
| self.output_scalers.append(scaler) | |
| y_scaled_list.append(y_scaled) | |
| scaler_path = os.path.join(self.model_dir,f'output_scaler_{i}.pkl') | |
| joblib.dump(scaler,scaler_path) | |
| y_scaled = np.hstack(y_scaled_list) | |
| # 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 = self.split_labels(y_train) | |
| self.y_val = self.split_labels(y_val) | |
| self.y_test = self.split_labels(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, A = True): | |
| X_list = [] | |
| I_list = [] | |
| V_list = [] | |
| for file_path in csv_files: | |
| df = pd.read_csv(file_path) | |
| if not A: | |
| df["I"] = df["I"]*1e-3 | |
| #jsc = float(interp1d(df['V'], df['I'], bounds_error=False, fill_value='extrapolate')(0)) | |
| #print('jsc', jsc) | |
| #df["I"] = df["I"] - jsc | |
| if df['I'].iloc[-1] < 0: | |
| df["I"] = -df["I"] | |
| if abs(df['I'].iloc[-1]) >1: | |
| df['I'] = df['I']*1e-3 | |
| 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') | |
| self.output_scalers = [] | |
| for i in range(5): | |
| scaler_path = os.path.join(self.model_dir,f'output_scaler_{i}.pkl') | |
| scaler = joblib.load(scaler_path) | |
| self.output_scalers.append(scaler) | |
| self.input_scaler = joblib.load(input_path) | |
| # Vérifier si le scaler est fitted en vérifiant les attributs nécessaires | |
| if not hasattr(self.input_scaler, 'mean_') or not hasattr(self.input_scaler, 'scale_'): | |
| logger.warning("Le scaler chargé n'est pas fitted. Utilisation de fit_transform.") | |
| # Si le scaler n'est pas fitted, on utilise fit_transform | |
| X_scaled = self.input_scaler.fit_transform(X_flat) | |
| else: | |
| # Si le scaler est fitted, on utilise transform | |
| logger.info("Le scaler est correctement fitted. Utilisation de transform.") | |
| X_scaled = self.input_scaler.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_list): | |
| """ | |
| 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_list = [] | |
| for i, scaler in enumerate(self.output_scalers): | |
| y_orig = scaler.inverse_transform(y_scaled_list[i]) | |
| if i in [3,4]: | |
| y_orig = 10 ** y_orig | |
| y_orig_list.append(y_orig) | |
| return np.hstack(y_orig_list) | |
| 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() | |