Python for AI

from sklearn.datasets        import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble        import RandomForestClassifier
from sklearn.metrics         import accuracy_score, classification_report

# 1. Load data
X, y = load_iris(return_X_y=True)
print(f"Dataset: {X.shape[0]} samples, {X.shape[1]} features")
# Dataset: 150 samples, 4 features

# 2. Split — keep 20% unseen for honest evaluation
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# 3. Train
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)

# 4. Evaluate
preds = model.predict(X_test)
print(f"Accuracy: {accuracy_score(y_test, preds):.1%}")
print(classification_report(y_test, preds, target_names=load_iris().target_names))

Accuracy: 96.7%

              precision  recall  f1-score  support
      setosa       1.00    1.00      1.00       10
  versicolor       1.00    0.91      0.95       11
   virginica       0.90    1.00      0.95        9

# Same fit/predict API — just change the model class
from sklearn.linear_model import LogisticRegression
from sklearn.tree         import DecisionTreeClassifier
from sklearn.svm          import SVC

for clf in [RandomForestClassifier(), LogisticRegression(), DecisionTreeClassifier()]:
    clf.fit(X_train, y_train)
    acc = accuracy_score(y_test, clf.predict(X_test))
    print(f"{clf.__class__.__name__:28}  {acc:.1%}")

# RandomForestClassifier       96.7%
# LogisticRegression           93.3%
# DecisionTreeClassifier       90.0%

from openai import OpenAI

client = OpenAI()   # reads OPENAI_API_KEY from environment

def ask_ai(question):
    response = client.chat.completions.create(
        model    = "gpt-4o-mini",
        messages = [{"role": "user", "content": question}],
    )
    return response.choices[0].message.content

print(ask_ai("Explain recursion in one sentence."))
# Recursion is a function calling itself with a simpler version of the
# problem until it reaches a base case that stops the calls.

import anthropic

client = anthropic.Anthropic()   # reads ANTHROPIC_API_KEY from env

message = client.messages.create(
    model      = "claude-3-5-haiku-20241022",
    max_tokens = 256,
    messages   = [{"role": "user", "content": "What is a neural network?"}]
)
print(message.content[0].text)

import anthropic, csv, json, time, logging

logging.basicConfig(level=logging.INFO, format="%(asctime)s %(message)s")
logger = logging.getLogger(__name__)
client = anthropic.Anthropic()

REVIEWS = [
    "Absolutely love this product! Best purchase I've made.",
    "It broke after two days. Very disappointed.",
    "Decent quality, arrived on time. Nothing special.",
    "Customer service was brilliant, resolved my issue instantly!",
    "The colour was different from the photo. A bit misleading.",
]

def classify_review(review):
    """Ask Claude to classify a review. Returns dict with label + reason."""
    prompt = f"""Classify this customer review as POSITIVE, NEGATIVE, or NEUTRAL.
Respond ONLY with valid JSON in this exact format:
{{"label": "POSITIVE", "confidence": 0.95, "reason": "one sentence"}}

Review: {review}"""

    msg = client.messages.create(
        model="claude-3-5-haiku-20241022", max_tokens=128,
        messages=[{"role": "user", "content": prompt}]
    )
    return json.loads(msg.content[0].text)

results = []
for i, review in enumerate(REVIEWS, 1):
    logger.info(f"Processing review {i}/{len(REVIEWS)}")
    result = classify_review(review)
    results.append({"review": review[:50], **result})
    time.sleep(0.5)   # stay within rate limits

# Save to CSV (uses your file I/O skills)
with open("classified.csv", "w", newline="") as f:
    w = csv.DictWriter(f, fieldnames=["review", "label", "confidence", "reason"])
    w.writeheader()
    w.writerows(results)

print("
=== Results ===")
for r in results:
    icon = {"POSITIVE": "✅", "NEGATIVE": "❌", "NEUTRAL": "➖"}[r["label"]]
    print(f"{icon} {r['label']:8} ({r['confidence']:.0%})  {r['review']}")

=== Results ===
✅ POSITIVE  (95%)  Absolutely love this product! Best purchase...
❌ NEGATIVE  (98%)  It broke after two days. Very disappointed.
➖ NEUTRAL   (80%)  Decent quality, arrived on time. Nothing spe...
✅ POSITIVE  (97%)  Customer service was brilliant, resolved my...
❌ NEGATIVE  (72%)  The colour was different from the photo. A bi...

import numpy as np

# One forward pass through a single neural network layer
# input: batch of 4 samples, each with 3 features
X = np.array([[0.5, 0.2, 0.8],
              [0.1, 0.9, 0.3],
              [0.7, 0.4, 0.6],
              [0.3, 0.7, 0.2]])   # shape: (4, 3)

# weights: learned parameters of the layer (3 inputs → 2 outputs)
W = np.random.randn(3, 2) * 0.1    # shape: (3, 2)
b = np.zeros(2)                    # bias: shape (2,)

# Linear transformation: output = X @ W + b
# This ONE line is the core operation of every neural network
z = X @ W + b                      # shape: (4, 2)

# Apply activation function (ReLU: max(0, x))
def relu(x): return np.maximum(0, x)

output = relu(z)
print("Layer output shape:", output.shape)  # (4, 2)
print(output)