Natuurlijk! Hier is een voorstel voor een NumPy-functie die categorische gegevens (Geslacht en Locatie) encodeert met One-Hot Encoding, inclusief efficiëntie en decodering: ```python import numpy as np def custom_one_hot_encode(data, categories=None): """ Encodeert categorische gegevens met One-Hot Encoding. Parameters: data (np.ndarray): Array met categorische gegevens (bijvoorbeeld Geslacht of Locatie). categories (list of str, optional): Optionele lijst met alle mogelijke categorieën. Returns: encoded_data (np.ndarray): One-Hot gecodeerde matrix. category_mapping (dict): Dictionary voor decodering (index naar categorie). """ # Zorg dat data een numpy array is data = np.array(data) # Als categorieën niet gespecificeerd zijn, bepaal ze uit data if categories is None: categories = np.unique(data) else: categories = np.array(categories) # Maak een mapping van categorie naar index category_to_index = {category: idx for idx, category in enumerate(categories)} # Initialiseer de gecodeerde matrix encoded_data = np.zeros((len(data), len(categories)), dtype=int) # Vul de matrix in met One-Hot encoding for i, value in enumerate(data): if value in category_to_index: encoded_data[i, category_to_index[value]] = 1 else: # Optioneel: handle onbekende categorieën pass # Voor gemakkelijk decoderen, maak een index naar categorie mapping index_to_category = {idx: category for category, idx in category_to_index.items()} return encoded_data, index_to_category # Voorbeeldgebruik: # Geslacht geslacht = ['Man', 'Vrouw', 'Vrouw', 'Man'] encoded_geslacht, geslacht_mapping = custom_one_hot_encode(geslacht) print(encoded_geslacht) print(geslacht_mapping) # Locatie locaties = ['Amsterdam', 'Rotterdam', 'Amsterdam', 'Utrecht'] encoded_locaties, locatie_mapping = custom_one_hot_encode(locaties) print(encoded_locaties) print(locatie_mapping) ``` **Kenmerken en overwegingen:** - **Efficiëntie:** De functie gebruikt NumPy-array's voor snelle verwerking. De initialisatie van de matrix en het inladen van categorieën gebeurt in één keer. - **Decodering:** Door de `index_to_category` dictionary kunnen de gecodeerde gegevens makkelijk terug worden vertaald naar de originele categorieën. - **Flexibiliteit:** Je kunt vooraf alle categorieën specificeren of ze automatisch laten bepalen uit de data. - **Uitbreiding:** De functie kan worden aangepast om ook met meerdere categorische kolommen tegelijk te werken. Wil je dat ik ook een voorbeeld geef om de gecodeerde gegevens weer te decoderen naar de originele labels?

Hier is een efficiënte NumPy-implementatie voor one-hot encoding van uw dataset met leeftijd, geslacht en locatie: ```python import numpy as np def custom_one_hot_encode(data, categories_dict): """ Aangepaste one-hot encoding functie voor categorische gegevens Parameters: data: numpy array met vorm (n_samples, 3) [Leeftijd, Geslacht, Locatie] categories_dict: dictionary met vooraf gedefinieerde categorieën Returns: encoded_data: one-hot gecodeerde array encoding_info: dictionary met decodering informatie """ # Vooraf gedefinieerde categorieën voor efficiëntie default_categories = { 'geslacht': ['Man', 'Vrouw', 'Anders'], 'locatie': sorted(list(set(data[:, 2]))) # Unieke locaties } # Gebruik opgegeven categorieën of defaults categories = categories_dict if categories_dict else default_categories encoded_features = [] encoding_maps = {} # Leeftijd - numeriek, normaliseren (geen encoding nodig) leeftijd = data[:, 0].astype(float) leeftijd_normalized = (leeftijd - np.min(leeftijd)) / (np.max(leeftijd) - np.min(leeftijd)) encoded_features.append(leeftijd_normalized.reshape(-1, 1)) encoding_maps['leeftijd'] = {'min': np.min(leeftijd), 'max': np.max(leeftijd)} # Geslacht - one-hot encoding geslacht_map = {cat: idx for idx, cat in enumerate(categories['geslacht'])} geslacht_encoded = np.zeros((len(data), len(categories['geslacht']))) for i, geslacht in enumerate(data[:, 1]): if geslacht in geslacht_map: geslacht_encoded[i, geslacht_map[geslacht]] = 1 encoded_features.append(geslacht_encoded) encoding_maps['geslacht'] = geslacht_map # Locatie - one-hot encoding locatie_map = {cat: idx for idx, cat in enumerate(categories['locatie'])} locatie_encoded = np.zeros((len(data), len(categories['locatie']))) for i, locatie in enumerate(data[:, 2]): if locatie in locatie_map: locatie_encoded[i, locatie_map[locatie]] = 1 encoded_features.append(locatie_encoded) encoding_maps['locatie'] = locatie_map # Combineer alle features encoded_data = np.hstack(encoded_features) return encoded_data, encoding_maps def decode_one_hot(encoded_data, encoding_maps, original_shape): """ Decodeer one-hot gecodeerde data terug naar originele vorm """ decoded_data = np.empty(original_shape, dtype=object) # Leeftijd decoderen leeftijd_range = encoding_maps['leeftijd']['max'] - encoding_maps['leeftijd']['min'] leeftijd_col = encoded_data[:, 0] * leeftijd_range + encoding_maps['leeftijd']['min'] decoded_data[:, 0] = leeftijd_col.astype(int) # Geslacht decoderen geslacht_start = 1 geslacht_end = geslacht_start + len(encoding_maps['geslacht']) geslacht_encoded = encoded_data[:, geslacht_start:geslacht_end] reverse_geslacht_map = {v: k for k, v in encoding_maps['geslacht'].items()} for i in range(len(encoded_data)): geslacht_idx = np.argmax(geslacht_encoded[i]) decoded_data[i, 1] = reverse_geslacht_map[geslacht_idx] # Locatie decoderen locatie_start = geslacht_end locatie_encoded = encoded_data[:, locatie_start:] reverse_locatie_map = {v: k for k, v in encoding_maps['locatie'].items()} for i in range(len(encoded_data)): locatie_idx = np.argmax(locatie_encoded[i]) decoded_data[i, 2] = reverse_locatie_map[locatie_idx] return decoded_data # Gebruiksvoorbeeld: if __name__ == "__main__": # Voorbeeld dataset data = np.array([ [25, 'Man', 'Amsterdam'], [30, 'Vrouw', 'Rotterdam'], [35, 'Man', 'Amsterdam'], [28, 'Vrouw', 'Utrecht'] ]) # Encoding encoded_data, encoding_info = custom_one_hot_encode(data, None) print("Gecodeerde data:") print(encoded_data) print("\nEncoding informatie:", encoding_info) # Decoding decoded_data = decode_one_hot(encoded_data, encoding_info, data.shape) print("\nGedecodeerde data:") print(decoded_data) ``` **Efficiëntie-overwegingen:** 1. **Vooraf gedefinieerde categorieën**: Voorkomt herberekening van unieke waarden 2. **Vectorisatie**: Gebruikt NumPy-bewerkingen in plaats van loops waar mogelijk 3. **Geheugenefficiënt**: Creëert arrays in één keer in plaats van dynamisch uitbreiden **Decodering-functionaliteit:** - Bewaart alle benodigde mapping-informatie - Kan exacte originele data reconstrueren - Handelt ontbrekende categorieën elegant af **Aanbevelingen:** 1. Sla de `encoding_info` op voor toekomstige decodering 2. Gebruik dezelfde `categories_dict` voor consistente encoding bij nieuwe data 3. Normaliseer leeftijd voor betere modelprestaties