拓端tecdat|python在Keras中使用LSTM解决序列问题
原文链接：http://tecdat.cn/?p=8461
原文出处：拓端数据部落公众号
时间序列预测是指我们必须根据时间相关的输入来预测结果的问题类型。时间序列数据的典型示例是股市数据，其中股价随时间变化。
递归神经网络（RNN）已被证明可以有效解决序列问题。特别地，作为RNN的变体的长期短期记忆网络（LSTM）当前正在各种领域中用于解决序列问题。
相关视频：LSTM神经网络架构和工作原理及其在Python中的预测应用
LSTM神经网络架构和原理及其在Python中的预测应用
序列问题的类型
序列问题可以大致分为以下几类：
- 一对一：其中有一个输入和一个输出。一对一序列问题的典型示例是您拥有一幅图像并且想要为该图像预测单个标签的情况。
- 多对一：在多对一序列问题中，我们将数据序列作为输入，并且必须预测单个输出。文本分类是多对一序列问题的主要示例，其中我们有一个单词输入序列，并且我们希望预测一个输出标签。
- 一对多：在一对多序列问题中，我们只有一个输入和一个输出序列。典型示例是图像及其相应的说明。
- 多对多：多对多序列问题涉及序列输入和序列输出。例如，将7天的股票价格作为输入，并将接下来7天的股票价格作为输出。聊天机器人还是多对多序列问题的一个示例，其中文本序列是输入，而另一个文本序列是输出。
在本文中，我们将了解如何使用LSTM及其不同的变体来解决一对一和多对一的序列问题。
阅读本文后，您将能够基于历史数据解决诸如股价预测，天气预报等问题。由于文本也是单词序列，因此本文中获得的知识也可以用于解决自然语言处理任务，例如文本分类，语言生成等。
一对一序列问题
正如我之前所说，在一对一序列问题中，只有一个输入和一个输出。在本节中，我们将看到两种类型的序列问题。首先，我们将了解如何使用单个特征解决一对一的序列问题，然后我们将了解如何使用多个特征解决一对一的序列问题。
单一特征的一对一序列问题
在本节中，我们将看到如何解决每个时间步都有一个特征的一对一序列问题。
首先，我们导入将在本文中使用的必需库：
from numpy import array
from keras.preprocessing.text import one_hot
from keras.preprocessing.sequence import pad_sequences
from keras.models import Sequential
from keras.layers.core import Activation, Dropout, Dense
from keras.layers import Flatten, LSTM
from keras.layers import GlobalMaxPooling1D
from keras.models import Model
from keras.layers.embeddings import Embedding
from sklearn.model_selection import train_test_split
from keras.preprocessing.text import Tokenizer
from keras.layers import Input
from keras.layers.merge import Concatenate
from keras.layers import Bidirectionalimport pandas as pd
import numpy as np
import reimport matplotlib.pyplot as plt
创建数据集
在下一步中，我们将准备本节要使用的数据集。
X = list()
Y = list()
X = [x+1 for x in range(20)]
Y = [y * 15 for y in X]print(X)
print(Y)
在上面的脚本中，我们创建20个输入和20个输出。每个输入都包含一个时间步，而该时间步又包含一个特征。每个输出值是相应输入值的15倍。如果运行上面的脚本，应该看到如下所示的输入和输出值：
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
[15, 30, 45, 60, 75, 90, 105, 120, 135, 150, 165, 180, 195, 210, 225, 240, 255, 270, 285, 300]
LSTM层的输入应为3D形状，即（样本，时间步长，特征）。样本是输入数据中样本的数量。输入中有20个样本。时间步长是每个样本的时间步长数。我们有1个时间步。最后，特征对应于每个时间步的特征数量。每个时间步都有一个特征。
X = array(X).reshape(20, 1, 1)
通过简单LSTM解决方案
现在，我们可以创建具有一个LSTM层的简单LSTM模型。
model = Sequential()
model.add(LSTM(50, activation='relu', input_shape=(1, 1)))
model.add(Dense(1))
model.compile(optimizer='adam', loss='mse')
print(model.summary())
在上面的脚本中，我们创建了一个LSTM模型，该模型具有一层包含50个神经元和relu激活函数的LSTM层。您可以看到输入形状为（1,1），因为我们的数据具有一个特征的时间步长。
Layer (type) Output Shape Param #
=================================================================
lstm_16 (LSTM) (None, 50) 10400
_________________________________________________________________
dense_15 (Dense) (None, 1) 51
=================================================================
Total params: 10,451
Trainable params: 10,451
Non-trainable params: 0
现在让我们训练模型：
model.fit(X, Y, epochs=2000, validation_split=0.2, batch_size=5)
我们为2000个时期训练模型，批大小为5。您可以选择任何数字。训练模型后，我们可以对新实例进行预测。
假设我们要预测输入为30的输出。实际输出应为30 x 15 =450。 首先，我们需要按照LSTM的要求将测试数据转换为正确的形状，即3D形状。以下 预测数字30的输出：
print(test_output)
我得到的输出值437.86略小于450。
通过堆叠LSTM解决方案
现在让我们创建一个堆叠的LSTM，看看是否可以获得更好的结果。数据集将保持不变，模型将被更改。看下面的脚本：
print(model.summary())
在上面的模型中，我们有两个LSTM层。注意，第一个LSTM层的参数return_sequences设置为True。当返回序列设置True为时，每个神经元隐藏状态的输出将用作下一个LSTM层的输入。以上模型的摘要如下：
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
lstm_33 (LSTM) (None, 1, 50) 10400
_________________________________________________________________
lstm_34 (LSTM) (None, 50) 20200
_________________________________________________________________
dense_24 (Dense) (None, 1) 51
=================================================================
Total params: 30,651
Trainable params: 30,651
Non-trainable params: 0
________________________
接下来，我们需要训练我们的模型，如以下脚本所示：
print(test_output)
我得到的输出为459.85，好于我们通过单个LSTM层获得的数字437。
具有多个特征的一对一序列问题
在最后一节中，每个输入样本都有一个时间步，其中每个时间步都有一个特征。在本节中，我们将看到如何解决输入时间步长具有多个特征的一对一序列问题。
创建数据集
首先创建数据集。看下面的脚本：
nums = 25X1 = list()
X2 = list()
X = list()
Y = list()print(X1)
print(X2)
print(Y)
在上面的脚本中，我们创建三个列表：X1，X2，和Y。每个列表包含25个元素，这意味着总样本大小为25。最后，Y包含输出。X1，X2以及Y列表已输出在下面：
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50]
[3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48, 51, 54, 57, 60, 63, 66, 69, 72, 75]
[6, 24, 54, 96, 150, 216, 294, 384, 486, 600, 726, 864, 1014, 1176, 1350, 1536, 1734, 1944, 2166, 2400, 2646, 2904, 3174, 3456, 3750]
输出列表中的每个元素基本上都是X1和 X2列表中相应元素的乘积。例如，输出列表中的第二个元素是24，这是列表中的第二个元素（X1即4）和列表中的第二个元素（X2即6 ）的乘积。
输入将由X1和X2列表的组合组成，其中每个列表将表示为一列。以下脚本创建最终输入：
X = np.column_stack((X1, X2))
print(X)
这是输出：
[[ 2 3][ 4 6][ 6 9][ 8 12][10 15][12 18][14 21][16 24][18 27][20 30][22 33][24 36][26 39][28 42][30 45][32 48][34 51][36 54][38 57][40 60][42 63][44 66][46 69][48 72][50 75]]
可以看到它包含两列，即每个输入两个特征。如前所述，我们需要将输入转换为3维形状。我们的输入有25个样本，其中每个样本包含1个时间步，每个时间步包含2个特征。以下脚本可重塑输入。
X = array(X).reshape(25, 1, 2)
通过简单LSTM解决方案
我们现在准备训练我们的LSTM模型。让我们首先像上一节中那样开发一个LSTM模型：
model = Sequential()
model.add(LSTM(80, activation='relu', input_shape=(1, 2)))print(model.summary())
在这里，我们的LSTM层包含80个神经元。我们有两个神经层，其中第一层包含10个神经元，第二个密集层（也作为输出层）包含1个神经元。该模型的摘要如下：
Layer (type) Output Shape Param #
=================================================================
lstm_38 (LSTM) (None, 80) 26560
_________________________________________________________________
dense_29 (Dense) (None, 10) 810
_________________________________________________________________
dense_30 (Dense) (None, 1) 11
=================================================================
Total params: 27,381
Trainable params: 27,381
Non-trainable params: 0
_________________________________________________________________
None
以下脚本训练模型：
model.fit(X, Y, epochs=2000, validation_split=0.2, batch_size=5)
让我们在一个新的数据点上测试我们训练有素的模型。我们的数据点将具有两个特征，即（55,80）实际输出应为55 x 80 =4400。让我们看看我们的算法预测了什么。执行以下脚本：
print(test_output)
我的输出为3263.44，与实际输出相差甚远。
通过堆叠LSTM解决方案
现在，让我们创建一个具有多个LSTM和密集层的更复杂的LSTM，看看是否可以改善我们的结果：
model = Sequential()print(model.summary())
模型摘要如下：
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
lstm_53 (LSTM) (None, 1, 200) 162400
_________________________________________________________________
lstm_54 (LSTM) (None, 1, 100) 120400
_________________________________________________________________
lstm_55 (LSTM) (None, 1, 50) 30200
_________________________________________________________________
lstm_56 (LSTM) (None, 25) 7600
_________________________________________________________________
dense_43 (Dense) (None, 20) 520
_________________________________________________________________
dense_44 (Dense) (None, 10) 210
_________________________________________________________________
dense_45 (Dense) (None, 1) 11
=================================================================
Total params: 321,341
Trainable params: 321,341
Non-trainable params: 0
下一步是训练我们的模型，并在测试数据点（即（55,80））上对其进行测试。
为了提高准确性，我们将减小批量大小，并且由于我们的模型更加复杂，现在我们还可以减少时期数。以下脚本训练LSTM模型并在测试数据点上进行预测。
print(test_output)
在输出中，我得到的值3705.33仍小于4400，但比以前使用单个LSTM层获得的3263.44的值好得多。您可以将LSTM层，密集层，批处理大小和时期数进行不同的组合，以查看是否获得更好的结果。
多对一序列问题
在前面的部分中，我们看到了如何使用LSTM解决一对一的序列问题。在一对一序列问题中，每个样本都包含一个或多个特征的单个时间步长。具有单个时间步长的数据实际上不能视为序列数据。事实证明，密集连接的神经网络在单个时间步长数据下表现更好。
实际序列数据包含多个时间步长，例如过去7天的股票市场价格，包含多个单词的句子等等。
在本节中，我们将看到如何解决多对一序列问题。在多对一序列问题中，每个输入样本具有多个时间步长，但是输出由单个元素组成。输入中的每个时间步都可以具有一个或多个特征。我们将从具有一个特征的多对一序列问题开始，然后我们将了解如何解决输入时间步长具有多个特征的多对一问题。
具有单个特征的多对一序列问题
首先创建数据集。我们的数据集将包含15个样本。每个样本将具有3个时间步长，其中每个时间步长将包含一个单一特征，即一个数字。每个样本的输出将是三个时间步长中每个步长的数字之和。例如，如果我们的样本包含序列4,5,6，则输出将为4 + 5 + 6 = 10。
创建数据集
首先创建一个从1到45的整数列表。由于我们要在数据集中获得15个样本，因此我们将对包含前45个整数的整数列表进行整理。
X = np.array([x+1 for x in range(45)])
print(X)
在输出中，您应该看到前45个整数：
[ 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 2425 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45]
我们可以使用以下函数将其整理为样本数，时间步长和特征：
X = X.reshape(15,3,1)
print(X)
上面的脚本将列表X转换为带有15个样本，3个时间步长和1个特征的3维形状。上面的脚本还输出了调整后的数据。
[[[ 1][ 2][ 3]][[ 4][ 5][ 6]][[ 7][ 8][ 9]][[10][11][12]][[13][14][15]][[16][17][18]][[19][20][21]][[22][23][24]][[25][26][27]][[28][29][30]][[31][32][33]][[34][35][36]][[37][38][39]][[40][41][42]][[43][44][45]]]
我们已经将输入数据转换为正确的格式，现在让我们创建输出向量。正如我之前所说，输出中的每个元素将等于相应输入样本中时间步长中的值之和。以下脚本创建输出向量：
Y = list()
for x in X:print(Y)
输出数组Y如下所示：
[ 6 15 24 33 42 51 60 69 78 87 96 105 114 123 132]
通过简单LSTM解决方案
现在让我们用一个LSTM层创建模型。
model = Sequential()model.compile(optimizer='adam', loss='mse')
以下脚本训练了我们的模型：
history = model.fit(...)
训练完模型后，我们就可以使用它对测试数据点进行预测。让我们预测数字序列50、51、52的输出。实际输出应为50 + 51 + 52 =153。以下脚本将我们的测试点转换为3维形状，然后预测输出：
print(test_output)
我的输出为145.96，比实际输出值153少7点。
通过堆叠LSTM解决方案
现在，让我们创建一个具有多层的复杂LSTM模型，看看是否可以获得更好的结果。执行以下脚本来创建和训练具有多个LSTM和密集层的复杂模型：
model = Sequential()model.compile(optimizer='adam', loss='mse')history = model.fit(X, Y, epochs=1000, validation_split=0.2, verbose=1)
现在让我们在测试序列（即50、51、52）上测试模型：
print(test_output)
我在这里得到的答案是155.37，比我们之前得到的145.96更好。在这种情况下，我们与153的实际差值只有2分。
通过双向LSTM解决方案
双向LSTM是一种LSTM，可以从正向和反向两个方向的输入序列中学习。最终的序列解释是向前和向后学习遍历。让我们看看使用双向LSTM是否可以获得更好的结果。
以下脚本创建了一个双向LSTM模型，该模型具有一个双向层和一个作为模型输出的密集层。
from keras.layers import Bidirectionalmodel.compile(optimizer='adam', loss='mse')
以下脚本训练模型并根据测试序列50、51和52进行预测。
print(test_output)
我得到的结果是152.26，仅比实际结果少一小部分。因此，我们可以得出结论，对于我们的数据集，具有单层的双向LSTM的性能优于单层和堆叠的单向LSTM。
具有多个特征的多对一序列问题
在多对一序列问题中，我们有一个输入，其中每个时间步均包含多个特征。输出可以是一个值或多个值，在输入时间步长中每个特征一个。我们将在本节中介绍这两种情况。
创建数据集
我们的数据集将包含15个样本。每个样本将包含3个时间步。
让我们创建两个列表。一个将包含3的倍数，直到135，即总共45个元素。第二个列表将包含5的倍数，从1到225。第二个列表也将总共包含45个元素。以下脚本创建这两个列表：
X1 = np.array([x+3 for x in range(0, 135, 3)])print(X2)
您可以在以下输出中看到列表的内容：
[ 3 6 9 12 15 18 21 24 27 30 33 36 39 42 45 48 51 5457 60 63 66 69 72 75 78 81 84 87 90 93 96 99 102 105 108111 114 117 120 123 126 129 132 135]
[ 5 10 15 20 25 30 35 40 45 50 55 60 65 70 75 80 85 9095 100 105 110 115 120 125 130 135 140 145 150 155 160 165 170 175 180185 190 195 200 205 210 215 220 225]
上面的每个列表代表时间样本中的一个特征。可以通过合并两个列表来创建聚合数据集，如下所示：
X = np.column_stack((X1, X2))
print(X)
输出显示汇总的数据集：
[ 6 10][ 9 15][ 12 20][ 15 25][ 18 30][ 21 35][ 24 40][ 27 45][ 30 50][ 33 55][ 36 60][ 39 65][ 42 70][ 45 75][ 48 80][ 51 85][ 54 90][ 57 95][ 60 100][ 63 105][ 66 110][ 69 115][ 72 120][ 75 125][ 78 130][ 81 135][ 84 140][ 87 145][ 90 150][ 93 155][ 96 160][ 99 165][102 170][105 175][108 180][111 185][114 190][117 195][120 200][123 205][126 210][129 215][132 220][135 225]]
我们需要将数据重塑为三个维度，以便LSTM可以使用它。我们的数据集有45行，两列。我们将数据集整理为15个样本，3个时间步长和两个特征。
X = array(X).reshape(15, 3, 2)
print(X)
您可以在以下输出中看到15个样本：
[[[ 3 5][ 6 10][ 9 15]][[ 12 20][ 15 25][ 18 30]][[ 21 35][ 24 40][ 27 45]][[ 30 50][ 33 55][ 36 60]][[ 39 65][ 42 70][ 45 75]][[ 48 80][ 51 85][ 54 90]][[ 57 95][ 60 100][ 63 105]][[ 66 110][ 69 115][ 72 120]][[ 75 125][ 78 130][ 81 135]][[ 84 140][ 87 145][ 90 150]][[ 93 155][ 96 160][ 99 165]][[102 170][105 175][108 180]][[111 185][114 190][117 195]][[120 200][123 205][126 210]][[129 215][132 220][135 225]]]
输出还将具有对应于15个输入样本的15个值。输出中的每个值将是每个输入样本的第三时间步中两个特征值的总和。例如，第一个样本的第三时间步长具有特征9和15，因此输出将为24。类似地，第二个样本的第三时间步长中的两个特征值分别为18和30；第二个时间步长中的两个特征值分别为18和30。相应的输出将是48，依此类推。
以下脚本创建并显示输出向量：
[ 24 48 72 96 120 144 168 192 216 240 264 288 312 336 360]
现在让我们通过简单的，堆叠的和双向的LSTM解决多对一序列问题。
通过简单LSTM解决方案
model = Sequential()history = model.fit(X, Y, epochs=1000, validation_split=0.2, verbose=1)
模型经过训练。我们将创建一个测试数据点，然后将使用我们的模型对测试点进行预测。
print(test_output)
输入的第三时间步长的两个特征的总和为14 + 61 =75。我们的带有一个LSTM层的模型预测为73.41，这非常接近。
通过堆叠LSTM解决方案
以下脚本训练堆叠的LSTM并在测试点上进行预测：
model = Sequential()
model.add(LSTM(200, activation='relu', return_sequences=True, input_shape=(3, 2)))print(test_output)
我收到的输出为71.56，比简单的LSTM差。似乎我们堆叠的LSTM过度拟合。
通过双向LSTM解决方案
这是简单双向LSTM的训练脚本，以及用于对测试数据点进行预测的代码：
from keras.layers import Bidirectionalmodel = Sequential()print(test_output)
输出为76.82，非常接近75。同样，双向LSTM似乎胜过其余算法。
到目前为止，我们已经基于来自不同时间步长的多个要素值预测了单个值。在多对一序列的另一种情况下，您希望在时间步长中为每个特征预测一个值。例如，我们在本节中使用的数据集具有三个时间步，每个时间步具有两个特征。我们可能希望预测每个特征系列的单独价值。下面的示例很清楚，假设我们有以下输入：
[[[ 3 5][ 6 10][ 9 15]]
在输出中，我们需要一个具有两个特征的时间步长，如下所示：
[12, 20]
您可以看到输出中的第一个值是第一个序列的延续，第二个值是第二个序列的延续。我们可以通过简单地将输出密集层中神经元的数量更改为我们想要的输出中的特征值的数量来解决此类问题。但是，首先我们需要更新输出向量Y。输入向量将保持不变：
Y = list()
for x in X:print(Y)
上面的脚本创建一个更新的输出向量并将其输出，输出如下所示：
[[ 12 20][ 21 35][ 30 50][ 39 65][ 48 80][ 57 95][ 66 110][ 75 125][ 84 140][ 93 155][102 170][111 185][120 200][129 215][138 230]]
现在，让我们在数据集上训练我们的简单，堆叠和双向LSTM网络。以下脚本训练了一个简单的LSTM：
model = Sequential()
...
history = model.fit(X, Y, epochs=1000, validation_split=0.2, verbose=1)
下一步是在测试数据点上测试我们的模型。以下脚本创建一个测试数据点：
test_input = array([[20,34],[23,39],[26,44]])
...
print(test_output)
实际输出为[29，45]。我们的模型预测[29.089157，48.469097]，这非常接近。
现在让我们训练一个堆叠的LSTM并预测测试数据点的输出：
model = Sequential()
model.add(LSTM(100, activation='relu', return_sequences=True, input_shape=(3, 2)))
...
print(test_output)
输出为[29.170143，48.688267]，再次非常接近实际输出。
最后，我们可以训练双向LSTM并在测试点上进行预测：
from keras.layers import Bidirectionalmodel = Sequential()
...
print(test_output)
输出为[29.2071，48.737988]。
您可以再次看到双向LSTM做出最准确的预测。
结论
简单的神经网络不适用于解决序列问题，因为在序列问题中，除了当前输入之外，我们还需要跟踪先前的输入。具有某种记忆的神经网络更适合解决序列问题。LSTM就是这样一种网络。
最受欢迎的见解
1.用于NLP的Python：使用Keras的多标签文本LSTM神经网络分类
2.Python中利用长短期记忆模型LSTM进行时间序列预测分析 – 预测电力消耗数据
3.python在Keras中使用LSTM解决序列问题
4.Python中用PyTorch机器学习分类预测银行客户流失模型
5.R语言多元Copula GARCH 模型时间序列预测
6.在r语言中使用GAM（广义相加模型）进行电力负荷时间序列分析
7.R语言中ARMA，ARIMA（Box-Jenkins），SARIMA和ARIMAX模型用于预测时间序列数
8.R语言估计时变VAR模型时间序列的实证研究分析案例
9.用广义加性模型GAM进行时间序列分析
拓端tecdat|python在Keras中使用LSTM解决序列问题相关推荐
- 拓端tecdat荣获掘金社区入驻新人奖
2021年7月,由掘金发起了"入驻成长礼"颁奖活动.本次活动邀请到知名开发者.服务机构代表等业界人士. 据了解,掘金社区"新入驻创作者礼"主要对已经积累了一定历 ...
- 拓端tecdat荣获2022年度51CTO博主之星
相信技术,传递价值,这是51CTO每一个技术创作者的动力与信念,2022 年度,拓端tecdat 作为新锐的数据分析咨询公司,在51CTO平台上,不断的输出优质的技术文章,分享前沿创新技术,输出最佳生 ...
- keras中一个LSTM的具体例子
keras中一个LSTM的具体例子 LSTM:long short-term memory-保存信息以便后面使用,从而防止较早期的信号在处理过程中逐渐消失.SimpleRNN并不是Keras中唯一可用 ...
- 拓端tecdat|bilibili视频流量数据潜望镜
最近我们被客户要求撰写关于bilibili视频流量的研究报告,包括一些图形和统计输出. 最新研究表明,中国有超过7亿人在观看在线视频内容.Bilibili,被称为哔哩哔哩或简称为B站,是中国大陆第二个 ...
- lstm模型java实现_如何在Keras中构建LSTM分类器模型
你想做的是: from keras.models import Sequential from keras.layers import LSTM, Dense from keras.optimizer ...
- 拓端tecdat|R语言用LOESS(局部加权回归)季节趋势分解（STL）进行时间序列异常检测
最近我们被客户要求撰写关于LOESS(局部加权回归)的研究报告,包括一些图形和统计输出. 这篇文章描述了一种对涉及季节性和趋势成分的时间序列的中点进行建模的方法.我们将对一种叫做STL的算法进行研究, ...
- 拓端tecdat|R语言向量误差修正模型 (VECMs)分析长期利率和通胀率影响关系
最近我们被客户要求撰写关于向量误差修正模型的研究报告,包括一些图形和统计输出. 向量自回归模型估计的先决条件之一是被分析的时间序列是平稳的.但是,经济理论认为,经济变量之间在水平上存在着均衡关系,可以 ...
- 拓端tecdat|R语言线性回归和时间序列分析北京房价影响因素可视化案例
最近我们被客户要求撰写关于北京房价影响因素的研究报告,包括一些图形和统计输出. 目的 房价有关的数据可能反映了中国近年来的变化: 人们得到更多的资源(薪水),期望有更好的房子 人口众多 独生子女政策: ...
- python中sample怎么用_python – 在Keras中使用sample_weight进行序列标记
我正在研究不平衡类的顺序标签问题,我想使用sample_weight来解决不平衡问题.基本上如果我训练模型大约10个时代,我会得到很好的结果.如果我训练更多的时代,val_loss不断下降,但我的结果 ...
- 拓端tecdat|R语言逻辑回归（Logistic回归）模型分类预测病人冠心病风险
最近我们被客户要求撰写关于冠心病风险的研究报告,包括一些图形和统计输出. 相关视频:R语言逻辑回归(Logistic回归)模型分类预测病人冠心病风险 逻辑回归Logistic模型原理和R语言分类预测冠 ...
最新文章
- html 中embed标签使用
- angular6的响应式表单
- 六. 异常处理7.throw：异常的抛出
- java中.of,java中的sizeof
- lumen 配置数据库结果自动转数组_lumen 数据库操作 Cannot use object of type stdClass as array...
- （05）FPGA内部资源
- pythonfor循环语句例子_Python for循环学习总结
- 财务有必要学python吗-工作三年却被实习生抢了饭碗，学会Python到底有多吃香？...
- mysql从库新增_MySQL新增从库
- A Knee_Guided Evolutionary Algorithm for Compressing Deep Neural Network （KGEA）解读
- 图文并茂讲VLAN，让你看一遍就理解VLAN
- bp神经网络及ROC曲线绘制
- 小红书笔记api_小红书学习笔记
- 中年失业的处境有多艰难，成年人的生活不容易，且行且珍惜
- 程序员需要了解的硬核知识之操作系统入门
- 北京师范大学网络教育高级c 语言作业答案,北京师范大学网络教育教育心理学离线作业及答案...
- codevs 4052 黎恒健大战YJY
- 小狐狸 metamask 私钥
- C#对serialport 类的封装
- 恩施聚硒：实施“四大工程” 打造“六大中心”