深度学习入门---《白话机器学习的数学》笔记

news2025/1/16 14:41:24

文章目录

    • 一、基础：回归的实现
        • 1、训练数据click.csv
        • 2、参考公式：
        • 3、代码实现：
        • 4、运行结果：
        • 5、验证：
    • 二、多项式回归
        • 1、参考公式
        • 2、代码实现
        • 3、运行结果
    • 三、随机梯度下降法的实现
        • 1、参考公式
          • 小批量（mini-batch）梯度下降法
        • 2、代码实现
        • 3、运行结果
    • 四、感知机
        • 1、训练数据images1.csv
        • 2、参考公式
          • 感知机模型
          • 判别函数
          • 权重向量的更新表达式
        • 3、代码实现
        • 4、运行结果
        • 5、验证
    • 五、分类——逻辑回归的实现
        • 1、训练数据images2.csv
        • 2、参考公式
          • sigmoid函数
          • 参数更新表达式
        • 3、代码实现
        • 4、运行结果
        • 5、验证
    • 六、线性不可分分类的实现
        • 1、训练数据data3.csv
        • 2、代码实现
        • 3、运行结果
          • 绘制精度上升曲线
        • 4、用随机梯度下降法实现
    • 七、正则化
        • 1、准备工作
        • 2、代码实现
        • 3、运行结果
          • 未应用正则化的实现
          • 应用了正则化的实现

一、基础：回归的实现

1、训练数据click.csv

x,y
235,591
216,539
148,413
35,310
85,308
204,519
49,325
25,332
173,498
191,498
134,392
99,334
117,385
112,387
162,425
272,659
159,400
159,427
59,319
198,522

2、参考公式：

首先把 fθ(x) 作为一次函数来实现
在这里插入图片描述
参数更新表达式：
在这里插入图片描述
学习率先设置为10−3 。

3、代码实现：

'''
回归的实现
'''
import numpy as np
import matplotlib.pyplot as plt

# 读入训练数据
train = np.loadtxt('click.csv',delimiter=',',skiprows=1)
train_x = train[:,0]
train_y = train[:,1]

# 参数初始化
theta0 = np.random.rand()
theta1 = np.random.rand()
# 预测函数
def f(x):
    return  theta0 + theta1 * x
# 目标函数
def E(x,y):
    return 0.5 * np.sum((y - f(x))**2)
# 标准化
mu = train_x.mean()
sigma = train_x.std()
def standardize(x):
    return (x - mu)/sigma
train_z = standardize(train_x)

# 绘图
# plt.plot(train_z,train_y,'o')
# plt.show()

# 学习率
ETA = 1e-3
# 误差的差值
diff = 1
# 更新次数
count = 0

# 直到误差的值小于0.01为止，重复参数更新
error = E(train_z, train_y)
while diff > 1e-2:
    # 更新结果保存到临时变量
    tmp0 = theta0 - ETA * np.sum((f(train_z) - train_y))
    tmp1 = theta1 - ETA * np.sum((f(train_z) - train_y) * train_z)
    # 更新参数
    theta0 = tmp0
    theta1 = tmp1
    # 计算与上一次误差的差值
    current_error = E(train_z,train_y)
    diff = error - current_error
    error = current_error
    # 输出日志
    count += 1
    log = '第{}次：theta0 = {:.3f},theta1 = {:.3f},差值 = {:.4f}'
    # print(log.format(count,theta0,theta1,diff))

# 绘图确认
x = np.linspace(-3, 3, 100)
plt.plot(train_z,train_y,'o')
plt.plot(x,f(x))
# plt.show()
# print(f(standardize(100)))

4、运行结果：

在这里插入图片描述

5、验证：

在这里插入图片描述

二、多项式回归

提示：增加参数theta2，并替换预测函数
多重回归：将参数和训练数据都作为向量来处理，使计算变得简单

1、参考公式

在这里插入图片描述
将参数和训练数据都作为向量来处理，可以使计算变得更简单
在这里插入图片描述
由于训练数据有很多，所以我们把 1 行数据当作 1 个训练数据，以矩阵的形式来处理会更好
在这里插入图片描述

2、代码实现

'''
多项式回归
增加参数theta2，并替换预测函数
多重回归：将参数和训练数据都作为向量来处理，使计算变得简单
'''
import numpy as np
import matplotlib.pyplot as plt
# 读入训练数据
train = np.loadtxt('click.csv',delimiter=',',skiprows=1)
train_x = train[:,0]
train_y = train[:,1]
# 标准化
mu = train_x.mean()
sigma = train_x.std()
def standardize(x):
    return (x - mu)/sigma
train_z = standardize(train_x)

# 初始化参数
theta = np.random.rand(3)
# 学习率
ETA = 1e-3
# 误差的差值
diff = 1
# 均方误差的历史记录
errors = []

# 创建训练数据的矩阵
def to_matrix(x):
    return  np.vstack([np.ones(x.shape[0]),x,x ** 2]).T
X = to_matrix(train_z)


# 预测函数
def f(x):
    return np.dot(x,theta)
# 目标函数
def E(x,y):
    return 0.5 * np.sum((y - f(x))**2)
# 均方误差
def MSE(x, y):
    return (1 / x.shape[0]) * np.sum((y - f(x)) ** 2)


# 重复学习
error = E(X, train_y)
errors.append(MSE(X, train_y))
while diff > 1e-2:
    # 更新参数
    theta = theta - ETA * np.dot(f(X) - train_y,X)
    # 计算与上一次误差的差值
    current_error = E(X, train_y)
    diff = error - current_error
    error = current_error

    errors.append(MSE(X, train_y))
    # diff = errors[-2] - errors[-1]

# 绘制拟合曲线
x = np.linspace(-3,3,100)
plt.plot(train_z,train_y,'o')
plt.plot(x,f(to_matrix(x)))
plt.show()

# 绘制误差变化图
x = np.arange(len(errors))
plt.plot(x, errors)
plt.show()

3、运行结果

在这里插入图片描述
绘制误差变化图：
在这里插入图片描述

三、随机梯度下降法的实现

1、参考公式

在随机梯度下降法中会随机选择一个训练数据并使用它来更新参数。表达式中的 k 就是被随机选中的数据索引。
在这里插入图片描述
随机梯度下降法由于训练数据是随机选择的，更新参数时使用的又是选择数据时的梯度，所以不容易陷入目标函数的局部最优解。

小批量（mini-batch）梯度下降法

前面提到了随机选择 1 个训练数据的做法，此外还有随机选择 m 个训练数据来更新参数的做法。设随机选择 m 个训练数据的索引的集合为 K：
在这里插入图片描述

2、代码实现

"""
随机梯度下降法的实现
"""
import numpy as np
import matplotlib.pyplot as plt
# 读入训练数据
train = np.loadtxt('click.csv',delimiter=',',skiprows=1)
train_x = train[:,0]
train_y = train[:,1]
# 标准化
mu = train_x.mean()
sigma = train_x.std()
def standardize(x):
    return (x - mu)/sigma
train_z = standardize(train_x)

# 初始化参数
theta = np.random.rand(3)
# 均方误差的历史记录
errors = []
# 误差的差值
diff = 1
# 学习率
ETA = 1e-3

# 创建训练数据的矩阵
def to_matrix(x):
    return  np.vstack([np.ones(x.shape[0]),x,x ** 2]).T
X = to_matrix(train_z)

# 预测函数
def f(x):
    return np.dot(x,theta)
# 目标函数
def E(x,y):
    return 0.5 * np.sum((y - f(x))**2)
# 均方误差
def MSE(x, y):
    return (1 / x.shape[0]) * np.sum((y - f(x)) ** 2)

# 重复学习
errors.append(MSE(X, train_y))
while diff > 1e-2:
    # 为了调整训练数据的顺序，准备随机的序列permutation
    p = np.random.permutation(X.shape[0])
    # 随机取出训练数据，使用随机梯度下降法更新参数
    for x,y in zip(X[p,:],train_y[p]):
        theta = theta - ETA * (f(x) - y) * x
    # 计算与上一次误差的差值
    errors.append(MSE(X, train_y))
    diff = errors[-2] - errors[-1]

x = np.linspace(-3,3,100)
plt.plot(train_z,train_y,'o')
plt.plot(x,f(to_matrix(x)))
plt.show()

3、运行结果

在这里插入图片描述

四、感知机

1、训练数据images1.csv

x1,x2,y
153,432,-1
220,262,-1
118,214,-1
474,384,1
485,411,1
233,430,-1
369,361,1
484,349,1
429,259,1
286,220,1
399,433,-1
403,340,1
252,34,1
497,472,1
379,416,-1
76,163,-1
263,112,1
26,193,-1
61,473,-1
420,253,1

2、参考公式

感知机模型

在这里插入图片描述

判别函数

根据参数向量 x 来判断图像是横向还是纵向的函数，即返回 1 或者 −1 的函数 fw(x)的定义如下。
在这里插入图片描述
内积是衡量向量之间相似程度的指标。结果为正，说明二者相似；为 0 则二者垂直；为负则说明二者不相似。

权重向量的更新表达式

在这里插入图片描述

3、代码实现

使权重向量成为法线向量的直线方程是内积为 0 的 x 的集合。所以对它进行移项变形，最终绘出以下表达式的图形即可。
在这里插入图片描述

"""
分类---感知机
"""
import numpy as np
import matplotlib.pyplot as plt
# 读入训练数据
train = np.loadtxt('images1.csv',delimiter=',',skiprows=1)
train_x = train[:,0:2]
train_y = train[:,2]
# print(list(zip(train_x,train_y)))


# 权重初始化
# 返回一个或一组服从“0~1”均匀分布的随机样本值。随机样本取值范围是[0,1)，不包括1
w = np.random.rand(2)
#判别函数
def f(x):
    if np.dot(w,x) >= 0:
        return 1
    else:
        return -1

# 重复次数
epoch = 10
# 更新次数
count = 0
# 学习权重
for _ in range(epoch):
    for x,y in zip(train_x,train_y):
        if f(x) != y:
            w = w + y * x
            # 输出日志
            count += 1
            print("第{}次：w = {}".format(count,w))

# 绘制直线：使权重向量称为法线向量的直线方程是内积为0的x的集合
x1 = np.arange(0,500)
plt.plot(train_x[train_y == 1,0], train_x[train_y == 1,1],'o')
plt.plot(train_x[train_y == -1,0], train_x[train_y == -1,1],'x')
plt.plot(x1, -w[0]/w[1]*x1,linestyle = 'dashed')
# plt.axis('scaled')
# plt.show()

print(f([200,100]))

4、运行结果

在这里插入图片描述

5、验证

在这里插入图片描述

五、分类——逻辑回归的实现

1、训练数据images2.csv

x1,x2,y
153,432,0
220,262,0
118,214,0
474,384,1
485,411,1
233,430,0
369,361,1
484,349,1
429,259,1
286,220,1
399,433,0
403,340,1
252,34,1
497,472,1
379,416,0
76,163,0
263,112,1
26,193,0
61,473,0
420,253,1

2、参考公式

与感知机的不同之处在于，逻辑回归是把分类作为概率来考虑的。

sigmoid函数

在这里插入图片描述
在这里插入图片描述
决策边界：
从图中可以看出在 fθ(x) ⩾ 0.5 时，θTx ⩾ 0，反过来在 fθ(x) < 0.5 时，θTx < 0;
在这里插入图片描述

参数更新表达式

在这里插入图片描述

3、代码实现

首先初始化参数，然后对训练数据标准化。x1和 x2 要分别标准 化。另外不要忘了加一个 x0 列。
θTx = 0这条直线是决策边界
在这里插入图片描述

"""
分类：逻辑回归的实现
"""
import numpy as np
import matplotlib.pyplot as plt
# 读入训练数据
train = np.loadtxt('images2.csv',delimiter=',',skiprows=1)
train_x = train[:,0:2]
train_y = train[:,2]

# 初始化参数
theta = np.random.rand(3)
# 标准化:对x1和x2分别取平均值和标准差，进行标准化
mu = train_x.mean(axis = 0)
sigma = train_x.std(axis = 0)
def standardize(x):
    return (x - mu)/sigma
train_z = standardize(train_x)

# 增加x0
def to_matrix(x):
    x0 = np.ones([x.shape[0], 1])
    return np.hstack([x0, x])

X = to_matrix(train_z)

# sigmoid函数
def f(x):
    return 1/(1 + np.exp(-np.dot(x, theta)))

# 学习率
ETA = 1e-3
# 重复次数
epoch = 5000
# 更新次数
count = 0
# 重复学习
for _ in range(epoch):
    theta = theta - ETA * np.dot(f(X) - train_y, X)
    # 日志输出
    count += 1
    print('第{}次：theta = {}'.format(count,theta))


# 验证：对预测数据进行标准化
# f(to_matrix(standardize([
#     [200,100], # 200x100的横向图像
#     [100,200]  # 100x200的纵向图像
# ])))
def classify(x):
    return (f(x) >= 0.5).astype(np.int)
rst = classify(to_matrix(standardize([
        [200,100], # 200x100的横向图像
        [100,200]  # 100x200的纵向图像
])))
# print(rst)
x1 = np.linspace(-2,2,100)
# 将标准化后的训练数据画成图
plt.plot(train_z[train_y == 1, 0], train_z[train_y == 1, 1], 'o')
plt.plot(train_z[train_y == 0, 0], train_z[train_y == 0, 1], 'x')
plt.plot(x1, -(theta[0] + theta[1] * x1) / theta[2], linestyle = "dashed")
plt.show()

4、运行结果

在这里插入图片描述

5、验证

在这里插入图片描述

六、线性不可分分类的实现

1、训练数据data3.csv

x1,x2,y
0.54508775,2.34541183,0
0.32769134,13.43066561,0
4.42748117,14.74150395,0
2.98189041,-1.81818172,1
4.02286274,8.90695686,1
2.26722613,-6.61287392,1
-2.66447221,5.05453871,1
-1.03482441,-1.95643469,1
4.06331548,1.70892541,1
2.89053966,6.07174283,0
2.26929206,10.59789814,0
4.68096051,13.01153161,1
1.27884366,-9.83826738,1
-0.1485496,12.99605136,0
-0.65113893,10.59417745,0
3.69145079,3.25209182,1
-0.63429623,11.6135625,0
0.17589959,5.84139826,0
0.98204409,-9.41271559,1
-0.11094911,6.27900499,0

2、代码实现

这个数据看上去不能用一条直线来分类，要用二次函数
对于有4个参数的公式变形：
在这里插入图片描述

"""
线性不可分分类的实现
"""
import numpy as np
import matplotlib.pyplot as plt

# 读入训练数据
train = np.loadtxt('data3.csv',delimiter=',',skiprows=1)
train_x = train[:,0:2]
train_y = train[:,2]

# 参数初始化
theta = np.random.rand(4)
# 标准化:对x1和x2分别取平均值和标准差，进行标准化
mu = train_x.mean(axis = 0)
sigma = train_x.std(axis = 0)
def standardize(x):
    return (x - mu)/sigma
train_z = standardize(train_x)

# 数据看上去确实不能用一条直线来分类，要用二次函数，在训练数据里加上 x1的平方 就能很好地分类了。
# 增加x0和x3
def to_matrix(x):
    x0 = np.ones([x.shape[0], 1])
    # 增加维度：np.newaxis 放在哪个位置，就会给哪个位置增加维度
    # x[:, np.newaxis] ，放在后面，会给列上增加维度
    x3 = x[:,0,np.newaxis] ** 2
    return np.hstack([x0, x, x3])

X = to_matrix(train_z)

# sigmoid函数
def f(x):
    return 1/(1 + np.exp(-np.dot(x, theta)))

def classify(x):
    return (f(x) >= 0.5).astype(np.int64)

# 学习率
ETA = 1e-3
# 重复次数
epoch = 5000
# 更新次数
count = 0
# 将重复次数作为横轴，精度作为纵轴来绘图，可以看到精度上升
# 精度的历史记录
accuracies = []
# 重复学习
for _ in range(epoch):
    theta = theta - ETA * np.dot(f(X) - train_y, X)
    # 日志输出
    count += 1
    # print('第{}次：theta = {}'.format(count,theta))
    # 计算现在的精度
    result = classify(X) == train_y
    accurancy = len(result[result == True]) / len(result)
    accuracies.append(accurancy)

# 将精度画成图
x = np.arange(len(accuracies))
plt.plot(x,accuracies)
plt.show()

# 将结果画成图
x1 = np.linspace(-2, 2, 100)
x2 = -(theta[0] + theta[1]*x1 + theta[3] * x1 ** 2)/theta[2]
plt.plot(train_z[train_y == 1, 0], train_z[train_y == 1, 1], 'o')
plt.plot(train_z[train_y == 0, 0], train_z[train_y == 0, 1], 'x')
plt.plot(x1,x2,linestyle='dashed')
# plt.show()

3、运行结果

在这里插入图片描述

绘制精度上升曲线

根据公式：
在这里插入图片描述

在这里插入图片描述

4、用随机梯度下降法实现

"""
随机梯度下降法的实现
"""
import numpy as np
import matplotlib.pyplot as plt

# 读入训练数据
train = np.loadtxt('data3.csv',delimiter=',',skiprows=1)
train_x = train[:,0:2]
train_y = train[:,2]

# 参数初始化
theta = np.random.rand(4)
# 标准化:对x1和x2分别取平均值和标准差，进行标准化
mu = train_x.mean(axis = 0)
sigma = train_x.std(axis = 0)
def standardize(x):
    return (x - mu)/sigma
train_z = standardize(train_x)

# 增加x0和x3
def to_matrix(x):
    x0 = np.ones([x.shape[0], 1])
    # 增加维度
    x3 = x[:,0,np.newaxis] ** 2
    return np.hstack([x0, x, x3])

X = to_matrix(train_z)
print(X)
# sigmoid函数
def f(x):
    return 1/(1 + np.exp(-np.dot(x, theta)))

def classify(x):
    return (f(x) >= 0.5).astype(np.int64)

# 学习率
ETA = 1e-3
# 重复次数
epoch = 5000
# 更新次数
count = 0
# 将重复次数作为横轴，精度作为纵轴来绘图，可以看到精度上升
# 精度的历史记录
accuracies = []
# 重复学习
for _ in range(epoch):
    # 使用随机梯度下降法更新参数
    p = np.random.permutation(X.shape[0])
    for x,y in zip(X[p,:], train_y[p]):
        theta = theta - ETA * (f(x) - y)*x

# 将结果画成图
x1 = np.linspace(-2, 2, 100)
x2 = -(theta[0] + theta[1]*x1 + theta[3] * x1 ** 2)/theta[2]
plt.plot(train_z[train_y == 1, 0], train_z[train_y == 1, 1], 'o')
plt.plot(train_z[train_y == 0, 0], train_z[train_y == 0, 1], 'x')
plt.plot(x1,x2,linestyle='dashed')
plt.show()

# Iris 数据集也可以用在分类上，可以用它进行更多尝试

运行结果：
在这里插入图片描述

七、正则化

1、准备工作

自定义函数，并加入一些噪声数据：
在这里插入图片描述虚线就是正确的 g(x) 的图形，圆点就是加入了一点噪声的训练数据：
在这里插入图片描述
假设用 10 次多项式来学习这个训练数据。10 次多项式，包括参数 θ0 在内，一共有 11 个参数。

2、代码实现

"""
正则化的实现
"""
import numpy as np
import matplotlib.pyplot as plt
# 真正的函数
def g(x):
    return 0.1 * (x ** 3 + x ** 2 + x)
# 随意准备一些向真正的函数加入了一点噪声的训练数据
train_x = np.linspace(-2,2,8)
train_y = g(train_x) + np.random.randn(train_x.size) * 0.05

# 标准化
mu = train_x.mean(axis = 0)
sigma = train_x.std(axis = 0)
def standardize(x):
    return (x - mu)/sigma
train_z = standardize(train_x)

# 创建训练数据的矩阵，假设我们用 10 次多项式来学习这个训练数据。
# 按垂直方向（行顺序）堆叠数组构成一个新的数组.堆叠的数组需要具有相同的维度
def to_matrix(x):
    return np.vstack([
        np.ones(x.size),
        x,
        x ** 2,
        x ** 3,
        x ** 4,
        x ** 5,
        x ** 6,
        x ** 7,
        x ** 8,
        x ** 9,
        x ** 10,
    ]).T

X = to_matrix(train_z)
# 参数初始化
# X.shape[1]：有几列
# randn是从标准正态分布中返回一个或多个样本值。正态分布,也即这些随机数的期望为0,方差为1;
# rand则会产生[0, 1)之间的随机数

theta = np.random.randn(X.shape[1])
# 预测函数
def f(x):
    return np.dot(x, theta)

# 绘图确认
x = np.linspace(-2,2,100)
# plt.plot(train_x,train_y,'o')
# plt.plot(x,g(x),linestyle='dashed')
# plt.ylim(-1,2)
# plt.show()

# 学习率
ETA = 1e-4
# 误差
diff1 = 1
# 目标函数
def E(x,y):
    return 0.5 * np.sum((y - f(x)) ** 2)
# 重复学习
error = E(X, train_y)

'''不应用正则化的实现'''
''''''
while diff1 > 1e-6:
    theta = theta - ETA * np.dot(f(X)-train_y,X)
    current_error1 = E(X, train_y)
    diff1 = error - current_error1
    error = current_error1

z = standardize(x)
plt.plot(train_z,train_y,'o')
plt.plot(z, f(to_matrix(z)),linestyle='dashed')
plt.show()


'''应用了正则化的实现'''
'''
# 保存未正则化的参数，然后再次参数初始化
theta1 = theta
theta = np.random.randn(X.shape[1])
# 正则化常量
LAMBDA = 1
# 误差
diff2 = 1

while diff2 > 1e-6:
    # 正则化项。偏置项不适用正则化，所以为0
    reg_term = LAMBDA * np.hstack([0,theta[1:]])
    # 应用正则化项，更新参数
    theta = theta - ETA * (np.dot(f(X)-train_y,X) + reg_term)
    current_error2 = E(X, train_y)
    diff2 = error - current_error2
    error = current_error2

# 对结果绘图
z = standardize(x)
plt.plot(train_z,train_y,'o')
plt.plot(z, f(to_matrix(z)))
plt.show()
'''

3、运行结果

未应用正则化的实现

在这里插入图片描述

应用了正则化的实现

在这里插入图片描述
绘制在一起进行比较：
在这里插入图片描述

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

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

相关文章

F. Quests(二分)

F. Quests(二分)

Problem - F - Codeforces 有n个任务。如果你完成第i个任务&#xff0c;你将获得ai币。你每天最多只能完成一个任务。然而&#xff0c;一旦你完成了一个任务&#xff0c;在K天内你不能再做同样的任务。(例如&#xff0c;如果k2&#xff0c;你在第1天做了任务1&#xff0c;那么你…
阅读更多...
radiantq：jQuery Gantt Package--好使的HTML5甘特图

radiantq：jQuery Gantt Package--好使的HTML5甘特图

Radiantq--jQuery Gantt Package是一个真正跨平台的、基于原生 HTML5/jQuery 的实现&#xff0c;带有 2 个不同的甘特图小部件。 部署在众多垂直领域 无论您的应用程序属于哪个领域&#xff0c;甘特图都是基于时间的信息的理想可视化工具&#xff0c;包括在软件开发、施工、钻井…
阅读更多...
JNoteHelper 给你的java swing或桌面程序提供一双翅膀

JNoteHelper 给你的java swing或桌面程序提供一双翅膀

JNoteHelper 使用swing构建的java程序, 主要基于miglayout,swingx,flatlatf, 本来打算作为个人笔记的助手, 但是事与愿违, 发现理想和现实很骨感. 项目基于windows测试及开发 ,所以运行效果图片都基于windows 截图 1. 项目地址 JNoteHelper github地址 gitee地址 gitcode地址…
阅读更多...
玩法专利获批，发布4年《Beat Saber》为何持续火爆

玩法专利获批，发布4年《Beat Saber》为何持续火爆

从2018年首次上线以来&#xff0c;《Beat Saber》被大家爱了4年多&#xff0c;直到现在热度未减&#xff0c;依然是史上最赚钱的VR游戏之一。该作最开始的概念&#xff0c;就是用红、蓝两色的光剑&#xff0c;根据箭头方向和节奏去切方块&#xff0c;玩法简单爽快&#xff0c;受…
阅读更多...
Qt QSS QSlider样式

Qt QSS QSlider样式

本文章主要学习QSlider样式 准备下面几张背景图片&#xff1a; 调小图标 、调大图标 ​、QSlider位置图标 ​QSlider划过的背景图标 ​、QSlider未划过的背景图标 ​最终效果图 自己创建一个QSlider工程&#xff0c;此处省略…… CSDN QT大纲&#xff1a;Qt开发必备技术栈学…
阅读更多...
[附源码]java毕业设计鞋店销售管理

[附源码]java毕业设计鞋店销售管理

项目运行 环境配置&#xff1a; Jdk1.8 Tomcat7.0 Mysql HBuilderX&#xff08;Webstorm也行&#xff09; Eclispe&#xff08;IntelliJ IDEA,Eclispe,MyEclispe,Sts都支持&#xff09;。 项目技术&#xff1a; SSM mybatis Maven Vue 等等组成&#xff0c;B/S模式 M…
阅读更多...
DM-VERITY流程分析

DM-VERITY流程分析

DM-Verity分析报告 0.问题的表现形式 1.dm-verity的初始化及验证流程 1.1 dm-verity的初始化 初始化dm的log: [ 3.579718] md: Waiting for all devices to be available before autodetect [ 3.586549] md: If you dont use raid, use raidnoautodetect [ 3.594…
阅读更多...
Allegro如何录制SCR快捷键操作指导

Allegro如何录制SCR快捷键操作指导

Allegro如何录制SCR快捷键操作指导 Allegro可以录制SCR快捷键，里面记录了一些操作，类似一个插件，使用的时候可以直接调用，节省时间。下面介绍如何录制 选择file-Script 会出现一个对话框，任意输入一个名字，比如666 然后点击record 比如录制一个打开层面的scr，操作如…
阅读更多...
基于matlab的排队系统仿真

基于matlab的排队系统仿真

欢迎订阅《FPGA学习入门100例教程》、《MATLAB学习入门100例教程》 目录 一、理论基础 二、核心程序 三、测试结果 一、理论基础 排队系统是基本的离散事件系统&#xff0c;了解掌握离散事件系统是研究排队系统仿真不可或缺的前提。离散事件系统是指其状态变量只在某些离散时…
阅读更多...
SAP-FICO概览培训 的PPT 文档

SAP-FICO概览培训 的PPT 文档

目录 SAP ERP 系统功能模块概览 财务会计&#xff08;FI&#xff09;、管理会计&#xff08;CO&#xff09; 财务会计&#xff08;FI&#xff09;、管理会计&#xff08;CO&#xff09;需求出发点 FI 与CO灵活性对比 财务会计&#xff08;FI&#xff09; 财务业务一体化平台示…
阅读更多...
JSP概述

JSP概述

JSP JSP是Sun为了解决动态生成HTML文档的技术&#xff0c;通过Servlet输出简单html页面信息都非常不方便。如果要输出一个复杂页面的时候&#xff0c;就更加的困难&#xff0c;而且不利于页面的维护和调试。所以sun公司推出一种叫做jsp的动态页面技术来实现对页面的输出繁锁工…
阅读更多...
四维轻云地理空间数据协作管理平台的使用流程介绍

四维轻云地理空间数据协作管理平台的使用流程介绍

倾斜摄影模型和点云数据采集制作完成后&#xff0c;很多行业在进行数据查看管理和共享时具有很大的不便&#xff0c;通常需要依赖专业软件才能在电脑上进行浏览&#xff0c;倘若想将数据分享给他人查看&#xff0c;则需要进行大文件传输以及让对方安装专业软件。现如今&#xf…
阅读更多...
年薪百万的程序员，上网都在看什么？

年薪百万的程序员，上网都在看什么？

这个问题相信不少人都好奇&#xff0c;我揪出一位年薪百万的程序员老友&#xff0c;翻遍他的收藏夹&#xff0c;总结整理了6个网站&#xff0c;甩出来给大家。 有几个干货网站大家记得当场保存&#xff0c;要不然划过就忘了&#xff01;&#xff01; 国际各行业报告&#xff1…
阅读更多...
python 异步线程 实现 异步生产 同步通信

python 异步线程 实现 异步生产 同步通信

🍿*★,*:.☆欢迎您/$:*.★* 🍿 目录 背景 正文 总结 背景描述
阅读更多...
傅里叶变换的四种形式

傅里叶变换的四种形式

此文转自知乎的jinjin 傅里叶变换的四种形式 - 知乎 傅里叶变换是信号的一种描述方式&#xff0c;通过增加频域的视角&#xff0c;将时域复杂波形表示为简单的频率函数&#xff0c;获得时域不易发现的与信号有关的其他特征。 根据时间域信号x自变量的不同&#xff0c;可以将信号…
阅读更多...
sqli-labs/Less-45

sqli-labs/Less-45

这一关有没有报错信息 所以我们不能从报错信息中得知注入类型 我们只能通过登陆成功或者失败去辨别我们判断的注入类型正确与否 然后我们也不懂注入点 所以只能进行尝试了 如果两个参数在SQL语句中都被单引号包裹住 那么假设username为注入点输入如下 username admin# pass…
阅读更多...
【强大的数据迁移和恢复解决方案】KernelApps及其产品介绍

【强大的数据迁移和恢复解决方案】KernelApps及其产品介绍

KernelApps是 范围广泛的强大的数据迁移和 恢复解决方案 可以根据用户的需求提供多种采购方案 KernelApps提供 交换服务器、Office 365、 电子邮件迁移、Outlook等方面工具 其产品包括数据恢复、文件修复、 数据迁移、电子邮件迁移、 媒体恢复、云备份、云迁移等解决方…
阅读更多...
基于32单片机的多功能电子语音时钟

基于32单片机的多功能电子语音时钟

本设计是32单片机的多功能电子语音时钟设计&#xff0c;主要实现以下功能&#xff1a; 1.通过OLED显示时间&#xff0c;日期&#xff0c;温度&#xff0c;湿度等信息 2.到达整点时能够语音播报时间和温湿度 3.可通过按键使语音模块播报时间和温湿度 4.可通过按键调整当前时间&…
阅读更多...
Mac M1安装Centos8

Mac M1安装Centos8

M1 芯片 Centos8 百度网盘下载的慢&#xff0c;大家可以直接给我留言&#xff0c;我用奶牛快传分享给大家 链接: https://pan.baidu.com/s/1gT7TnBk5HnT27F82FGht7w?pwd1234 提取码: 1234 复制这段内容后打开百度网盘手机App&#xff0c;操作更方便哦 安装 第一次输入 r 依…
阅读更多...
推荐一款高效率前端开发神器，功能太强大了

推荐一款高效率前端开发神器，功能太强大了

当前端收到一张设计稿的时候&#xff0c;他们需要考虑非常多的问题。 而第一个摆在面前的问题就是 - 切图。作为连接设计师和前端的重要“纽带”&#xff0c;如果切图不准确&#xff0c;很容易导致最终的产品呈现与设计稿大相径庭。 随之而来的第二个问题就是 - 设计还原。页面…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023