# supervised_vs_unsupervised.py
from sklearn.tree import DecisionTreeClassifier
from sklearn.cluster import KMeans
from sklearn.metrics.pairwise import cosine_similarity
import numpy as np
import matplotlib.pyplot as plt

# Configure font for better visualization
plt.rcParams['font.family'] = 'DejaVu Sans'
plt.rcParams['axes.unicode_minus'] = False

# -----------------------
# Supervised Learning: Fruit Classification
# -----------------------
print("📘 Supervised Learning - Decision Tree Fruit Prediction")

# Fruit features: [color, size, sweetness]
X = [[1, 1, 9], [1, 2, 10], [3, 4, 3], [2, 4, 4], [4, 1, 8]]
y = [0, 0, 1, 1, 2]  # 0:apple, 1:banana, 2:grape

clf = DecisionTreeClassifier(random_state=42)
clf.fit(X, y)

# Predict new fruit
prediction = clf.predict([[1, 1, 10]])
print("Prediction result (label):", prediction)
print("Feature importance:", clf.feature_importances_)

# -----------------------
# Unsupervised Learning: Fruit Clustering
# -----------------------
print("\n📘 Unsupervised Learning - KMeans Clustering")

kmeans = KMeans(n_clusters=3, random_state=42)
clusters = kmeans.fit_predict(X)
print("Cluster results:", clusters)
print("Cluster centers:", kmeans.cluster_centers_)

# Visualization
plt.figure(figsize=(10, 6))
plt.subplot(1, 2, 1)
plt.scatter([x[0] for x in X], [x[2] for x in X], c=y, cmap='viridis')
plt.xlabel("Color")
plt.ylabel("Sweetness")
plt.title("True Labels")
plt.colorbar()

plt.subplot(1, 2, 2)
plt.scatter([x[0] for x in X], [x[2] for x in X], c=clusters, cmap='viridis')
plt.xlabel("Color")
plt.ylabel("Sweetness")
plt.title("KMeans Clusters")
plt.colorbar()
plt.tight_layout()
plt.show()

# -----------------------
# Similarity Analysis (Cosine)
# -----------------------
print("\n📘 Similarity - Cosine Similarity Analysis")

apple = np.array([[1, 1, 9]])
pear = np.array([[2, 1, 9]])
banana = np.array([[3, 4, 3]])

sim_apple_pear = cosine_similarity(apple, pear)[0][0]
sim_apple_banana = cosine_similarity(apple, banana)[0][0]

print(f"Apple-Pear similarity: {sim_apple_pear:.4f}")
print(f"Apple-Banana similarity: {sim_apple_banana:.4f}")

# Calculate all pairwise similarities
fruits = np.array([[1, 1, 9], [2, 1, 9], [3, 4, 3]])
fruit_names = ['Apple', 'Pear', 'Banana']
similarity_matrix = cosine_similarity(fruits)

print("\nSimilarity Matrix:")
for i, name1 in enumerate(fruit_names):
    for j, name2 in enumerate(fruit_names):
        print(f"{name1}-{name2}: {similarity_matrix[i][j]:.4f}")

# iris_classification.py
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC
from sklearn.neighbors import KNeighborsClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.cluster import KMeans
from sklearn.metrics import accuracy_score, confusion_matrix
import pandas as pd
import numpy as np

# Load Iris dataset
iris = datasets.load_iris()
X, y = iris.data, iris.target
feature_names = iris.feature_names
target_names = iris.target_names

print("📊 Iris Dataset Overview")
print(f"Dataset shape: {X.shape}")
print(f"Features: {feature_names}")
print(f"Classes: {target_names}")
print(f"Class distribution: {np.bincount(y)}")

# Split data for supervised learning
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42, stratify=y
)

# -----------------------
# Supervised Learning: Multiple Algorithms
# -----------------------
print("\n📘 Supervised Learning - Multiple Classification Algorithms")

algorithms = {
    'SVM': SVC(random_state=42),
    'KNN': KNeighborsClassifier(n_neighbors=3),
    'LogisticRegression': LogisticRegression(random_state=42, max_iter=200)
}

results = {}
for name, model in algorithms.items():
    model.fit(X_train, y_train)
    y_pred = model.predict(X_test)
    accuracy = accuracy_score(y_test, y_pred)
    results[name] = accuracy
    print(f"{name} accuracy: {accuracy:.3f}")

# -----------------------
# Unsupervised Learning: KMeans Clustering
# -----------------------
print("\n📘 Unsupervised Learning - KMeans Clustering Analysis")

kmeans = KMeans(n_clusters=3, random_state=42)
cluster_labels = kmeans.fit_predict(X)

print("KMeans cluster results:", cluster_labels)
print("True species labels:", y)

# Compare clustering with true labels
conf_matrix = confusion_matrix(y, cluster_labels)
print("Cluster-Truth confusion matrix:")
print(conf_matrix)

# Calculate cluster purity
def calculate_purity(y_true, y_pred):
    """Calculate clustering purity score"""
    conf_matrix = confusion_matrix(y_true, y_pred)
    return np.sum(np.amax(conf_matrix, axis=0)) / np.sum(conf_matrix)

purity = calculate_purity(y, cluster_labels)
print(f"Clustering purity: {purity:.3f}")

# Analyze cluster characteristics
print("\nCluster Analysis:")
for i in range(3):
    cluster_mask = cluster_labels == i
    cluster_data = X[cluster_mask]
    true_labels = y[cluster_mask]
    
    print(f"\nCluster {i}:")
    print(f"  Size: {np.sum(cluster_mask)} samples")
    print(f"  Dominant species: {target_names[np.bincount(true_labels).argmax()]}")
    print(f"  Average features: {np.mean(cluster_data, axis=0)}")

# -----------------------
# Feature Analysis
# -----------------------
print("\n📊 Feature Importance Analysis")

# Use trained LogisticRegression for feature importance
lr_model = algorithms['LogisticRegression']
feature_importance = np.abs(lr_model.coef_).mean(axis=0)

print("Feature importance ranking:")
for i, (feature, importance) in enumerate(zip(feature_names, feature_importance)):
    print(f"{i+1}. {feature}: {importance:.3f}")

# ecommerce_recommendation.py
import numpy as np
from sklearn.cluster import KMeans
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics.pairwise import cosine_similarity
from sklearn.preprocessing import StandardScaler

class EcommerceRecommendationSystem:
    def __init__(self):
        self.user_clusters = None
        self.product_features = None
        self.purchase_predictor = None
        self.scaler = StandardScaler()
        
    def analyze_user_behavior(self, user_data):
        """Unsupervised: Cluster users by behavior patterns"""
        # user_data: [browsing_time, purchase_frequency, avg_order_value, ...]
        
        scaled_data = self.scaler.fit_transform(user_data)
        
        # Find optimal number of clusters
        kmeans = KMeans(n_clusters=5, random_state=42)
        user_clusters = kmeans.fit_predict(scaled_data)
        
        self.user_clusters = kmeans
        return user_clusters
    
    def train_purchase_predictor(self, user_features, purchase_history):
        """Supervised: Predict purchase likelihood"""
        
        self.purchase_predictor = RandomForestClassifier(
            n_estimators=100, random_state=42
        )
        self.purchase_predictor.fit(user_features, purchase_history)
        
        return self.purchase_predictor.score(user_features, purchase_history)
    
    def calculate_product_similarity(self, product_features):
        """Calculate product similarity matrix"""
        
        self.product_features = product_features
        similarity_matrix = cosine_similarity(product_features)
        
        return similarity_matrix
    
    def recommend_products(self, user_id, user_features, n_recommendations=5):
        """Hybrid recommendation using both approaches"""
        
        # 1. Predict purchase probability (supervised)
        purchase_prob = self.purchase_predictor.predict_proba([user_features])[0][1]
        
        # 2. Find user cluster (unsupervised)
        user_cluster = self.user_clusters.predict([user_features])[0]
        
        # 3. Use similarity for product recommendations
        # (In practice, this would use actual user-product interactions)
        recommendations = {
            'user_id': user_id,
            'purchase_probability': purchase_prob,
            'user_cluster': user_cluster,
            'recommended_products': list(range(n_recommendations))  # Simplified
        }
        
        return recommendations

# Example usage
np.random.seed(42)

# Generate synthetic user data
n_users = 1000
user_data = np.random.rand(n_users, 5)  # 5 behavioral features
purchase_history = np.random.binomial(1, 0.3, n_users)  # 30% purchase rate

# Initialize and train system
rec_system = EcommerceRecommendationSystem()

# Unsupervised analysis
user_clusters = rec_system.analyze_user_behavior(user_data)
print(f"Identified {len(np.unique(user_clusters))} user clusters")

# Supervised training
accuracy = rec_system.train_purchase_predictor(user_data, purchase_history)
print(f"Purchase prediction accuracy: {accuracy:.3f}")

# Generate recommendations for a new user
new_user_features = [0.7, 0.5, 0.8, 0.3, 0.6]
recommendations = rec_system.recommend_products(
    user_id=1001, 
    user_features=new_user_features
)

print("\nRecommendation Results:")
for key, value in recommendations.items():
    print(f"{key}: {value}")