AI数学基础

import numpy as np

# 创建系数矩阵 A
# 使用 np.array() 创建一个 3x3 的系数矩阵 A
A = np.array([[1, 2, 3],  # 矩阵 A 的第一行
              [1, 6, 7],  # 矩阵 A 的第二行
              [1, 10, 6]])  # 矩阵 A 的第三行

# 创建常数向量 b
# 使用 np.array() 创建一个长度为 3 的常数向量 b
b = np.array([5, 9, 8])  # 常数向量 b

# 解方程 Ax = b
# 使用 np.linalg.solve() 函数求解线性方程组
# 这里假设 A 是一个非奇异矩阵（即可逆矩阵），并且 A 和 b 的维度匹配
x = np.linalg.solve(A, b)

# 打印结果
print("解：", x)  # 输出方程组的解

# 导入必要的库
import numpy as np
import matplotlib
matplotlib.use('TkAgg')  # 设置matplotlib使用TkAgg作为绘图后端，确保在不支持默认后端的环境中正确显示图形
import matplotlib.pyplot as plt

# 定义Sigmoid激活函数
def sigmoid(x):
    """Sigmoid函数：1 / (1 + e^(-x))"""
    return 1 / (1 + np.exp(-x))

# 定义一个通用的函数来绘制激活函数图像
def plot_activation_function(func, x, title):
    """根据给定的激活函数和输入值绘制其图像"""
    y = func(x)  # 计算激活函数对应的输出值
    plt.plot(x, y)  # 绘制函数曲线
    plt.title(title)  # 设置图表标题
    plt.xlabel('x')  # 设置x轴标签
    plt.ylabel('f(x)')  # 设置y轴标签
    plt.grid(True)  # 显示网格线
    plt.show()  # 显示图表

# 定义tanh（双曲正切）激活函数
def tanh(x):
    """tanh函数：(e^x - e^(-x)) / (e^x + e^(-x))"""
    return np.tanh(x)

# 定义ReLU激活函数
def relu(x):
    """ReLU函数：max(0, x)"""
    return np.maximum(0, x)

# 定义Leaky ReLU激活函数
def leaky_relu(x, alpha=0.01):
    """Leaky ReLU函数：x > 0 ? x : alpha * x"""
    return np.where(x > 0, x, x * alpha)

# 定义Parametric ReLU激活函数
def parametric_relu(x, parm=0.5):
    """Parametric ReLU函数：x > 0 ? x : parm * x"""
    return np.where(x > 0, x, x * parm)

# 定义ELU（Exponential Linear Unit）激活函数
def elu(x, alpha=1):
    """ELU函数：x > 0 ? x : alpha * (e^x - 1)"""
    return np.where(x > 0, x, alpha * (np.exp(x) - 1))

# 创建从-10到10（包括10），步长为0.1的数组，用于作为各激活函数的输入
x_value = np.arange(-10, 10.1, 0.1)

# 分别绘制不同激活函数的图像
plot_activation_function(sigmoid, x_value, title='Sigmoid')
plot_activation_function(tanh, x_value, title='tanh')
plot_activation_function(relu, x_value, title='ReLU')
plot_activation_function(leaky_relu, x_value, title='Leaky ReLU')
plot_activation_function(parametric_relu, x_value, title='Parametric ReLU')
plot_activation_function(elu, x_value, title='ELU')

# 定义输入值和期望输出
x_1 = 40.0
x_2 = 80.0
expected_output = 60.0

# 初始化
# 定义权重
w_1_11 = 0.5
w_1_12 = 0.5
w_1_13 = 0.5
w_1_21 = 0.5
w_1_22 = 0.5
w_1_23 = 0.5

w_2_11 = 1.0
w_2_21 = 1.0
w_2_31 = 1.0

# 前向传播
z_1 = x_1 * w_1_11 + x_2 * w_1_21
z_2 = x_1 * w_1_12 + x_2 * w_1_22
z_3 = x_1 * w_1_13 + x_2 * w_1_23
y_pred = z_1 * w_2_11 + z_2 * w_2_21 + z_3 * w_2_31

print(f"前向传播测值为{y_pred}")

# 计算损失值（L2损失）
loss = 0.5 * (expected_output - y_pred) ** 2
print(f"当前Loss值为{loss}")

# 开始计算梯度
# 计算输出层关于损失函数的梯度
d_loss_predictied_output = -(expected_output - y_pred)

# 计算权重关于损失函数的梯度
d_loss_w_2_11 = d_loss_predictied_output * z_1
d_loss_w_2_21 = d_loss_predictied_output * z_2
d_loss_w_2_31 = d_loss_predictied_output * z_3

d_loss_w_1_11 = d_loss_predictied_output * w_2_11 * x_1
d_loss_w_1_21 = d_loss_predictied_output * w_2_11 * x_2
d_loss_w_1_12 = d_loss_predictied_output * w_2_21 * x_1
d_loss_w_1_22 = d_loss_predictied_output * w_2_21 * x_2
d_loss_w_1_13 = d_loss_predictied_output * w_2_31 * x_1
d_loss_w_1_23 = d_loss_predictied_output * w_2_31 * x_2

# 使用梯度下降法更新权重

# 使用梯度下降法更新权重
learning_rate = 1e-5
w_2_11 -= learning_rate * d_loss_w_2_11
w_2_21 -= learning_rate * d_loss_w_2_21
w_2_31 -= learning_rate * d_loss_w_2_31

w_1_11 -= learning_rate * d_loss_w_1_11
w_1_12 -= learning_rate * d_loss_w_1_12
w_1_13 -= learning_rate * d_loss_w_1_13
w_1_21 -= learning_rate * d_loss_w_1_21
w_1_22 -= learning_rate * d_loss_w_1_22
w_1_23 -= learning_rate * d_loss_w_1_23

# 前向传播
z_1 = x_1 * w_1_11 + x_2 * w_1_21
z_2 = x_1 * w_1_12 + x_2 * w_1_22
z_3 = x_1 * w_1_13 + x_2 * w_1_23
y_pred = z_1 * w_2_11 + z_2 * w_2_21 + z_3 * w_2_31

print(f"前向传播测值为{y_pred}")

# 计算损失值（L2损失）
loss = 0.5 * (expected_output - y_pred) ** 2
print(f"当前Loss值为{loss}")

def forward_propagation(layer_1_list, layer_2_list):
    w_1_11, w_1_12, w_1_13, w_1_21, w_1_22, w_1_23 = layer_1_list
    w_2_11, w_2_21, w_2_31 = layer_2_list
    z_1 = x_1 * w_1_11 + x_2 * w_1_21
    z_2 = x_1 * w_1_12 + x_2 * w_1_22
    z_3 = x_1 * w_1_13 + x_2 * w_1_23
    y_pred = z_1 * w_2_11 + z_2 * w_2_21 + z_3 * w_2_31
    return y_pred


def compute_loss(y_true, y_pred):
    loss = 0.5 * (y_true - y_pred) ** 2
    return loss

def backward_propagation(layer_1_list,layer_2_list,learning_rate):

    w_1_11, w_1_12, w_1_13, w_1_21, w_1_22, w_1_23 = layer_1_list
    w_2_11, w_2_21, w_2_31 = layer_2_list
    z_1 = x_1 * w_1_11 + x_2 * w_1_21
    z_2 = x_1 * w_1_12 + x_2 * w_1_22
    z_3 = x_1 * w_1_13 + x_2 * w_1_23

    # 计算输出层关于损失函数的梯度
    d_loss_predicted_output = -(y_true - y_pred)

    # 计算权重关于损失函数的梯度
    d_loss_w_2_11 = d_loss_predicted_output * z_1
    d_loss_w_2_21 = d_loss_predicted_output * z_2
    d_loss_w_2_31 = d_loss_predicted_output * z_3

    d_loss_w_1_11 = d_loss_predicted_output * w_2_11 * x_1
    d_loss_w_1_21 = d_loss_predicted_output * w_2_11 * x_2
    d_loss_w_1_12 = d_loss_predicted_output * w_2_21 * x_1
    d_loss_w_1_22 = d_loss_predicted_output * w_2_21 * x_2
    d_loss_w_1_13 = d_loss_predicted_output * w_2_31 * x_1
    d_loss_w_1_23 = d_loss_predicted_output * w_2_31 * x_2

    # 使用梯度下降法更新权重
    w_2_11 -= learning_rate * d_loss_w_2_11
    w_2_21 -= learning_rate * d_loss_w_2_21
    w_2_31 -= learning_rate * d_loss_w_2_31

    w_1_11 -= learning_rate * d_loss_w_1_11
    w_1_12 -= learning_rate * d_loss_w_1_12
    w_1_13 -= learning_rate * d_loss_w_1_13
    w_1_21 -= learning_rate * d_loss_w_1_21
    w_1_22 -= learning_rate * d_loss_w_1_22
    w_1_23 -= learning_rate * d_loss_w_1_23

    layer_1_list = [w_1_11, w_1_12, w_1_13, w_1_21, w_1_22, w_1_23]
    layer_2_list = [w_2_11, w_2_21, w_2_31]
    return layer_1_list,layer_2_list


def parm_init():
    # 初始化定义权重
    w_1_11 = 0.5
    w_1_12 = 0.5
    w_1_13 = 0.5
    w_1_21 = 0.5
    w_1_22 = 0.5
    w_1_23 = 0.5

    w_2_11 = 1.0
    w_2_21 = 1.0
    w_2_31 = 1.0

    layer_1_list = [w_1_11,w_1_12,w_1_13,w_1_21,w_1_22,w_1_23]
    layer_2_list = [w_2_11,w_2_21,w_2_31]
    return layer_1_list, layer_2_list

if __name__ == '__main__':
    # 定义输入值和期望输出
    x_1 = 40.0
    x_2 = 80.0
    y_true = 60.0
    learning_rate = 1e-5

    epoch = 100

    '''
    初始化
    '''
    # 初始化定义权重
    layer_1_list, layer_2_list = parm_init()

    for i in range(epoch):

        # 正向传播
        y_pred = forward_propagation(layer_1_list,layer_2_list)
        # 计算损失
        loss = compute_loss(y_true, y_pred)
        print(f"第{i}次 预测值为： ", y_pred, " 误差为： ",loss)
        # 反向传播
        layer_1_list,layer_2_list = backward_propagation(layer_1_list,layer_2_list,learning_rate)

import numpy as np
import matplotlib.pyplot as plt

# 定义函数
def f(x):
    return x ** 2

# 导数（梯度）
def df(x):
    return 2 * x

# 梯度下降参数
lr = 0.1  # 学习率
n_iterations = 10  # 迭代次数
# x1 = np.random.uniform(-3, 3)  # 随机初始化 x
x1 = 2.5

# 梯度下降算法
for i in range(n_iterations):
    gradient = df(x1)
    x1 = x1 - lr * gradient  # 更新 x

# 绘制原始函数
x = np.linspace(-3, 3, 100)
y = f(x)
plt.figure(figsize=(8, 6))
plt.plot(x, y, label="f(x) = x^2")

# 绘制梯度下降过程中 x 的位置
x_history = []
y_history = []

# 重新初始化 x1 用于演示
x1 = np.random.uniform(-3, 3)
for i in range(n_iterations):
    gradient = df(x1)
    x1 = x1 - lr * gradient  # 更新 x
    x_history.append(x1)
    y_history.append(f(x1))
    plt.scatter(x1, f(x1), color='red')

# 绘制梯度下降路径
plt.plot(x_history, y_history, label="Gradient Descent", color='red')

# 设置图形
plt.legend()
plt.xlabel('x')
plt.ylabel('f(x)')
plt.title('Function and Gradient Descent Path')
plt.grid(True)
plt.show()

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation

# 定义函数
def f(x):
    return x ** 2

# 导数（梯度）
def df(x):
    return 2 * x

# 梯度下降参数
lr = 0.1  # 学习率
n_iterations = 10  # 迭代次数
x1 = np.random.uniform(-3, 3)  # 随机初始化 x

# 绘制原始函数
x = np.linspace(-3, 3, 100)
y = f(x)

fig, ax = plt.subplots(figsize=(8, 6))
ax.plot(x, y, label="f(x) = x^2")
point, = ax.plot([], [], 'ro', label="Gradient Descent")
value_display = ax.text(0.7, 0.02, '', transform=ax.transAxes)

# 初始化梯度下降过程的点
def init():
    point.set_data([], [])
    value_display.set_text('')
    return point, value_display

# 动画更新函数
def update(i):
    global x1
    gradient = df(x1)
    x1 -= lr * gradient  # 更新 x
    point.set_data(x1, f(x1))
    value_display.set_text('Min = ({:.2f}, {:.2f})'.format(x1, f(x1)))
    return point, value_display

# 创建动画
ani = FuncAnimation(fig, update, frames=np.arange(0, n_iterations), init_func=init, blit=True)

# 设置图形
ax.legend()
ax.set_xlabel('x')
ax.set_ylabel('f(x)')
ax.set_title('Function and Gradient Descent Animation')
ax.grid(True)

plt.show()

import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
import numpy as np

# 创建x，y的数据点
x = np.linspace(-5, 5, 100)
y = np.linspace(-5, 5, 100)
x, y = np.meshgrid(x, y)

# 定义三维函数
def f(x, y):
    return x**2 + y**2

# 计算z的值
z = f(x, y)

# 创建图形和轴
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')

# 绘制表面
ax.plot_surface(x, y, z, cmap='viridis')

# 设置标签和标题
ax.set_xlabel('X axis')
ax.set_ylabel('Y axis')
ax.set_zlabel('Z axis')
ax.set_title('3D Surface Plot')

# 显示图形
plt.show()

import matplotlib.pyplot as plt
import numpy as np

# 定义三维函数
def f(x, y):
    return x**2 + y**2

# 定义函数的梯度
def grad_f(x, y):
    return 2*x, 2*y

# 梯度下降函数
def gradient_descent(grad, start_x, start_y, learning_rate, num_iterations):
    x, y = start_x, start_y
    xs, ys, zs = [], [], []
    for i in range(num_iterations):
        dx, dy = grad(x, y)
        x, y = x - learning_rate * dx, y - learning_rate * dy
        z = f(x, y)
        xs.append(x)
        ys.append(y)
        zs.append(z)
    return xs, ys, zs

# 初始点
start_x, start_y = 3.0, 3.0

# 运行梯度下降
xs, ys, zs = gradient_descent(grad_f, start_x, start_y, 0.1, 50)

# 创建图形和轴
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')

# 创建x，y的数据点
x = np.linspace(-5, 5, 100)
y = np.linspace(-5, 5, 100)
x, y = np.meshgrid(x, y)
z = f(x, y)

# 绘制表面
ax.plot_surface(x, y, z, cmap='viridis', alpha=0.7)

# 绘制梯度下降的点
ax.scatter(xs, ys, zs, color='r', s=50)

# 绘制点的连接线
for i in range(len(xs)-1):
    ax.plot([xs[i], xs[i+1]], [ys[i], ys[i+1]], [zs[i], zs[i+1]], 'r-')

# 设置标签和标题·
ax.set_xlabel('X axis')
ax.set_ylabel('Y axis')
ax.set_zlabel('Z axis')
ax.set_title('Gradient Descent on 3D Surface')

# 显示图形
plt.show()

import random

# 模拟掷硬币函数，'H'表示正面，'T'表示反面
def toss_coin():
    return 'H' if random.random() < 0.5 else 'T'

# 进行N次掷硬币试验
N = 10
results = [toss_coin() for _ in range(N)]

# 打印结果
print(results)

import random
import matplotlib.pyplot as plt

# 模拟掷硬币函数，'H'代表正面，'T'代表反面
def toss_coin():
    return 'H' if random.random() < 0.5 else 'T'

# 进行N次掷硬币实验
N = 1000
results = [toss_coin() for _ in range(N)]

print(results)


# 计算正面和反面的频率
heads = results.count('H')
tails = results.count('T')

# 概率质量函数的值
pmf = [heads/N, tails/N]

# 绘制概率质量函数
labels = ['Heads', 'Tails']
plt.bar(labels, pmf, color=['blue', 'orange'])
plt.title('Probability Mass Function of Coin Toss')
plt.ylabel('Probability')
plt.show()

import numpy as np

# 生成两组随机数据
data1 = np.random.randn(1000)
data2 = np.random.randn(1000)

# 计算期望（平均值）
expectation1 = np.mean(data1)
expectation2 = np.mean(data2)

# 计算方差
variance1 = np.var(data1)
variance2 = np.var(data2)

# 计算协方差矩阵（注意：协方差是两个变量间的关系度量）
covariance_matrix = np.cov(data1, data2)

print(f"期望值 Data1: {expectation1}, Data2: {expectation2}")
print(f"方差 Data1: {variance1}, Data2: {variance2}")
print(f"协方差矩阵:\n{covariance_matrix}")

# 从协方差矩阵中提取data1和data2的协方差
covariance = covariance_matrix[0, 1]
print(f"Data1 和 Data2 的协方差: {covariance}")

import numpy as np
import matplotlib.pyplot as plt

# 设定随机种子，以便于结果的复现
np.random.seed(0)

# 伯努利分布（参数p为成功概率）
p = 0.5
bernoulli_dist = np.random.binomial(1, p, 1000)

# 二项分布（参数n为试验次数，p为每次成功概率）
n = 10
binomial_dist = np.random.binomial(n, p, 1000)

# 正态分布（参数mu为均值，sigma为标准差）
mu, sigma = 0, 0.1
normal_dist = np.random.normal(mu, sigma, 1000)

# 指数分布（参数lambda为率参数，其倒数为平均间隔时间）
lambd = 1.0
exponential_dist = np.random.exponential(1/lambd, 1000)

# Logistic分布（参数mu为位置参数，s为尺度参数）
mu, s = 0, 1
logistic_dist = np.random.logistic(mu, s, 1000)

# 绘制柱状图
fig, axs = plt.subplots(5, 1, figsize=(5, 8))

# 伯努利分布柱状图
axs[0].hist(bernoulli_dist, bins=2)
axs[0].set_title('Bernoulli Distribution')

# 二项分布柱状图
axs[1].hist(binomial_dist, bins=range(n+2))
axs[1].set_title('Binomial Distribution')

# 正态分布柱状图
axs[2].hist(normal_dist, bins=30)
axs[2].set_title('Normal Distribution')

# 指数分布柱状图
axs[3].hist(exponential_dist, bins=30)
axs[3].set_title('Exponential Distribution')

# Logistic分布柱状图
axs[4].hist(logistic_dist, bins=30)
axs[4].set_title('Logistic Distribution')

plt.tight_layout()
plt.show()

import numpy as np
import matplotlib.pyplot as plt


def gamble_game(trials):
    # 抛硬币游戏，正面为1，反面为-1
    results = np.random.choice([1, -1], size=trials)
    return results


def simulate_gambling(trials):
    results = gamble_game(trials)

    # 计算累积盈亏
    cumulative_sum = np.cumsum(results)

    # 计算平均盈亏
    average_win_loss = cumulative_sum / np.arange(1, trials + 1)

    return cumulative_sum, average_win_loss


def plot_results(trials):
    cumulative_sum, average_win_loss = simulate_gambling(trials)

    # 绘制累积盈亏图
    plt.figure(figsize=(12, 6))
    plt.subplot(1, 2, 1)
    plt.plot(cumulative_sum)
    plt.title('Cumulative Win/Loss Over Trials')
    plt.xlabel('Trials')
    plt.ylabel('Cumulative Sum')

    # 绘制平均盈亏图
    plt.subplot(1, 2, 2)
    plt.plot(average_win_loss)
    plt.axhline(y=0, color='r', linestyle='-')  # 期望值线
    plt.title('Average Win/Loss Over Trials')
    plt.xlabel('Trials')
    plt.ylabel('Average Win/Loss')

    plt.tight_layout()
    plt.show()


# 模拟10000次游戏
plot_results(10000)

import numpy as np
import matplotlib.pyplot as plt

def roll_dice():
    """模拟掷一个六面骰子"""
    return np.random.randint(1, 7)

def experiment(num_rolls):
    """进行一次实验，实验包括num_rolls次掷骰子"""
    total = 0
    for _ in range(num_rolls):
        total += roll_dice()
    return total / num_rolls

def run_experiments(num_experiments, num_rolls):
    """运行多次实验，并记录每次实验的平均值"""
    averages = []
    for _ in range(num_experiments):
        averages.append(experiment(num_rolls))
    return averages

def plot_histogram(averages):
    """绘制实验平均值的直方图"""
    plt.hist(averages, bins=20, edgecolor='black', density=True)
    plt.xlabel('Average of Rolls')
    plt.ylabel('Frequency')
    plt.title('Central Limit Theorem Demonstration')
    plt.show()

# 参数设置
num_experiments = 10000  # 实验次数
num_rolls = 30          # 每次实验掷骰子的次数

# 运行实验并绘图
averages = run_experiments(num_experiments, num_rolls)
plot_histogram(averages)