Natuurlijk! Hier zijn twee aangepaste NumPy-functies die je kunnen helpen bij het automatisch afhandelen van ontbrekende waarden en het detecteren en verwijderen van uitschieters met behulp van z-scores. Ze zijn ontworpen om efficiënt, herbruikbaar en goed gedocumenteerd te zijn voor integratie in je dataverwerkingsworkflow. ```python import numpy as np def imputatie_gemiddelde(data): """ Vult ontbrekende waarden (NaN) in de dataset in met het gemiddelde van de beschikbare waarden. Parameters: data (np.ndarray): 1D of 2D array met mogelijk ontbrekende waarden (NaN). Returns: np.ndarray: Dezelfde array met NaN-waarden vervangen door het gemiddelde. """ data_imputed = np.array(data, copy=True) # Als het een 2D array is, voer de imputatie kolom voor kolom uit if data_imputed.ndim == 2: for col in range(data_imputed.shape[1]): kolom = data_imputed[:, col] gemiddelde = np.nanmean(kolom) # Vervang NaN door het gemiddelde kolom[np.isnan(kolom)] = gemiddelde data_imputed[:, col] = kolom else: # Voor 1D array gemiddelde = np.nanmean(data_imputed) data_imputed[np.isnan(data_imputed)] = gemiddelde return data_imputed def detecteer_en_verwijder_uitschieters_zscore(data, z_threshold=3.0): """ Detecteert en verwijdert uitschieters op basis van de z-score. Parameters: data (np.ndarray): 1D of 2D array zonder NaN-waarden. z_threshold (float): De drempel voor de z-score om uitschieters te bepalen. Returns: np.ndarray: Data zonder uitschieters. """ # Maak een kopie om mutatie te voorkomen data_clean = np.array(data, copy=True) # Als 2D, voer de detectie per kolom uit if data_clean.ndim == 2: mask = np.ones(data_clean.shape, dtype=bool) for col in range(data_clean.shape[1]): kolom = data_clean[:, col] mean = np.mean(kolom) std = np.std(kolom) if std == 0: # Geen variatie, geen uitschieters continue z_scores = (kolom - mean) / std # Markeer uitschieters uitschieters = np.abs(z_scores) > z_threshold mask[:, col] = ~uitschieters # Filter de data data_filtered = data_clean[mask].reshape(data_clean.shape[0], data_clean.shape[1]) if data_clean.shape[0] > 1 else data_clean[mask] else: # Voor 1D array mean = np.mean(data_clean) std = np.std(data_clean) if std == 0: # Geen variatie return data_clean z_scores = (data_clean - mean) / std data_filtered = data_clean[np.abs(z_scores) <= z_threshold] return data_filtered ``` **Gebruikstips:** 1. Voordat je de uitschietersdetectie toepast, zorg dat je dataset geen NaN-waarden bevat. Gebruik eerst `imputatie_gemiddelde`. 2. Pas de functies toe op je sensordata zoals nodig. 3. De functies zijn flexibel voor 1D- en 2D-array's, wat handig is voor bijvoorbeeld meerdere sensoren of meerdere tijdreeksen. **Voorbeeld:** ```python # Voorbeeld dataset met NaN en ruis data = np.array([[1.2, np.nan, 3.4], [2.1, 4.5, np.nan], [np.nan, 5.1, 3.3], [4.8, 2.2, 100.0]]) # 100.0 als uitschieter # Stap 1: Missing values imputation data_imputed = imputatie_gemiddelde(data) # Stap 2: Uitschieters detectie en verwijdering data_clean = detecteer_en_verwijder_uitschieters_zscore(data_imputed, z_threshold=3.0) ``` Deze functies helpen je data efficiënt te schonen en te prepareren voor verdere analyse.

Absoluut. Hieronder vindt u een volledige, goed gedocumenteerde implementatie van de gevraagde functies in een herbruikbare stijl, geschreven in het Nederlands. ### Eerst: Het opzetten van de module Sla de volgende code op in een bestand, bijvoorbeeld `mijn_data_cleaner.py`. U kunt deze module dan importeren in uw workflow. ```python import numpy as np import scipy.stats as stats def imputeer_ontbrekende_waarden_met_gemiddelde(data, asis=False): """ Vervang ontbrekende waarden (aangeduid als NaN) in een NumPy array door het kolomgemiddelde. Deze functie is ideaal voor sensorreeksen waar ontbrekende waarden willekeurig voorkomen en het kolomgemiddelde een redelijke schatter is. Parameters: data : np.ndarray Een 1D of 2D NumPy array die de ruwe sensorwaarden bevat, inclusief NaN's. asis : bool, optioneel Indien True, wordt een gewijzigde kopie van de array geretourneerd. Indien False, wordt de originele array gewijzigd op plaats (default is False). Returns: np.ndarray De array met geïmputeerde waarden. Voorbeeld: >>> data = np.array([[1, 2, np.nan], [4, np.nan, 6]]) >>> imputeer_ontbrekende_waarden_met_gemiddelde(data) array([[1., 2., 6.], [4., 2., 6.]]) """ if asis: data = data.copy() # Controleer of de array NaN's bevat om onnodige berekening te voorkomen if np.isnan(data).any(): # Bereken het gemiddelde per kolom, negeert NaN's standaard kolom_gemiddelden = np.nanmean(data, axis=0) # Vind de indices waar NaN's staan waar_nan = np.isnan(data) # Vervang elke NaN in een kolom door het gemiddelde van die kolom data[waar_nan] = np.take(kolom_gemiddelden, np.where(waar_nan)[1]) return data def verwijder_uitschieters_met_zscore(data, drempel=3, asis=False): """ Identificeer en verwijder uitschieters op basis van hun Z-score. De Z-score meet hoeveel standaardafwijkingen een datapunt van het gemiddelde af ligt. Waarden met een absolute Z-score hoger dan de drempel worden als uitschieter beschouwd en vervangen door NaN. Geschikt voor het filteren van ruis in sensordata. Parameters: data : np.ndarray Een 1D of 2D NumPy array met de te zuiveren data (bij voorkeur al geïmputeerd). drempel : float, optioneel De absolute Z-score drempelwaarde. Alles met |Z-score| > drempel wordt een uitschieter. Standaard is 3 (ongeveer 99.7% van de data in een normale verdeling). asis : bool, optioneel Indien True, wordt een gewijzigde kopie van de array geretourneerd. Indien False, wordt de originele array gewijzigd op plaats (default is False). Returns: np.ndarray De array met uitschieters vervangen door NaN. Voorbeeld: >>> data = np.array([1, 2, 3, 1000]) # 1000 is een duidelijke uitschieter >>> verwijder_uitschieters_met_zscore(data, drempel=2) array([ 1., 2., 3., nan]) """ if asis: data = data.copy() # Bereken de Z-scores voor elke kolom. ddof=1 voor steekproef-standaardafwijking. z_scores = np.abs(stats.zscore(data, axis=0, nan_policy='omit')) # Creëer een masker dat True is op de posities van uitschieters uitschieter_masker = z_scores > drempel # Vervang uitschieters door NaN data[uitschieter_masker] = np.nan return data def automatische_data_zuivering(data, z_drempel=3): """ Een complete, geautomatiseerde pijplijn voor datazuivering. Deze functie combineert imputatie en uitschieterdetectie in één workflow. 1. Het verwijdert eerst uitschieters door ze te markeren als NaN. 2. Vervolgens worden alle NaN's (zowel originele missing values als uitschieters) geïmputeerd. Parameters: data : np.ndarray De ruwe, ongezuiverde sensordata array. z_drempel : float, optioneel De Z-score drempel voor `verwijder_uitschieters_met_zscore`. Standaard is 3. Returns: np.ndarray Een volledig gezuiverde array, klaar voor analyse. Voorbeeld: >>> ruwe_data = np.array([[1, 200], [2, np.nan], [50, 4]]) >>> automatische_data_zuivering(ruwe_data) """ # Maak een kopie om de originele data niet te wijzigen gezuiverde_data = data.copy() # Stap 1: Verwijder uitschieters (worden NaN) gezuiverde_data = verwijder_uitschieters_met_zscore(gezuiverde_data, drempel=z_drempel, asis=True) # Stap 2: Imputeer alle NaN's (zowel missing values als verwijderde uitschieters) gezuiverde_data = imputeer_ontbrekende_waarden_met_gemiddelde(gezuiverde_data, asis=True) return gezuiverde_data ``` --- ### Hoe te gebruiken in uw workflow 1. **Plaats het bestand `mijn_data_cleaner.py`** in dezelfde map als uw hoofdscript of in een map die in uw Python-pad staat. 2. **Importeer de functies** in uw script of Jupyter notebook: ```python import numpy as np from mijn_data_cleaner import imputeer_ontbrekende_waarden_met_gemiddelde, verwijder_uitschieters_met_zscore, automatische_data_zuivering # Laad uw sensordata (voorbeeld) # data = np.loadtxt('sensor_data.csv', delimiter=',') data = np.array([[1, 200, 3.5], # 200 is een potentiële uitschieter [2, np.nan, 4.1], # Ontbrekende waarde [50, 3.9, 10]]) # 50 en 10 zijn potentiële uitschieters print("Originele Data:") print(data) # Optie 1: Gebruik de functies individueel (meer controle) data_zonder_uitschieters = verwijder_uitschieters_met_zscore(data, drempel=2, asis=True) data_volledig_gezuiverd = imputeer_ontbrekende_waarden_met_gemiddelde(data_zonder_uitschieters, asis=True) print("\nData na individuele zuivering:") print(data_volledig_gezuiverd) # Optie 2: Gebruik de geautomatiseerde pijplijn (snel en eenvoudig) data_gezuiverd = automatische_data_zuivering(data, z_drempel=2) print("\nData na automatische zuiveringspijplijn:") print(data_gezuiverd) ``` ### Belangrijke punten en overwegingen * **`asis` Parameter:** De `asis` parameter geeft u controle over of de originele array wordt gewijzigd (`asis=False`) of dat er een veilige kopie wordt gemaakt (`asis=True`). Standaard is `False` om per ongeluk overschrijven te voorkomen. * **Volgorde is belangrijk:** In de `automatische_data_zuivering` pijplijn worden eerst uitschieters verwijderd (en NaN gemaakt) en daarna pas alle NaN's geïmputeerd. Deze volgorde is cruciaal. * **Z-score Drempel:** De standaarddrempel van 3 is strikt. Voor sensordata met meer ruis kunt u een hogere waarde (bv. 4) overwegen. Voor zeer schone data of strenge filtering kunt u een lagere waarde (bv. 2.5) proberen. Pas deze aan op basis van uw kennis van de data. * **Gebruik van `scipy.stats`:** De `scipy.stats` bibliotheek wordt gebruikt voor een efficiënte berekening van de Z-score. Zorg ervoor dat deze is geïnstalleerd (`pip install scipy`). Deze code is ontworpen om efficiënt, duidelijk en direct integreerbaar te zijn in een bestaande NumPy-gebaseerde workflow.