CG平台实验——逻辑回归

news2024/11/24 8:46:20

文章目录

  • 练习2：逻辑回归
    • 介绍
    • 1 Logistic回归
      • 1.1 数据可视化
      • 1.2 实现
        • 1.2.1 Sigmoid函数
        • 1.2.2 代价函数和梯度
          • 1.2.2.1 代价函数
          • 1.2.2.2 梯度下降
        • 1.2.3 寻找最优参数
        • 1.2.4 评估逻辑回归
    • 2 正则化逻辑回归
      • 2.1 数据可视化
      • 2.2 特征映射
      • 2.3 代价函数和梯度
      • 2.4 寻找最优参数
      • 2.5 评估正则化逻辑回归

练习2：逻辑回归

介绍

在本练习中，您将实现逻辑回归并将其应用于两个不同的数据集。还将通过将正则化加入训练算法，来提高算法的鲁棒性，并用更复杂的情形来测试模型算法。

在开始练习前，需要下载如下的文件进行数据上传：

  • ex2data1.txt -前半部分的训练数据集
  • ex2data2.txt -后半部分的训练数据集

在整个练习中，涉及如下的必做作业：

  • 绘制2D分类数据的函数----(3分)
  • 实现Sigmoid函数--------(5分)
  • 实现Logistic回归代价函数和梯度函数—(60分)
  • 实现回归预测函数--------(5分)
  • 实现正则Logisitic回归成本函数-------(27分)

1 Logistic回归

在该部分练习中，将建立一个逻辑回归模型，用以预测学生能否被大学录取。

假设你是大学某个部门的负责人，你要根据两次考试的结果来决定每个申请人的入学机会。目前已经有了以往申请者的历史数据，并且可以用作逻辑回归的训练集。对于每行数据，都包含对应申请者的两次考试分数和最终的录取结果。

在本次练习中，你需要建立一个分类模型，根据这两次的考试分数来预测申请者的录取结果。

1.1 数据可视化

在开始实施任何算法模型之前，最好先对数据进行可视化，这将会更加直观的获取数据特征。

现在，你需要编写代码来完成数据的绘图，显示如下所示的图形。

在这里插入图片描述

要点：

  • 导入需要使用的python库，并将从文件ex2data1.txt中读取数据，并显示前5行
  • x-y轴分别为两次考试的分数
  • 正负示例需要用不同的标记显示（不同的颜色）
###在这里填入代码###
###主要实现要点1###
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

path = 'ex2data1.txt'
data = pd.read_csv(path, header=None, names=['Exam 1', 'Exam 2', 'Admitted'])
data.head()
Exam 1Exam 2Admitted
034.62366078.0246930
130.28671143.8949980
235.84740972.9021980
360.18259986.3085521
479.03273675.3443761
###在这里填入代码###
###绘制数据散点图###
positive = data[data['Admitted'].isin([1])]
negative = data[data['Admitted'].isin([0])]

fig, ax = plt.subplots(figsize=(12,8))
ax.scatter(positive['Exam 1'], positive['Exam 2'], s=50, c='b', marker='o', label='Admitted')
ax.scatter(negative['Exam 1'], negative['Exam 2'], s=50, c='r', marker='x', label='Not Admitted')
ax.legend()
ax.set_xlabel('Exam 1 Score')
ax.set_ylabel('Exam 2 Score')
plt.show()

1.2 实现

在前部分练习中所绘制的数据分布图中可以看出，在不同标识的数据点间，有一个较为清晰的决策边界。现在需要实现逻辑回归，并使用逻辑回归来训练模型用以预测分类结果。

1.2.1 Sigmoid函数

在正式开始之前，我们先来了解一个函数：Sigmoid函数。
我们还记得逻辑回归假设的定义是：
\[{{h}{\theta }}\left( x \right)=g\left({{{\theta }^{T}}X} \right)\]
其中 g 代表一个常用的逻辑函数为S形函数（Sigmoid function），公式为：
\[g\left( z \right)=\frac{1}{1+{{e}^{-z}}}\]
合起来，我们得到逻辑回归模型的假设函数：
\[{{h}{\theta }}\left( x \right)=\frac{1}{1+{{e}^{-{{\theta }^{T}}X}}}\]

接下来，你需要编写代码实现Sigmoid函数，编写后试着测试一些值，如果x的正值较大，则函数值应接近1；如果x的负值较大，则函数值应接近0。而对于x等于0时，则函数值为0.5。

确保在进行调用你实现的Sigmoid函数后，以下代码会输出如下的图片：
在这里插入图片描述

###在这里填入代码###
def sigmoid(z):
    return 1 / (1 + np.exp(-z))

###请运行并测试你的代码###
nums = np.arange(-10, 10, step=1)

fig, ax = plt.subplots(figsize=(12,8))
ax.plot(nums, sigmoid(nums), 'r')
plt.show()

1.2.2 代价函数和梯度

1.2.2.1 代价函数

我们知道逻辑回归的代价函数是：
J ( θ ) = 1 m ∑ i = 1 m [ − y ( i ) log ⁡ ( h θ ( x ( i ) ) ) − ( 1 − y ( i ) ) log ⁡ ( 1 − h θ ( x ( i ) ) ) ] J\left( \theta \right)=\frac{1}{m}\sum\limits_{i=1}^{m}{[-{{y}^{(i)}}\log \left( {{h}_{\theta }}\left( {{x}^{(i)}} \right) \right)-\left( 1-{{y}^{(i)}} \right)\log \left( 1-{{h}_{\theta }}\left( {{x}^{(i)}} \right) \right)]} J(θ)=m1​i=1∑m​[−y(i)log(hθ​(x(i)))−(1−y(i))log(1−hθ​(x(i)))]

现在，你需要编写代码实现代价函数以进行逻辑回归的成本计算，并且经过所给数据测试后，初始的成本约为0.693。

要点：

  • 实现cost函数，参数为theta，X，y.
  • 返回计算的成本值。
  • 其中theta为参数，X为训练集中的特征列，y为训练集的标签列，三者均为矩阵。
###在这里填入代码###
def cost(theta,X,y):
    theta = np.matrix(theta)
    X = np.matrix(X)
    y = np.matrix(y)
    first = np.multiply(-y,np.log(sigmoid(X* theta.T)))
    second = np.multiply((1-y),np.log(1-sigmoid(X*theta.T)))
    return np.sum(first-second)/(len(X))

###请运行并测试你的代码###
#增加一列值为1，这和我们在练习1中的操作很相似
data.insert(0, 'Ones', 1)

# 定义X为训练数据，y为目的变量
cols = data.shape[1]
X = data.iloc[:,0:cols-1]
y = data.iloc[:,cols-1:cols]

# 将X,y转换为numpy数组，并初始化theta值为0
X = np.array(X.values)
y = np.array(y.values)
theta = np.zeros(3)

cost(theta, X, y)

0.6931471805599453
1.2.2.2 梯度下降

接下来，我们需要编写代码实现梯度下降用来计算我们的训练数据、标签和一些参数 θ \theta θ的梯度。

要点：

  • 代码实现gradient函数，参数为theta，X，y.
  • 返回计算的梯度值。
  • 其中theta为参数，X为训练集中的特征列，y为训练集的标签列，三者均为矩阵。

批量梯度下降转化为向量化计算： 1 m X T ( S i g m o i d ( X θ ) − y ) \frac{1}{m} X^T( Sigmoid(X\theta) - y ) m1​XT(Sigmoid(Xθ)−y)

∂ J ( θ ) ∂ θ j = 1 m ∑ i = 1 m ( h θ ( x ( i ) ) − y ( i ) ) x j ( i ) \frac{\partial J\left( \theta \right)}{\partial {{\theta }_{j}}}=\frac{1}{m}\sum\limits_{i=1}^{m}{({{h}_{\theta }}\left( {{x}^{(i)}} \right)-{{y}^{(i)}})x_{_{j}}^{(i)}} ∂θj​∂J(θ)​=m1​i=1∑m​(hθ​(x(i))−y(i))xj​(i)​

这里需要注意的是，我们实际上没有在这个函数中执行梯度下降，我们仅仅在计算一个梯度步长。由于我们使用Python，我们可以用SciPy的optimize命名空间来做同样的事情。

###在这里填入代码###
def gradient(theta, X, y):
    theta = np.matrix(theta)
    X = np.matrix(X)
    y = np.matrix(y)
    
    parameters = int(theta.ravel().shape[1])
    grad = np.zeros(parameters)
    
    error = sigmoid(X * theta.T) - y
    
    for i in range(parameters):
        term = np.multiply(error, X[:,i])
        grad[i] = np.sum(term) / len(X)
    
    return grad

###请运行并测试你的代码###
gradient(theta, X, y)

array([ -0.1       , -12.00921659, -11.26284221])

1.2.3 寻找最优参数

现在可以用SciPy’s truncated newton（TNC）实现寻找最优参数。

###请运行并测试你的代码###
import scipy.optimize as opt
result = opt.fmin_tnc(func=cost, x0=theta, fprime=gradient, args=(X, y))
result

(array([-25.16131872,   0.20623159,   0.20147149]), 36, 0)

让我们看看在这个结论下代价函数的值：

###请运行并测试你的代码###
cost(result[0], X, y)

0.20349770158947425

1.2.4 评估逻辑回归

接下来，我们需要编写代码实现预测函数，用所学的最优参数 θ \theta θ来为数据集X输出预测结果。然后，可以使用这个函数来给我们定义的分类器的训练精度进行打分。

逻辑回归的假设函数：

\[{{h}_{\theta }}\left( x \right)=\frac{1}{1+{{e}^{-{{\theta }^{T}}X}}}\]
当 h θ {{h}_{\theta }} hθ​大于等于0.5时，预测 y=1

当 h θ {{h}_{\theta }} hθ​小于0.5时，预测 y=0。

要点：

  • 代码实现predict函数，参数为theta，X.
  • 返回X中的每行数据对应的预测结果。
  • 其中theta为参数，X为训练集中的特征列。
###在这里填入代码###
def predict(theta, X):
    probability = sigmoid(X * theta.T)
    return [1 if x >= 0.5 else 0 for x in probability]

###请运行并测试你的代码###
theta_min = np.matrix(result[0])
predict(theta_min, X)

[0,
 0,
 0,
 1,
 1,
 0,
 1,
 0,
 1,
 1,
 1,
 0,
 1,
 1,
 0,
 1,
 0,
 0,
 1,
 1,
 0,
 1,
 0,
 0,
 1,
 1,
 1,
 1,
 0,
 0,
 1,
 1,
 0,
 0,
 0,
 0,
 1,
 1,
 0,
 0,
 1,
 0,
 1,
 1,
 0,
 0,
 1,
 1,
 1,
 1,
 1,
 1,
 1,
 0,
 0,
 0,
 1,
 1,
 1,
 1,
 1,
 0,
 0,
 0,
 0,
 0,
 1,
 0,
 1,
 1,
 0,
 1,
 1,
 1,
 1,
 1,
 1,
 1,
 0,
 1,
 1,
 1,
 1,
 0,
 1,
 1,
 0,
 1,
 1,
 0,
 1,
 1,
 0,
 1,
 1,
 1,
 1,
 1,
 0,
 1]

###请运行并测试你的代码###
#theta_min = np.matrix(result[0])
predictions = predict(theta_min, X)
correct = [1 if ((a == 1 and b == 1) or (a == 0 and b == 0)) else 0 for (a, b) in zip(predictions, y)]
accuracy = (sum(map(int, correct)) % len(correct))
print ('accuracy = {0}%'.format(accuracy))

accuracy = 89%

2 正则化逻辑回归

在本部分练习中，我们将要通过加入正则项提升逻辑回归算法。

正则化是成本函数中的一个术语，它使算法更倾向于“更简单”的模型。这个理论助于减少过拟合，提高模型的泛化能力。

设想你是工厂的生产主管，你有一些芯片在两次测试中的测试结果。对于这两次测试，你想决定芯片是要被接受或抛弃。为了帮助你做出艰难的决定，你拥有过去芯片的测试数据集，从其中你可以构建一个逻辑回归模型。

2.1 数据可视化

与第一部分的练习类似，首先对数据进行可视化：

path =  'ex2data2.txt'
data2 = pd.read_csv(path, header=None, names=['Test 1', 'Test 2', 'Accepted'])
data2.head()
Test 1Test 2Accepted
00.0512670.699561
1-0.0927420.684941
2-0.2137100.692251
3-0.3750000.502191
4-0.5132500.465641
positive = data2[data2['Accepted'].isin([1])]
negative = data2[data2['Accepted'].isin([0])]

fig, ax = plt.subplots(figsize=(12,8))
ax.scatter(positive['Test 1'], positive['Test 2'], s=50, c='b', marker='o', label='Accepted')
ax.scatter(negative['Test 1'], negative['Test 2'], s=50, c='r', marker='x', label='Rejected')
ax.legend()
ax.set_xlabel('Test 1 Score')
ax.set_ylabel('Test 2 Score')
plt.show()

在这里插入图片描述

对于这部分数据，我们可以看出不同类别的数据点之间没有明显的线性决策界限用于划分两类数据。

因此，逻辑回归无法在此数据集上得到较好的效果，因为逻辑回归只能知道线性决策边界。

2.2 特征映射

一种能够更好地拟合数据的方法是构造从原始特征的多项式中得到的特征，即特征映射。如下图所示，作为这种映射的结果，我们的两个特征向量 x 1 , x 2 x_1,x_2 x1​,x2​（两次质量保证测试的分数）已经被转换成了28维的向量。
在这里插入图片描述

在这个高维特征向量上训练的逻辑回归分类器将具有更复杂的决策边界，并在二维图中绘制时呈现非线性的划分曲线。

虽然特征映射允许我们构建一个更具有表现力的分类器，但它也更容易过拟合。接下来，你需要实现正则化逻辑回归用于拟合数据，并使用正则化来帮助解决过拟合问题。

我们通过创建一组多项式特征来开始！

# 设定映射深度
degree = 5
# 分别取两次测试的分数
x1 = data2['Test 1']
x2 = data2['Test 2']

data2.insert(3, 'Ones', 1)

# 设定计算方式进行映射
for i in range(1, degree):
    for j in range(0, i):
        data2['F' + str(i) + str(j)] = np.power(x1, i-j) * np.power(x2, j)

# 整理数据列
data2.drop('Test 1', axis=1, inplace=True)
data2.drop('Test 2', axis=1, inplace=True)

print("特征映射后具有特征维数：%d" %data2.shape[1])
data2.head()

特征映射后具有特征维数：12
AcceptedOnesF10F20F21F30F31F32F40F41F42F43
0110.0512670.0026280.0358640.0001350.0018390.0250890.0000070.0000940.0012860.017551
111-0.0927420.008601-0.063523-0.0007980.005891-0.0435090.000074-0.0005460.004035-0.029801
211-0.2137100.045672-0.147941-0.0097610.031616-0.1024120.002086-0.0067570.021886-0.070895
311-0.3750000.140625-0.188321-0.0527340.070620-0.0945730.019775-0.0264830.035465-0.047494
411-0.5132500.263426-0.238990-0.1352030.122661-0.1112830.069393-0.0629560.057116-0.051818

2.3 代价函数和梯度

接下来，你需要编写代码来实现计算正则化逻辑回归的代价函数和梯度，并返回计算的代价值和梯度。

正则化逻辑回归的代价函数如下：
J ( θ ) = 1 m ∑ i = 1 m [ − y ( i ) log ⁡ ( h θ ( x ( i ) ) ) − ( 1 − y ( i ) ) log ⁡ ( 1 − h θ ( x ( i ) ) ) ] + λ 2 m ∑ j = 1 n θ j 2 J\left( \theta \right)=\frac{1}{m}\sum\limits_{i=1}^{m}{[-{{y}^{(i)}}\log \left( {{h}_{\theta }}\left( {{x}^{(i)}} \right) \right)-\left( 1-{{y}^{(i)}} \right)\log \left( 1-{{h}_{\theta }}\left( {{x}^{(i)}} \right) \right)]}+\frac{\lambda }{2m}\sum\limits_{j=1}^{n}{\theta _{j}^{2}} J(θ)=m1​i=1∑m​[−y(i)log(hθ​(x(i)))−(1−y(i))log(1−hθ​(x(i)))]+2mλ​j=1∑n​θj2​

其中 λ \lambda λ是“学习率”参数，其值会影响函数中的正则项值。且不应该正则化参数 θ 0 \theta_0 θ0​。

###在这里填入代码###
def costReg(theta, X, y, learningRate):
    theta = np.matrix(theta)
    X = np.matrix(X)
    y = np.matrix(y)
    first = np.multiply(-y, np.log(sigmoid(X * theta.T)))
    second = np.multiply((1 - y), np.log(1 - sigmoid(X * theta.T)))
    reg = (learningRate / (2 * len(X))) * np.sum(np.power(theta[:,1:theta.shape[1]], 2))
    return np.sum(first - second) / len(X) + reg

接下来，我们需要实现正则化梯度函数，使用梯度下降法使得代价函数最小化。

因为在代价函数的计算中我们未对 θ 0 \theta_0 θ0​进行正则化，所以梯度下降算法将分为两种情况：

\begin{align}
& Repeat\text{ }until\text{ }convergence\text{ }!!{!!\text{ } \
& \text{ }{{\theta }{0}}:={{\theta }{0}}-a\frac{1}{m}\sum\limits_{i=1}^{m}{[{{h}{\theta }}\left( {{x}^{(i)}} \right)-{{y}{(i)}}]x_{_{0}}{(i)}} \
& \text{ }{{\theta }{j}}:={{\theta }{j}}-a\frac{1}{m}\sum\limits{i=1}^{m}{[{{h}{\theta }}\left( {{x}^{(i)}} \right)-{{y}{(i)}}]x_{j}{(i)}}+\frac{\lambda }{m}{{\theta }{j}} \
& \text{ }!!}!!\text{ } \
& Repeat \
\end{align}

对上面的算法中 j=1,2,…,n 时的更新式子进行调整可得：
θ j : = θ j ( 1 − a λ m ) − a 1 m ∑ i = 1 m ( h θ ( x ( i ) ) − y ( i ) ) x j ( i ) {{\theta }_{j}}:={{\theta }_{j}}(1-a\frac{\lambda }{m})-a\frac{1}{m}\sum\limits_{i=1}^{m}{({{h}_{\theta }}\left( {{x}^{(i)}} \right)-{{y}^{(i)}})x_{j}^{(i)}} θj​:=θj​(1−amλ​)−am1​i=1∑m​(hθ​(x(i))−y(i))xj(i)​

###在这里填入代码###
def gradientReg(theta, X, y, learningRate):
    theta = np.matrix(theta)
    X = np.matrix(X)
    y = np.matrix(y)
    
    parameters = int(theta.ravel().shape[1])
    grad = np.zeros(parameters)
    
    error = sigmoid(X * theta.T) - y
    
    for i in range(parameters):
        term = np.multiply(error, X[:,i])
        
        if (i == 0):
            grad[i] = np.sum(term) / len(X)
        else:
            grad[i] = (np.sum(term) / len(X)) + ((learningRate / len(X)) * theta[:,i])
    
    return grad

接下来，类似于第一部分的练习中，进行变量的初始化。

# 从数据集中取得对应的特征列和标签列
cols = data2.shape[1]
X2 = data2.iloc[:,1:cols]
y2 = data2.iloc[:,0:1]

# 转换为Numpy数组并初始化theta为零矩阵
X2 = np.array(X2.values)
y2 = np.array(y2.values)
theta2 = np.zeros(11)

# 设置初始学习率为1，后续可以修改
learningRate = 1

接下来，使用初始化的变量值来测试你实现的代价函数和梯度函数。

###请运行并测试你的代码###
costReg(theta2, X2, y2, learningRate)

0.6931471805599454

###请运行并测试你的代码###
gradientReg(theta2, X2, y2, learningRate)

array([0.00847458, 0.01878809, 0.05034464, 0.01150133, 0.01835599,
       0.00732393, 0.00819244, 0.03934862, 0.00223924, 0.01286005,
       0.00309594])

2.4 寻找最优参数

现在我们可以使用和第一部分相同的优化函数来计算优化后的结果。

result2 = opt.fmin_tnc(func=costReg, x0=theta2, fprime=gradientReg, args=(X2, y2, learningRate))
result2

(array([ 0.53010248,  0.29075567, -1.60725764, -0.58213819,  0.01781027,
        -0.21329508, -0.40024142, -1.37144139,  0.02264304, -0.9503358 ,
         0.0344085 ]), 22, 1)

2.5 评估正则化逻辑回归

最后，我们可以使用第1部分中的预测函数来查看我们的方案在训练数据上的准确度。

theta_min = np.matrix(result2[0])
predictions = predict(theta_min, X2)
correct = [1 if ((a == 1 and b == 1) or (a == 0 and b == 0)) else 0 for (a, b) in zip(predictions, y2)]
accuracy = (sum(map(int, correct)) % len(correct))
print ('accuracy = {0}%'.format(accuracy))

accuracy = 78%

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/613921.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

rust疑难进阶手册（1）-安装和管理，类型推断，打印输出（1）

rust疑难进阶手册（1）-安装和管理，类型推断，打印输出（1）

目录 安装管理和配置工具项目管理类型推断格式输出位置参数格式化文本命名参数安装 不管OS是否带有rust，都应使用rustup来安装rust linux/freebsdcurl https://sh.rustup.rs -sSf | shwindows https://www.rust-lang.org/tools/install windows下建议使用GNU的编译链接库，不…
阅读更多...
GraphQL入门实战

GraphQL入门实战

解决什么问题 根据请求控制返回结果 例如： 一个User对象，有id，name，mobile，email 有些接口只要返回id,name ，有些接口还要要返回 mobile 适用场景 弱文档管理，公司对文档要求不高需求复杂变…
阅读更多...
【JavaEE进阶】springBoot热部署、请求转发与重定向

【JavaEE进阶】springBoot热部署、请求转发与重定向

目录 一、SpringBoot热部署 1.1热部署的步骤 1.1.1导入maven中央仓库的jar包 1.1.2开启项目自动编译 1.1.3启动项目 1.2热部署的原理 二、请求转发&重定向 2.1关键字不一样 2.2定义不同 请求转发(forward)： 请求重定向(redirect): 2.3数据共享不一样…
阅读更多...
如何用MASM32开发Windows应用程序

如何用MASM32开发Windows应用程序

提醒：以下内容仅做参考，可自行发散。在发布作品前，请把不需要的内容删掉。IT技术日异月异，无论是初学者还是有经验的专业人士，都需要与时俱进，不断学习新技术。在学习一门新的IT技术时，都需要采…
阅读更多...
Github自定义个人首页

Github自定义个人首页

前言 GitHub 个人主页，官方称呼是 profile，是一个以 Markdown 脚本语言编写的个人 GitHub 展示主页面。Guthub 个人主页可以展示很多有用的信息，例如添加一个首页被访问次数的计数器，一个 Github 被 Star 与 Commit 的概览信息&a…
阅读更多...
JVM-学习笔记

JVM-学习笔记

一 . JVM架构图 JVM是Java Virtual Machine的简称，意为Java虚拟机。JVM有很多种，使用最为广泛的JVM为HotSpot。 如上面架构图所示，JVM分为三个主要子系统： 类加载器子系统（Class Loader Subsystem） 运行…
阅读更多...
Linux命令学习之cp和mv

Linux命令学习之cp和mv

cp man 1 cp可以看一下cp的帮助说明。 cp -r /learnwell/good/ /tmp把good目录复制到/tmp目录下，注意想要复制目录，一定要加上-r选项。 接下来学习复制文件，cp 源文件 目标目录（相对路径方法）或者是cp /源文件所在目…
阅读更多...
华为OD机试题【IPv4地址转换成整数】【2023 B卷 100分】

华为OD机试题【IPv4地址转换成整数】【2023 B卷 100分】

文章目录 🎯 前言🎯 题目描述🎯 解题思路示例 1示例 2📙 Python代码实现📗 Java代码实现📘 C语言代码实现 🎯 前言 🏆 《华为机试真题》专栏含2023年牛客网面经、华为面经试题、华为…
阅读更多...
Spark安装和编程实践（Spark2.4.0）

Spark安装和编程实践（Spark2.4.0）

系列文章目录 Ubuntu常见基本问题 Hadoop3.1.3安装（单机、伪分布） Hadoop集群搭建 HBase2.2.2安装（单机、伪分布） Zookeeper集群搭建 HBase集群搭建 Spark安装和编程实践（Spark2.4.0） Spark集群搭建 文章目…
阅读更多...
linux（信号产生的各种方式）

linux（信号产生的各种方式）

目录： 1.引入 2.介绍系统支持的信号列表 3.键盘方式产生信号 4.程序中存在异常问题，产生信号 5.系统调用产生信号 6.软件条件也能产生信号 7.任何理解OS给进程发送信号 1.引入 我怎么证明ctrlc是向指定进程发送了2号信号呢？？ sig…
阅读更多...
5万字大数据实验室建设方案能源大数据中心建设方案word

5万字大数据实验室建设方案能源大数据中心建设方案word

本资料来源公开网络，仅供个人学习，请勿商用，如有侵权请联系删除篇幅有限，无法完全展示，喜欢资料可转发评论，私信了解更多信息。 大数据实验室建设方案 大数据实验室建设方案 目录 1概述 1.1建设背景 1.…
阅读更多...
chatgpt赋能python：Python抓取数据：从入门到精通

chatgpt赋能python：Python抓取数据：从入门到精通

Python抓取数据：从入门到精通 Python是当下最热门的编程语言之一，其强大的数据处理能力使得Python在数据抓取方面也越来越受欢迎。本文将从入门到精通介绍Python抓取数据的方法，希望对初学者有所帮助。 网络爬虫 网络爬虫是Python基于网络…
阅读更多...
CG平台实验——线性回归

CG平台实验——线性回归

文章目录 练习1：线性回归介绍1 实现简单示例函数1.1 提交解决方案 2 单变量线性回归2.1 绘制数据2.2 梯度下降2.2.1 更新公式2.2.2 实现2.2.3 计算成本J(θ)2.2.4 梯度下降 2.3 可视化成本函数 选做练习3 多变量线性回归3.1 特征标准化3.2 梯度下降 练习1&#xff1…
阅读更多...
chatgpt赋能python：Python在边框中写文字：优雅展示内容的方式

chatgpt赋能python：Python在边框中写文字：优雅展示内容的方式

Python在边框中写文字：优雅展示内容的方式 当我们需要在网页上展示一些信息时，通常会使用边框来突出显示内容，然而，普通的边框可能会显得过于单调，缺少设计感，这时我们可以借助Python来实现一个功能强大的…
阅读更多...
chatgpt赋能python：Python备份列表：从小白到大神，这里有你需要的一切

chatgpt赋能python：Python备份列表：从小白到大神，这里有你需要的一切

Python备份列表：从小白到大神，这里有你需要的一切 随着信息科技的发展，数字资料的价值越发具有现实意义，但是数据泄露、系统崩溃、病毒攻击、硬件故障等情况也时有发生。因此，对数据进行备份是非常必要的。Python作为…
阅读更多...
Select选择器（antd-design组件库）简单使用以及增加搜索功能

Select选择器（antd-design组件库）简单使用以及增加搜索功能

1.Select选择器 下拉选择器。 2.何时使用 弹出一个下拉菜单给用户选择操作，用于代替原生的选择器，或者需要一个更优雅的多选器时。 当选项少时（少于 5 项），建议直接将选项平铺，使用 Radio 是更好的选择。 组…
阅读更多...
chatgpt赋能python：Python如何倒序输出列表

chatgpt赋能python：Python如何倒序输出列表

Python如何倒序输出列表 Python是一种高级编程语言，自由、开源、跨平台，被广泛用于Web开发、数据分析、机器学习等领域。在Python中，列表是一种常见的数据结构，它允许存储多个元素，并支持索引、切片等操作。本文将介绍…
阅读更多...
chatgpt赋能python：Python如何保存文件-最全面的指南

chatgpt赋能python：Python如何保存文件-最全面的指南

Python如何保存文件 - 最全面的指南 Python是一种强大的编程语言，它在处理文本文件、CSV文件、Excel文件、图像文件和PDF文件等方面表现出色。然而，如何在Python中保存这些文件，对于初学者来说可能会有些棘手。在本篇文章中，我们…
阅读更多...
自建极简Ethercat主站-底层驱动编写

自建极简Ethercat主站-底层驱动编写

1、简介 MECM（Mini Ethercat Master）,名字随便起的。已经学习了一段时间的Ethercat总线了，目前的想法就是自己简单实现一个Ethercat主站，没有太多的冗余功能，暂时不考虑太多的容错机制，仅实现目前用到的FO…
阅读更多...
chatgpt赋能python：Python奇偶求和：简单实用的算法

chatgpt赋能python：Python奇偶求和：简单实用的算法

Python奇偶求和：简单实用的算法 Python作为一门高级编程语言，不仅适用于数据分析及科学计算领域，也可用于日常生活中的实用问题。例如，人们常常需要对一个整数序列中的奇数和偶数进行求和，以便了解各自的总数或者对它…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023