深度学习

# 导入 Python 的 numpy 库，并把它起一个简写名字 np 使用
import numpy as np

def main():
    # Create a 3x3 array of random floats between 0 and 1
    array = np.random.rand(3, 3)
    
    # Print the array
    print("3x3 Array of Random Floats:")
    print(array)


if __name__ == "__main__":
    main()

import numpy as np

import matplotlib.pyplot as plt

from matplotlib.image import imread

img= imread('car.jpg')
plt.imshow(img)

plt.show()

import numpy as np

import matplotlib.pyplot as plt


def step_function(x):
    return np.array(x > 0, dtype=np.int32)

x = np.arange(-5.0, 5.0, 0.1)
y = step_function(x)

plt.plot(x, y)
plt.ylim(-0.1, 1.1)
plt.title("Step Function")
plt.xlabel("X Axis")
plt.ylabel("Y Axis")
# plt.grid()
plt.show()

import numpy as np

import matplotlib.pyplot as plt

def sigmoid(x):
    return 1 / (1 + np.exp(-x))

x = np.arange(-10.0, 10.0, 0.1)
y = sigmoid(x)
plt.plot(x, y)
plt.ylim(-0.1, 1.1)
plt.title("Sigmoid Function")
plt.xlabel("X Axis")
plt.ylabel("Y Axis")
# plt.grid()
plt.show()

import numpy as np

a = np.array([[1, 2, 3], [4, 5, 6]])
print(a.ndim)  # 输出数组的维度
print(a.shape)  # 输出数组的形状
print(a.dtype)  # 输出数组中元素的数据类型
print(a.size)  # 输出数组中元素的总数

# 矩阵乘法
# 1 2 3
# 4 5 6
# 乘以
# 7  8
# 9 10
# 11 12

b = np.array([[7, 8], [9, 10], [11, 12]])
c = np.dot(a, b)
print(c)  # 输出矩阵乘法的结果

# 2 x 3 乘以 3 x 2 得到 2 x 2 矩阵

# 58 64
# 139 154

# 矩阵乘法不支持交换律
d = np.dot(b, a)
print(d)  # 输出矩阵乘法的结果

# 3 x 2 乘以 2 x 3 得到 3 x 3 矩阵

# 39 54 69
# 49 68 87
# 59 82 105

# 矩阵乘法的行数和列数必须匹配，否则会报错

x = np.array([1, 2])
print(x.shape)  # 输出数组的形状
y = np.array([[1, 3, 5], [2, 4,6]])
print(y.shape)  # 输出数组的形状
z = np.dot(x, y)  # 1 x 2 乘以 2 x 3 得到 1 x 3 矩阵
print(z)  # 输出矩阵乘法的结果

import numpy as np
import matplotlib.pyplot as plt

def sigmoid(x):
    return 1 / (1 + np.exp(-x))

X = np.array([1.0, 0.5]) # 输入层的输入
W1 = np.array([[0.1, 0.3, 0.5], [0.2, 0.4, 0.6]]) # 输入层到隐藏层的权重
B1 = np.array([0.1, 0.2, 0.3]) # 隐藏层的偏置

print("X shape:", X.shape) # （2，）
print("W1 shape:", W1.shape) # （2，3）
print("B1 shape:", B1.shape) # （3，）

A1 = np.dot(X, W1) + B1 # 计算隐藏层的加权和

Z1 = sigmoid(A1) # 计算隐藏层的输出

print(A1) # 输出隐藏层的加权和 [0.3 0.7 1.1]
print(Z1) # 输出隐藏层的输出 [0.57444252 0.66818777 0.75026011]

# 第二层（隐藏层到输出层）
W2 = np.array([[0.1, 0.4], [0.2, 0.5], [0.3, 0.6]]) # 隐藏层到输出层的权重
B2 = np.array([0.1, 0.2]) # 输出层的偏置

A2 = np.dot(Z1, W2) + B2 # 计算输出层的加权和

Z2 = sigmoid(A2) # 计算输出层的输出

print(A2) # 输出输出层的加权和 [0.4 0.8]
print(Z2) # 输出输出层的输出 [0.59868766 0.68997448]

# 第三层（输出层到最终输出）
W3 = np.array([[0.1, 0.3], [0.2, 0.4]]) # 输出层到最终输出的权重
B3 = np.array([0.1, 0.2]) # 最终输出的偏置
A3 = np.dot(Z2, W3) + B3 # 计算最终输出的加权和
Z3 = sigmoid(A3) # 计算最终输出
print(A3) # 输出最终输出的加权和 [0.42336002 0.78658716]

print(Z3) # 输出最终输出 [0.60451623 0.68621873]

import numpy as np
import matplotlib.pyplot as plt

def sigmoid(x):
    return 1 / (1 + np.exp(-x))

def init_network():
    network = {}
    network['W1'] = np.array([[0.1, 0.3, 0.5], [0.2, 0.4, 0.6]])
    network['b1'] = np.array([0.1, 0.2, 0.3])
    network['W2'] = np.array([[0.1, 0.4], [0.2, 0.5], [0.3, 0.6]])
    network['b2'] = np.array([0.1, 0.2])
    network['W3'] = np.array([[0.1, 0.3], [0.2, 0.4]])
    network['b3'] = np.array([0.1, 0.2])
    return network

# 前向传播函数
def forward(network, x):
    W1, W2, W3 = network['W1'], network['W2'], network['W3']
    b1, b2, b3 = network['b1'], network['b2'], network['b3']

    a1 = np.dot(x, W1) + b1
    z1 = sigmoid(a1)

    a2 = np.dot(z1, W2) + b2
    z2 = sigmoid(a2)

    a3 = np.dot(z2, W3) + b3

    return a3

network = init_network()
x = np.array([1.0, 0.5])
output = forward(network, x)
print("Final output:", output)  # 输出最终结果

def softmax(a):
    c = np.max(a)
    exp_a = np.exp(a - c)  # 防止溢出
    sum_exp_a = np.sum(exp_a)
    y = exp_a / sum_exp_a
    return y

url_base = 'https://storage.googleapis.com/cvdf-datasets/mnist/'
key_file = {
    'train_img':'train-images-idx3-ubyte.gz', # 60,000 训练图像
    'train_label':'train-labels-idx1-ubyte.gz', # 60,000 训练标签
    'test_img':'t10k-images-idx3-ubyte.gz', # 10,000 测试图像
    'test_label':'t10k-labels-idx1-ubyte.gz' # 10,000 测试标签
}

import sys, os
import pickle
import numpy as np
import gzip
from PIL import Image

# MNIST数据保存路径
save_file = "./mnist.pkl"

# 
def _change_one_hot_label(X):
    T = np.zeros((X.size, 10))
    for idx, row in enumerate(T):
        row[X[idx]] = 1
        
    return T

def load_mnist(normalize=True, flatten=True, one_hot_label=False):
    """读入MNIST数据集
    
    Parameters
    ----------
    normalize : 将图像的像素值正规化为0.0~1.0
    one_hot_label : 
        one_hot_label为True的情况下，标签作为one-hot数组返回
        one-hot数组是指[0,0,1,0,0,0,0,0,0,0]这样的数组
    flatten : 是否将图像展开为一维数组
    
    Returns
    -------
    (训练图像, 训练标签), (测试图像, 测试标签)
    """
    # 判断mnist.pkl文件是否存在 
    with open(save_file, 'rb') as f:
        dataset = pickle.load(f)  # 载入数据集
    
    # 进行数据处理
    if normalize:
        for key in ('train_img', 'test_img'):
            dataset[key] = dataset[key].astype(np.float32)
            dataset[key] /= 255.0
    # one-hot编码
    if one_hot_label:
        dataset['train_label'] = _change_one_hot_label(dataset['train_label'])
        dataset['test_label'] = _change_one_hot_label(dataset['test_label'])

    # 展开为一维数组
    if not flatten:
         for key in ('train_img', 'test_img'):
            dataset[key] = dataset[key].reshape(-1, 1, 28, 28)

    # 返回训练数据和测试数据
    return (dataset['train_img'], dataset['train_label']), (dataset['test_img'], dataset['test_label']) 

def img_show(img):
    pil_img = Image.fromarray(np.uint8(img))
    pil_img.show()

# 读入MNIST数据集
(x_train, t_train), (x_test, t_test) = load_mnist(flatten=True, normalize=False)

img = x_train[0]
label = t_train[0]
print(label)  # 输出标签
print(img.shape)  # 输出图像形状(784,)
img = img.reshape(28, 28)  # 将一维数组形状转换为二维数组形状(28, 28)
print(img.shape)  # 输出图像形状(28, 28)
img_show(img)  # 显示图像

# 获取MNIST数据集
def get_data():
    (x_train, t_train), (x_test, t_test) = load_mnist(flatten=True, normalize=False)
    return (x_train, t_train), (x_test, t_test)

# 学习到大权重参数
def init_network():
    with open("sample_weight.pkl", 'rb') as f:
        network = pickle.load(f)
    return network

# 预测函数
def sigmoid(x):
    # 数值稳定的 sigmoid 实现，避免在 np.exp 中出现溢出
    x = np.clip(x, -500, 500)
    return 1.0 / (1.0 + np.exp(-x))

# 前向传播中的softmax函数
def softmax(a):
    c = np.max(a)
    exp_a = np.exp(a - c)  # 防止溢出
    sum_exp_a = np.sum(exp_a)
    y = exp_a / sum_exp_a
    return y

# 预测函数
def predict(network, x):
    # 神经网络中的权重
    W1, W2, W3 = network['W1'], network['W2'], network['W3']

    # 神经网络中的偏置
    b1, b2, b3 = network['b1'], network['b2'], network['b3']
    
    # 前向传播
    a1 = np.dot(x, W1) + b1
    z1 = sigmoid(a1)
    
    # 前向传播
    a2 = np.dot(z1, W2) + b2
    z2 = sigmoid(a2)
    
    # 前向传播 
    a3 = np.dot(z2, W3) + b3
    y = softmax(a3)
    
    return y

# 测试预测函数

(x_train, t_train), (x_test, t_test) = get_data()
# 使用测试集进行评估
x, t = x_test, t_test
network = init_network()

accuracy_cnt = 0
for i in range(len(x)):
    y = predict(network, x[i])
    p = np.argmax(y)  # 取得预测结果
    if p == t[i]:  # 预测正确
        accuracy_cnt += 1 # 统计正确次数

print("Accuracy:" + str(float(accuracy_cnt) / len(x)))  # 输出正确率

(x_train, t_train), (x_test, t_test) = get_data()
# 使用测试集进行评估
x, t = x_test, t_test

# print(x.shape)  # (10000, 784)
# print(t.shape)  # (10000,)

network = init_network()
batch_size = 100  # 每次处理的样本数量（一次送入模型预测100张图片）
accuracy_cnt = 0  # 用于累计预测正确的样本数

# 使用批处理方式对数据集进行评估
# 从第0个样本开始，每次步进 batch_size（100）
for i in range(0, len(x), batch_size):
    
    # 取出当前批次的数据，例如第0~99张图片、第100~199张图片……
    x_batch = x[i:i+batch_size]
    
    # 使用训练好的网络进行预测
    # 输出 y_batch 通常是每个样本属于各类别的概率（或得分）
    y_batch = predict(network, x_batch)
    
    # np.argmax(axis=1) 表示：
    # 在每一行（每张图片的预测结果）中，取概率最大的类别索引
    # 即模型最终预测的类别标签
    p = np.argmax(y_batch, axis=1)
    
    # 将预测结果 p 与真实标签 t[i:i+batch_size] 进行比较
    # p == t[...] 会得到一个布尔数组（True/False）
    # np.sum(...) 统计预测正确的数量
    accuracy_cnt += np.sum(p == t[i:i+batch_size])


print("Accuracy:" + str(float(accuracy_cnt) / len(x)))  # 输出正确率

def _change_one_hot_label(X):
    T = np.zeros((X.size, 10))    # 1️⃣ 创建一个全零矩阵，行数 = 标签数量，列数 = 10（类别数）
    for idx, row in enumerate(T):
        row[X[idx]] = 1           # 2️⃣ 对应行 X[idx] 的位置设为 1
    return T                      # 3️⃣ 返回 one-hot 编码后的矩阵

# 对应上面的 X
array([[0., 0., 0., 1., 0., 0., 0., 0., 0., 0.],  # 类别 3
       [1., 0., 0., 0., 0., 0., 0., 0., 0., 0.],  # 类别 0
       [0., 0., 0., 0., 1., 0., 0., 0., 0., 0.],  # 类别 4
       [0., 1., 0., 0., 0., 0., 0., 0., 0., 0.]]) # 类别 1

import sys, os
import numpy as np
from mnist_demo import load_mnist, init_network, predict

(x_train, t_train), (x_test, t_test) = load_mnist(flatten=True, normalize=False, one_hot_label=True)

print(x_train.shape)  # (60000, 784)
print(t_train.shape)  # (60000, 10)

train_size = x_train.shape[0]
batch_size = 10

# 从训练数据中随机抽取batch_size个样本
batch_mask = np.random.choice(train_size, batch_size)

# 选取对应的样本
xbatch = x_train[batch_mask]

# 选取对应的标签
tbatch = t_train[batch_mask]

def cross_entropy_error(y, t):
    """
    计算交叉熵误差（Cross-Entropy Loss）
    
    参数：
    y : np.ndarray
        神经网络输出的预测概率（Softmax 输出），形状为 (batch_size, 类别数)
    t : np.ndarray
        真实标签，one-hot 编码，形状为 (batch_size, 类别数) 或一维标签
    
    返回：
    float
        平均交叉熵损失值
    """
    
    # 如果 y 是一维数组（单个样本），则将其扩展为二维数组
    # 这样可以统一处理单样本和批量样本的情况
    if y.ndim == 1:
        t = t.reshape(1, t.size)  # 将真实标签从 (类别数,) 转为 (1, 类别数)
        y = y.reshape(1, y.size)  # 将预测概率从 (类别数,) 转为 (1, 类别数)
    
    # 获取批量样本的数量
    batch_size = y.shape[0]
    
    # 计算交叉熵误差
    # 公式：L = -1/N * Σ Σ t_ij * log(y_ij)
    # 1e-7 是为了避免 log(0) 出现数值错误
    # t * np.log(y + 1e-7) 是逐元素相乘，只保留真实标签对应位置的 log 概率
    # np.sum() 对所有样本和类别求和
    loss = -np.sum(t * np.log(y + 1e-7)) / batch_size
    
    return loss

import numpy as np
import matplotlib.pylab as plt

def funcion_1(x):
    return 0.01 * x ** 2 + 0.1 * x

def numerical_diff(f, x):
    h = 1e-4  # 0.0001
    return (f(x + h) - f(x - h)) / (2 * h)

x = np.arange(0.0, 20.0, 0.1)
y = funcion_1(x)
plt.xlabel("x")
plt.ylabel("f(x)")
plt.plot(x, y)


a = numerical_diff(funcion_1, 5)  # 0.2
b = numerical_diff(funcion_1, 10)  # 0.3

print(a)
print(b)

# 计算并绘制数值导数
y_diff = numerical_diff(funcion_1, x)
plt.plot(x, y_diff, color="orange", linestyle='--', label="f'(x)")

# 在 x=5 和 x=10 处画竖线、标记导数值并注释数值
plt.axvline(5, color='green', linestyle=':', linewidth=1)
plt.axvline(10, color='red', linestyle=':', linewidth=1)
plt.plot(5, a, 'o', color='green', label="f'(5)={:.3f}".format(a))
plt.plot(10, b, 'o', color='red', label="f'(10)={:.3f}".format(b))
plt.text(5, a, ' {:.3f}'.format(a), color='green', va='bottom')
plt.text(10, b, ' {:.3f}'.format(b), color='red', va='bottom')

plt.legend()
plt.grid(alpha=0.3)

plt.show()

# coding: utf-8
"""梯度下降法的实现与可视化。

本模块演示了梯度下降优化算法的基本原理：通过沿负梯度方向迭代更新参数，
最终使目标函数收敛到最小值附近。脚本会绘制优化过程中参数的轨迹。
"""

import numpy as np
import matplotlib.pylab as plt
from gradient_2d import numerical_gradient


def gradient_descent(f, init_x, lr=0.01, step_num=100):
    """使用梯度下降法优化目标函数。

    通过计算目标函数的数值梯度，沿负梯度方向迭代更新参数，直到达到
    指定的迭代步数。记录每一步的参数值以便后续绘制优化轨迹。

    参数
    -----
    f : callable
        目标函数，接受 numpy 数组并返回标量。
    init_x : numpy.ndarray
        初始参数值，维数为问题的维度。
    lr : float，可选
        学习率（步长），控制每步的更新幅度。默认值为 0.01。
    step_num : int，可选
        迭代步数。默认值为 100。

    返回
    -----
    x : numpy.ndarray
        最终优化得到的参数值。
    x_history : numpy.ndarray
        所有迭代步骤的参数值，形状为 (step_num, dim)，可用于绘制优化轨迹。
    """
    x = init_x
    # 存储每次迭代的参数值以便后续绘制
    x_history = []

    for i in range(step_num):
        # 记录当前参数值
        x_history.append( x.copy() )

        # 计算目标函数在当前点的梯度（数值方法）
        grad = numerical_gradient(f, x)
        # 沿负梯度方向更新参数：x_{k+1} = x_k - lr * ∇f(x_k)
        x -= lr * grad

    # 返回最终参数和完整的优化轨迹
    return x, np.array(x_history)


def function_2(x):
    """目标函数：f(x0, x1) = x0^2 + x1^2。

    这是一个简单的凸函数，在原点 (0, 0) 处达到全局最小值 0。
    """
    return x[0]**2 + x[1]**2


# ============ 主程序 ============

# 设置初始参数值
init_x = np.array([-3.0, 4.0])

# 设置学习率和迭代步数
lr = 0.1  # 较大的学习率使收敛更快
step_num = 20  # 迭代 20 步

# 执行梯度下降优化
x, x_history = gradient_descent(function_2, init_x, lr=lr, step_num=step_num)

# ============ 绘制结果 ============

# 绘制坐标轴参考线（x=0 和 y=0 轴）
plt.plot( [-5, 5], [0,0], '--b')
plt.plot( [0,0], [-5, 5], '--b')

# 绘制优化过程中的参数轨迹点
plt.plot(x_history[:,0], x_history[:,1], 'o')

# 设置图的范围和标签
plt.xlim(-3.5, 3.5)
plt.ylim(-4.5, 4.5)
plt.xlabel("X0")
plt.ylabel("X1")

# 显示图像
plt.show()