// Network: 2 inputs → H hidden (activation) → 1 output (sigmoid)
for (each point (x, y, target)) {
  h   = act(W1 · [x, y] + b1)          // hidden layer
  out = sigmoid(W2 · h + b2)            // probability of class B
  loss += −[t·log(out) + (1−t)·log(1−out)]  // binary cross-entropy

  dOut = out − t                        // gradient of BCE through sigmoid
  dW2 += dOut · h ;  db2 += dOut
  dH   = dOut · W2 · act'(h)            // chain rule back to hidden layer
  dW1 += dH ⊗ [x, y] ;  db1 += dH
}
W −= η · dW / N   // full-batch gradient descent

# 1 · Create and activate a virtual environment
python3 -m venv ai-env
source ai-env/bin/activate          # Windows: ai-env\Scripts\activate

# 2 · Install the libraries used on this page
pip install numpy pandas scikit-learn torch sentence-transformers anthropic openai requests

# 3 · Store API keys as environment variables — never in your code
export ANTHROPIC_API_KEY="sk-..."   # Windows PowerShell: $env:ANTHROPIC_API_KEY="sk-..."
export OPENAI_API_KEY="sk-..."

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

X, y = load_iris(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

model = RandomForestClassifier(n_estimators=200, random_state=42)
model.fit(X_train, y_train)                 # training

pred = model.predict(X_test)                # inference
print(classification_report(y_test, pred))  # precision / recall / F1

# Which measurements mattered most?
for name, imp in zip(load_iris().feature_names, model.feature_importances_):
    print(f"{name:<20} {imp:.2f}")

import torch
from torch import nn

device = "cuda" if torch.cuda.is_available() else "cpu"

# Synthetic "circle" dataset: label 1 if the point is inside radius 0.5
X = torch.rand(2000, 2) * 2 - 1
y = ((X ** 2).sum(dim=1) < 0.25).float().unsqueeze(1)
X, y = X.to(device), y.to(device)

model = nn.Sequential(
    nn.Linear(2, 16), nn.ReLU(),
    nn.Linear(16, 16), nn.ReLU(),
    nn.Linear(16, 1)                    # raw logit
).to(device)

loss_fn = nn.BCEWithLogitsLoss()
opt = torch.optim.AdamW(model.parameters(), lr=1e-2)

for epoch in range(500):
    opt.zero_grad()
    loss = loss_fn(model(X), y)   # 1. forward  2. loss
    loss.backward()               # 3. backpropagation
    opt.step()                    # 4. gradient descent
    if epoch % 100 == 0:
        acc = ((model(X) > 0).float() == y).float().mean()
        print(f"epoch {epoch:3d}  loss {loss.item():.4f}  acc {acc:.2%}")

torch.save(model.state_dict(), "circle_model.pt")

// Run on a server (Node 18+). NEVER call a paid API with your key from browser JavaScript.
const res = await fetch("https://api.anthropic.com/v1/messages", {
  method: "POST",
  headers: {
    "x-api-key": process.env.ANTHROPIC_API_KEY,
    "anthropic-version": "2023-06-01",
    "content-type": "application/json",
  },
  body: JSON.stringify({
    model: "MODEL_NAME",
    max_tokens: 512,
    messages: [{ role: "user", content: "Suggest 3 beginner woodworking projects." }],
  }),
});
if (!res.ok) throw new Error(`API error ${res.status}`);
const data = await res.json();
console.log(data.content[0].text);

import numpy as np
import anthropic
from sentence_transformers import SentenceTransformer

docs = [
    "Use a 6 mm masonry bit and brown plugs for 6 mm screws in solid brick.",
    "Hollow brick needs long nylon plugs or chemical anchors for heavy loads.",
    "Plasterboard can hold light shelves with metal cavity (molly) fixings.",
]

embedder = SentenceTransformer("all-MiniLM-L6-v2")
doc_vecs = embedder.encode(docs, normalize_embeddings=True)   # index once

def retrieve(question, k=2):
    q = embedder.encode([question], normalize_embeddings=True)[0]
    scores = doc_vecs @ q                   # cosine similarity (vectors are normalized)
    top = np.argsort(scores)[::-1][:k]
    return [docs[i] for i in top]

question = "What fixing should I use for a heavy shelf on hollow brick?"
context = "\n".join(f"- {c}" for c in retrieve(question))

client = anthropic.Anthropic()
answer = client.messages.create(
    model="MODEL_NAME", max_tokens=400,
    messages=[{"role": "user", "content":
        f"Answer using ONLY this context. If it's not there, say so.\n\n"
        f"Context:\n{context}\n\nQuestion: {question}"}],
)
print(answer.content[0].text)