Name That LLM:
ML vs DL
Classification

# Install dependencies as needed:
# pip install kagglehub[pandas-datasets] pandas numpy matplotlib seaborn scikit-learn tensorflow

import kagglehub
from kagglehub import KaggleDatasetAdapter
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

# Set the path to the file you'd like to load
# Check the Kaggle dataset page → Files tab for the exact filename
file_path = "name_that_llm.csv"

# Load the latest version
df = kagglehub.load_dataset(
    KaggleDatasetAdapter.PANDAS,
    "prvsiyan/prvsiyans-extended-name-that-llm-dataset",
    file_path,
)

print("Dataset shape:", df.shape)
print("First 5 records:")
print(df.head())
print(df.info())
print(df.describe())

# Check for missing values
print("Missing values:\n", df.isnull().sum())
print("\nDuplicates:", df.duplicated().sum())

categorical_cols = df.select_dtypes(include=['object']).columns
numeric_cols = df.select_dtypes(include=[np.number]).columns
print(f"\nCategorical columns: {list(categorical_cols)}")
print(f"Numeric columns: {list(numeric_cols)}")

# Auto-detect the classification target column
target_col = None
for candidate in ['llm', 'model', 'label', 'class', 'category',
               'target', 'name', 'llm_name', 'model_name', 'type']:
    if candidate in df.columns.str.lower().tolist():
        target_col = df.columns[df.columns.str.lower() == candidate][0]
        break
if target_col is None:
    if len(categorical_cols) > 0:
        target_col = categorical_cols[0]
    else:
        target_col = numeric_cols[-1]
        df[target_col] = pd.qcut(df[target_col], q=2, labels=[0, 1])

print(f"Classification target column: '{target_col}'")
print(f"Number of classes: {df[target_col].nunique()}")
print(f"Class distribution:\n{df[target_col].value_counts()}")

# Plot target distribution
plt.figure(figsize=(10, 6))
sns.countplot(data=df, x=target_col, palette='viridis')
plt.title(f'Distribution of {target_col}')
plt.xticks(rotation=45)
plt.tight_layout()
plt.show()

# Distributions of key numeric features
key_cols = list(numeric_cols[:4])
if len(key_cols) > 0:
    fig, axes = plt.subplots(1, len(key_cols), figsize=(5*len(key_cols), 5))
    colors = ['#4C72B0', '#55A868', '#C44E52', '#8172B2']
    for ax, col, color in zip(axes, key_cols, colors):
        sns.histplot(df[col], kde=True, color=color, ax=ax)
        ax.axvline(df[col].mean(), color='black', linestyle='--', label=f"Mean: {df[col].mean():.1f}")
        ax.set_title(f'Distribution of {col}')
        ax.legend()
    plt.tight_layout()
    plt.show()

# Correlation heatmap
if len(numeric_cols) > 1:
    plt.figure(figsize=(10, 8))
    sns.heatmap(df[numeric_cols].corr(), annot=True, cmap='coolwarm', fmt='.2f',
                square=True, linewidths=0.5)
    plt.title('Correlation Between Numeric Features')
    plt.show()

from sklearn.preprocessing import LabelEncoder, StandardScaler
from sklearn.model_selection import train_test_split

data = df.copy()
data = data.dropna()

le = LabelEncoder()
# Encode all categorical columns
for col in categorical_cols:
    data[col] = le.fit_transform(data[col].astype(str))

# If target wasn't in categorical_cols but is object, encode it
if data[target_col].dtype == 'object':
    data[target_col] = le.fit_transform(data[target_col].astype(str))

# Define features (X) and target (y)
X = data.drop(columns=[target_col])
y = data[target_col]

# Train/test split (80/20)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42)

# Feature scaling (no leakage)
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

num_classes = len(np.unique(y_train))
print(f"Number of classes for modeling: {num_classes}")

from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.svm import SVC
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, confusion_matrix

# Use 'weighted' average for multiclass compatibility
avg_method = 'weighted' if num_classes > 2 else 'binary'

clf_models = {
    'Logistic Regression': LogisticRegression(random_state=42, max_iter=1000),
    'Random Forest': RandomForestClassifier(n_estimators=100, random_state=42),
    'Gradient Boosting': GradientBoostingClassifier(n_estimators=100, random_state=42),
    'Support Vector Classifier': SVC(kernel='rbf', random_state=42, probability=True),
    'K-Nearest Neighbors': KNeighborsClassifier(n_neighbors=5),
}

clf_results = []
for name, model in clf_models.items():
    model.fit(X_train_scaled, y_train)
    y_pred = model.predict(X_test_scaled)
    clf_results.append({
        'Model': name,
        'Accuracy': round(accuracy_score(y_test, y_pred), 4),
        'Precision': round(precision_score(y_test, y_pred, average=avg_method, zero_division=0), 4),
        'Recall': round(recall_score(y_test, y_pred, average=avg_method, zero_division=0), 4),
        'F1 Score': round(f1_score(y_test, y_pred, average=avg_method, zero_division=0), 4),
    })

clf_results_df = pd.DataFrame(clf_results).sort_values('Accuracy', ascending=False)
print(clf_results_df.to_string(index=False))

# Confusion matrix for best model
best_clf = clf_models[clf_results_df.iloc[0]['Model']]
y_pred_best = best_clf.predict(X_test_scaled)
cm = confusion_matrix(y_test, y_pred_best)
plt.figure(figsize=(8, 6))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues')
plt.title(f'Confusion Matrix — {clf_results_df.iloc[0]["Model"]}')
plt.show()

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout, BatchNormalization
from tensorflow.keras.callbacks import EarlyStopping, ReduceLROnPlateau

tf.random.set_seed(42)
np.random.seed(42)

def build_dl_classification_model(input_dim, num_classes):
    model = Sequential([
        Dense(128, activation='relu', input_shape=(input_dim,)),
        BatchNormalization(), Dropout(0.3),
        Dense(64, activation='relu'),
        BatchNormalization(), Dropout(0.2),
        Dense(32, activation='relu'),
        Dropout(0.1)
    ])
    
    if num_classes == 2:
        model.add(Dense(1, activation='sigmoid'))
        model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
    else:
        model.add(Dense(num_classes, activation='softmax'))
        model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
    return model

dl_clf_model = build_dl_classification_model(X_train_scaled.shape[1], num_classes)

early_stop = EarlyStopping(monitor='val_loss', patience=20, restore_best_weights=True, verbose=1)
reduce_lr = ReduceLROnPlateau(monitor='val_loss', factor=0.5, patience=10, min_lr=1e-6, verbose=1)

history = dl_clf_model.fit(
    X_train_scaled, y_train,
    validation_split=0.2,
    epochs=200,
    batch_size=32,
    callbacks=[early_stop, reduce_lr],
    verbose=1
)

# Evaluate DL
dl_pred_prob = dl_clf_model.predict(X_test_scaled)
if num_classes == 2:
    dl_pred = (dl_pred_prob >= 0.5).astype(int).flatten()
else:
    dl_pred = np.argmax(dl_pred_prob, axis=1)

dl_acc = accuracy_score(y_test, dl_pred)
dl_f1 = f1_score(y_test, dl_pred, average=avg_method, zero_division=0)
print(f"\nDL Classification - Accuracy: {dl_acc:.4f}, F1 Score: {dl_f1:.4f}")

# Classification comparison
combined_clf = pd.concat([clf_results_df, pd.DataFrame([{
    'Model': 'Deep Learning (Neural Network)',
    'Accuracy': round(dl_acc, 4),
    'Precision': round(precision_score(y_test, dl_pred, average=avg_method, zero_division=0), 4),
    'Recall': round(recall_score(y_test, dl_pred, average=avg_method, zero_division=0), 4),
    'F1 Score': round(dl_f1, 4)
}])], ignore_index=True).sort_values('Accuracy', ascending=False)

print(combined_clf.to_string(index=False))