SUPERVISED LEARNING EXAMPLE

from sklearn.datasets import load_iris

# Load Iris data

iris = load_iris()
X = iris.data
y = iris.target

# Feature names and target classes

print("Feature names:", iris.feature_names)
print("Target names:", iris.target_names)

# Sample data
print("First 5 samples:\n", X[:5])
print("First 5 targets:\n", y[:5])
import pandas as pd

df = pd.DataFrame(X, columns=iris.feature_names)
df['species'] = [iris.target_names[i] for i in y]

# Display first few rows

print(df.head())

from sklearn.model_selection import train_test_split

# 80% train, 20% test

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

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

from sklearn.tree import DecisionTreeClassifier

model = DecisionTreeClassifier()
model.fit(X_train_scaled, y_train)

y_pred = model.predict(X_test_scaled)

from sklearn.metrics import accuracy_score, classification_report, confusion_matrix

print("Accuracy:", accuracy_score(y_test, y_pred))
print("Classification Report:\n", classification_report(y_test, y_pred,
target_names=iris.target_names))

X_reduced = X[:, [0, 2, 3]] # keep indices 0, 2, 3

X_train_r, X_test_r, y_train_r, y_test_r = train_test_split(X_reduced, y, test_size=0.2,

random_state=42)

scaler_r = StandardScaler()
X_train_r_scaled = scaler_r.fit_transform(X_train_r)
X_test_r_scaled = scaler_r.transform(X_test_r)

model_r = DecisionTreeClassifier()
model_r.fit(X_train_r_scaled, y_train_r)
y_pred_r = model_r.predict(X_test_r_scaled)

print("Accuracy without 'sepal width':", accuracy_score(y_test_r, y_pred_r))

model_ns = DecisionTreeClassifier()
model_ns.fit(X_train, y_train)
y_pred_ns = model_ns.predict(X_test)

print("Accuracy without scaling:", accuracy_score(y_test, y_pred_ns))

import seaborn as sns

import matplotlib.pyplot as plt
from sklearn.metrics import confusion_matrix

cm = confusion_matrix(y_test, y_pred)
sns.heatmap(cm, annot=True, cmap='Blues', xticklabels=iris.target_names,
yticklabels=iris.target_names)
plt.xlabel('Predicted')
plt.ylabel('True')
plt.title('Confusion Matrix')
plt.show()
UNSUPERVISED LEARNING EXAMPLE

# Step 1: Load libraries

import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
from sklearn.cluster import KMeans
from sklearn.decomposition import PCA

# Step 2: Load the Iris dataset (without using target labels)

iris = load_iris()
X = iris.data
feature_names = iris.feature_names
df = pd.DataFrame(X, columns=feature_names)

# Step 3: Use KMeans clustering

kmeans = KMeans(n_clusters=3, random_state=42)
df['cluster'] = kmeans.fit_predict(X)

# Step 4: Reduce dimensions for visualization using PCA

pca = PCA(n_components=2)
components = pca.fit_transform(X)
df['PC1'] = components[:, 0]
df['PC2'] = components[:, 1]

# Step 5: Plot the clusters

sns.scatterplot(data=df, x='PC1', y='PC2', hue='cluster', palette='Set1')
plt.title("K-Means Clustering (Unsupervised)")
plt.show()

# Optional: Add actual labels for visual comparison

df['actual'] = iris.target

# Compare real species and predicted clusters

sns.scatterplot(data=df, x='PC1', y='PC2', hue='actual', palette='Set2')
plt.title("Actual Iris Species")
plt.show()

import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
from sklearn.cluster import KMeans, AgglomerativeClustering, DBSCAN
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler

# Step 2: Load the Iris dataset

iris = load_iris()
X = iris.data
feature_names = iris.feature_names
df = pd.DataFrame(X, columns=feature_names)

def add_pca(df, X):

pca = PCA(n_components=2)
components = pca.fit_transform(X)
df['PC1'] = components[:, 0]
df['PC2'] = components[:, 1]
return df

for k in [2, 3, 4, 5]:

kmeans = KMeans(n_clusters=k, random_state=42)
df_k = df.copy()
df_k['cluster'] = kmeans.fit_predict(X)
df_k = add_pca(df_k, X)

plt.figure()
sns.scatterplot(data=df_k, x='PC1', y='PC2', hue='cluster', palette='Set1')
plt.title(f"KMeans Clustering with k={k}")
plt.show()

agg = AgglomerativeClustering(n_clusters=3)
df_agg = df.copy()
df_agg['cluster'] = agg.fit_predict(X)
df_agg = add_pca(df_agg, X)

plt.figure()
sns.scatterplot(data=df_agg, x='PC1', y='PC2', hue='cluster', palette='Set2')
plt.title("Agglomerative Clustering")
plt.show()

# Standardize data first (important for DBSCAN)

scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

dbscan = DBSCAN(eps=0.8, min_samples=5)

df_db = df.copy()
df_db['cluster'] = dbscan.fit_predict(X_scaled)
df_db = add_pca(df_db, X_scaled)

plt.figure()
sns.scatterplot(data=df_db, x='PC1', y='PC2', hue='cluster', palette='Set3')
plt.title("DBSCAN Clustering")
plt.show()

X_petal = df[['petal length (cm)', 'petal width (cm)']].values

kmeans_petal = KMeans(n_clusters=3, random_state=42)

df_petal = df.copy()
df_petal['cluster'] = kmeans_petal.fit_predict(X_petal)
df_petal = add_pca(df_petal, X_petal)

plt.figure()
sns.scatterplot(data=df_petal, x='PC1', y='PC2', hue='cluster', palette='coolwarm')
plt.title("KMeans on Petal Features Only")
plt.show()

df_labels = add_pca(df.copy(), X)
df_labels['label'] = iris.target

plt.figure()
sns.scatterplot(data=df_labels, x='PC1', y='PC2', hue='label', palette='Dark2')
plt.title("Actual Iris Species Labels")
plt.show()

ENSEMBLE METHODS
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier,
GradientBoostingClassifier, VotingClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score

# Load the Iris dataset

iris = load_iris()
X, y = iris.data, iris.target

# Split into training and test sets

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3,
random_state=42)

rf = RandomForestClassifier(n_estimators=100, random_state=42)
rf.fit(X_train, y_train)
y_pred_rf = rf.predict(X_test)

print("🌳 Random Forest Accuracy:", accuracy_score(y_test, y_pred_rf))

ada = AdaBoostClassifier(n_estimators=50, random_state=42)

ada.fit(X_train, y_train)
y_pred_ada = ada.predict(X_test)

print("⚡ AdaBoost Accuracy:", accuracy_score(y_test, y_pred_ada))

gb = GradientBoostingClassifier(n_estimators=100, random_state=42)
gb.fit(X_train, y_train)
y_pred_gb = gb.predict(X_test)

print("📈 Gradient Boosting Accuracy:", accuracy_score(y_test, y_pred_gb))

log_clf = LogisticRegression(max_iter=200)
svc_clf = SVC(probability=True)

voting_clf = VotingClassifier(
estimators=[('lr', log_clf), ('rf', rf), ('svc', svc_clf)],
voting='hard' # can also be 'soft'
)

voting_clf.fit(X_train, y_train)
y_pred_vote = voting_clf.predict(X_test)

print(" Voting Classifier Accuracy:", accuracy_score(y_test, y_pred_vote))

MODEL EVALUATION

from sklearn.datasets import load_iris, load_diabetes

from sklearn.model_selection import train_test_split, cross_val_score, KFold
from sklearn.metrics import accuracy_score, confusion_matrix, classification_report,
roc_curve, auc
from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score
from sklearn.linear_model import LogisticRegression, LinearRegression
from sklearn.preprocessing import label_binarize
import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np

# Load the iris dataset

iris = load_iris()
X, y = iris.data, iris.target

# Binary classification for ROC demo

y_binary = (y == 2).astype(int) # classify class 2 vs others

# Split the data

X_train, X_test, y_train, y_test = train_test_split(X, y_binary, test_size=0.3,
random_state=42)

# Train a logistic regression model

model = LogisticRegression()
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

acc = accuracy_score(y_test, y_pred)

print("✅ Accuracy Score:", acc)

cm = confusion_matrix(y_test, y_pred)
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues')
plt.xlabel("Predicted")
plt.ylabel("Actual")
plt.title("Confusion Matrix")
plt.show()

print("📊 Classification Report:")

print(classification_report(y_test, y_pred))

y_proba = model.predict_proba(X_test)[:, 1]
fpr, tpr, _ = roc_curve(y_test, y_proba)
roc_auc = auc(fpr, tpr)

plt.plot(fpr, tpr, label=f"AUC = {roc_auc:.2f}")

plt.plot([0, 1], [0, 1], linestyle='--')
plt.xlabel("False Positive Rate")
plt.ylabel("True Positive Rate")
plt.title("ROC Curve")
plt.legend()
plt.show()

# Load diabetes dataset (regression)

diabetes = load_diabetes()
X, y = diabetes.data, diabetes.target

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

# Train a linear regression model

reg = LinearRegression()
reg.fit(X_train, y_train)
y_pred = reg.predict(X_test)

mae = mean_absolute_error(y_test, y_pred)

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

print(f"📈 MAE: {mae:.2f}")

print(f"📉 MSE: {mse:.2f}")
print(f"📏 RMSE: {rmse:.2f}")
print(f"🔢 R² Score: {r2:.2f}")

NEURAL NETWORK

#Örnek 1: Basit Sınıflandırma (Digits Dataset)

from sklearn.datasets import load_digits

from sklearn.model_selection import train_test_split
from sklearn.neural_network import MLPClassifier
from sklearn.metrics import accuracy_score

# Veri setini yükle

digits = load_digits()
X, y = digits.data, digits.target

# Eğitim ve test veri setine ayır

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

# MLP modeli oluştur

mlp = MLPClassifier(hidden_layer_sizes=(32,), max_iter=300, random_state=1)
mlp.fit(X_train, y_train)

# Tahmin ve başarı
y_pred = mlp.predict(X_test)
print("Accuracy:", accuracy_score(y_test, y_pred))
#✅ Örnek 2: XOR Problemi (2 Girişli Mantıksal Problem)

import numpy as np
from sklearn.neural_network import MLPClassifier

# XOR verisi
X = np.array([[0,0],[0,1],[1,0],[1,1]])
y = np.array([0, 1, 1, 0])

# Model
model = MLPClassifier(hidden_layer_sizes=(4,), activation='tanh', max_iter=1000)
model.fit(X, y)

# Tahmin
print("Predictions:", model.predict(X))
#✅ Örnek 3: Tek Girişli Regresyon (sin fonksiyonu)

import numpy as np
import matplotlib.pyplot as plt
from sklearn.neural_network import MLPRegressor

# sin(x) verisi üret

X = np.linspace(0, 2*np.pi, 100).reshape(-1, 1)
y = np.sin(X).ravel()

# MLP Regressor
mlp = MLPRegressor(hidden_layer_sizes=(10,10), max_iter=1000)
mlp.fit(X, y)

# Tahmin & Görselleştirme

y_pred = mlp.predict(X)
plt.plot(X, y, label='Actual')
plt.plot(X, y_pred, label='Prediction')
plt.legend()
plt.title("sin(x) regression")
plt.show()
#✅ Örnek 4: Çok Katmanlı (MLP) – Wine Dataset

from sklearn.datasets import load_wine

from sklearn.model_selection import train_test_split
from sklearn.neural_network import MLPClassifier
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import classification_report

# Veri seti
data = load_wine()
X, y = data.data, data.target

# Normalizasyon
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Veri ayırma
X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.3,
random_state=0)

# MLP model
clf = MLPClassifier(hidden_layer_sizes=(50,), max_iter=500)
clf.fit(X_train, y_train)

# Sonuçlar
y_pred = clf.predict(X_test)
print(classification_report(y_test, y_pred))

#Örnek 5 Basit MLP: AND problemi (Sigmoid aktivasyon, ağırlık güncelleme)

import numpy as np

# Sigmoid aktivasyon fonksiyonu ve türevi

def sigmoid(x):
return 1 / (1 + np.exp(-x))

def sigmoid_deriv(x):
return sigmoid(x) * (1 - sigmoid(x))

# Giriş (input) verisi - AND problemi

X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]]) # 4 örnek
y = np.array([[0], [0], [0], [1]]) # Hedef sonuçlar

# Ağırlıklar ve bias - rastgele başlat

np.random.seed(0)
weights = np.random.rand(2, 1) # 2 giriş -> 1 çıkış
bias = np.random.rand(1)

# Eğitim parametreleri
lr = 0.1 # öğrenme oranı
epochs = 10000 # kaç tekrar

# Eğitim döngüsü
for epoch in range(epochs):
# 1. İleri yayılım (forward propagation)
z = np.dot(X, weights) + bias
output = sigmoid(z)

# 2. Hata hesabı
error = y - output

# 3. Geri yayılım (backpropagation)

d_weights = np.dot(X.T, error * sigmoid_deriv(z))
d_bias = np.sum(error * sigmoid_deriv(z))

# 4. Güncelleme
weights += lr * d_weights
bias += lr * d_bias

# Durumu yazdır (isteğe bağlı)

if epoch % 2000 == 0:
loss = np.mean(np.abs(error))
print(f"Epoch {epoch}, Loss: {loss:.4f}")

# Sonuçları yazdır
print("\nResults:")
for i in range(len(X)):
result = sigmoid(np.dot(X[i], weights) + bias)
print(f"input: {X[i]}, prediction: {result[0]:.4f}")

TIME SERIES AND FORECASTING

# Example 1: ARIMA Forecasting with Airline Dataset

import pandas as pd
import matplotlib.pyplot as plt
from statsmodels.tsa.arima.model import ARIMA
from statsmodels.datasets import get_rdataset
# Load dataset
data = get_rdataset('AirPassengers').data
data['time'] = pd.date_range(start='1949-01', periods=len(data), freq='M')
data.set_index('time', inplace=True)

# Plot
data.plot(title='Monthly Air Passengers')
plt.ylabel('Passengers')
plt.show()

# Fit ARIMA Model

model = ARIMA(data['value'], order=(2, 1, 2)) # ARIMA(p,d,q)
model_fit = model.fit()
print(model_fit.summary())

# Forecast
forecast = model_fit.forecast(steps=12)
forecast.plot(title="12-Month Forecast")
plt.show()

# Example 2: Forecasting with Prophet

!pip install prophet

import pandas as pd
from prophet import Prophet
import matplotlib.pyplot as plt

# Load dataset
df = pd.read_csv("https://raw.githubusercontent.com/jbrownlee/Datasets/master/
airline-passengers.csv")
df.columns = ['ds', 'y']

# Fit model
model = Prophet()
model.fit(df)

# Forecast next 12 months

future = model.make_future_dataframe(periods=12, freq='M')
forecast = model.predict(future)

# Plot
model.plot(forecast)
plt.title('Forecast with Prophet')
plt.show()
# Example 3: Machine Learning Approach (Random Forest)

import pandas as pd
import numpy as np
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_squared_error
import matplotlib.pyplot as plt

# Load data
url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/airline-
passengers.csv"
df = pd.read_csv(url)
df.columns = ['Month', 'Passengers']
df['Month'] = pd.to_datetime(df['Month'])
df.set_index('Month', inplace=True)

# Create lag features

for lag in range(1, 13):
df[f'lag_{lag}'] = df['Passengers'].shift(lag)
df.dropna(inplace=True)

# Split data
train = df.iloc[:-12]
test = df.iloc[-12:]

X_train = train.drop('Passengers', axis=1)

y_train = train['Passengers']
X_test = test.drop('Passengers', axis=1)
y_test = test['Passengers']

# Train model
model = RandomForestRegressor(n_estimators=100)
model.fit(X_train, y_train)

# Predict
preds = model.predict(X_test)

# Plot
plt.plot(y_test.index, y_test, label='Actual')
plt.plot(y_test.index, preds, label='Predicted')
plt.legend()
plt.title('Random Forest Forecasting')
plt.show()

# RMSE
print("RMSE:", mean_squared_error(y_test, preds, squared=False))