This code implements a Particle Swarm Optimization (PSO) algorithm to...

May 12, 2024 at 02:37 PM

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score

data = pd.read_csv(r"C:\Users\ASUS\Desktop\Coding\Machine Learning Projects\enron_spam_data.csv")
X = data["Message"]       
y = data["Spam/Ham"]
class Particle:
    def __init__(self, num_features):
        self.position = np.random.choice([0, 1], size=num_features)
        self.velocity = np.random.uniform(-1, 1, size=num_features)
        self.best_position = self.position
        self.best_score = float('-inf')

def fitness_function(features, X_train, X_test, y_train, y_test):
    clf = RandomForestClassifier(n_estimators=100, random_state=42)
    clf.fit(X_train[:, features], y_train)
    y_pred = clf.predict(X_test[:, features])
    return accuracy_score(y_test, y_pred)

def particle_swarm_optimization(X, y, num_particles, num_iterations):
    num_features = X.shape[1]
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
    particles = [Particle(num_features) for _ in range(num_particles)]
    global_best_position = None
    global_best_score = float('-inf')

    for _ in range(num_iterations):
        for particle in particles:
            score = fitness_function(particle.position, X_train, X_test, y_train, y_test)
            if score > particle.best_score:
                particle.best_position = particle.position
                particle.best_score = score
            if score > global_best_score:
                global_best_position = particle.position
                global_best_score = score

        for particle in particles:
            inertia_weight = 0.7
            c1 = 1.5
            c2 = 1.5
            r1 = np.random.rand(num_features)
            r2 = np.random.rand(num_features)
            particle.velocity = inertia_weight * particle.velocity + \
                    c1 * r1 * np.logical_xor(particle.best_position, particle.position) + \
                    c2 * r2 * np.logical_xor(global_best_position, particle.position)
            particle.position = (particle.position + particle.velocity) > 0

    return global_best_position



# For demonstration purposes, let's create synthetic data
X = np.random.rand(100, 10)  # Example: 100 samples, 10 features
y = np.random.randint(2, size=100)  # Binary labels

# Call the PSO function
selected_features = particle_swarm_optimization(X, y, num_particles=20, num_iterations=50)

# Use selected features for training your classifier
X_selected = X[:, selected_features]

# Train your classifier (example with RandomForestClassifier)
X_train, X_test, y_train, y_test = train_test_split(X_selected, y, test_size=0.2, random_state=42)
clf = RandomForestClassifier(n_estimators=100, random_state=42)
clf.fit(X_train, y_train)

# Evaluate your classifier
y_pred = clf.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print("Accuracy:", accuracy*100)

This code implements a Particle Swarm Optimization (PSO) algorithm to select the best features for a classifier. It reads data from a CSV file, initializes particles with random positions and velocities, calculates fitness using a random forest classifier, updates particle positions based on the best solutions found so far, and returns the best feature selection. Finally, it trains a RandomForestClassifier on the selected features and evaluates its accuracy on a test set.

Generate your own explanations

Download our vscode extension

Read other generated explanations

Built by @thebuilderjr