Python机器学习笔记（七、深度学习-神经网络）

news2025/7/13 3:14:44

深度学习算法经过精确调整，只适用于特定的使用场景。先学习较为简单的深度学习算法，用于分类和回归的多层感知机（multilayer perceptron，MLP），它可以作为研究更复杂的深度学习方法的起点。MLP 也被称为（普通）前馈神经网络，也简称为神经网络。

1. 神经网络模型

MLP 被视为广义的线性模型，执行多层处理后得到结论。再回顾下线性回归的预测公式：

\dot{y}=w[0]*x[0]+w[1]*x[1]+...+w[p]*x[p]+b

ŷ 是输入特征 x[0] 到 x[p] 的加权求和，权重为学到的系数 w[0] 到 w[p]。将这个公式可视化：

import mglearn

s = mglearn.plots.plot_logistic_regression_graph()
s.render('output',view=True)

上图输出的是：Logistic 回归的可视化，其中输入特征和预测结果显示为结点，系数是结点之间的连线。图中，左边的每个结点代表一个输入特征，连线代表学到的系数，右边的结点代表输出， 是输入的加权求和。

在 MLP 中，多次重复这个计算加权求和的过程，首先计算代表中间过程的隐单元（hidden unit），然后再计算这些隐单元的加权求和并得到最终结果：

import matplotlib.pyplot as plt
import mglearn

s = mglearn.plots.plot_single_hidden_layer_graph()
s.render('output1',view=True)

输出的图形是：单隐层的多层感知机图示。这个模型需要学习更多的系数（也叫作权重）：在每个输入与每个隐单元（隐单元组成了隐层）之间有一个系数，在每个隐单元与输出之间也有一个系数。

从数学的角度看，计算一系列加权求和与只计算一个加权求和是完全相同的，因此，为了让这个模型真正比线性模型更为强大，我们还需要一个技巧。在计算完每个隐单元的加权求和之后，对结果再应用一个非线性函数——通常是校正非线性（rectifying nonlinearity， 也叫校正线性单元或 relu）或正切双曲线（tangens hyperbolicus，tanh）。然后将这个函数的结果用于加权求和，计算得到输出 ŷ。这两个函数的可视化效果我们下面代码实现。relu截断小于0的值，而 tanh 在输入值较小时接近 -1，在输入值较大时接近 +1。有了这两种非线性函数，神经网络可以学习比线性模型复杂得多的函数。

import numpy as np
import matplotlib.pyplot as plt

line = np.linspace(-3, 3, 100)
plt.plot(line, np.tanh(line), label="tanh")
plt.plot(line, np.maximum(line, 0), label="relu")
plt.legend(loc="best")
plt.xlabel("x")
plt.ylabel("relu(x), tanh(x)")
plt.show()

输出可视化图：

 上图是：双曲正切激活函数与校正线性激活函数

对于上上图所示的小型神经网络，计算回归问题的\hat{y}的完整公式如下（使用 tanh 非线性）：

其中，w 是输入 x 与隐层 h 之间的权重，v 是隐层 h 与输出\hat{y}之间的权重。权重 w 和 v 从数据中学习得到，x 是输入特征，\hat{y}是计算得到的输出，h 是计算的中间结果。需要设置的一个重要参数是隐层中的结点个数。对于非常小或非常简单的数据集，这个值可以小到 10；对于非常复杂的数据，这个值可以大到10 000。也可以添加多个隐层，如下面代码输出的可视化图所示：

import mglearn

s = mglearn.plots.plot_two_hidden_layer_graph()
s.render('output2', view=True)

 上图是，有两个隐层的多层感知机。这些由许多计算层组成的大型神经网络，正是术语“深度学习”的灵感来源。

2. 神经网络调参

我们将 MLPClassifier 应用到前面用过的 two_moons 数据集上，以此学习 MLP 的工作原理。

import matplotlib.pyplot as plt
import mglearn
from sklearn.model_selection import train_test_split
from sklearn.neural_network import MLPClassifier
from sklearn.datasets import make_moons

X, y = make_moons(n_samples=100, noise=0.25, random_state=3)
X_train, X_test, y_train, y_test = train_test_split(X, y, stratify=y, random_state=42)
mlp = MLPClassifier(solver='lbfgs', random_state=0).fit(X_train, y_train)
mglearn.plots.plot_2d_separator(mlp, X_train, fill=True, alpha=.3)
mglearn.discrete_scatter(X_train[:, 0], X_train[:, 1], y_train)
plt.xlabel("Feature 0")
plt.ylabel("Feature 1")
plt.show()

输出图形：

上图是：包含 100 个隐单元的神经网络在 two_moons 数据集上学到的决策边界。如图所见，神经网络学到的决策边界完全是非线性的，但相对平滑。我们用到了 solver='lbfgs'，这一点稍后再学习讨论。 默认情况下，MLP 使用 100 个隐结点，这对于这个小型数据集来说已经相当多了。我们可 以减少其数量（从而降低模型复杂度），从下面调整后的输出来看，结果仍然很好：

import matplotlib.pyplot as plt
import mglearn
from sklearn.model_selection import train_test_split
from sklearn.neural_network import MLPClassifier
from sklearn.datasets import make_moons

X, y = make_moons(n_samples=100, noise=0.25, random_state=3)
X_train, X_test, y_train, y_test = train_test_split(X, y, stratify=y, random_state=42)
mlp = MLPClassifier(solver='lbfgs', random_state=0, hidden_layer_sizes=[10])
mlp.fit(X_train, y_train)
mglearn.plots.plot_2d_separator(mlp, X_train, fill=True, alpha=.3)
mglearn.discrete_scatter(X_train[:, 0], X_train[:, 1], y_train)
plt.xlabel("Feature 0")
plt.ylabel("Feature 1")
plt.show()

下面使用2个隐层，每个包含10个单元并使用默认的非线性relu：

import matplotlib.pyplot as plt
import mglearn
from sklearn.model_selection import train_test_split
from sklearn.neural_network import MLPClassifier
from sklearn.datasets import make_moons

X, y = make_moons(n_samples=100, noise=0.25, random_state=3)
X_train, X_test, y_train, y_test = train_test_split(X, y, stratify=y, random_state=42)
# 使用2个隐层，每个包含10个单元
mlp = MLPClassifier(solver='lbfgs', random_state=0, hidden_layer_sizes=[10, 10])
mlp.fit(X_train, y_train)
mglearn.plots.plot_2d_separator(mlp, X_train, fill=True, alpha=.3)
mglearn.discrete_scatter(X_train[:, 0], X_train[:, 1], y_train)
plt.xlabel("Feature 0")
plt.ylabel("Feature 1")

plt.show()

输出图形如下：

下面使用2个隐层，每个包含10个单元，但使用tanh非线性：

import matplotlib.pyplot as plt
import mglearn
from sklearn.model_selection import train_test_split
from sklearn.neural_network import MLPClassifier
from sklearn.datasets import make_moons

X, y = make_moons(n_samples=100, noise=0.25, random_state=3)
X_train, X_test, y_train, y_test = train_test_split(X, y, stratify=y, random_state=42)
# 使用2个隐层，每个包含10个单元，使用tanh非线性
mlp = MLPClassifier(solver='lbfgs', activation='tanh', random_state=0, hidden_layer_sizes=[10, 10])
mlp.fit(X_train, y_train)
mglearn.plots.plot_2d_separator(mlp, X_train, fill=True, alpha=.3)
mglearn.discrete_scatter(X_train[:, 0], X_train[:, 1], y_train)
plt.xlabel("Feature 0")
plt.ylabel("Feature 1")

plt.show()

最后，我们还可以利用 L2 惩罚使权重趋向于 0，从而控制神经网络的复杂度，正如前面在岭回归和线性分类器中学习的那样。MLPClassifier 中调节 L2 惩罚的参数是 alpha（与线性回归模型中的相同），它的默认值很小（弱正则化）。

下面我们使用不同 alpha 值观察对 two_ moons 数据集的影响，用的是2个隐层的神经网络，每层包含 10 个或 100 个单元：

import matplotlib.pyplot as plt
import mglearn
from sklearn.model_selection import train_test_split
from sklearn.neural_network import MLPClassifier
from sklearn.datasets import make_moons

X, y = make_moons(n_samples=100, noise=0.25, random_state=3)
X_train, X_test, y_train, y_test = train_test_split(X, y, stratify=y, random_state=42)

fig, axes = plt.subplots(2, 4, figsize=(20, 8))
for axx, n_hidden_nodes in zip(axes, [10, 100]):
    for ax, alpha in zip(axx, [0.0001, 0.01, 0.1, 1]):
        mlp = MLPClassifier(solver='lbfgs', random_state=0,
        hidden_layer_sizes=[n_hidden_nodes, n_hidden_nodes], alpha=alpha)
        mlp.fit(X_train, y_train)
        mglearn.plots.plot_2d_separator(mlp, X_train, fill=True, alpha=.3, ax=ax)
        mglearn.discrete_scatter(X_train[:, 0], X_train[:, 1], y_train, ax=ax)
        ax.set_title("n_hidden=[{}, {}]\nalpha={:.4f}".format(n_hidden_nodes, n_hidden_nodes, alpha))

plt.show()

输出结果：

上图可视化：不同隐单元个数与 alpha 参数的不同设定下的决策函数

现在已经认识到了，控制神经网络复杂度的方法有很多种：隐层的个数、每个隐层中的单元个数与正则化（alpha）。其实还有很多，自己学习。

神经网络的一个重要性质是，在开始学习之前其权重是随机设置的，这种随机初始化会影响学到的模型。也就是说，即使使用完全相同的参数，如果随机种子不同的话，我们也可能得到非常不一样的模型。如果网络很大，并且复杂度选择合理的话，那么这应该不会对精度有太大影响，但应该记住这一点（特别是对于较小的网络）。下面我们使用相同的参数设置对模型进行学习：

import matplotlib.pyplot as plt
import mglearn
from sklearn.model_selection import train_test_split
from sklearn.neural_network import MLPClassifier
from sklearn.datasets import make_moons

X, y = make_moons(n_samples=100, noise=0.25, random_state=3)
X_train, X_test, y_train, y_test = train_test_split(X, y, stratify=y, random_state=42)

fig, axes = plt.subplots(2, 4, figsize=(20, 8))
for i, ax in enumerate(axes.ravel()):
    mlp = MLPClassifier(solver='lbfgs', random_state=i,
    hidden_layer_sizes=[100, 100])
    mlp.fit(X_train, y_train)
    mglearn.plots.plot_2d_separator(mlp, X_train, fill=True, alpha=.3, ax=ax)
    mglearn.discrete_scatter(X_train[:, 0], X_train[:, 1], y_train, ax=ax)
plt.show()

 

上图输出的是： 相同参数但不同随机初始化的情况下学到的决策函数。

为了在现实世界的数据上进一步理解神经网络，我们将 MLPClassifier 应用在乳腺癌数据集上。首先使用默认参数，先观察下数据特征：

from sklearn.datasets import load_breast_cancer

cancer = load_breast_cancer()
print("Cancer data per-feature maxima:\n{}".format(cancer.data.max(axis=0)))

输出：

Cancer data per-feature maxima:
[2.811e+01 3.928e+01 1.885e+02 2.501e+03 1.634e-01 3.454e-01 4.268e-01
 2.012e-01 3.040e-01 9.744e-02 2.873e+00 4.885e+00 2.198e+01 5.422e+02
 3.113e-02 1.354e-01 3.960e-01 5.279e-02 7.895e-02 2.984e-02 3.604e+01
 4.954e+01 2.512e+02 4.254e+03 2.226e-01 1.058e+00 1.252e+00 2.910e-01
 6.638e-01 2.075e-01]

使用MLP预测，看下训练集和测试集的精度：

from sklearn.model_selection import train_test_split
from sklearn.neural_network import MLPClassifier
from sklearn.datasets import load_breast_cancer

cancer = load_breast_cancer()
X_train, X_test, y_train, y_test = train_test_split(cancer.data, cancer.target, random_state=0)
mlp = MLPClassifier(random_state=42)
mlp.fit(X_train, y_train)
print("Accuracy on training set: {:.2f}".format(mlp.score(X_train, y_train)))
print("Accuracy on test set: {:.2f}".format(mlp.score(X_test, y_test)))

输出：

Accuracy on training set: 0.94
Accuracy on test set: 0.92

MLP 的精度相当好，但没有其他模型好。原因可能在于数据的缩放。神经网络也要求所有输入特征的变化范围相似，最理想的情况是均值为 0、方差为 1。我们必须对数据进行缩放以满足这些要求。这里我们人工完成缩放，后面再学习使用 StandardScaler 自动完成：

from sklearn.model_selection import train_test_split
from sklearn.neural_network import MLPClassifier
from sklearn.datasets import load_breast_cancer

cancer = load_breast_cancer()
X_train, X_test, y_train, y_test = train_test_split(cancer.data, cancer.target, random_state=0)

# 计算训练集中每个特征的平均值
mean_on_train = X_train.mean(axis=0)
# 计算训练集中每个特征的标准差
std_on_train = X_train.std(axis=0)
# 减去平均值，然后乘以标准差的倒数
# 如此运算之后，mean=0，std=1
X_train_scaled = (X_train - mean_on_train) / std_on_train
# 对测试集做相同的变换（使用训练集的平均值和标准差）
X_test_scaled = (X_test - mean_on_train) / std_on_train
mlp = MLPClassifier(random_state=0)
mlp.fit(X_train_scaled, y_train)
print("Accuracy on training set: {:.3f}".format(mlp.score(X_train_scaled, y_train)))
print("Accuracy on test set: {:.3f}".format(mlp.score(X_test_scaled, y_test)))

输出：

ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.
  warnings.warn(
Accuracy on training set: 0.991
Accuracy on test set: 0.965

缩放之后的结果要好得多。不过模型给出了一个警告，告诉我们已经达到最大迭代次数，应该增加迭代次数：

from sklearn.model_selection import train_test_split
from sklearn.neural_network import MLPClassifier
from sklearn.datasets import load_breast_cancer

cancer = load_breast_cancer()
X_train, X_test, y_train, y_test = train_test_split(cancer.data, cancer.target, random_state=0)

# 计算训练集中每个特征的平均值
mean_on_train = X_train.mean(axis=0)
# 计算训练集中每个特征的标准差
std_on_train = X_train.std(axis=0)
# 减去平均值，然后乘以标准差的倒数
# 如此运算之后，mean=0，std=1
X_train_scaled = (X_train - mean_on_train) / std_on_train
# 对测试集做相同的变换（使用训练集的平均值和标准差）
X_test_scaled = (X_test - mean_on_train) / std_on_train
mlp = MLPClassifier(max_iter=1000, random_state=0)
mlp.fit(X_train_scaled, y_train)
print("Accuracy on training set: {:.3f}".format(mlp.score(X_train_scaled, y_train)))
print("Accuracy on test set: {:.3f}".format(mlp.score(X_test_scaled, y_test)))

增加迭代次数后输出：

Accuracy on training set: 1.000
Accuracy on test set: 0.972

增加迭代次数训练集性能和泛化性能都有所提高。模型的表现相当不错。由于训练性能和测试性能之间仍有一些差距，所以我们可以尝试降低模型复杂度来得到更好的泛化性能。这里我们选择增大 alpha 参数（变化范围相当大，从 0.0001 到 1），以此向权重添加更强的正则化：

from sklearn.model_selection import train_test_split
from sklearn.neural_network import MLPClassifier
from sklearn.datasets import load_breast_cancer

cancer = load_breast_cancer()
X_train, X_test, y_train, y_test = train_test_split(cancer.data, cancer.target, random_state=0)

# 计算训练集中每个特征的平均值
mean_on_train = X_train.mean(axis=0)
# 计算训练集中每个特征的标准差
std_on_train = X_train.std(axis=0)
# 减去平均值，然后乘以标准差的倒数
# 如此运算之后，mean=0，std=1
X_train_scaled = (X_train - mean_on_train) / std_on_train
# 对测试集做相同的变换（使用训练集的平均值和标准差）
X_test_scaled = (X_test - mean_on_train) / std_on_train
mlp = MLPClassifier(max_iter=1000, alpha=1, random_state=0)
mlp.fit(X_train_scaled, y_train)
print("Accuracy on training set: {:.3f}".format(mlp.score(X_train_scaled, y_train)))
print("Accuracy on test set: {:.3f}".format(mlp.score(X_test_scaled, y_test)))

输出：

Accuracy on training set: 0.988
Accuracy on test set: 0.972

从结果来看，训练性能反而减低了，泛化性能没有变化。

虽然可以分析神经网络学到了什么，但这通常比分析线性模型或基于树的模型更为复杂。 要想观察模型学到了什么，一种方法是查看模型的权重。可以在 scikit-learn 示例库中查看这样的一个示例（http://scikit-learn.org/stable/auto_examples/neural_networks/plot_mnist_ filters.html）。对于乳腺癌数据集，这可能有点难以理解。下面代码输出的图形显示了连接输入和第一个隐层之间的权重。图中的行对应 30 个输入特征，列对应 100 个隐单元。 浅色代表较大的正值，而深色代表负值：

import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.neural_network import MLPClassifier
from sklearn.datasets import load_breast_cancer

cancer = load_breast_cancer()
X_train, X_test, y_train, y_test = train_test_split(cancer.data, cancer.target, random_state=0)

# 计算训练集中每个特征的平均值
mean_on_train = X_train.mean(axis=0)
# 计算训练集中每个特征的标准差
std_on_train = X_train.std(axis=0)
# 减去平均值，然后乘以标准差的倒数
# 如此运算之后，mean=0，std=1
X_train_scaled = (X_train - mean_on_train) / std_on_train
# 对测试集做相同的变换（使用训练集的平均值和标准差）
X_test_scaled = (X_test - mean_on_train) / std_on_train
mlp = MLPClassifier(max_iter=1000, alpha=1, random_state=0)
mlp.fit(X_train_scaled, y_train)
plt.figure(figsize=(20, 5))
plt.imshow(mlp.coefs_[0], interpolation='none', cmap='viridis')
plt.yticks(range(30), cancer.feature_names)
plt.xlabel("Columns in weight matrix")
plt.ylabel("Input feature")
plt.colorbar()
plt.show()

输出：

上图是：神经网络在乳腺癌数据集上学到的第一个隐层权重的热图。

我们可以推断，如果某个特征对所有隐单元的权重都很小，那么这个特征对模型来说就 “不太重要”。可以看到，与其他特征相比，“mean smoothness” “mean compactness”以及 “smoothness error”和“fractal dimension error”之间的特征的权重都相对较小。这可能说明这些特征不太重要，也可能是我们没有用神经网络可以使用的方式来表示这些特征。我们还可以将连接隐层和输出层的权重可视化，但它们更加难以解释。

虽然 MLPClassifier 和 MLPRegressor 为最常见的神经网络架构提供了易于使用的接口，但它们只包含神经网络潜在应用的一部分。如果有兴趣使用更灵活或更大的模型，建议你看一下除了 scikit-learn 之外的深度学习库。对于 Python 用户来说，最为完善的是 keras、lasagna 和 tensor-flow。lasagna 是基于 theano 库构建的，而 keras 既可以用 tensor-flow 也可以用 theano。这些库提供了更为灵活的接口，可以用来构建神经网络并跟踪深度学习研究的快速发展。所有流行的深度学习库也都允许使用高性能的图形处理单元（GPU），而 scikit-learn 不支持 GPU。使用 GPU 可以将计算速度加快 10 到 100 倍，GPU 对于将深度学习方法应用到大型数据集上至关重要。

3. 优点、缺点和参数

神经网络的主要优点之一是能够获取大量数据中包含的信息，并构建无比复杂的模型。给定足够的计算时间和数据，并且仔细调节参数，神经网络通常可以打败其他机器学习算法（无论是分类任务还是回归任务）。 神经网络（特别是功能强大的大型神经网络）通常需要很长的训练时间。它还需要仔细地预处理数据。与 SVM 类似， 神经网络在“均匀”数据上的性能最好，其中“均匀”是指所有特征都具有相似的含义。 如果数据包含不同种类的特征，那么基于树的模型可能表现得更好。神经网络调参本身也是一门艺术。调节神经网络模型和训练模型的方法有很多种，需要再深入学习。

估计神经网络的复杂度。最重要的参数是层数和每层的隐单元个数。应该首先设置 1 个 或 2 个隐层，然后可以逐步增加。每个隐层的结点个数通常与输入特征个数接近，但在几千个结点时很少会多于特征个数。

在考虑神经网络的模型复杂度时，一个有用的度量是学到的权重（或系数）的个数。如果有一个包含 100 个特征的二分类数据集，模型有 100 个隐单元，那么输入层和第一个隐层之间就有 100 * 100 = 10 000 个权重。在隐层和输出层之间还有 100 * 1 = 100 个权重，总共约 10 100 个权重。如果添加含有 100 个隐单元的第二个隐层，那么在第一个隐层和第二个隐层之间又有 100 * 100 = 10 000 个权重，总数变为约 20 100 个权重。如果使用包含 1000 个隐单元的单隐层，那么在输入层和隐层之间需要学习 100 * 1000 = 100 000 个权重， 隐层到输出层之间需要学习 1000 * 1 = 1000 个权重，总共 101 000 个权重。如果再添加第二个隐层，就会增加 1000 * 1000 = 1 000 000 个权重，总数变为巨大的 1 101 000 个权重， 这比含有 2 个隐层、每层 100 个单元的模型要大 50 倍。

神经网络调参的常用方法是，首先创建一个大到足以过拟合的网络，确保这个网络可以对任务进行学习。知道训练数据可以被学习之后，要么缩小网络，要么增大 alpha 来增强正则化，这可以提高泛化性能。

在上面的学习中，主要关注模型的定义：层数、每层的结点个数、正则化和非线性。这些内容定义了我们想要学习的模型。还有一个问题是，如何学习模型或用来学习参数的算法，这一点由 solver 参数设定。solver 有两个好用的选项。默认选项是 'adam'，在大多数情况下效果都很好，但对数据的缩放相当敏感（因此，始终将数据缩放为均值为 0、方差为 1 是很重要的）。另一个选项是 'lbfgs'，其鲁棒性相当好，但在大型模型或大型数据集上的时间会比较长。还有更高级的 'sgd' 选项，许多深度学习研究人员都会用到。'sgd' 选项还有许多其他参数需要调节，以便获得最佳结果。可以学习官方用户指南文档。当刚开始学习使用 MLP 时，建议使用 'adam' 和 'lbfgs'。

 

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

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

相关文章

Kylin麒麟操作系统 | Nginx服务部署

Kylin麒麟操作系统 | Nginx服务部署

目录 一、理论储备1. Nginx概述2. Nginx与Apache的区别3. Nginx的服务配置 二、任务实施任务1 Nginx的编译安装1. Server配置2. 客户端测试 任务2 Nginx反向代理1. Server1配置2. Server2配置3. 客户端测试 一、理论储备 1. Nginx概述 Nginx是一个轻量级的web服务器&#xff…
阅读更多...
【html网页页面012】html+css制作品牌主题宏宝莱网页含视频、留言表单（7页面附效果及源码）

【html网页页面012】html+css制作品牌主题宏宝莱网页含视频、留言表单（7页面附效果及源码）

品牌主题宏宝莱网页制作 🥤1、写在前面🍧2、涉及知识🌳3、网页效果完整效果(7页)：代码目录结构：page1、首页page2、衍生品page3、包装设计page4、视频介绍page5、留言板page6、联系我们page7、详情页（三层页…
阅读更多...
机器学习之交叉熵

机器学习之交叉熵

交叉熵（Cross-Entropy）是机器学习中用于衡量预测分布与真实分布之间差异的一种损失函数，特别是在分类任务中非常常见。它源于信息论，反映了两个概率分布之间的距离。 交叉熵的数学定义 对于分类任务，假设我们有&#…
阅读更多...
0001.基于springmvc简易酒店管理系统后台

0001.基于springmvc简易酒店管理系统后台

一.系统架构 springmvcjsplayuimysql 二.功能特性 简单易学习，虽然版本比较老但是部署方便，tomcat环境即可启用；代码简洁，前后端代码提供可统一学习；祝愿您能成尽快为一位合格的程序员，愿世界没有BUG; …
阅读更多...
无限次使用 cursor pro

无限次使用 cursor pro

github地址 cursor-vip 使用方式 在 MacOS/Linux 中，请打开终端； 在 Windows 中，请打开 Git Bash。 然后执行以下命令来安装： 部分电脑可能会误报毒，需要关闭杀毒软件/电脑管家/安全防护再进行 方式1：通过…
阅读更多...
AI 语言模型产业的投资困境与发展困境分析

AI 语言模型产业的投资困境与发展困境分析

https://benn.substack.com/p/do-ai-companies-work 巨额投资与成本困境 大型语言模型（LLM）的开发成本惊人。根据报道，OpenAI 正在筹集 65 亿美元资金，每年约消耗 70 亿美元用于研究、开发新的 AI 服务和扩充团队。Anthropic 预计…
阅读更多...
tryhackme——Pre Security(安检前)-Offensive Security（进攻性安全）

tryhackme——Pre Security(安检前)-Offensive Security（进攻性安全）

这里我用的edge的插件闪击翻译。这里我英语不好，所以用这个可以顺便学习下英语。 任务一：What is Offensive Security?（什么是进攻性安全?） 很简单啊，通过阅读，知道以下哪个选项更能代表您模拟黑客操作…
阅读更多...
[论文阅读] |智能体长期记忆与反思

[论文阅读] |智能体长期记忆与反思

写在前面：10月份的时候，联发科天玑9400发布，搭载这款旗舰 5G 智能体 AI 芯片的荣耀MagicOS9.0实现了一句话让手机自动操作美团点咖啡。很快商场实体店里便能看到很多品牌手机已经升级为智能体语音助手。下一步，这些智能体或许便能…
阅读更多...
CQRS Design Pattern in Microservices - CQRS模式

CQRS Design Pattern in Microservices - CQRS模式

原文链接 CQRS Design Pattern in Microservices - GeeksforGeeks 【文章看起来像是AI写的。。。 😂😂😂】 简介 实现步骤 1，识别有界上下文：（Identify Bounded Contexts:） 2，命…
阅读更多...
《拉依达的嵌入式\驱动面试宝典》—C/CPP基础篇(二)

《拉依达的嵌入式\驱动面试宝典》—C/CPP基础篇(二)

《拉依达的嵌入式\驱动面试宝典》—C/CPP基础篇(二) 你好，我是拉依达。 感谢所有阅读关注我的同学支持，目前博客累计阅读 27w，关注1.5w人。其中博客《最全Linux驱动开发全流程详细解析（持续更新）-CSDN博客》已经是 Linux驱动 相关内容搜索的推荐首位，感谢大家支持。 《拉…
阅读更多...
RPC远程服务调用详解和gRPC简介

RPC远程服务调用详解和gRPC简介

RPC (Remote Procedure Call)是远程过程调用，比如说现在有两台服务器A, B，一个在A服务器上的应用想要调用B服务器上的应用提供的某个，由于不在两个方法不在一个内存空间，不能直接调用，需要通过网络表达调用的语义和传达…
阅读更多...
计算机网络知识点全梳理（三.TCP知识点总结）

计算机网络知识点全梳理（三.TCP知识点总结）

目录 TCP基本概念 为什么需要TCP 什么是TCP 什么是TCP链接 如何唯一确定一个 TCP 连接 TCP三次握手 握手流程 为什么是三次握手，而不是两次、四次 为什么客户端和服务端的初始序列号 ISN 不同 既然 IP 层会分片，为什么 TCP 层还需要 MSS TCP四…
阅读更多...
PDFMathTranslate,PDF多语言翻译,批量处理,学术论文,双语对照（WIN/MAC）

PDFMathTranslate,PDF多语言翻译,批量处理,学术论文,双语对照（WIN/MAC）

分享一个非常实用的PDF文档翻译项目——PDFMathTranslate。作为一个经常逛GitHub的开发者，我总喜欢翻看各种项目附带的论文，虽然大多时候是瞎研究，但却乐在其中。该项目能够完美保留公式、图表、目录和注释，对于需要阅读外文文献的…
阅读更多...
前端成长之路：CSS元素显示模式

前端成长之路：CSS元素显示模式

元素显示模式 网页中的标签非常的多，在不同的地方会使用到不同类型的标签，了解这些标签的特点可以更好的布局我们的网页。 元素显示模式就是元素（标签）按照什么方式进行显示，比如：div标签会自己独占一行&a…
阅读更多...
如何在 Ubuntu 22.04 上使用 vnStat 监控网络流量

如何在 Ubuntu 22.04 上使用 vnStat 监控网络流量

简介 vnStat是一个免费的、开源的、基于控制台的Linux操作系统网络流量监控工具。通过vnStat，你可以在不同的时间段监控网络统计数据。它简单、轻量级，并且消耗的系统资源很小。vnStat允许你按小时、日、月、周和日生成网络流量数据。本教程将向你展示如…
阅读更多...
解决pip下载慢

解决pip下载慢

使用pip下载大量安装包，下载速度太慢了 1、问题现象 pip安装包速度太慢 2、解决方案 配置国内源 vi /root/.config/pip/pip.conf[global] timeout 6000 index-url https://mirrors.aliyun.com/pypi/simple/ trusted-host mirrors.aliyun.com
阅读更多...
RabbitMQ中的Publish-Subscribe模式

RabbitMQ中的Publish-Subscribe模式

在现代分布式系统中，消息队列（Message Queue）是实现异步通信和解耦系统的关键组件。RabbitMQ 是一个功能强大且广泛使用的开源消息代理，支持多种消息传递模式。其中，Publish/Subscribe（发布/订阅&#xff0…
阅读更多...
专业140+总分410+浙江大学842信号系统与数字电路考研经验浙大电子信息与通信工程，真题，大纲，参考书。

专业140+总分410+浙江大学842信号系统与数字电路考研经验浙大电子信息与通信工程，真题，大纲，参考书。

考研落幕，本人本中游211，如愿以偿考入浙江大学，专业课842信号系统与数字电路140，总分410，和考前多次模考预期差距不大（建议大家平时做好定期模考测试，直接从实战分数中，找到复习的脉…
阅读更多...
Unity类银河战士恶魔城学习总结（P178 Archer s arrow 弓箭手的箭）

Unity类银河战士恶魔城学习总结（P178 Archer s arrow 弓箭手的箭）

【Unity教程】从0编程制作类银河恶魔城游戏_哔哩哔哩_bilibili 教程源地址：https://www.udemy.com/course/2d-rpg-alexdev/ 本章节制作了一个弓箭手的箭 Arrow_Controller.cs 1.OnTriggerEnter2D方法 功能：检测箭矢与其他对象的碰撞。逻辑&#xff1…
阅读更多...
后端接受前端传递数组进行批量删除

后端接受前端传递数组进行批量删除

问题描述：当我们需要做批量删除功能的时候，我们循环单次删除的接口也能进行批量删除，但要删除100条数据就要调用100次接口，或者执行100次sql，这样系统开销是比较大的，那么我们直接采用接收的数组格式数据sq…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023