目录
[常用操作(设：a=1,2 , b=3,4)](#常用操作(设：a=[1,2] , b=[3,4]))
python中向量化编程
向量化编程（Vectorized Programming）是一种利用数组或矩阵运算替代显式循环 的高效编程范式，尤其在科学计算和机器学习中至关重要。而向量化编程在python中依靠numpy包实现。
一般引入格式为：import numpy as np
常用操作(设：a=1,2 , b=3,4)
| 函数 | 说明 | 示例 |
|---|---|---|
np.add() |
逐元素加法 | a + b → [1+3, 2+4] |
np.subtract() |
逐元素减法 | a - b → [1-3, 2-4] |
np.multiply() |
逐元素乘法 | a * b → [1*3, 2*4] |
np.divide() |
逐元素除法 | a / b → [1/3, 2/4] |
np.power() |
幂运算 | a**2 → [1, 4] |
np.exp() |
指数运算 | e^a |
np.log |
对数计算 | log(默认ln) |
python中实现逻辑回归
伪代码
代码实现
python
import numpy as np
# 初始化
num_iterations = 1000
learning_rate = 0.5
X = np.array([
[1.2, 0.5], # 样本1
[-0.3, 1.8], # 样本2
[0.7, -1.1] # 样本3
])
Y = np.array([[1, 0, 1]]) # 改为行向量以便计算
W = np.zeros((2, 1)) # 权重矩阵
b = 0.0 # 偏置项
costs = [] # 存储损失值历史
def sigmoid(x):
"""Sigmoid激活函数"""
return 1 / (1 + np.exp(-x))
def propagate(W, b, X, Y):
"""
前向传播和反向传播
参数:
W: 权重 (2,1)
b: 偏置 (标量)
X: 输入数据 (3,2)
Y: 真实标签 (1,3)
返回:
grads: 包含梯度的字典
cost: 当前损失值
"""
m = X.shape[0] # 样本数量
# 前向传播
Z = np.dot(X, W) + b # (3,1)
A = sigmoid(Z) # (3,1)
# 计算损失(添加极小值防止log(0))
epsilon = 1e-5
cost = -(1 / m) * np.sum(Y * np.log(A.T + epsilon) + (1 - Y) * np.log(1 - A.T + epsilon))
# 反向传播
dZ = A - Y.T # (3,1)
dW = (1 / m) * np.dot(X.T, dZ) # (2,1)
db = (1 / m) * np.sum(dZ)
grads = {"dW": dW, "db": db}
return grads, cost
def optimize(W, b, X, Y, num_iterations, learning_rate):
"""
梯度下降优化
参数:
W, b: 初始参数
X, Y: 训练数据和标签
num_iterations: 迭代次数
learning_rate: 学习率
返回:
params: 优化后的参数
grads: 最终梯度
costs: 损失历史
"""
costs = []
for i in range(num_iterations):
# 计算梯度和损失
grads, cost = propagate(W, b, X, Y)
# 获取梯度
dW = grads["dW"]
db = grads["db"]
# 更新参数
W = W - learning_rate * dW
b = b - learning_rate * db
# 记录损失
if i % 100 == 0:
costs.append(cost)
print(f"迭代次数 {i}: 损失值 = {cost:.6f}")
params = {"W": W, "b": b}
grads = {"dW": dW, "db": db}
return params, grads, costs
def predict(W, b, X):
"""
使用训练好的参数预测
参数:
W, b: 训练好的参数
X: 输入数据
返回:
Y_prediction: 预测结果 (0或1)
"""
m = X.shape[0]
Y_prediction = np.zeros((1, m))
A = sigmoid(np.dot(X, W) + b)
for i in range(A.shape[0]):
Y_prediction[0, i] = 1 if A[i] > 0.5 else 0
return Y_prediction
if __name__ == '__main__':
# 训练模型
params, grads, costs = optimize(W, b, X, Y, num_iterations, learning_rate)
# 获取训练好的参数
W = params["W"]
b = params["b"]
# 预测
Y_prediction = predict(W, b, X)
print(f"预测结果: {Y_prediction}")
print(f"真实标签: {Y}")在代码实现时，很容易遇到因为数组维度的问题，导致向量化运算出错。下面简单解释一下部分数组。
样本X ={ x01 , x02 , x03 ...... x0m，
x11 , x12 , x13 ...... x1m ，
x21 , x22 , x23 ...... x2m }
注意不一定是2维数组，每一行代表着一个样本，而每一列代表着一种类型。 这个例子中可以看到，该样本数组中一共有3个样本，每个样本有m个特征**。**
权重W=w1 , w2 , w3 ...... wn权重数组中元素数量等于于样本的特征数量，每一个特征的权重可能有所差异，需要不断迭代使其合理。