# 每一課第一格都會看到這行：安裝／更新 fastai
# You will see this in the first cell of every lesson: install or update fastai
!pip install -Uqq fastai

1 + 2          # 最後一行自動顯示 3 / the last line is shown: 3

epochs = 3              # int 整數
lr = 0.002              # float 小數（learning rate 學習率）
label = "bird"          # str 字串
is_bird = True          # bool 布林
print(type(epochs), type(lr), type(label), type(is_bird))

prob = 0.9987
print(round(prob * 100, 1))   # 99.9

o = "forest"
print(f"{o} photo")            # forest photo（L01 搜尋關鍵字 / L01 search term）

is_bird, _, probs = "bird", 0, [0.0013, 0.9987]
print(f"This is a: {is_bird}.")
print(f"Probability it's a bird: {probs[1]:.4f}")   # 小數 4 位 / 4 decimals

name = "  Bird Photo  "
print(name.strip().lower())    # "bird photo"
print("anchor; target".split("; "))   # ['anchor', 'target']（L04 切文字）

searches = ["forest", "bird"]
print(searches[0])        # forest
print(searches[-1])       # bird（-1 是最後一個 / last item）

nums = [10, 20, 30, 40, 50]
print(nums[1:3])          # [20, 30]
print(nums[:2])           # [10, 20] 前兩個 / first two
print(nums[::2])          # [10, 30, 50] 每隔一個 / every other
print(len(nums))          # 5

nums.append(60)           # 加到最後 / add to end
print(nums)

vocab = {0: "bird", 1: "forest"}
print(vocab[0])                     # bird
vocab[2] = "cat"                    # 新增 / add
for k, v in vocab.items():
    print(k, v)

# L01：learn.predict 回傳三個值，用拆包接收
# L01: learn.predict returns three values; unpack them
result = ("bird", 0, [0.9987, 0.0013])
is_bird, idx, probs = result
print(is_bird, probs[idx])

# 不需要的值習慣用 _ 接 / use _ for values you don't need
is_bird, _, probs = result

# L01 下載圖片的結構（簡化）/ simplified L01 download loop
searches = ["forest", "bird"]
for o in searches:
    print(f"downloading {o} photos ...")

# range(n) 產生 0 到 n-1 / range(n) gives 0..n-1
for epoch in range(3):
    loss = 1 / (epoch + 1)
    print(f"epoch {epoch}: loss={loss:.3f}")

prob = 0.97
if prob > 0.5:
    print("bird")
else:
    print("not bird")

nums = [1, 2, 3, 4, 5]

# 一般寫法 / long way
squares = []
for x in nums:
    squares.append(x * x)

# 生成式 / comprehension
squares = [x * x for x in nums]
evens = [x for x in nums if x % 2 == 0]
print(squares, evens)

# 字典生成式 / dict comprehension
lengths = {w: len(w) for w in ["bird", "forest"]}
print(lengths)            # {'bird': 4, 'forest': 6}

# L03：二次函數 / quadratic function from L03
def quad(a, b, c, x):
    return a * x**2 + b * x + c

print(quad(3, 2, 1, 1.5))      # 10.75

# 預設值 / default value
def resize_note(size=400):
    return f"resize to {size}px"
print(resize_note(), resize_note(192))

# 函式當參數 / function as an argument
def parent_label(path):
    return path.split("/")[-2]        # 取資料夾名 / folder name

def label_all(paths, get_y):
    return [get_y(p) for p in paths]

print(label_all(["dest/bird/1.jpg", "dest/forest/2.jpg"], parent_label))

# lambda：一行的小函式 / one-line function
double = lambda x: x * 2
print(double(5))

import math
print(math.sqrt(16))

import numpy as np          # 慣例縮寫 / conventional alias
import pandas as pd

from pathlib import Path    # 只拿一個名稱 / import one name

# 課程第一課會看到 / seen in L01:
# from fastai.vision.all import *
# from duckduckgo_search import DDGS

from pathlib import Path

path = Path("bird_or_not")
dest = path / "forest"              # bird_or_not/forest
print(dest, dest.name, dest.parent)

dest.mkdir(parents=True, exist_ok=True)   # 建資料夾 / make folder
(dest / "note.txt").write_text("hello")
print([p.name for p in dest.iterdir()])   # 列出檔案 / list files
print(Path("dest/bird/1.jpg").parent.name)   # bird（就是 parent_label 的做法）

try:
    print(10 / 0)
except ZeroDivisionError as e:
    print("出錯了 / error:", e)

import numpy as np

a = np.array([1, 2, 3])
print(a * 10, a.sum(), a.mean())

m = np.array([[1, 2, 3],
              [4, 5, 6]])
print(m.shape)               # (2, 3)：2 列 3 欄 / 2 rows, 3 cols
coeffs = np.array([0.5, 1.0, 2.0])
print(m * coeffs)            # 廣播：每列都乘 coeffs / broadcast to every row
print((m * coeffs).sum(axis=1))   # 每列加總 = 每個乘客的預測 / per-row sum (L05 predictions)
print(m @ coeffs)            # 矩陣乘法，結果一樣 / matrix multiply, same result
print(np.log1p(np.array([0, 9, 99])))   # L05 處理票價用的 log / log used for Fare

import numpy as np
import pandas as pd

df = pd.DataFrame({
    "Name": ["Ann", "Bob", "Cat", "Dan"],
    "Age": [22, None, 35, 58],
    "Fare": [7.25, 71.3, 8.05, 30.0],
    "Survived": [0, 1, 1, 0],
})
# 真實課程用 df = pd.read_csv("train.csv") / the course uses read_csv

print(df.head())             # 前幾列 / first rows
print(df.describe())         # 統計摘要 / summary stats
print(df.isna().sum())       # 每欄缺幾個 / missing per column

df["Age"] = df["Age"].fillna(df["Age"].mode()[0])   # L05：用眾數補缺值 / fill with mode
df["LogFare"] = np.log1p(df["Fare"])                 # 新增欄位 / new column
print(df[df["Survived"] == 1])                       # 篩選列 / filter rows
print(df.groupby("Survived")["Fare"].mean())         # 分組平均 / group mean

import torch

t = torch.tensor([[1., 2.], [3., 4.]])
print(t.shape, t.mean(), t @ t)

# L03 的梯度下降縮小版 / a tiny version of L03 gradient descent
xs = torch.linspace(-2, 2, 20)
ys = 3 * xs**2 + 2 * xs + 1                 # 真正的答案 / the true function

params = torch.tensor([1.0, 1.0, 1.0], requires_grad=True)   # a, b, c 從亂猜開始
lr = 0.01
for step in range(200):
    a, b, c = params
    preds = a * xs**2 + b * xs + c
    loss = ((preds - ys) ** 2).mean()       # MSE 損失
    loss.backward()                         # 算梯度 / compute gradients
    with torch.no_grad():
        params -= lr * params.grad          # 更新 / update
        params.grad.zero_()                 # 清空梯度 / reset
print(params, loss.item())                  # 會接近 [3, 2, 1] / approaches [3, 2, 1]

class Dog:
    def __init__(self, name):
        self.name = name
    def say(self):
        return f"{self.name}: woof"

d = Dog("Lucky")
print(d.say())

# L07：協同過濾的點積模型 / L07 dot-product model
import torch
from torch import nn

class DotProduct(nn.Module):
    def __init__(self, n_users, n_movies, n_factors):
        super().__init__()                         # 先跑父類別的 init / run parent init
        self.user_factors = nn.Embedding(n_users, n_factors)
        self.movie_factors = nn.Embedding(n_movies, n_factors)
    def forward(self, x):
        users = self.user_factors(x[:, 0])
        movies = self.movie_factors(x[:, 1])
        return (users * movies).sum(dim=1)

model = DotProduct(n_users=10, n_movies=20, n_factors=5)
x = torch.tensor([[0, 3], [2, 7]])                 # (使用者, 電影) / (user, movie)
print(model(x))                                    # 呼叫 model(x) 就是執行 forward

class Dataset:
    def __init__(self, xs, ys): self.xs, self.ys = xs, ys
    def __len__(self): return len(self.xs)
    def __getitem__(self, i): return self.xs[i], self.ys[i]

ds = Dataset([1, 2, 3], ["a", "b", "c"])
print(len(ds), ds[1])          # 3 (2, 'b')

def batches(items, bs):
    for i in range(0, len(items), bs):
        yield items[i:i + bs]

for b in batches(list(range(10)), bs=4):
    print(b)          # [0,1,2,3] [4,5,6,7] [8,9]

it = iter([10, 20, 30])
print(next(it), next(it))   # 10 20

def train(model, epochs=1, **kwargs):
    print(model, epochs, kwargs)
train("resnet18", 3, lr=0.01, wd=0.1)

from functools import partial
def power(x, n): return x ** n
square = partial(power, n=2)
print(square(5))      # 25

import time
def timer(f):
    def wrapper(*args, **kwargs):
        t0 = time.time()
        out = f(*args, **kwargs)
        print(f"{f.__name__} took {time.time() - t0:.3f}s")
        return out
    return wrapper

@timer
def slow_sum(n):
    return sum(range(n))
slow_sum(1_000_000)