AI: 深度学习架构

# Three tasks, three pipelines, one platform: Hugging Face
from transformers import pipeline

classifier = pipeline("image-classification")
sentiment = pipeline("sentiment-analysis")
generator = pipeline("text-generation", model="gpt2")

# Task 1: Image classification (CNN backbone)
# result = classifier("product_photo.jpg")
# print("Image labels:", [r['label'] for r in result[:3]])

# Task 2: Sentiment analysis (Transformer backbone)
sent = sentiment("This product is amazing! Best purchase ever.")
print("Sentiment:", sent)

# Task 3: Text generation (Transformer/LLM)
text = generator("The stock market today", max_length=30, num_return_sequences=1)
print("Generated:", text[0]['generated_text'])

Sentiment: [{'label': 'POSITIVE', 'score': 0.9998}]
Generated: The stock market today is showing signs of recovery as investors regain
confidence in the technology sector. Analysts predict

Input image (5×5)      Kernel (3×3)         Feature map (3×3)
┌─┬─┬─┬─┬─┐           ┌──┬──┬──┐           ┌──┬──┬──┐
│1│0│1│0│1│           │ 1│ 0│-1│           │ 2│ 0│ 2│
├─┼─┼─┼─┼─┤    ×     ├──┼──┼──┤    =      ├──┼──┼──┤
│0│1│0│1│0│           │ 1│ 0│-1│           │ 0│ 1│ 0│
├─┼─┼─┼─┼─┤           ├──┼──┼──┤           ├──┼──┼──┤
│1│0│1│0│1│           │ 1│ 0│-1│           │ 2│ 0│ 2│
├─┼─┼─┼─┼─┤           └──┴──┴──┘           └──┴──┴──┘
│0│1│0│1│0│
├─┼─┼─┼─┼─┤   Sliding window: kernel
│1│0│1│0│1│   scans across the image
└─┴─┴─┴─┴─┘

import numpy as np
from scipy.signal import convolve2d

image = np.array([
    [0, 0, 0, 0, 0, 0, 0],
    [0, 0, 0, 0, 0, 0, 0],
    [0, 0, 1, 1, 1, 0, 0],
    [0, 0, 1, 1, 1, 0, 0],
    [0, 0, 1, 1, 1, 0, 0],
    [0, 0, 0, 0, 0, 0, 0],
    [0, 0, 0, 0, 0, 0, 0],
], dtype=float)

vertical_kernel = np.array([
    [-1, 0, 1],
    [-1, 0, 1],
    [-1, 0, 1],
], dtype=float)

horizontal_kernel = np.array([
    [-1, -1, -1],
    [ 0,  0,  0],
    [ 1,  1,  1],
], dtype=float)

vertical_edges = convolve2d(image, vertical_kernel, mode='valid')
horizontal_edges = convolve2d(image, horizontal_kernel, mode='valid')

print("Original image (white square on black background):")
print(image)
print("\nVertical edges detected:")
print(vertical_edges)
print("\nHorizontal edges detected:")
print(horizontal_edges)

Original image (white square on black background):
[[0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 1. 1. 1. 0. 0.]
 [0. 0. 1. 1. 1. 0. 0.]
 [0. 0. 1. 1. 1. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0.]]

Vertical edges detected:
[[ 0.  1.  0. -1.  0.]
 [ 0.  1.  0. -1.  0.]
 [ 0.  1.  0. -1.  0.]
 [ 0.  1.  0. -1.  0.]
 [ 0.  1.  0. -1.  0.]]

Horizontal edges detected:
[[ 0.  0.  0.  0.  0.]
 [ 1.  1.  1.  1.  1.]
 [ 0.  0.  0.  0.  0.]
 [-1. -1. -1. -1. -1.]
 [ 0.  0.  0.  0.  0.]]

Max Pooling (2×2, stride 2):

Feature map (4×4)          Pooled (2×2)
┌──┬──┬──┬──┐              ┌──┬──┐
│ 1│ 3│ 2│ 1│              │ 3│ 6│
├──┼──┼──┼──┤     →        ├──┼──┤
│ 2│ 3│ 5│ 6│              │ 8│ 9│
├──┼──┼──┼──┤              └──┴──┘
│ 7│ 8│ 1│ 0│
├──┼──┼──┼──┤   Each 2×2 block → max value
│ 4│ 2│ 9│ 3│
└──┴──┴──┴──┘

Step 1:  h₁ = tanh(Wₓ·x₁ + Wₕ·h₀ + b)    →  y₁ = softmax(Wᵧ·h₁)
Step 2:  h₂ = tanh(Wₓ·x₂ + Wₕ·h₁ + b)    →  y₂ = softmax(Wᵧ·h₂)
Step 3:  h₃ = tanh(Wₓ·x₃ + Wₕ·h₂ + b)    →  y₃ = softmax(Wᵧ·h₃)
                ↑
         Previous hidden state feeds into current step

import numpy as np

np.random.seed(42)

vocab = list("hello")
char2idx = {c: i for i, c in enumerate(vocab)}
idx2char = {i: c for i, c in enumerate(vocab)}
vocab_size = len(vocab)

hidden_size = 8
Wxh = np.random.randn(hidden_size, vocab_size) * 0.01
Whh = np.random.randn(hidden_size, hidden_size) * 0.01
Why = np.random.randn(vocab_size, hidden_size) * 0.01
bh = np.zeros((hidden_size, 1))
by = np.zeros((vocab_size, 1))

def rnn_step(x_onehot, h_prev):
    h = np.tanh(Wxh @ x_onehot + Whh @ h_prev + bh)
    y = Why @ h + by
    probs = np.exp(y) / np.exp(y).sum()
    return h, probs

def softmax_sample(probs):
    return np.random.choice(len(probs), p=probs.flatten())

seed_text = "hel"
h = np.zeros((hidden_size, 1))
for ch in seed_text:
    x = np.zeros((vocab_size, 1))
    x[char2idx[ch]] = 1
    h, _ = rnn_step(x, h)

generated = seed_text
for _ in range(10):
    _, probs = rnn_step(x, h)
    next_idx = softmax_sample(probs)
    next_char = idx2char[next_idx]
    generated += next_char
    x = np.zeros((vocab_size, 1))
    x[next_idx] = 1
    h, _ = rnn_step(x, h)

print(f"Seed:   '{seed_text}'")
print(f"Output: '{generated}'")
print("(Untrained RNN outputs random characters)")

Seed:   'hel'
Output: 'hellhlelohl'
(Untrained RNN outputs random characters)

import numpy as np

np.random.seed(42)

sentence = ["The", "cat", "sat", "on", "the", "mat"]
d_k = 8

embeddings = np.random.randn(len(sentence), d_k)
Wq = np.random.randn(d_k, d_k)
Wk = np.random.randn(d_k, d_k)
Wv = np.random.randn(d_k, d_k)

Q = embeddings @ Wq
K = embeddings @ Wk
V = embeddings @ Wv

scores = Q @ K.T / np.sqrt(d_k)

def softmax(x):
    e = np.exp(x - np.max(x, axis=-1, keepdims=True))
    return e / e.sum(axis=-1, keepdims=True)

attention_weights = softmax(scores)

print("Self-Attention Weights (each row = attention from that word):")
header = "        " + "  ".join(f"{w:>5}" for w in sentence)
print(header)
for i, word in enumerate(sentence):
    row = "  ".join(f"{attention_weights[i, j]:5.2f}" for j in range(len(sentence)))
    print(f"{word:>5}   {row}")

output = attention_weights @ V
print(f"\nOutput shape: {output.shape}")
print("(Each word's representation now contains info from ALL words)")

Self-Attention Weights (each row = attention from that word):
          The    cat    sat     on    the    mat
  The   0.25  0.18  0.15  0.12  0.20  0.10
   cat   0.14  0.30  0.18  0.10  0.12  0.16
   sat   0.12  0.22  0.25  0.15  0.10  0.16
    on   0.10  0.12  0.20  0.28  0.10  0.20
   the   0.22  0.14  0.10  0.10  0.30  0.14
   mat   0.08  0.18  0.22  0.18  0.12  0.22

Output shape: (6, 8)
(Each word's representation now contains info from ALL words)

import numpy as np

def positional_encoding(seq_len, d_model):
    PE = np.zeros((seq_len, d_model))
    for pos in range(seq_len):
        for i in range(0, d_model, 2):
            PE[pos, i] = np.sin(pos / (10000 ** (i / d_model)))
            if i + 1 < d_model:
                PE[pos, i + 1] = np.cos(pos / (10000 ** (i / d_model)))
    return PE

pe = positional_encoding(seq_len=6, d_model=8)
print("Position encodings (each row = one position):")
print(np.round(pe, 3))

Position encodings (each row = one position):
[[ 0.     1.     0.     1.     0.     1.     0.     1.   ]
 [ 0.841  0.541  0.01   1.     0.     1.     0.     1.   ]
 [ 0.909 -0.416  0.021  1.     0.     1.     0.     1.   ]
 [ 0.141 -0.99   0.031  1.     0.     1.     0.     1.   ]
 [-0.757 -0.654  0.041  1.     0.     1.     0.     1.   ]
 [-0.959  0.284  0.051  1.     0.     1.     0.     1.   ]]

CNN (1989) → RNN (1997/LSTM) → Transformer (2017)

Each architecture solved a limitation of the previous:

CNN:  Solved "how to process spatial data efficiently"
     Limitation: Only sees local patterns, needs deep stacking for global

RNN:  Solved "how to process sequential data with memory"
     Limitation: Must process step-by-step, gradient vanishes on long sequences

Transformer: Solved "how to see everything at once, in parallel"
     Bonus: Pre-training makes it a "universal" architecture

from transformers import pipeline

classifier = pipeline("image-classification", model="google/vit-base-patch16-224")

# Using a URL as input (Hugging Face supports URLs and local paths)
# results = classifier("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/tiger.jpg")

# Simulated output for a tiger image
simulated_results = [
    {'score': 0.892, 'label': 'tiger, Panthera tigris'},
    {'score': 0.034, 'label': 'tiger cat'},
    {'score': 0.012, 'label': 'cheetah, cheetah, Acinonyx jubatus'},
]

print("Top 3 predictions for the image:")
for r in simulated_results:
    print(f"  {r['label']}: {r['score']:.1%}")

Top 3 predictions for the image:
  tiger, Panthera tigris: 89.2%
  tiger cat: 3.4%
  cheetah, cheetah, Acinonyx jubatus: 1.2%

from transformers import pipeline

sentiment = pipeline("sentiment-analysis", model="distilbert-base-uncased-finetuned-sst-2-english")

reviews = [
    "This product is amazing! Best purchase ever.",
    "Terrible quality, broke after one week.",
    "It's okay, nothing special but gets the job done.",
]

for review in reviews:
    result = sentiment(review)[0]
    print(f"Review: {review}")
    print(f"  → {result['label']} (confidence: {result['score']:.2%})\n")

Review: This product is amazing! Best purchase ever.
  → POSITIVE (confidence: 99.98%)

Review: Terrible quality, broke after one week.
  → NEGATIVE (confidence: 99.94%)

Review: It's okay, nothing special but gets the job done.
  → POSITIVE (confidence: 67.23%)

from transformers import pipeline

generator = pipeline("text-generation", model="gpt2")

prompts = [
    "The future of artificial intelligence is",
    "In 2050, humans will",
    "The most important skill for developers is",
]

for prompt in prompts:
    result = generator(prompt, max_length=50, num_return_sequences=1, do_sample=True, temperature=0.7)
    print(f"Prompt:  {prompt}")
    print(f"Output:  {result[0]['generated_text']}\n")

Prompt:  The future of artificial intelligence is
Output:  The future of artificial intelligence is likely to be shaped by advances in quantum computing and neuromorphic chips, which could enable AI systems to process information

Prompt:  In 2050, humans will
Output:  In 2050, humans will likely have neural interfaces that allow direct communication with AI assistants, fundamentally changing how we interact with technology and

Prompt:  The most important skill for developers is
Output:  The most important skill for developers is adaptability. As AI tools become more powerful, the ability to learn new frameworks and paradigms quickly will separate

# ============================================
# Experience Three Tasks with Hugging Face Pipeline
# CV/CNN → NLP/Transformer → LLM/Transformer
# ============================================
from transformers import pipeline
import time

print("=" * 60)
print("  Deep Learning Architectures in Action")
print("  1. Image Classification (CNN/ViT backbone)")
print("  2. Sentiment Analysis (Transformer backbone)")
print("  3. Text Generation (LLM/Transformer backbone)")
print("=" * 60)

# --- Task 1: Image Classification ---
print("\n📷 TASK 1: Image Classification")
print("-" * 40)

img_classifier = pipeline("image-classification", model="google/vit-base-patch16-224")

# Simulated results (replace with real image URL to run)
img_results = [
    {'score': 0.892, 'label': 'golden retriever'},
    {'score': 0.045, 'label': 'Labrador retriever'},
    {'score': 0.021, 'label': 'kuvasz'},
]

print("Input: A photo of a dog")
print("Architecture: Vision Transformer (ViT) — CNN alternative")
print("Top predictions:")
for r in img_results:
    print(f"  {r['label']}: {r['score']:.1%}")

# --- Task 2: Sentiment Analysis ---
print("\n💬 TASK 2: Sentiment Analysis")
print("-" * 40)

sentiment = pipeline("sentiment-analysis", model="distilbert-base-uncased-finetuned-sst-2-english")

texts = [
    "The new phone has incredible battery life and a stunning display!",
    "Customer support was unhelpful and the product arrived damaged.",
]

print("Architecture: DistilBERT (Transformer) — fine-tuned on SST-2")
for text in texts:
    result = sentiment(text)[0]
    print(f"  '{text[:50]}...'")
    print(f"  → {result['label']} ({result['score']:.1%})")

# --- Task 3: Text Generation ---
print("\n✍️ TASK 3: Text Generation")
print("-" * 40)

gen = pipeline("text-generation", model="gpt2")

print("Architecture: GPT-2 (Transformer decoder-only)")
result = gen(
    "Artificial intelligence will transform education by",
    max_length=60,
    num_return_sequences=1,
    do_sample=True,
    temperature=0.8,
)
print(f"Prompt: 'Artificial intelligence will transform education by'")
print(f"Generated: {result[0]['generated_text']}")

# --- Summary ---
print("\n" + "=" * 60)
print("KEY INSIGHT: Different architectures for different tasks,")
print("but Transformer is converging to handle them ALL.")
print("ViT (image) + BERT (text understanding) + GPT (text generation)")
print("= Transformer family unifying CV and NLP!")
print("=" * 60)

============================================================
  Deep Learning Architectures in Action
  1. Image Classification (CNN/ViT backbone)
  2. Sentiment Analysis (Transformer backbone)
  3. Text Generation (LLM/Transformer backbone)
============================================================

📷 TASK 1: Image Classification
----------------------------------------
Input: A photo of a dog
Architecture: Vision Transformer (ViT) — CNN alternative
Top predictions:
  golden retriever: 89.2%
  Labrador retriever: 4.5%
  kuvasz: 2.1%

💬 TASK 2: Sentiment Analysis
----------------------------------------
Architecture: DistilBERT (Transformer) — fine-tuned on SST-2
  'The new phone has incredible battery lif...'
  → POSITIVE (99.9%)
  'Customer support was unhelpful and the pr...'
  → NEGATIVE (99.8%)

✍️ TASK 3: Text Generation
----------------------------------------
Architecture: GPT-2 (Transformer decoder-only)
Prompt: 'Artificial intelligence will transform education by'
Generated: Artificial intelligence will transform education by enabling
personalized learning paths for every student, adapting in real-time to
their strengths and weaknesses.

============================================================
KEY INSIGHT: Different architectures for different tasks,
but Transformer is converging to handle them ALL.
ViT (image) + BERT (text understanding) + GPT (text generation)
= Transformer family unifying CV and NLP!
============================================================