Natuurlijk! Hieronder vind je een voorbeeld van een NumPy-functie die zowel Min-Max-scaling als Z-score-normalisatie kan toepassen op je dataset met klantleeftijden en aankoopbedragen. Ik neem hierbij rekening met de volgende overwegingen: - Het behouden van gegevensintegriteit door geen gegevens te vervormen die niet geschikt zijn voor normalisatie. - Omgaan met ontbrekende waarden (NaN) door deze te negeren tijdens de berekeningen en ze niet te wijzigen. - Flexibiliteit in het kiezen van de normalisatietechniek via een parameter. Hier is de implementatie in Python: ```python import numpy as np def normaliseer_gegevens(data, techniek='minmax'): """ Normaliseert een dataset met opties voor Min-Max of Z-score normalisatie. Parameters: data (np.ndarray): 2D array met gegevens, waarbij elke kolom een variabele is. techniek (str): 'minmax' of 'zscore' voor de normalisatietechniek. Returns: np.ndarray: De genormaliseerde dataset, met NaN-waarden behouden waar ze waren. """ # Maak een kopie om de originele data niet te wijzigen genormaliseerde_data = np.array(data, copy=True) # Loop door elke kolom (variabele) for col in range(genormaliseerde_data.shape[1]): kolom = genormaliseerde_data[:, col] # Vind niet-NaN indices geldige_mask = ~np.isnan(kolom) geldige_values = kolom[geldige_mask] if geldige_values.size == 0: # Als alle waarden NaN zijn, doe niets continue if techniek == 'minmax': min_val = np.min(geldige_values) max_val = np.max(geldige_values) # Vermijd deling door nul if min_val == max_val: # Alle waarden zijn gelijk, zet ze op 0 kolom[geldige_mask] = 0 else: kolom[geldige_mask] = (geldige_values - min_val) / (max_val - min_val) elif techniek == 'zscore': mean_val = np.mean(geldige_values) std_val = np.std(geldige_values) # Vermijd deling door nul if std_val == 0: # Alle waarden zijn gelijk, zet ze op 0 kolom[geldige_mask] = 0 else: kolom[geldige_mask] = (geldige_values - mean_val) / std_val else: raise ValueError("Onbekende normalisatietechniek. Kies 'minmax' of 'zscore'.") return genormaliseerde_data ``` **Gebruikvoorbeeld:** ```python import numpy as np # Voorbeeld dataset: kolom 0 = leeftijd, kolom 1 = aankoopbedrag dataset = np.array([ [25, 200], [30, np.nan], [22, 150], [np.nan, 300], [40, 250] ], dtype=float) # Normaliseer met Min-Max genormaliseerd_minmax = normaliseer_gegevens(dataset, techniek='minmax') print("Min-Max genormaliseerd:\n", genormaliseerd_minmax) # Normaliseer met Z-score genormaliseerd_zscore = normaliseer_gegevens(dataset, techniek='zscore') print("Z-score genormaliseerd:\n", genormaliseerd_zscore) ``` **Samenvatting van overwegingen:** - Ontbrekende waarden (NaN) worden niet gewijzigd en blijven in hun oorspronkelijke positie. - Normalisatie wordt kolom-voor-kolom uitgevoerd, wat geschikt is voor verschillende variabelen. - Bij kolommen met gelijke waarden wordt de normalisatie gestopt om deling door nul te voorkomen. - De functie is flexibel en kan gemakkelijk worden aangepast voor andere technieken. Als je nog verdere vragen hebt of de code wilt aanpassen, laat het gerust weten!

Hier is een uitgebreide NumPy-functie voor gegevensnormalisatie met specifieke aandacht voor uw dataset met klantleeftijden en aankoopbedragen: ```python import numpy as np def normaliseer_dataset(data, methode='minmax', kenmerken=None, ontbrekende_waarden='negeren'): """ Normaliseert een dataset met klantleeftijden en aankoopbedragen Parameters: ----------- data : numpy array 2D array met vorm (samples, kenmerken) - [leeftijd, aankoopbedrag] methode : str 'minmax' voor Min-Max schaling, 'zscore' voor Z-score normalisatie kenmerken : list of None Welke kenmerken te normaliseren [0,1] voor alle, [0] voor alleen leeftijd, etc. ontbrekende_waarden : str 'negeren' (standaard), 'vullen_mediaan', 'vullen_gemiddelde' Returns: -------- genormaliseerde_data : numpy array normalisatie_info : dict met gebruikte parameters voor inverse transformatie """ # Maak een kopie om originele data niet te wijzigen data = np.copy(data).astype(float) # Controleer input if data.ndim != 2: raise ValueError("Data moet 2D array zijn") if kenmerken is None: kenmerken = [0, 1] # Standaard beide kenmerken normaliseren normalisatie_info = { 'methode': methode, 'kenmerken': kenmerken, 'parameters': {} } # Omgaan met ontbrekende waarden (NaN) if ontbrekende_waarden != 'negeren': for kolom in kenmerken: nan_mask = np.isnan(data[:, kolom]) if np.any(nan_mask): if ontbrekende_waarden == 'vullen_mediaan': vul_waarde = np.nanmedian(data[:, kolom]) elif ontbrekende_waarden == 'vullen_gemiddelde': vul_waarde = np.nanmean(data[:, kolom]) else: raise ValueError("Ongeldige optie voor ontbrekende waarden") data[nan_mask, kolom] = vul_waarde print(f"Waarschuwing: {np.sum(nan_mask)} ontbrekende waarden in kenmerk {kolom} vervangen door {vul_waarde:.2f}") # Specifieke overwegingen voor klantleeftijden en aankoopbedragen for kolom in kenmerken: kolom_data = data[:, kolom] # Verwijder eventuele resterende NaN waarden geldige_data = kolom_data[~np.isnan(kolom_data)] if len(geldige_data) == 0: raise ValueError(f"Geen geldige data in kenmerk {kolom}") # Controleer op realistische waarden if kolom == 0: # Leeftijd if np.any(geldige_data < 0) or np.any(geldige_data > 120): print("Waarschuwing: Onrealistische leeftijden gedetecteerd") elif kolom == 1: # Aankoopbedrag if np.any(geldige_data < 0): print("Waarschuwing: Negatieve aankoopbedragen gedetecteerd") # Pas normalisatie toe for kolom in kenmerken: kolom_data = data[:, kolom] geldige_mask = ~np.isnan(kolom_data) geldige_data = kolom_data[geldige_mask] if methode == 'minmax': min_val = np.min(geldige_data) max_val = np.max(geldige_data) if max_val == min_val: # Voorkom deling door nul data[geldige_mask, kolom] = 0.5 else: data[geldige_mask, kolom] = (geldige_data - min_val) / (max_val - min_val) normalisatie_info['parameters'][kolom] = { 'type': 'minmax', 'min': min_val, 'max': max_val } elif methode == 'zscore': gemiddelde = np.mean(geldige_data) std = np.std(geldige_data) if std == 0: # Voorkom deling door nul data[geldige_mask, kolom] = 0 else: data[geldige_mask, kolom] = (geldige_data - gemiddelde) / std normalisatie_info['parameters'][kolom] = { 'type': 'zscore', 'gemiddelde': gemiddelde, 'std': std } else: raise ValueError("Ongeldige normalisatiemethode. Kies 'minmax' of 'zscore'") return data, normalisatie_info # Voorbeeld gebruik: if __name__ == "__main__": # Voorbeeld dataset: [leeftijd, aankoopbedrag] data = np.array([ [25, 150.50], [32, 89.99], [45, 200.00], [28, 75.25], [60, 300.75], [np.nan, 120.50], # Ontbrekende leeftijd [35, np.nan], # Ontbrekend aankoopbedrag [22, 50.00] ]) print("Originele data:") print(data) # Min-Max normalisatie met mediaan voor ontbrekende waarden genormaliseerd, info = normaliseer_dataset( data, methode='minmax', ontbrekende_waarden='vullen_mediaan' ) print("\nGenormaliseerde data (Min-Max):") print(genormaliseerd) print("\nNormalisatie informatie:") print(info) # Z-score normalisatie genormaliseerd_z, info_z = normaliseer_dataset( data, methode='zscore', ontbrekende_waarden='vullen_gemiddelde' ) print("\nGenormaliseerde data (Z-score):") print(genormaliseerd_z) ``` **Belangrijke kenmerken en overwegingen voor uw dataset:** 1. **Gegevensintegriteit:** - Maakt een kopie van de data om origineel te behouden - Controleert op realistische waarden (leeftijden 0-120, positieve aankopen) - Behandelt numerieke kolommen correct 2. **Ontbrekende waarden:** - Drie strategieën: negeren, vullen met mediaan, vullen met gemiddelde - Waarschuwingen wanneer waarden worden vervangen 3. **Dataset-specifiek:** - Geschikt voor leeftijden (discreet) en aankoopbedragen (continu) - Aparte logica voor elk kenmerktype - Bescherming tegen deling door nul 4. **Flexibiliteit:** - Keuze tussen Min-Max (0-1 range) en Z-score (gemiddelde=0, std=1) - Selecteer welke kenmerken te normaliseren - Retourneert normalisatie-info voor inverse transformatie **Aanbevelingen voor uw dataset:** - Gebruik Min-Max voor leeftijden als u de relatieve schaling wilt behouden - Gebruik Z-score voor aankoopbedragen als u met uitschieters te maken heeft - Overweeg mediaan voor ontbrekende leeftijden (minder gevoelig voor uitschieters)