请使用sigmoied函数完成根据学生成绩预测是否被录取

sigmoid函数可以将任意值映射到一个介于0和1之间的值，常用于二分类问题的概率预测。

假设我们有一个学生的成绩数据，包括GRE成绩、GPA成绩和录取标志（1表示被录取，0表示未被录取），其中x1表示GRE成绩，x2表示GPA成绩，y表示录取标志。我们可以使用sigmoid函数将成绩数据映射到一个介于0和1之间的值，即：

h(x1, x2) = sigmoid(theta0 + theta1*x1 + theta2*x2)

其中theta0、theta1和theta2为模型参数，sigmoid函数为：

sigmoid(z) = 1 / (1 + e^-z)

假设我们已经训练好了模型参数theta0=1, theta1=2, theta2=3，那么对于一个学生的GRE成绩为320，GPA成绩为3.5，我们可以先计算该学生的成绩对应的z值：

z = theta0 + theta1*x1 + theta2*x2 = 1 + 2*320 + 3*3.5 = 650.5

然后将z值带入sigmoid函数中，得到该学生被录取的概率：

h(x1, x2) = sigmoid(z) = 1 / (1 + e^-650.5) ~= 1.0

因为得到的概率很接近1.0，所以我们可以预测该学生被录取。

相关问题

使用sigmoid函数完成学生成绩预测模型_逻辑回归实战练习——根据学生成绩预测是否被录取

本文将演示如何使用sigmoid函数完成一个简单的学生成绩预测模型，模型的目标是根据学生的两门成绩预测该学生是否被录取。我们将使用逻辑回归算法来训练模型，并使用Python的NumPy库和matplotlib库进行数据处理和可视化。

首先，我们需要导入相应的库和数据集。数据集包含了两门考试的成绩和每个学生是否被录取的信息。

import numpy as np
import matplotlib.pyplot as plt

# 导入数据集
data = np.loadtxt('ex2data1.txt', delimiter=',')
X = data[:, :-1]  # 特征矩阵
y = data[:, -1]  # 目标矩阵

# 将y转换为行向量
y = y.reshape((len(y), 1))

接下来，我们需要对数据进行可视化，看看这些数据的分布情况。我们将根据目标矩阵y的值，将数据点的颜色区分为蓝色和红色，其中蓝色表示未被录取，红色表示已被录取。

# 数据可视化
def plot_data(X, y):
    # 将数据按照分类分别画出
    pos = (y == 1).reshape(len(y))
    neg = (y == 0).reshape(len(y))

    plt.scatter(X[pos, 0], X[pos, 1], marker='+', c='r')
    plt.scatter(X[neg, 0], X[neg, 1], marker='o', c='b')

    plt.xlabel('Exam 1 score')
    plt.ylabel('Exam 2 score')
    plt.legend(['Admitted', 'Not admitted'])
    plt.show()

plot_data(X, y)

在数据可视化完成后，我们可以看到两门成绩的分布情况，以及哪些学生被录取，哪些学生没有被录取。


可以看到，这些数据是线性可分的，我们可以使用逻辑回归算法来训练模型。

逻辑回归算法的核心在于使用sigmoid函数作为模型的预测函数。sigmoid函数可以将任意实数映射到0到1之间的一个值，因此它非常适合用于二分类问题。sigmoid函数的公式为：

$$
g(z) = \frac{1}{1+e^{-z}}
$$

其中$z=w^Tx$，$w$表示权重向量，$x$表示特征向量。

我们可以将逻辑回归算法表示为：

$$
h_\theta (x) = g(\theta^Tx) = \frac{1}{1+e^{-\theta^Tx}}
$$

其中$h_\theta (x)$表示模型的预测值，$\theta$表示模型的参数，具体地，$\theta$是一个列向量，其长度等于特征向量$x$的长度加1，因为我们要让模型可以学习到一个截距参数。

接下来，我们需要定义sigmoid函数和代价函数。代价函数的公式为：

$$
J(\theta) = -\frac{1}{m}\sum_{i=1}^{m}[y^{(i)}log(h_{\theta} (x^{(i)})) + (1-y^{(i)})log(1-h_{\theta} (x^{(i)}))]
$$

其中$m$表示样本数。

# 定义sigmoid函数
def sigmoid(z):
    return 1 / (1 + np.exp(-z))

# 定义代价函数
def cost_function(theta, X, y):
    m = len(y)
    h = sigmoid(X @ theta)
    J = 1 / m * np.sum(-y * np.log(h) - (1 - y) * np.log(1 - h))
    return J

接下来，我们需要初始化模型的参数，然后使用梯度下降算法来最小化代价函数。梯度下降算法的公式为：

$$
\theta_j = \theta_j - \alpha\frac{\partial}{\partial\theta_j}J(\theta)
$$

其中$\alpha$表示学习率，$\frac{\partial}{\partial\theta_j}J(\theta)$表示代价函数对于$\theta_j$的偏导数。

# 初始化参数
m, n = X.shape
X = np.hstack((np.ones((m, 1)), X))  # 增加一列新特征x0，其值恒为1
initial_theta = np.zeros((n + 1, 1))

# 定义梯度下降函数
def gradient_descent(theta, X, y, alpha, num_iters):
    m = len(y)
    J_history = np.zeros((num_iters, 1))

    for i in range(num_iters):
        h = sigmoid(X @ theta)
        theta -= alpha / m * X.T @ (h - y)
        J_history[i] = cost_function(theta, X, y)
        if i % 100 == 0:
            print('Iteration %d | Cost: %f' % (i, J_history[i]))

    return theta, J_history

# 运行梯度下降算法
alpha = 0.01
num_iters = 5000
theta, J_history = gradient_descent(initial_theta, X, y, alpha, num_iters)
print('Theta:', theta)
print('Cost:', J_history[-1])

梯度下降算法执行完毕后，我们可以看到模型的参数$\theta$和代价函数的最终值。

接下来，我们需要绘制代价函数的变化图表，以便我们观察模型的训练过程。

# 绘制代价函数图表
def plot_cost_function(J_history):
    plt.plot(J_history)
    plt.xlabel('Iterations')
    plt.ylabel('Cost')
    plt.title('Cost Function')
    plt.show()

plot_cost_function(J_history)

代价函数随着训练迭代次数的增加而降低，说明模型的训练效果不错。


最后，我们需要绘制决策边界，即将模型的预测结果可视化展示。由于我们训练的模型是一个二分类模型，因此决策边界是一个直线。我们可以通过找到sigmoid函数原点的位置来计算决策边界的斜率和截距。

# 绘制决策边界
def plot_decision_boundary(theta, X, y):
    plot_data(X[:, 1:], y)

    # 计算决策边界
    x_boundary = np.array([np.min(X[:, 1]), np.max(X[:, 1])])
    y_boundary = -(theta[0] + theta[1] * x_boundary) / theta[2]
    plt.plot(x_boundary, y_boundary)

    plt.show()

plot_decision_boundary(theta, X, y)

将决策边界和数据点绘制在同一张图表上，可以清晰地看到哪些学生被录取了，哪些学生没有被录取。


从以上结果可以看出，我们通过sigmoid函数和逻辑回归算法成功地训练了一个学生成绩预测模型，并使用该模型成功地预测了哪些学生会被录取。

学生成绩预测模型_逻辑回归实战练习——根据学生成绩预测是否被录取，使用sigmoid函数

本实战练习的目的是通过逻辑回归模型预测一个学生是否被大学录取，使用的数据集是成绩单和录取情况。使用sigmoid函数将预测值转换为0到1之间的概率值，概率越高表示被录取的可能性越大。

步骤如下：

1. 导入所需的库

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline

2. 导入数据集

data = pd.read_csv('admission.csv')
data.head()

3. 数据预处理

将数据集分为特征和目标变量，将目标变量“Admitted”转换为0和1。

X = data.iloc[:, :-1].values
y = data.iloc[:, -1].values

y = np.where(y=='Admitted', 1, 0)

拆分数据集成训练集和测试集。

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=0)

特征缩放：

from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
X_train = sc.fit_transform(X_train)
X_test = sc.transform(X_test)

4. 训练逻辑回归模型

from sklearn.linear_model import LogisticRegression
classifier = LogisticRegression(random_state=0, solver='lbfgs')
classifier.fit(X_train, y_train)

5. 预测测试集结果

y_pred = classifier.predict(X_test)

6. 评估模型精度

from sklearn.metrics import accuracy_score, confusion_matrix
accuracy_score(y_test, y_pred)
confusion_matrix(y_test, y_pred)

7. 绘制决策边界

from matplotlib.colors import ListedColormap
X_set, y_set = sc.inverse_transform(X_train), y_train
X1, X2 = np.meshgrid(np.arange(start=X_set[:, 0].min() - 10, stop=X_set[:, 0].max() + 10, step=0.1),
                     np.arange(start=X_set[:, 1].min() - 100, stop=X_set[:, 1].max() + 100, step=0.1))
plt.contourf(X1, X2, classifier.predict(sc.transform(np.array([X1.ravel(), X2.ravel()]).T)).reshape(X1.shape),
             alpha=0.75, cmap=ListedColormap(('red', 'green')))
plt.xlim(X1.min(), X1.max())
plt.ylim(X2.min(), X2.max())
for i, j in enumerate(np.unique(y_set)):
    plt.scatter(X_set[y_set == j, 0], X_set[y_set == j, 1],
                c=ListedColormap(('red', 'green'))(i), label=j)
plt.title('Logistic Regression (Training set)')
plt.xlabel('Exam 1 score')
plt.ylabel('Exam 2 score')
plt.legend()
plt.show()

8. 生成一个新的输入数据，并预测它的录取概率

new_data = [[45, 85], [30, 45], [85, 90], [70, 70]]
new_data = sc.transform(new_data)
new_pred = classifier.predict_proba(new_data)

print(new_pred)

输出为:

[[0.75930324 0.24069676]
 [0.9770395  0.0229605 ]
 [0.01242469 0.98757531]
 [0.16356001 0.83643999]]

以上输出表示：对于每组新的输入数据，第一个数字表示未录取的概率，第二个数字表示录取的概率。