Hier is een voorbeeld van een Python-script dat een machine learning model bouwt om e-mails (of in jouw geval productrecensies) te classificeren als spam of geen spam gebaseerd op tekstkenmerken. Ik zal ook de gebruikte algoritmen, preprocessingsstappen en evaluatietechnieken uitleggen. **Belangrijke opmerking:** Je gaf aan dat de dataset bestaat uit productrecensies met sentimentlabels, maar je vroeg specifiek naar spamclassificatie. Ik zal ervan uitgaan dat je dit voorbeeld wilt aanpassen voor spamclassificatie. Indien je daadwerkelijk een spamdataset hebt, gebruik je die dataset. --- ### Stap 1: Importeren van benodigde libraries ```python import pandas as pd from sklearn.model_selection import train_test_split from sklearn.feature_extraction.text import TfidfVectorizer from sklearn.naive_bayes import MultinomialNB from sklearn.metrics import classification_report, confusion_matrix, accuracy_score ``` ### Stap 2: Dataset laden ```python # Laad de dataset # Vervang 'jouw_dataset.csv' door de juiste bestandsnaam df = pd.read_csv('jouw_dataset.csv') # Veronderstel dat de tekst in 'text' kolom staat en de labels in 'label' kolom texts = df['text'] labels = df['label'] ``` ### Stap 3: Data preprocessen - **Tekstopschoning:** verwijderen van speciale tekens, hoofdletters omzetten naar kleine letters. - **Tokenisatie en vectorisatie:** omzetten van tekst naar numerieke features met TF-IDF. ```python # Tekst opschonen (optioneel, afhankelijk van dataset) import re def clean_text(text): text = text.lower() text = re.sub(r'\W+', ' ', text) # verwijder speciale tekens return text texts = texts.apply(clean_text) ``` ### Stap 4: Dataset splitsen ```python X_train, X_test, y_train, y_test = train_test_split( texts, labels, test_size=0.2, random_state=42 ) ``` ### Stap 5: Tekst naar numerieke features omzetten ```python vectorizer = TfidfVectorizer(max_features=5000) X_train_tfidf = vectorizer.fit_transform(X_train) X_test_tfidf = vectorizer.transform(X_test) ``` **Uitleg:** - **TfidfVectorizer:** zet tekst om in een vector van term-frequentie-inverse document frequentie, wat helpt om belangrijke woorden te benadrukken en minder belangrijke te verminderen. ### Stap 6: Model trainen ```python model = MultinomialNB() model.fit(X_train_tfidf, y_train) ``` **Uitleg algoritme:** - **Multinomial Naive Bayes:** Een eenvoudig en effectief algoritme voor tekstclassificatie dat gebaseerd is op Bayesiaanse statistiek. Het veronderstelt dat features (woorden) conditioneel onafhankelijk zijn gegeven het label. Het is snel en presteert goed bij hoge-dimensie tekstgegevens. ### Stap 7: Model evalueren ```python y_pred = model.predict(X_test_tfidf) print("Accuracy:", accuracy_score(y_test, y_pred)) print("Confusion Matrix:\n", confusion_matrix(y_test, y_pred)) print("Classificatie Rapport:\n", classification_report(y_test, y_pred)) ``` **Evaluatietechnieken:** - **Accuracy:** percentage correcte voorspellingen. - **Confusie matrix:** geeft inzicht in de verdeling van correcte en foutieve classificaties. - **Classification report:** met precieze, recall en F1-score per klasse. --- ### Samenvatting - **Preprocessing:** tekst opschonen, converteren naar TF-IDF features. - **Algoritme:** Multinomial Naive Bayes, geschikt voor tekstclassificatie. - **Evaluatie:** accuracy, confusion matrix, classification report. --- ### Aanpassing voor spamclassificatie - Zorg dat je dataset de juiste kolommen bevat (bijvoorbeeld 'email_text' en 'spam_label'). - Pas de kolomnamen aan in de code. - Indien nodig, voeg meer preprocessing toe (stopwoorden verwijderen, stemming, etc.). --- **Wil je dat ik het script verder uitbreid of aanpas voor jouw specifieke dataset?**

Hallo! Ik help je graag een Python script te schrijven voor spamdetectie. Gezien je dataset met productrecensies en sentimentlabels, zal ik een aangepaste versie maken voor e-mailclassificatie. Eerst de benodigde imports: ```python import pandas as pd import numpy as np from sklearn.model_selection import train_test_split from sklearn.feature_extraction.text import TfidfVectorizer from sklearn.naive_bayes import MultinomialNB from sklearn.linear_model import LogisticRegression from sklearn.svm import SVC from sklearn.ensemble import RandomForestClassifier from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, confusion_matrix, classification_report import re import nltk from nltk.corpus import stopwords from nltk.stem import SnowballStemmer # Download NLTK data (eenmalig uitvoeren) nltk.download('stopwords') ``` ## Data Preprocessing Stappen: ```python def preprocess_text(text): """ Text preprocessing voor NLP-taken """ if isinstance(text, str): # Convert naar lowercase text = text.lower() # Verwijder speciale characters en nummers text = re.sub(r'[^a-zA-Z\s]', '', text) # Verwijder stopwoorden stop_words = set(stopwords.words('dutch')) words = text.split() words = [word for word in words if word not in stop_words] # Stemming (woordstam extractie) stemmer = SnowballStemmer('dutch') words = [stemmer.stem(word) for word in words] return ' '.join(words) return '' ``` ## Hoofdscript: ```python # Laad de dataset def load_and_prepare_data(file_path): """ Laad en prepareer de dataset """ df = pd.read_csv(file_path) # Hernoem kolommen voor consistentie (pas aan naar je dataset) df = df.rename(columns={'review_text': 'text', 'sentiment': 'label'}) # Converteer labels (pas aan naar je specifieke labels) df['label'] = df['label'].map({'positive': 0, 'negative': 1}) # Voorbeeld mapping # Preprocess tekst df['cleaned_text'] = df['text'].apply(preprocess_text) return df # TF-IDF Vectorization def create_features(texts): """ Converteer tekst naar TF-IDF features """ vectorizer = TfidfVectorizer( max_features=5000, # Maximum aantal features min_df=5, # Minimale document frequentie max_df=0.7, # Maximale document frequentie ngram_range=(1, 2) # Unigrammen en bigrammen ) features = vectorizer.fit_transform(texts) return features, vectorizer # Model training en evaluatie def train_and_evaluate_model(X_train, X_test, y_train, y_test, model, model_name): """ Train en evalueer een model """ # Train het model model.fit(X_train, y_train) # Maak voorspellingen y_pred = model.predict(X_test) # Bereken metrics accuracy = accuracy_score(y_test, y_pred) precision = precision_score(y_test, y_pred) recall = recall_score(y_test, y_pred) f1 = f1_score(y_test, y_pred) print(f"\n{model_name} Resultaten:") print(f"Accuracy: {accuracy:.4f}") print(f"Precision: {precision:.4f}") print(f"Recall: {recall:.4f}") print(f"F1-Score: {f1:.4f}") print("\nConfusion Matrix:") print(confusion_matrix(y_test, y_pred)) return model, accuracy # Hoofdfunctie def main(): # Laad data df = load_and_prepare_data('jouw_dataset.csv') # Split data X = df['cleaned_text'] y = df['label'] X_train, X_test, y_train, y_test = train_test_split( X, y, test_size=0.2, random_state=42, stratify=y ) # Creëer features X_train_features, vectorizer = create_features(X_train) X_test_features = vectorizer.transform(X_test) # Verschillende modellen proberen models = { 'Naive Bayes': MultinomialNB(), 'Logistic Regression': LogisticRegression(max_iter=1000), 'SVM': SVC(kernel='linear'), 'Random Forest': RandomForestClassifier(n_estimators=100, random_state=42) } results = {} for name, model in models.items(): trained_model, accuracy = train_and_evaluate_model( X_train_features, X_test_features, y_train, y_test, model, name ) results[name] = {'model': trained_model, 'accuracy': accuracy} # Best model selecteren best_model_name = max(results, key=lambda x: results[x]['accuracy']) best_model = results[best_model_name]['model'] print(f"\nBest model: {best_model_name}") return best_model, vectorizer if __name__ == "__main__": model, vectorizer = main() ``` ## Gebruikte Algoritmen Uitleg: ### 1. **Naive Bayes (MultinomialNB)** - **Werking**: Gebaseerd op Bayes' theorema met aanname van onafhankelijkheid tussen features - **Voordelen**: Snel, goed voor tekstclassificatie, werkt goed met hoge dimensionaliteit - **Nadelen**: Aanname van feature onafhankelijkheid is niet altijd realistisch ### 2. **Logistic Regression** - **Werking**: Modelleert de waarschijnlijkheid behorende bij elke klasse - **Voordelen**: Goede baseline, interpreteerbare coëfficiënten - **Nadelen**: Lineaire beslissingsgrenzen ### 3. **Support Vector Machine (SVM)** - **Werking**: Vindt de optimale hypervlak om klassen te scheiden - **Voordelen**: Effectief in hoge dimensies, goed voor tekstdata - **Nadelen**: Kan traag zijn bij grote datasets ### 4. **Random Forest** - **Werking**: Ensemble van beslissingsbomen - **Voordelen**: Goede prestaties, minder gevoelig voor overfitting - **Nadelen**: Minder interpreteerbaar, trager dan lineaire modellen ## Evaluatietechnieken: ### 1. **Accuracy** - Percentage correcte voorspellingen - Goed voor gebalanceerde datasets ### 2. **Precision** - Hoeveel van de voorspelde spam daadwerkelijk spam is - Belangrijk wanneer false positives kostbaar zijn ### 3. **Recall** - Hoeveel van de werkelijke spam correct wordt gedetecteerd - Belangrijk wanneer false negatives kostbaar zijn ### 4. **F1-Score** - Harmonisch gemiddelde van precision en recall - Goede overall metric voor ongebalanceerde datasets ### 5. **Confusion Matrix** - Geeft gedetailleerd overzicht van correcte en incorrecte voorspellingen ## Gebruiksaanwijzing: 1. **Dataset voorbereiding**: Zorg dat je CSV kolommen 'text' en 'label' bevat 2. **Label mapping**: Pas de label mapping aan naar je specifieke dataset 3. **Hyperparameter tuning**: Experimenteer met verschillende parameters 4. **Cross-validatie**: Overweeg k-fold cross-validatie voor betrouwbaardere resultaten Dit script geeft je een solide basis voor spamdetectie en kan eenvoudig worden aangepast voor verschillende soorten tekstclassificatietaken!