【AI学习路线 01】入门基础 - 数学与编程基础

# 基本数据类型
name = "AI学习者"      # 字符串
age = 25               # 整数
score = 95.5           # 浮点数
is_active = True       # 布尔值

# 类型转换
num_str = "123"
num_int = int(num_str)  # 字符串转整数

# 条件判断
score = 85
if score >= 90:
    print("优秀")
elif score >= 60:
    print("及格")
else:
    print("不及格")

# 循环结构
for i in range(5):
    print(f"第{i+1}次循环")

# while循环
count = 0
while count < 3:
    print(count)
    count += 1

def calculate_area(radius):
    """计算圆的面积"""
    import math
    return math.pi * radius ** 2

# 带默认参数的函数
def greet(name, greeting="你好"):
    return f"{greeting}, {name}!"

# Lambda表达式
square = lambda x: x ** 2

class NeuralNetwork:
    """简单的神经网络类示例"""
    
    def __init__(self, input_size, hidden_size, output_size):
        self.input_size = input_size
        self.hidden_size = hidden_size
        self.output_size = output_size
        self.weights = None
    
    def initialize_weights(self):
        """初始化权重"""
        import numpy as np
        self.weights = np.random.randn(self.input_size, self.hidden_size)
        return self.weights
    
    def forward(self, x):
        """前向传播"""
        if self.weights is None:
            self.initialize_weights()
        return np.dot(x, self.weights)

# 使用类
nn = NeuralNetwork(10, 5, 2)

# 列表 - 有序可变
numbers = [1, 2, 3, 4, 5]
numbers.append(6)          # 添加元素
numbers.pop()              # 移除最后一个
numbers[0]                 # 索引访问

# 元组 - 有序不可变
point = (3, 4)
x, y = point               # 解包

# 字典 - 键值对
model_config = {
    "learning_rate": 0.001,
    "epochs": 100,
    "batch_size": 32
}

# 集合 - 无序不重复
unique_numbers = {1, 2, 3, 2, 1}  # 结果: {1, 2, 3}

import numpy as np

# 创建数组
arr = np.array([1, 2, 3, 4, 5])
matrix = np.array([[1, 2, 3], [4, 5, 6]])

# 数组运算
arr * 2              # 元素乘法
arr + arr            # 元素加法
np.dot(arr, arr)     # 点积

# 常用函数
np.mean(arr)         # 平均值
np.std(arr)          # 标准差
np.sum(arr)          # 求和
np.max(arr)          # 最大值

# 矩阵运算
A = np.random.randn(3, 4)
B = np.random.randn(4, 2)
C = np.dot(A, B)     # 矩阵乘法 (3x4) @ (4x2) = (3x2)

# 广播机制
matrix = np.array([[1, 2, 3], [4, 5, 6]])
row = np.array([1, 0, 1])
result = matrix + row  # 广播加法

import pandas as pd

# 创建DataFrame
data = {
    "name": ["Alice", "Bob", "Charlie"],
    "age": [25, 30, 35],
    "score": [85.5, 90.0, 78.5]
}
df = pd.DataFrame(data)

# 数据查看
df.head()                    # 查看前几行
df.info()                    # 数据类型信息
df.describe()                # 统计描述

# 数据选择
df["name"]                   # 选择列
df.loc[0]                    # 按标签选择
df.iloc[0:2]                 # 按位置选择

# 数据处理
df["age_group"] = df["age"].apply(lambda x: "青年" if x < 30 else "中年")
df.dropna()                  # 删除缺失值
df.fillna(0)                 # 填充缺失值
df.groupby("age_group").mean()  # 分组聚合

import matplotlib.pyplot as plt
import numpy as np

# 折线图
x = np.linspace(0, 10, 100)
y = np.sin(x)
plt.figure(figsize=(10, 6))
plt.plot(x, y, label='sin(x)')
plt.xlabel('x')
plt.ylabel('y')
plt.title('正弦函数')
plt.legend()
plt.grid(True)
plt.show()

# 散点图
x = np.random.randn(100)
y = np.random.randn(100)
plt.scatter(x, y, alpha=0.5)
plt.show()

# 直方图
data = np.random.randn(1000)
plt.hist(data, bins=30, edgecolor='black')
plt.show()

import numpy as np

# 向量定义
v1 = np.array([1, 2, 3])
v2 = np.array([4, 5, 6])

# 向量加法
v_add = v1 + v2  # [5, 7, 9]

# 向量点积
dot_product = np.dot(v1, v2)  # 1*4 + 2*5 + 3*6 = 32

# 向量范数（长度）
l2_norm = np.linalg.norm(v1)  # sqrt(1+4+9) = sqrt(14)

# 向量夹角
cos_angle = np.dot(v1, v2) / (np.linalg.norm(v1) * np.linalg.norm(v2))

# 矩阵定义
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])

# 矩阵乘法
C = np.dot(A, B)  # 或 A @ B

# 矩阵转置
A_T = A.T

# 矩阵求逆
A_inv = np.linalg.inv(A)

# 特征值和特征向量
eigenvalues, eigenvectors = np.linalg.eig(A)

# 行列式
det = np.linalg.det(A)

import numpy as np

# 数值导数
def numerical_derivative(f, x):
    """计算函数f在x处的数值导数"""
    h = 1e-5  # 很小的增量
    return (f(x + h) - f(x - h)) / (2 * h)

# 示例：计算 f(x) = x^2 在 x=3 处的导数
def f(x):
    return x ** 2

derivative_at_3 = numerical_derivative(f, 3)  # 约 6.0

# 梯度（多元函数的导数）
def numerical_gradient(f, x):
    """计算多元函数的梯度"""
    h = 1e-5
    grad = np.zeros_like(x)
    for i in range(len(x)):
        temp = x[i]
        x[i] = temp + h
        fxh1 = f(x)
        x[i] = temp - h
        fxh2 = f(x)
        grad[i] = (fxh1 - fxh2) / (2 * h)
        x[i] = temp
    return grad

# 复合函数 f(g(x)) 的导数 = f'(g(x)) * g'(x)
# 神经网络中的例子
def sigmoid(x):
    return 1 / (1 + np.exp(-x))

def sigmoid_derivative(x):
    s = sigmoid(x)
    return s * (1 - s)

# 多层网络的梯度计算
x = np.array([1.0, 2.0])
w1 = np.array([[0.1, 0.2], [0.3, 0.4]])
w2 = np.array([[0.5], [0.6]])

# 前向传播
h = sigmoid(np.dot(x, w1))      # 隐藏层
y = sigmoid(np.dot(h, w2))      # 输出层

# 反向传播（链式法则）
# dL/dw2 = dL/dy * dy/dh2 * dh2/dw2
# dL/dw1 = dL/dy * dy/dh2 * dh2/dh * dh/dh1 * dh1/dw1

import numpy as np
from scipy import stats

# 概率分布
# 正态分布
mean, std = 0, 1
x = np.linspace(-5, 5, 100)
pdf = stats.norm.pdf(x, mean, std)  # 概率密度函数

# 常用统计量
data = np.random.randn(1000)
print(f"均值: {np.mean(data)}")
print(f"方差: {np.var(data)}")
print(f"标准差: {np.std(data)}")
print(f"中位数: {np.median(data)}")

# 贝叶斯定理
# P(A|B) = P(B|A) * P(A) / P(B)
def bayes_theorem(p_b_given_a, p_a, p_b):
    """计算 P(A|B)"""
    return (p_b_given_a * p_a) / p_b

# 示例：医疗诊断
# P(患病|检测阳性) = P(检测阳性|患病) * P(患病) / P(检测阳性)
p_disease = 0.01                    # 患病概率
p_positive_given_disease = 0.95     # 患病时检测阳性的概率
p_positive = 0.05                   # 检测阳性的总概率
p_disease_given_positive = bayes_theorem(
    p_positive_given_disease, p_disease, p_positive
)

# 熵 - 不确定性度量
def entropy(p):
    """计算熵 H(p) = -Σ p(x) * log(p(x))"""
    p = p[p > 0]  # 避免 log(0)
    return -np.sum(p * np.log2(p))

# 交叉熵 - 分类任务常用损失函数
def cross_entropy(p, q):
    """计算交叉熵 H(p, q) = -Σ p(x) * log(q(x))"""
    q = np.clip(q, 1e-10, 1)  # 避免 log(0)
    return -np.sum(p * np.log(q))

# KL散度 - 分布差异度量
def kl_divergence(p, q):
    """KL散度 D_KL(p||q) = Σ p(x) * log(p(x)/q(x))"""
    q = np.clip(q, 1e-10, 1)
    p = np.clip(p, 1e-10, 1)
    return np.sum(p * np.log(p / q))