Machine Learning Fundamentals

# Example: Email Spam Classification
from sklearn.naive_bayes import MultinomialNB
from sklearn.feature_extraction.text import CountVectorizer

# Training data with labels
emails = [
    "Get rich quick! Buy now!",
    "Meeting notes from today",
    "Win a free iPhone now!!!",
    "Let's catch up over coffee",
    "Congratulations! You've won $1M"
]
labels = ['spam', 'not_spam', 'spam', 'not_spam', 'spam']

# Convert text to features
vectorizer = CountVectorizer()
X = vectorizer.fit_transform(emails)

# Train the model
model = MultinomialNB()
model.fit(X, labels)

# Predict on new email
new_email = ["Free money! Click here!"]
X_new = vectorizer.transform(new_email)
prediction = model.predict(X_new)

print(f"Prediction: {prediction[0]}")  # Output: spam
print(f"Confidence: {model.predict_proba(X_new)[0]}")
# Output: [0.27906977 0.72093023] - 72% confident it's spam

# Example: House Price Prediction
from sklearn.linear_model import LinearRegression
import numpy as np

# Training data: [square_feet, bedrooms, age]
X = np.array([
    [1500, 2, 10],
    [2000, 3, 5],
    [1200, 2, 20],
    [3000, 4, 2],
    [1800, 3, 15]
])

# Labels: prices in thousands
y = np.array([250, 350, 180, 500, 300])

# Train the model
model = LinearRegression()
model.fit(X, y)

# Predict price for a new house
new_house = np.array([[2200, 3, 8]])
predicted_price = model.predict(new_house)

print(f"Predicted price: {predicted_price[0]:.2f}k")
# Output: Predicted price: $375.50k

# Understand what model learned
print("Feature importance (coefficients):")
features = ['square_feet', 'bedrooms', 'age']
for feature, coef in zip(features, model.coef_):
    print(f"  {feature}: {coef:.2f}")
# Shows which features matter most for price

# Example: Customer Segmentation
from sklearn.cluster import KMeans
import numpy as np

# Customer data: [age, annual_income_k, spending_score]
customers = np.array([
    [25, 30, 80],   # Young, low income, high spending
    [45, 80, 20],   # Middle-aged, high income, low spending
    [23, 25, 85],   # Young, low income, high spending
    [50, 90, 15],   # Older, high income, low spending
    [28, 35, 75],   # Young, low income, high spending
    [42, 75, 25],   # Middle-aged, high income, low spending
])

# Find 2 clusters (groups)
kmeans = KMeans(n_clusters=2, random_state=42)
clusters = kmeans.fit_predict(customers)

print("Customer segments:")
print(clusters)  # Output: [0 1 0 1 0 1]
# Cluster 0: Young spenders
# Cluster 1: Wealthy savers

# Cluster centers (average profile of each group)
print("\nCluster centers:")
print(kmeans.cluster_centers_)
# [[25.3, 30.0, 80.0],   # Young spenders profile
#  [45.7, 81.7, 20.0]]   # Wealthy savers profile

# Predict segment for new customer
new_customer = np.array([[26, 28, 78]])
segment = kmeans.predict(new_customer)
print(f"\nNew customer belongs to segment: {segment[0]}")
# Output: 0 (Young spenders)

# Example: Reducing 100 features to 2 for visualization
from sklearn.decomposition import PCA
import numpy as np

# High-dimensional data: 100 features per sample
# (In reality: customer behavior, product features, etc.)
X = np.random.rand(1000, 100)  # 1000 samples, 100 features

# Reduce to 2 dimensions while preserving patterns
pca = PCA(n_components=2)
X_reduced = pca.fit_transform(X)

print(f"Original shape: {X.shape}")        # (1000, 100)
print(f"Reduced shape: {X_reduced.shape}") # (1000, 2)

# How much information retained?
variance_retained = sum(pca.explained_variance_ratio_)
print(f"Information retained: {variance_retained:.1%}")
# Output: Information retained: 15.2%

# Note: 15% might seem low, but these 2 dimensions
# capture the most important patterns from 100 features!

# Simplified example: Teaching an agent to play a game
class SimpleGameAgent:
    def __init__(self):
        # Q-table: stores learned values for state-action pairs
        self.q_table = {}
        self.learning_rate = 0.1
        self.discount_factor = 0.9

    def get_action(self, state):
        # Exploration vs Exploitation
        if random.random() < 0.2:  # 20% explore
            return random.choice(['up', 'down', 'left', 'right'])
        else:  # 80% exploit (use learned knowledge)
            return self.best_action(state)

    def learn(self, state, action, reward, next_state):
        # Update Q-value based on experience
        old_value = self.q_table.get((state, action), 0)
        next_max = max([self.q_table.get((next_state, a), 0)
                       for a in ['up', 'down', 'left', 'right']])

        # Q-learning formula
        new_value = old_value + self.learning_rate * (
            reward + self.discount_factor * next_max - old_value
        )
        self.q_table[(state, action)] = new_value

# Training process
agent = SimpleGameAgent()
for episode in range(1000):
    state = game.reset()
    total_reward = 0

    while not game.done:
        action = agent.get_action(state)
        next_state, reward, done = game.step(action)

        # Learn from this experience
        agent.learn(state, action, reward, next_state)

        state = next_state
        total_reward += reward

    if episode % 100 == 0:
        print(f"Episode {episode}: Total reward = {total_reward}")

# Result: Agent learns to maximize rewards over time