Natuurlijk! Hier volgt een gedetailleerde uitleg van de stappen die je moet nemen om een multi-label classificatiemodel te ontwikkelen met Scikit-learn, inclusief voorbeeldcode. Ik ga uit van je dataset met filmtitels, beschrijvingen, trefwoorden en genres. Stap 1: Data Voorbereiding -------------------------- 1. Data importeren 2. Tekstuele functies combineren 3. Tekstuele functies verwerken (vectoriseren) 4. Labels coderen met MultiLabelBinarizer 5. Data splitsen in trainings- en testsets Voorbeeldcode: ```python import pandas as pd from sklearn.model_selection import train_test_split from sklearn.preprocessing import MultiLabelBinarizer from sklearn.feature_extraction.text import TfidfVectorizer # Voorbeeld: Laden van data # df = pd.read_csv('jouw_dataset.csv') # Stel dat je dataframe kolommen heeft: 'titel', 'beschrijving', 'trefwoorden', 'genres' # Combineer tekstuele functies def combine_text(row): return f"{row['titel']} {row['beschrijving']} {row['trefwoorden']}" df['tekst'] = df.apply(combine_text, axis=1) # Labels als lijst van genres # Bijvoorbeeld: genres kan een string zijn zoals 'Actie, Avontuur' df['genres_list'] = df['genres'].apply(lambda x: [genre.strip() for genre in x.split(',')]) # Vectoriseer de tekst vectorizer = TfidfVectorizer(max_features=5000) X = vectorizer.fit_transform(df['tekst']) # Encodeer labels mlb = MultiLabelBinarizer() Y = mlb.fit_transform(df['genres_list']) # Split data X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.2, random_state=42) ``` Stap 2: Model Training ---------------------- Gebruik een geschikte classifier, bijvoorbeeld `OneVsRestClassifier` met Logistic Regression. ```python from sklearn.linear_model import LogisticRegression from sklearn.multiclass import OneVsRestClassifier # Instantiateer het model clf = OneVsRestClassifier(LogisticRegression(max_iter=1000)) # Train het model clf.fit(X_train, Y_train) ``` Stap 3: Model Evaluatie ----------------------- Gebruik metrics die geschikt zijn voor multi-label problemen, zoals: - Hamming Loss - Jaccard Similarity - F1-score (micro, macro) Voorbeeld: ```python from sklearn.metrics import hamming_loss, classification_report, jaccard_score # Voorspellingen Y_pred = clf.predict(X_test) # Hamming Loss print(f"Hamming Loss: {hamming_loss(Y_test, Y_pred):.4f}") # Jaccard Score (per label of gemiddeld) print(f"Jaccard (micro): {jaccard_score(Y_test, Y_pred, average='micro'):.4f}") print(f"Jaccard (macro): {jaccard_score(Y_test, Y_pred, average='macro'):.4f}") # Gedetailleerde classificatie rapport print(classification_report(Y_test, Y_pred, target_names=mlb.classes_)) ``` Stap 4: Verbeteringen en optimalisaties ---------------------------------------- - Experimenteer met verschillende vectorisatie-methoden (bijvoorbeeld CountVectorizer). - Pas hyperparameters aan (bijvoorbeeld regularisatieparameter van Logistic Regression). - Overweeg andere classifiers zoals Random Forest, SVM, of deep learning modellen. - Gebruik cross-validatie voor betere schatting van prestaties. Samenvatting ------------ - Combineer tekstuele functies tot één tekstuele kolom. - Vectoriseer tekst met TF-IDF. - Encodeer labels met MultiLabelBinarizer. - Split data in training en test. - Train een multi-label classificatiemodel (bijvoorbeeld OneVsRestClassifier met Logistic Regression). - Evalueer met geschikte metrics. Ik hoop dat dit je een goede start geeft! Mocht je verdere hulp nodig hebben, laat het gerust weten.

Zeker, hier is een gedetailleerd stappenplan met voorbeeldcode voor multi-label classificatie in Scikit-learn: ## Stap 1: Data Voorbereiding ```python import pandas as pd import numpy as np from sklearn.feature_extraction.text import TfidfVectorizer from sklearn.preprocessing import MultiLabelBinarizer from sklearn.model_selection import train_test_split from sklearn.linear_model import LogisticRegression from sklearn.multiclass import OneVsRestClassifier from sklearn.metrics import classification_report, hamming_loss, accuracy_score # Laad je dataset # Stel dat je DataFrame 'df' heet met kolommen: 'titel', 'beschrijving', 'trefwoorden', 'genres' df = pd.read_csv('films_dataset.csv') # Combineer tekstuele features df['gecombineerde_tekst'] = df['titel'] + ' ' + df['beschrijving'] + ' ' + df['trefwoorden'] # Converteer genres naar lijstvorm (als ze als string zijn opgeslagen) df['genres_lijst'] = df['genres'].apply(lambda x: x.split(',') if isinstance(x, str) else x) # Initialiseer MultiLabelBinarizer mlb = MultiLabelBinarizer() # Transformeer genres naar binaire matrix y = mlb.fit_transform(df['genres_lijst']) # Bewaar de genre labels voor later genre_labels = mlb.classes_ ``` ## Stap 2: Feature Extractie ```python # Gebruik TF-IDF voor tekstvectorisatie tfidf_vectorizer = TfidfVectorizer( max_features=10000, stop_words='english', # of 'dutch' als je Nederlandse tekst hebt ngram_range=(1, 2), min_df=2 ) # Transformeer tekst naar TF-IDF features X = tfidf_vectorizer.fit_transform(df['gecombineerde_tekst']) # Split data in train en test sets X_train, X_test, y_train, y_test = train_test_split( X, y, test_size=0.2, random_state=42, stratify=y ) ``` ## Stap 3: Model Training ```python # Initialiseer het model model = OneVsRestClassifier( LogisticRegression( random_state=42, max_iter=1000, class_weight='balanced' # belangrijk voor onbalans in genres ) ) # Train het model model.fit(X_train, y_train) # Maak voorspellingen y_pred = model.predict(X_test) y_pred_proba = model.predict_proba(X_test) # Kansvoorspellingen ``` ## Stap 4: Evaluatie ```python def evaluate_multilabel_model(y_true, y_pred, genre_labels): """Evalueer multi-label classificatie model""" print("=== MULTI-LABEL CLASSIFICATIE EVALUATIE ===\n") # Hamming Loss (lager is beter) hamming = hamming_loss(y_true, y_pred) print(f"Hamming Loss: {hamming:.4f}") # Subset Accuracy (exacte match) subset_acc = accuracy_score(y_true, y_pred) print(f"Subset Accuracy: {subset_acc:.4f}") # Gedetailleerde classificatie rapport print("\nGedetailleerd Classificatie Rapport:") print(classification_report(y_true, y_pred, target_names=genre_labels, zero_division=0)) # Genre-specifieke metrics print("\nGenre-specifieke Prestaties:") for i, genre in enumerate(genre_labels): precision = classification_report(y_true, y_pred, target_names=genre_labels, output_dict=True, zero_division=0)[genre]['precision'] recall = classification_report(y_true, y_pred, target_names=genre_labels, output_dict=True, zero_division=0)[genre]['recall'] f1 = classification_report(y_true, y_pred, target_names=genre_labels, output_dict=True, zero_division=0)[genre]['f1-score'] print(f"{genre}: Precision={precision:.3f}, Recall={recall:.3f}, F1={f1:.3f}") # Evalueer het model evaluate_multilabel_model(y_test, y_pred, genre_labels) ``` ## Stap 5: Gebruik voor Voorspellingen ```python def predict_genres(tekst, model, tfidf_vectorizer, mlb, drempel=0.3): """Voorspel genres voor nieuwe tekst""" # Transformeer tekst naar TF-IDF tekst_tfidf = tfidf_vectorizer.transform([tekst]) # Krijg kansvoorspellingen kansen = model.predict_proba(tekst_tfidf)[0] # Selecteer genres boven drempelwaarde voorspelde_genres = [] for i, kans in enumerate(kansen): if kans > drempel: voorspelde_genres.append(mlb.classes_[i]) return voorspelde_genres, kansen # Voorbeeld gebruik nieuwe_film_tekst = "Een spannende science fiction film over ruimtereizen en aliens" genres, kansen = predict_genres(nieuwe_film_tekst, model, tfidf_vectorizer, mlb) print(f"Voorspelde genres: {genres}") ``` ## Stap 6: Geavanceerde Optimalisatie (Optioneel) ```python from sklearn.model_selection import GridSearchCV from sklearn.pipeline import Pipeline # Maak een pipeline pipeline = Pipeline([ ('tfidf', TfidfVectorizer()), ('clf', OneVsRestClassifier(LogisticRegression())) ]) # Definieer parameter grid parameters = { 'tfidf__max_features': [5000, 10000], 'tfidf__ngram_range': [(1, 1), (1, 2)], 'clf__estimator__C': [0.1, 1, 10] } # Voer grid search uit (kan lang duren) grid_search = GridSearchCV( pipeline, parameters, cv=3, scoring='f1_micro', # of 'accuracy', 'f1_macro' n_jobs=-1, verbose=1 ) # Train met grid search # grid_search.fit(df['gecombineerde_tekst'], y) ``` ## Belangrijke Tips: 1. **Tekst Preprocessing**: Overweeg stemming/lemmatisering voor betere resultaten 2. **Class Weight**: Gebruik `class_weight='balanced'` voor ongelijke genre distributie 3. **Drempel Afstelling**: Experimenteer met verschillende drempelwaarden voor predicties 4. **Feature Engineering**: Overweeg aanvullende features zoals filmduur, jaar, etc. 5. **Cross-validatie**: Gebruik stratified k-fold voor betrouwbaardere evaluatie Dit geeft je een solide basis voor multi-label classificatie van filmgenres!