Natuurlijk! Hier is een stapsgewijze gids om een TensorFlow-model te ontwikkelen dat recensies gelijktijdig in meerdere genres kan classificeren: 1. Data Voorbereiding - Dataset Controleren: Zorg dat je dataset bestaat uit recensies en bijbehorende labels (meerdere genres per recensie). Omdat elk label even vaak voorkomt, is de dataset goed gebalanceerd. - Tekstvoorbewerking: Je hebt al aangegeven dat je tekst splitst in woorden. Overweeg het gebruik van Tokenizer van TensorFlow/Keras om woorden naar indices te converteren. 2. Tekst Tokenisatie en Sequentie-voorbewerking ```python from tensorflow.keras.preprocessing.text import Tokenizer from tensorflow.keras.preprocessing.sequence import pad_sequences # Stel je recensie data en labels voor: texts = [...] # lijst van recensies labels = [...] # lijst van sets/lijsten van genres voor elke recensie # Tokenizer instellen tokenizer = Tokenizer(num_words=10000, oov_token="<OOV>") tokenizer.fit_on_texts(texts) # Teksten omzetten in sequenties sequences = tokenizer.texts_to_sequences(texts) # Sequenties padding maxlen = 100 # of kies een geschikte lengte X = pad_sequences(sequences, maxlen=maxlen, padding='post', truncating='post') ``` 3. Labels Encoderen - Aangezien je meerdere genres per recensie hebt, gebruik je MultiLabelBinarizer: ```python from sklearn.preprocessing import MultiLabelBinarizer mlb = MultiLabelBinarizer() Y = mlb.fit_transform(labels) ``` 4. Model Ontwikkeling - Bouw een neuraal netwerk dat multi-label classificatie aankan: ```python import tensorflow as tf from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Embedding, Dense, GlobalAveragePooling1D model = Sequential([ Embedding(input_dim=10000, output_dim=64, input_length=maxlen), GlobalAveragePooling1D(), Dense(64, activation='relu'), Dense(len(mlb.classes_), activation='sigmoid') # sigmoid voor multi-label ]) ``` 5. Model Compilatie ```python model.compile( optimizer='adam', loss='binary_crossentropy', # geschikt voor multi-label metrics=['accuracy'] ) ``` 6. Model Training ```python model.fit(X, Y, epochs=10, batch_size=32, validation_split=0.2) ``` 7. Evaluatie en Gebruik - Gebruik `model.predict()` voor nieuwe recensies. - Om de voorspellingen te interpreteren, stel een drempel in (bijv. 0.5) voor de activaties. ```python import numpy as np predictions = model.predict(new_X) predicted_labels = mlb.inverse_transform((predictions > 0.5).astype(int)) ``` 8. Overwegingen - Experimenteer met de netwerkarchitectuur en hyperparameters. - Overweeg het gebruik van pretrained embeddings zoals GloVe voor betere prestaties. - Zorg voor goede preprocessing en eventueel data augmentation. Door deze stappen te volgen, ontwikkel je een TensorFlow-model dat recensies gelijktijdig in meerdere genres kan classificeren, rekening houdend met de gelijke verdeling van labels en jouw preprocessing-techniek.

Ik help je graag een TensorFlow-model te ontwikkelen voor multi-label tekstclassificatie. Hier is een complete oplossing in het Nederlands: ## 1. Data Preprocessing ```python import tensorflow as tf import pandas as pd import numpy as np from sklearn.model_selection import train_test_split from sklearn.preprocessing import MultiLabelBinarizer from tensorflow.keras.preprocessing.text import Tokenizer from tensorflow.keras.preprocessing.sequence import pad_sequences # Voorbeeld dataset structuur # Stel je voor dat je data er zo uitziet: # recensies = ["geweldige film met actie en humor", ...] # labels = [["actie", "komedie"], ...] def preprocess_data(recensies, labels, max_words=10000, max_length=200): # Multi-label binarisering mlb = MultiLabelBinarizer() y = mlb.fit_transform(labels) # Tekst tokenization tokenizer = Tokenizer(num_words=max_words, oov_token="<OOV>") tokenizer.fit_on_texts(recensies) # Tekst naar sequences sequences = tokenizer.texts_to_sequences(recensies) X = pad_sequences(sequences, maxlen=max_length) return X, y, tokenizer, mlb ``` ## 2. Model Architectuur ```python from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Embedding, LSTM, Dense, Dropout, Bidirectional from tensorflow.keras.optimizers import Adam def create_model(vocab_size, embedding_dim=100, max_length=200, num_classes=None): model = Sequential([ Embedding(vocab_size, embedding_dim, input_length=max_length), Bidirectional(LSTM(64, return_sequences=True)), Dropout(0.5), Bidirectional(LSTM(32)), Dropout(0.5), Dense(128, activation='relu'), Dropout(0.3), Dense(num_classes, activation='sigmoid') # sigmoid voor multi-label ]) model.compile( optimizer=Adam(learning_rate=0.001), loss='binary_crossentropy', metrics=['accuracy', 'precision', 'recall'] ) return model ``` ## 3. Complete Trainingspijplijn ```python def train_multi_label_model(recensies, labels, test_size=0.2): # Data preprocessing X, y, tokenizer, mlb = preprocess_data(recensies, labels) # Train/test split X_train, X_test, y_train, y_test = train_test_split( X, y, test_size=test_size, random_state=42 ) # Model creatie vocab_size = len(tokenizer.word_index) + 1 num_classes = y.shape[1] model = create_model( vocab_size=vocab_size, num_classes=num_classes, max_length=X.shape[1] ) # Callbacks callbacks = [ tf.keras.callbacks.EarlyStopping(patience=3, restore_best_weights=True), tf.keras.callbacks.ReduceLROnPlateau(factor=0.5, patience=2) ] # Training history = model.fit( X_train, y_train, epochs=20, batch_size=32, validation_data=(X_test, y_test), callbacks=callbacks, verbose=1 ) return model, history, tokenizer, mlb ``` ## 4. Evaluatie en Predicties ```python def evaluate_model(model, X_test, y_test, mlb): # Evaluatie loss, accuracy, precision, recall = model.evaluate(X_test, y_test, verbose=0) print(f"Test Loss: {loss:.4f}") print(f"Test Accuracy: {accuracy:.4f}") print(f"Test Precision: {precision:.4f}") print(f"Test Recall: {recall:.4f}") # Predicties y_pred = model.predict(X_test) y_pred_binary = (y_pred > 0.5).astype(int) return y_pred_binary def predict_new_text(model, tokenizer, mlb, new_text, max_length=200): # Preprocess nieuwe tekst sequence = tokenizer.texts_to_sequences([new_text]) padded_sequence = pad_sequences(sequence, maxlen=max_length) # Predictie prediction = model.predict(padded_sequence)[0] # Converteer naar labels threshold = 0.5 predicted_labels = mlb.inverse_transform( (prediction > threshold).reshape(1, -1) ) return predicted_labels[0] ``` ## 5. Gebruiksvoorbeeld ```python # Voorbeeld data (vervang met je eigen dataset) recensies = [ "geweldige actie film met spectaculaire scènes", "grappige komedie die me aan het lachen maakte", "spannende thriller met onverwachte wendingen", "romantisch drama over liefde en relaties", "science fiction avontuur in de ruimte" ] labels = [ ["actie"], ["komedie"], ["thriller"], ["drama", "romantiek"], ["science fiction", "avontuur"] ] # Train het model model, history, tokenizer, mlb = train_multi_label_model(recensies, labels) # Test met nieuwe tekst nieuwe_recensie = "een spannende film met actie en science fiction elementen" voorspelde_genres = predict_new_text(model, tokenizer, mlb, nieuwe_recensie) print(f"Voorspelde genres: {voorspelde_genres}") ``` ## 6. Belangrijke Punten voor Multi-label Classificatie 1. **Activatiefunctie**: Gebruik `sigmoid` in plaats van `softmax` 2. **Loss functie**: `binary_crossentropy` voor multi-label 3. **Threshold**: Stel een drempelwaarde in (meestal 0.5) voor binaire beslissingen 4. **Class imbalance**: Gebruik class weights als je dataset niet gebalanceerd is 5. **Evaluatie**: Gebruik precision, recall, F1-score voor multi-label evaluatie ## 7. Verbeteringen voor Productie ```python # Class weights voor gebalanceerde dataset from sklearn.utils.class_weight import compute_class_weight def compute_class_weights(y_train): class_weights = {} for i in range(y_train.shape[1]): weights = compute_class_weight( 'balanced', classes=np.unique(y_train[:, i]), y=y_train[:, i] ) class_weights[i] = weights[1] # weight voor positieve klasse return class_weights ``` Dit model kan meerdere genres gelijktijdig voorspellen voor elke recensie. Pas de parameters aan op basis van je specifieke dataset en vereisten!