1

Pasted Nov 2, 2026, 1:20 PM3 files270 lines

Scan to open on your phone

Point a camera at the QR code - it opens this exact paste, no app needed.

https://codepastes.com/hii

1Python

import pandas as pd
import numpy as np

from sklearn.preprocessing import StandardScaler, LabelEncoder
from sklearn.impute import SimpleImputer

# Sample open-access style dataset (HR/Employee Attrition style)
data = {
    'Age': [25, 32, np.nan, 45, 29, 38, np.nan, 51],
    'Department': ['Sales', 'IT', 'HR', 'IT', 'Sales', np.nan, 'HR', 'IT'],
    'Salary': [40000, 55000, 48000, np.nan, 42000, 60000, 47000, 72000],
    'YearsExperience': [1, 5, 3, 12, 2, 8, 4, 15],
    'Attrition': ['Yes', 'No', 'No', 'No', 'Yes', 'No', 'Yes', 'No']
}

# Create DataFrame
df = pd.DataFrame(data)

print("Original Dataset:\n")
print(df)

print("\nMissing values per column:\n")
print(df.isnull().sum())

# -------------------------------------------------
# Step 1: Handle Missing Values
# -------------------------------------------------

# Numerical columns - Mean Imputation
num_imputer = SimpleImputer(strategy='mean')
df['Age'] = num_imputer.fit_transform(df[['Age']])
df['Salary'] = num_imputer.fit_transform(df[['Salary']])

# Categorical column - Most Frequent Imputation
cat_imputer = SimpleImputer(strategy='most_frequent')
df['Department'] = cat_imputer.fit_transform(df[['Department']]).ravel()

print("\nAfter Handling Missing Values:\n")
print(df)

# -------------------------------------------------
# Step 2: Encode Categorical Variables
# -------------------------------------------------

# Label Encoding for Target Variable
le = LabelEncoder()
df['Attrition_Encoded'] = le.fit_transform(df['Attrition'])

# One-Hot Encoding for Department
df_encoded = pd.get_dummies(
    df,
    columns=['Department'],
    prefix='Dept'
)

print("\nAfter One-Hot Encoding 'Department':\n")
print(df_encoded)

# -------------------------------------------------
# Step 3: Feature Scaling
# -------------------------------------------------

scaler = StandardScaler()

num_cols = ['Age', 'Salary', 'YearsExperience']

df_encoded[num_cols] = scaler.fit_transform(df_encoded[num_cols])

print("\nAfter Feature Scaling (Standardization):\n")
print(df_encoded[num_cols].round(3))

print("\nFinal Model-Ready Dataset Shape:", df_encoded.shape)

2Python

import numpy as np
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt

from sklearn.datasets import load_wine
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score

import time
import os

# Create directory if it doesn't exist
os.makedirs("imgs", exist_ok=True)

# Load dataset
wine = load_wine()
X, y = wine.data, wine.target

print("Dataset shape:", X.shape, " Classes:", np.unique(y))

# Standardize features
X_scaled = StandardScaler().fit_transform(X)

# Train-test split
X_train, X_test, y_train, y_test = train_test_split(
    X_scaled, y, test_size=0.3, random_state=42
)

# -----------------------------
# Baseline (All 13 Features)
# -----------------------------
t0 = time.time()
clf = LogisticRegression(max_iter=1000)
clf.fit(X_train, y_train)

acc_full = accuracy_score(y_test, clf.predict(X_test))
t_full = time.time() - t0

# -----------------------------
# PCA (2 Components)
# -----------------------------
pca = PCA(n_components=2)

X_train_pca = pca.fit_transform(X_train)
X_test_pca = pca.transform(X_test)

t0 = time.time()
clf_pca = LogisticRegression(max_iter=1000)
clf_pca.fit(X_train_pca, y_train)

acc_pca = accuracy_score(y_test, clf_pca.predict(X_test_pca))
t_pca = time.time() - t0

print("\nPCA Explained Variance Ratio (2 components):")
print(pca.explained_variance_ratio_)

print(f"Total variance retained: {sum(pca.explained_variance_ratio_) * 100:.2f}%")

# -----------------------------
# LDA (2 Components)
# -----------------------------
lda = LinearDiscriminantAnalysis(n_components=2)

X_train_lda = lda.fit_transform(X_train, y_train)
X_test_lda = lda.transform(X_test)

t0 = time.time()
clf_lda = LogisticRegression(max_iter=1000)
clf_lda.fit(X_train_lda, y_train)

acc_lda = accuracy_score(y_test, clf_lda.predict(X_test_lda))
t_lda = time.time() - t0

# -----------------------------
# Results
# -----------------------------
print(f"\nAccuracy with all 13 features : {acc_full:.4f} (train time: {t_full*1000:.2f} ms)")
print(f"Accuracy with PCA (2 comp)    : {acc_pca:.4f} (train time: {t_pca*1000:.2f} ms)")
print(f"Accuracy with LDA (2 comp)    : {acc_lda:.4f} (train time: {t_lda*1000:.2f} ms)")

# -----------------------------
# Visualization
# -----------------------------
fig, axs = plt.subplots(1, 2, figsize=(11, 4.5))

colors = ['#4C72B0', '#DD8452', '#55A868']

for target, color, label in zip([0, 1, 2], colors, wine.target_names):
    axs[0].scatter(
        X_train_pca[y_train == target, 0],
        X_train_pca[y_train == target, 1],
        c=color,
        label=label,
        s=25
    )

    axs[1].scatter(
        X_train_lda[y_train == target, 0],
        X_train_lda[y_train == target, 1],
        c=color,
        label=label,
        s=25
    )

axs[0].set_title("PCA - Wine Dataset (2 Components)")
axs[0].set_xlabel("PC1")
axs[0].set_ylabel("PC2")
axs[0].legend()

axs[1].set_title("LDA - Wine Dataset (2 Components)")
axs[1].set_xlabel("LD1")
axs[1].set_ylabel("LD2")
axs[1].legend()

plt.tight_layout()
plt.savefig("imgs/a2_pca_lda.png", dpi=130)

print("\nPlot saved as imgs/a2_pca_lda.png")

3Python

import numpy as np
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt

from sklearn.datasets import load_diabetes
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score

# Load dataset
diabetes = load_diabetes(as_frame=True)
X = diabetes.data
y = diabetes.target

print("Features:", list(X.columns))
print("Dataset shape:", X.shape)
print(X.head(), "\n")

# Split dataset
X_train, X_test, y_train, y_test = train_test_split(
    X,
    y,
    test_size=0.2,
    random_state=42
)

# Create and train model
model = LinearRegression()
model.fit(X_train, y_train)

# Predict
y_pred = model.predict(X_test)

# Evaluation metrics
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
r2 = r2_score(y_test, y_pred)

# Print coefficients
print("Model Coefficients:")
for feature, coefficient in zip(X.columns, model.coef_):
    print(f"{feature:>6}: {coefficient:8.3f}")

print(f"Intercept: {model.intercept_:.3f}\n")

print(f"MSE  : {mse:.3f}")
print(f"RMSE : {rmse:.3f}")
print(f"R2   : {r2:.4f}")

# Plot Actual vs Predicted
plt.figure(figsize=(6, 5))
plt.scatter(
    y_test,
    y_pred,
    alpha=0.7,
    color="#4C72B0",
    edgecolor="k"
)

plt.plot(
    [y.min(), y.max()],
    [y.min(), y.max()],
    "r--",
    lw=2
)

plt.xlabel("Actual Disease Progression")
plt.ylabel("Predicted Disease Progression")
plt.title("Multiple Linear Regression: Actual vs Predicted")

plt.tight_layout()
plt.savefig("imgs/a3_mlr.png", dpi=130)

print("\nPlot saved.")

7,056 chars · codepastes.com