numpy初始化逻辑回归函数中的w,b的代码
时间: 2024-02-12 15:09:56 浏览: 102
以下是使用numpy初始化逻辑回归模型中w和b的代码示例:
```python
import numpy as np
def initialize_parameters(dim):
"""
初始化参数w和b
参数:
dim - 特征数量
返回:
w - 权重矩阵,大小为 (dim, 1)
b - 偏置项,一个标量
"""
w = np.zeros((dim, 1))
b = 0
assert(w.shape == (dim, 1))
assert(isinstance(b, float) or isinstance(b, int))
return w, b
```
在这个示例中,我们使用了numpy的`zeros`函数来创建一个大小为`(dim, 1)`的全零矩阵作为权重矩阵`w`的初始值,并将偏置项`b`初始化为0。最后,我们使用`assert`语句来确保`w`的形状是`(dim, 1)`,`b`是一个标量。
相关问题
用python+numpy编程实现逻辑回归模型,在给定数据集上,绘制损失函数曲线图。使用混淆矩阵、错误率、精度、查全率、查准率、F1指标评估逻辑回归模型性能表现,初始权值w为0,写出代码
好的,我可以回答你的问题。以下是实现逻辑回归模型的 Python 代码示例,包括绘制损失函数曲线图和评估模型性能表现的指标:
```python
import numpy as np
import matplotlib.pyplot as plt
# 定义sigmoid函数
def sigmoid(z):
return 1 / (1 + np.exp(-z))
# 定义损失函数
def loss(y_hat, y):
return (-y * np.log(y_hat) - (1 - y) * np.log(1 - y_hat)).mean()
# 定义逻辑回归模型和梯度下降算法
def logistic_regression(X, y, lr=0.01, num_iters=1000):
m, n = X.shape
w = np.zeros((n, 1))
b = 0
cost_list = []
for i in range(num_iters):
# 计算预测值和损失函数
y_hat = sigmoid(np.dot(X, w) + b)
J = loss(y_hat, y)
cost_list.append(J)
# 计算梯度并更新参数
dw = np.dot(X.T, (y_hat - y)) / m
db = np.mean(y_hat - y)
w -= lr * dw
b -= lr * db
return w, b, cost_list
# 生成一个样本数据集
np.random.seed(0)
m = 100
X = np.random.randn(m, 2)
w_true = np.array([[1], [2]])
b_true = 3
y_true = sigmoid(np.dot(X, w_true) + b_true) > 0.5
y_true = y_true.astype(int)
# 初始化模型参数并进行训练
w_init = np.zeros((2, 1))
b_init = 0
w_trained, b_trained, cost_list = logistic_regression(X, y_true, lr=0.1, num_iters=1000)
# 绘制损失函数曲线图
plt.plot(cost_list)
plt.xlabel('Iteration')
plt.ylabel('Cost')
plt.show()
# 评估模型性能表现
y_pred = sigmoid(np.dot(X, w_trained) + b_trained) > 0.5
y_pred = y_pred.astype(int)
TP = np.sum((y_pred == 1) & (y_true == 1))
FP = np.sum((y_pred == 1) & (y_true == 0))
TN = np.sum((y_pred == 0) & (y_true == 0))
FN = np.sum((y_pred == 0) & (y_true == 1))
accuracy = (TP + TN) / (TP + FP + TN + FN)
error_rate = (FP + FN) / (TP + FP + TN + FN)
precision = TP / (TP + FP)
recall = TP / (TP + FN)
F1 = 2 * precision * recall / (precision + recall)
print('Accuracy: {:.2f}'.format(accuracy))
print('Error rate: {:.2f}'.format(error_rate))
print('Precision: {:.2f}'.format(precision))
print('Recall: {:.2f}'.format(recall))
print('F1 score: {:.2f}'.format(F1))
```
numpy写逻辑回归预测的代码
下面是一个简单的使用 NumPy 实现逻辑回归预测的代码示例:
```python
import numpy as np
# 生成训练数据
X = np.array([[1, 2], [2, 3], [3, 4], [4, 5], [5, 6]])
y = np.array([0, 0, 1, 1, 1])
# 初始化参数
theta = np.zeros((X.shape[1] + 1, 1))
X = np.hstack((np.ones((X.shape[0], 1)), X))
# 定义 sigmoid 函数
def sigmoid(z):
return 1 / (1 + np.exp(-z))
# 定义代价函数
def cost_function(X, y, theta):
m = y.size
h = sigmoid(X @ theta)
J = -1 / m * (y @ np.log(h) + (1 - y) @ np.log(1 - h))
return J
# 定义梯度下降函数
def gradient_descent(X, y, theta, alpha, num_iters):
m = y.size
J_history = np.zeros(num_iters)
for i in range(num_iters):
h = sigmoid(X @ theta)
theta -= alpha * 1 / m * X.T @ (h - y)
J_history[i] = cost_function(X, y, theta)
return theta, J_history
# 进行训练
theta, J_history = gradient_descent(X, y, theta, 0.1, 100)
# 预测新数据
X_new = np.array([[6, 7], [7, 8]])
X_new = np.hstack((np.ones((X_new.shape[0], 1)), X_new))
y_pred = sigmoid(X_new @ theta)
print(y_pred)
```
在这个示例中,我们先生成了一些训练数据,然后使用梯度下降法对模型进行训练,最后对新数据进行预测。请注意,这里的代价函数和梯度下降函数都是使用了向量化的 NumPy 实现,这使得代码变得更加简洁和高效。
阅读全文