走进人工智能

python --version          # 查看 Python 版本，应输出 Python 3.x.x

# 进入项目目录后，创建并激活虚拟环境（强烈建议）
python -m venv .venv
.\.venv\Scripts\Activate.ps1

# 若提示脚本执行被禁止，可先执行（仅当前会话）：
# Set-ExecutionPolicy -Scope Process -ExecutionPolicy Bypass

# 安装本书常用的第三方库
pip install numpy pandas scikit-learn matplotlib
pip install torch            # 第 6、7 章深度学习部分（CPU 版即可学习）

# 国内用户可切换清华镜像加速下载
pip install numpy -i https://pypi.tuna.tsinghua.edu.cn/simple

# ========== 1. 基本数据类型 ==========
x = 3                 # int 整数
pi = 3.14159          # float 浮点数
name = "人工智能"      # str 字符串（Python 3 中字符串默认 Unicode，支持中文）
flag = True           # bool 布尔值：True / False
nothing = None        # None 表示"空"

print(type(x), type(pi), type(name))   # type() 查看类型
print(name[0], name[-1], len(name))    # 字符串索引与长度：人 能 4
print(f"圆周率约为 {pi:.2f}")          # f-string 格式化输出

# ========== 2. 容器 ==========
# 列表 list：可变、有序
fruits = ["苹果", "香蕉", "橙子"]
fruits.append("葡萄")
print(fruits[1:3])                     # 切片 ['香蕉', '橙子']

# 字典 dict：键值对
scores = {"张三": 90, "李四": 85}
scores["王五"] = 78
print(scores.get("赵六", "查无此人"))   # 键不存在时返回默认值

# 元组 tuple：不可变；集合 set：无序不重复
point = (3, 4)
uniq = set([1, 1, 2, 3, 3])
print(point, uniq)                     # (3, 4) {1, 2, 3}

# ========== 3. 控制流（注意用缩进表示代码块，通常 4 个空格）==========
for i in range(3):                     # range(3) 产生 0,1,2
    if i % 2 == 0:
        print(f"{i} 是偶数")
    else:
        print(f"{i} 是奇数")

# 列表推导式：简洁地构造列表
squares = [i ** 2 for i in range(5)]
print(squares)                         # [0, 1, 4, 9, 16]

# ========== 4. 函数 ==========
def sigmoid(z):
    """逻辑斯蒂函数，神经网络中最常用的激活函数之一。"""
    import math
    return 1.0 / (1.0 + math.exp(-z))

print(sigmoid(0))                      # 0.5
print(sigmoid(2))                      # 约 0.8808

def greet(name, greeting="你好"):       # 默认参数
    return f"{greeting}，{name}！"

print(greet("同学"))
print(greet("同学", greeting="晚上好"))  # 关键字参数

# ========== 5. 类与面向对象 ==========
class Animal:
    def __init__(self, name, sound):   # 构造方法，self 指向实例自身
        self.name = name
        self.sound = sound

    def speak(self):
        return f"{self.name} 发出 {self.sound} 的声音"

class Dog(Animal):                     # 继承 Animal
    def __init__(self, name):
        super().__init__(name, "汪汪")  # 调用父类构造

    def speak(self):                   # 方法重写（多态）
        return f"{self.name} 摇着尾巴说：{self.sound}！"

d = Dog("旺财")
print(d.speak())

# ========== 6. 模块与文件 ==========
import random
print(random.randint(1, 6))            # 模拟掷骰子

# with 语句自动关闭文件；encoding="utf-8" 避免中文乱码
with open("demo.txt", "w", encoding="utf-8") as f:
    f.write("第一行：知识就是力量\n")
with open("demo.txt", "r", encoding="utf-8") as f:
    print(f.read())

import numpy as np

# 从列表创建
a = np.array([1, 2, 3, 4], dtype=np.float64)
print(a, a.shape, a.dtype)        # [1. 2. 3. 4.]  (4,)  float64

# 常用快捷创建
print(np.zeros((2, 3)))           # 2行3列全 0
print(np.ones((2, 2)))            # 2行2列全 1
print(np.eye(3))                  # 3阶单位矩阵
print(np.arange(0, 10, 2))        # [0 2 4 6 8]
print(np.linspace(0, 1, 5))       # [0.   0.25 0.5  0.75 1.  ]
print(np.random.rand(2, 3))       # 2x3 的 [0,1) 均匀随机数
print(np.random.randn(2, 3))      # 2x3 的标准正态随机数

# 固定随机种子，使结果可复现（做实验的好习惯）
rng = np.random.default_rng(seed=42)
print(rng.integers(0, 10, size=5))

import numpy as np

m = np.array([[1, 2, 3],
              [4, 5, 6],
              [7, 8, 9]])

print(m.shape)          # (3, 3)
print(m[0, 0])          # 第1行第1列：1
print(m[1])             # 第2行：[4 5 6]
print(m[:, 0])          # 第1列：[1 4 7]
print(m[0:2, 1:3])      # 前2行、第2~3列
# [[2 3]
#  [5 6]]

print(m[m > 5])        # 布尔索引：[6 7 8 9]

m2 = m.reshape(1, 9)    # 改形状（不改变数据）
print(m2.shape)         # (1, 9)
print(m.T)              # 转置

# 向量的点积与矩阵乘法
v = np.array([1, 2, 3])
print(np.dot(v, v))              # 点积：14
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])
print(A @ B)                     # @ 是矩阵乘法运算符
# [[19 22]
#  [43 50]]

import numpy as np

a = np.array([1.0, 2.0, 3.0, 4.0])

# 逐元素运算（比 Python 循环快几十倍）
print(a + 10)             # [11. 12. 13. 14.]
print(a * 2)              # [2. 4. 6. 8.]
print(np.exp(a))          # 每个元素取 e^x
print(np.sqrt(a))
print(1 / (1 + np.exp(-a)))   # 对整个数组做 sigmoid！

# 聚合运算
print(a.sum(), a.mean(), a.max(), a.std())   # 10.0 2.5 4.0 1.118...

X = np.array([[1, 2, 3],
              [4, 5, 6]])
print(X.sum(axis=0))      # 沿第0轴（跨行）求和：[5 7 9]
print(X.sum(axis=1))      # 沿第1轴（跨列）求和：[ 6 15]

# 广播（broadcasting）：形状不同的数组自动扩展后运算
W = np.ones((3, 4))       # 3x4
b = np.array([10, 20, 30, 40])   # 形状 (4,)，自动扩展为 3x4
print(W + b)              # 每一行都加上 b

import numpy as np

# ---------- 1. 准备"观测数据" ----------
# 真实关系是 y = 2x + 1 加一点噪声（模拟现实中的测量误差）
rng = np.random.default_rng(0)
X = np.linspace(0, 10, 50)
y = 2 * X + 1 + rng.normal(0, 1.0, size=X.shape)

# ---------- 2. 初始化参数（随便猜） ----------
w = 0.0
b = 0.0
lr = 0.01          # 学习率 η
n = len(X)

# ---------- 3. 梯度下降：反复修正 w 和 b ----------
for epoch in range(200):
    y_pred = w * X + b                 # 前向：用当前参数做预测
    error = y_pred - y                 # 预测误差
    loss = (error ** 2).mean()         # 均方误差 MSE

    grad_w = (2 / n) * (error * X).sum()   # 损失对 w 的偏导
    grad_b = (2 / n) * error.sum()         # 损失对 b 的偏导

    w -= lr * grad_w                  # 更新参数
    b -= lr * grad_b

    if epoch % 40 == 0:
        print(f"第 {epoch:3d} 轮 | 损失 {loss:8.4f} | w={w:.3f} b={b:.3f}")

print(f"\n学习结果：w = {w:.3f}（真值 2），b = {b:.3f}（真值 1）")

# ---------- 4. 用学到的模型做预测 ----------
for area in [3.0, 7.5, 12.0]:
    print(f"面积 {area:5.1f}  →  预测价格 {w * area + b:.2f}")