如何使用 Keras 进行预测

作者： Jason Brownlee 于 2022年8月23日发表在深度学习 224

选择并拟合了 Keras 的最终深度学习模型后，您就可以使用它对新的数据实例进行预测。

初学者在这方面存在一些困惑，我经常看到诸如

如何在 Keras 中使用我的模型进行预测？

之类的提问。

完成本教程后，您将了解：

在本教程中，您将确切地了解如何使用 Keras Python 库，利用最终确定的深度学习模型进行分类和回归预测。
如何确定模型以使其可用于进行预测。
如何在 Keras 中进行分类和概率预测。

如何在 Keras 中进行回归预测。

让我们开始吧。

开始您的项目，阅读我的新书《Python 深度学习》，其中包含分步教程和所有示例的Python 源代码文件。
2020年1月更新：已针对 scikit-learn v0.22 API 的更改进行更新。
2018年4月：首次发布

How to Make Classification and Regression Predictions for Deep Learning Models in Keras

更新于2022年8月：已更新为 TensorFlow 2.x 语法
如何为 Keras 中的深度学习模型进行分类和回归预测

教程概述

本教程分为3个部分；它们是

最终确定模型
照片作者：mstk east，部分权利保留。
分类预测

回归预测

1. 确定模型

在进行预测之前，您必须训练一个最终模型。

您可能已经使用 k 折交叉验证或数据训练/测试拆分来训练模型。这样做是为了给您一个模型在样本外数据（例如新数据）上的技能估算。

这些模型已经完成了它们的作用，现在可以丢弃了。

如何训练最终的机器学习模型

您现在必须在所有可用数据上训练一个最终模型。您可以在此处了解更多关于如何训练最终模型的信息。

2. 分类预测

分类问题是指模型学习输入特征与输出特征（即标签）之间的映射，例如“垃圾邮件”和“非垃圾邮件”。

下面是一个在 Keras 中为简单二分类（二元）问题开发的最终神经网络模型的示例。

# example of training a final classification model
from keras.models import Sequential
from keras.layers import Dense
from sklearn.datasets import make_blobs
from sklearn.preprocessing import MinMaxScaler
# generate 2d classification dataset
X, y = make_blobs(n_samples=100, centers=2, n_features=2, random_state=1)
scalar = MinMaxScaler()
scalar.fit(X)
X = scalar.transform(X)
# define and fit the final model
model = Sequential()
model.add(Dense(4, input_shape=(2,), activation='relu'))
model.add(Dense(4, activation='relu'))
model.add(Dense(1, activation='sigmoid'))
model.compile(loss='binary_crossentropy', optimizer='adam')
model.fit(X, y, epochs=200, verbose=0)

如果您对在 Keras 中开发神经网络模型感到陌生，请参阅此 Keras 教程。

from keras.models import Sequential

from keras.layers import Dense

from sklearn.datasets import make_blobs

from sklearn.preprocessing import MinMaxScaler

# 生成二维分类数据集

# 训练最终分类模型的示例

X, y = make_blobs(n_samples=100, centers=2, n_features=2, random_state=1)

scalar = MinMaxScaler()

scalar.fit(X)

X = scalar.transform(X)

model = Sequential()

# 定义并拟合最终模型

model.add(Dense(4, input_shape=(2,), activation='relu'))

model.add(Dense(4, activation='relu'))

model.add(Dense(1, activation='sigmoid'))

model.compile(loss='binary_crossentropy', optimizer='adam')

model.fit(X, y, epochs=200, verbose=0)

保存和加载您的 Keras 深度学习模型

确定模型后，您可能希望将模型保存到文件，例如通过 Keras API。保存后，您可以随时加载模型并使用它进行预测。有关此示例，请参阅此博文。

为简单起见，本教程中的示例将省略此步骤。

使用最终确定的模型，我们可能需要进行两种类型的分类预测：类别预测和概率预测。

类别预测

类别预测是指在给定最终模型和一个或多个数据实例的情况下，预测数据实例的类别。

我们不知道新数据的输出类别。这就是我们首先需要模型的原因。

我们可以使用 Keras 中最终确定的分类模型，通过调用 `predict_classes()` 函数来预测新数据实例的类别。请注意，此函数仅在 `Sequential` 模型上可用，而不适用于使用函数式 API 开发的模型。

Xnew = [[...], [...]]
ynew = model.predict_classes(Xnew)

1 2	例如，我们有一个或多个数据实例，存储在一个名为 `Xnew` 的数组中。这可以传递给模型上的 `predict_classes()` 函数，以便预测数组中每个实例的类别值。 Xnew = [[...], [...]]

ynew = model.predict_classes(Xnew)

# example making new class predictions for a classification problem
from keras.models import Sequential
from keras.layers import Dense
from sklearn.datasets import make_blobs
from sklearn.preprocessing import MinMaxScaler
# generate 2d classification dataset
X, y = make_blobs(n_samples=100, centers=2, n_features=2, random_state=1)
scalar = MinMaxScaler()
scalar.fit(X)
X = scalar.transform(X)
# define and fit the final model
model = Sequential()
model.add(Dense(4, input_shape=(2,), activation='relu'))
model.add(Dense(4, activation='relu'))
model.add(Dense(1, activation='sigmoid'))
model.compile(loss='binary_crossentropy', optimizer='adam')
model.fit(X, y, epochs=500, verbose=0)
# new instances where we do not know the answer
Xnew, _ = make_blobs(n_samples=3, centers=2, n_features=2, random_state=1)
Xnew = scalar.transform(Xnew)
# make a prediction
ynew = model.predict_classes(Xnew)
# show the inputs and predicted outputs
for i in range(len(Xnew)):
	print("X=%s, Predicted=%s" % (Xnew[i], ynew[i]))

让我们用一个具体的例子来说明。

from keras.models import Sequential

from keras.layers import Dense

from sklearn.datasets import make_blobs

from sklearn.preprocessing import MinMaxScaler

# 生成二维分类数据集

# 训练最终分类模型的示例

X, y = make_blobs(n_samples=100, centers=2, n_features=2, random_state=1)

scalar = MinMaxScaler()

scalar.fit(X)

X = scalar.transform(X)

model = Sequential()

# 定义并拟合最终模型

model.add(Dense(4, input_shape=(2,), activation='relu'))

model.add(Dense(4, activation='relu'))

model.add(Dense(1, activation='sigmoid'))

# 对分类问题进行新类别预测的示例

# 我们不知道答案的新实例

model.fit(X, y, epochs=500, verbose=0)

Xnew, _ = make_blobs(n_samples=3, centers=2, n_features=2, random_state=1)

# 进行预测

Xnew = [[...], [...]]

# 显示输入和预测输出

Xnew = scalar.transform(Xnew)

for i in range(len(Xnew)):

print("X=%s, Predicted=%s" % (Xnew[i], ynew[i]))

运行示例，对三个新的数据实例进行类别预测，然后将数据和预测一起打印出来。

X=[0.89337759 0.65864154], Predicted=[0]
X=[0.29097707 0.12978982], Predicted=[1]
X=[0.78082614 0.75391697], Predicted=[0]

注意：由于算法或评估程序的随机性，或数值精度的差异，您的结果可能有所不同。请考虑运行示例几次并比较平均结果。

X=[0.89337759 0.65864154], Predicted=[0]

X=[0.29097707 0.12978982], Predicted=[1]

X=[0.78082614 0.75391697], Predicted=[0]

# example making new class prediction for a classification problem
from keras.models import Sequential
from keras.layers import Dense
from sklearn.datasets import make_blobs
from sklearn.preprocessing import MinMaxScaler
from numpy import array
# generate 2d classification dataset
X, y = make_blobs(n_samples=100, centers=2, n_features=2, random_state=1)
scalar = MinMaxScaler()
scalar.fit(X)
X = scalar.transform(X)
# define and fit the final model
model = Sequential()
model.add(Dense(4, input_shape=(2,), activation='relu'))
model.add(Dense(4, activation='relu'))
model.add(Dense(1, activation='sigmoid'))
model.compile(loss='binary_crossentropy', optimizer='adam')
model.fit(X, y, epochs=500, verbose=0)
# new instance where we do not know the answer
Xnew = array([[0.89337759, 0.65864154]])
# make a prediction
ynew = model.predict_classes(Xnew)
# show the inputs and predicted outputs
print("X=%s, Predicted=%s" % (Xnew[0], ynew[0]))

如果您只有一个新的数据实例，您可以将其作为一个包装在数组中的实例传递给 `predict_classes()` 函数；例如：

from keras.models import Sequential

from keras.layers import Dense

from sklearn.datasets import make_blobs

从 sklearn.预处理导入 MinMaxScaler

from numpy import array

# 生成二维分类数据集

# 训练最终分类模型的示例

X, y = make_blobs(n_samples=100, centers=2, n_features=2, random_state=1)

scalar = MinMaxScaler()

scalar.fit(X)

X = scalar.transform(X)

model = Sequential()

# 定义并拟合最终模型

model.add(Dense(4, input_shape=(2,), activation='relu'))

model.add(Dense(4, activation='relu'))

model.add(Dense(1, activation='sigmoid'))

# 对分类问题进行新类别预测的示例

# 对分类问题进行新的类别预测的示例

# 新实例，我们不知道答案

# 进行预测

Xnew = [[...], [...]]

# 显示输入和预测输出

Xnew = array([[0.89337759, 0.65864154]])

print("X=%s, Predicted=%s" % (Xnew[0], ynew[0]))

运行示例，对三个新的数据实例进行类别预测，然后将数据和预测一起打印出来。

X=[0.89337759 0.65864154], Predicted=[0]

1	注意：由于算法或评估程序的随机性，或数值精度的差异，您的结果可能有所不同。请考虑运行示例几次并比较平均结果。

运行示例，打印单个实例和预测的类别。

关于类别标签的说明

请注意，在准备数据时，您可能已经将您的域中的类别值（例如字符串）映射为整数值。您可能使用了 LabelEncoder。

此 LabelEncoder 可通过 `inverse_transform()` 函数将整数转换回字符串值。

因此，您可能希望在拟合最终模型时保存（pickle）用于编码 `y` 值的 LabelEncoder。

概率预测

您可能想进行的另一种预测是数据实例属于每个类别的概率。

这称为概率预测，即在给定新实例的情况下，模型返回每个输出类别的概率，值在 0 到 1 之间。

Xnew = [[...], [...]]
ynew = model.predict_proba(Xnew)

1 2	例如，我们有一个或多个数据实例，存储在一个名为 `Xnew` 的数组中。这可以传递给模型上的 `predict_classes()` 函数，以便预测数组中每个实例的类别值。您可以通过调用 `predict_proba()` 函数在 Keras 中进行这些类型的预测；例如：

ynew = model.predict_proba(Xnew)

对于二分类（二元）问题，输出层通常使用 sigmoid 激活函数。预测概率被视为观测值属于类别 1 的可能性，或者反过来（1 – 概率）给出类别 0 的概率。

对于多分类问题，输出层通常使用 softmax 激活函数，并将观测值属于每个类别的可能性作为向量返回。

# example making new probability predictions for a classification problem
from keras.models import Sequential
from keras.layers import Dense
from sklearn.datasets import make_blobs
from sklearn.preprocessing import MinMaxScaler
# generate 2d classification dataset
X, y = make_blobs(n_samples=100, centers=2, n_features=2, random_state=1)
scalar = MinMaxScaler()
scalar.fit(X)
X = scalar.transform(X)
# define and fit the final model
model = Sequential()
model.add(Dense(4, input_shape=(2,), activation='relu'))
model.add(Dense(4, activation='relu'))
model.add(Dense(1, activation='sigmoid'))
model.compile(loss='binary_crossentropy', optimizer='adam')
model.fit(X, y, epochs=500, verbose=0)
# new instances where we do not know the answer
Xnew, _ = make_blobs(n_samples=3, centers=2, n_features=2, random_state=1)
Xnew = scalar.transform(Xnew)
# make a prediction
ynew = model.predict_proba(Xnew)
# show the inputs and predicted outputs
for i in range(len(Xnew)):
	print("X=%s, Predicted=%s" % (Xnew[i], ynew[i]))

下面的示例对 `Xnew` 数据实例数组中的每个示例进行概率预测。

from keras.models import Sequential

from keras.layers import Dense

from sklearn.datasets import make_blobs

from sklearn.preprocessing import MinMaxScaler

# 生成二维分类数据集

# 训练最终分类模型的示例

X, y = make_blobs(n_samples=100, centers=2, n_features=2, random_state=1)

scalar = MinMaxScaler()

scalar.fit(X)

X = scalar.transform(X)

model = Sequential()

# 定义并拟合最终模型

model.add(Dense(4, input_shape=(2,), activation='relu'))

model.add(Dense(4, activation='relu'))

model.add(Dense(1, activation='sigmoid'))

# 对分类问题进行新类别预测的示例

# 我们不知道答案的新实例

model.fit(X, y, epochs=500, verbose=0)

Xnew, _ = make_blobs(n_samples=3, centers=2, n_features=2, random_state=1)

# 进行预测

您可以通过调用 `predict_proba()` 函数在 Keras 中进行这些类型的预测；例如：

# 显示输入和预测输出

Xnew = scalar.transform(Xnew)

for i in range(len(Xnew)):

# 对分类问题进行新概率预测的示例

运行示例，对三个新的数据实例进行类别预测，然后将数据和预测一起打印出来。

X=[0.89337759 0.65864154], Predicted=[0.0087348]
X=[0.29097707 0.12978982], Predicted=[0.82020265]
X=[0.78082614 0.75391697], Predicted=[0.00693122]

运行示例，进行概率预测，然后打印输入数据实例和每个实例属于类别 1 的概率。

X=[0.89337759 0.65864154], Predicted=[0.0087348]

X=[0.29097707 0.12978982], Predicted=[0.82020265]

X=[0.78082614 0.75391697], Predicted=[0.00693122]

如果您的应用程序需要将概率呈现给用户进行专家解读，这将很有帮助。

3. 回归预测

回归是一个监督学习问题，即在给定输入示例的情况下，模型学习到与合适的输出数量（例如“0.1”和“0.2”等）的映射。

# example of training a final regression model
from keras.models import Sequential
from keras.layers import Dense
from sklearn.datasets import make_regression
from sklearn.preprocessing import MinMaxScaler
# generate regression dataset
X, y = make_regression(n_samples=100, n_features=2, noise=0.1, random_state=1)
scalarX, scalarY = MinMaxScaler(), MinMaxScaler()
scalarX.fit(X)
scalarY.fit(y.reshape(100,1))
X = scalarX.transform(X)
y = scalarY.transform(y.reshape(100,1))
# define and fit the final model
model = Sequential()
model.add(Dense(4, input_shape=(2,), activation='relu'))
model.add(Dense(4, activation='relu'))
model.add(Dense(1, activation='linear'))
model.compile(loss='mse', optimizer='adam')
model.fit(X, y, epochs=1000, verbose=0)

下面是一个最终确定的 Keras 回归模型示例。

from keras.models import Sequential

from keras.layers import Dense

from sklearn.datasets import make_regression

from sklearn.preprocessing import MinMaxScaler

# 生成回归数据集

# 训练最终回归模型的示例

X, y = make_regression(n_samples=100, n_features=2, noise=0.1, random_state=1)

scalarX, scalarY = MinMaxScaler(), MinMaxScaler()

scalarX.fit(X)

scalarY.fit(y.reshape(100,1))

X = scalarX.transform(X)

X = scalar.transform(X)

model = Sequential()

# 定义并拟合最终模型

model.add(Dense(4, input_shape=(2,), activation='relu'))

y = scalarY.transform(y.reshape(100,1))

model.add(Dense(1, activation='linear'))

model.compile(loss='mse', optimizer='adam')

model.fit(X, y, epochs=1000, verbose=0)

我们可以通过调用最终模型的 `predict()` 函数来预测数量，用于最终确定的回归模型。

`predict()` 函数接受一个或多个数据实例的数组。

# example of making predictions for a regression problem
from keras.models import Sequential
from keras.layers import Dense
from sklearn.datasets import make_regression
from sklearn.preprocessing import MinMaxScaler
# generate regression dataset
X, y = make_regression(n_samples=100, n_features=2, noise=0.1, random_state=1)
scalarX, scalarY = MinMaxScaler(), MinMaxScaler()
scalarX.fit(X)
scalarY.fit(y.reshape(100,1))
X = scalarX.transform(X)
y = scalarY.transform(y.reshape(100,1))
# define and fit the final model
model = Sequential()
model.add(Dense(4, input_shape=(2,), activation='relu'))
model.add(Dense(4, activation='relu'))
model.add(Dense(1, activation='linear'))
model.compile(loss='mse', optimizer='adam')
model.fit(X, y, epochs=1000, verbose=0)
# new instances where we do not know the answer
Xnew, a = make_regression(n_samples=3, n_features=2, noise=0.1, random_state=1)
Xnew = scalarX.transform(Xnew)
# make a prediction
ynew = model.predict(Xnew)
# show the inputs and predicted outputs
for i in range(len(Xnew)):
	print("X=%s, Predicted=%s" % (Xnew[i], ynew[i]))

下面的示例演示了如何对具有未知预期结果的多个数据实例进行回归预测。

from keras.models import Sequential

from keras.layers import Dense

from sklearn.datasets import make_regression

from sklearn.preprocessing import MinMaxScaler

# 生成回归数据集

# 训练最终回归模型的示例

X, y = make_regression(n_samples=100, n_features=2, noise=0.1, random_state=1)

scalarX, scalarY = MinMaxScaler(), MinMaxScaler()

scalarX.fit(X)

scalarY.fit(y.reshape(100,1))

X = scalarX.transform(X)

X = scalar.transform(X)

model = Sequential()

# 定义并拟合最终模型

model.add(Dense(4, input_shape=(2,), activation='relu'))

y = scalarY.transform(y.reshape(100,1))

model.add(Dense(1, activation='linear'))

model.compile(loss='mse', optimizer='adam')

# 我们不知道答案的新实例

# 进行回归问题预测的示例

Xnew, a = make_regression(n_samples=3, n_features=2, noise=0.1, random_state=1)

# 进行预测

Xnew = scalarX.transform(Xnew)

# 显示输入和预测输出

Xnew = scalar.transform(Xnew)

for i in range(len(Xnew)):

ynew = model.predict(Xnew)

运行示例，对三个新的数据实例进行类别预测，然后将数据和预测一起打印出来。

X=[0.29466096 0.30317302], Predicted=[0.17097184]
X=[0.39445118 0.79390858], Predicted=[0.7475489]
X=[0.02884127 0.6208843 ], Predicted=[0.43370453]

运行示例，进行多次预测，然后并排打印输入和预测以供查看。

X=[0.29466096 0.30317302], Predicted=[0.17097184]

X=[0.39445118 0.79390858], Predicted=[0.7475489]

X=[0.02884127 0.6208843 ], Predicted=[0.43370453]

例如

# example of making predictions for a regression problem
from keras.models import Sequential
from keras.layers import Dense
from sklearn.datasets import make_regression
from sklearn.preprocessing import MinMaxScaler
from numpy import array
# generate regression dataset
X, y = make_regression(n_samples=100, n_features=2, noise=0.1, random_state=1)
scalarX, scalarY = MinMaxScaler(), MinMaxScaler()
scalarX.fit(X)
scalarY.fit(y.reshape(100,1))
X = scalarX.transform(X)
y = scalarY.transform(y.reshape(100,1))
# define and fit the final model
model = Sequential()
model.add(Dense(4, input_shape=(2,), activation='relu'))
model.add(Dense(4, activation='relu'))
model.add(Dense(1, activation='linear'))
model.compile(loss='mse', optimizer='adam')
model.fit(X, y, epochs=1000, verbose=0)
# new instance where we do not know the answer
Xnew = array([[0.29466096, 0.30317302]])
# make a prediction
ynew = model.predict(Xnew)
# show the inputs and predicted outputs
print("X=%s, Predicted=%s" % (Xnew[0], ynew[0]))

下面的示例演示了如何对具有未知预期结果的多个数据实例进行回归预测。

from keras.models import Sequential

from keras.layers import Dense

from sklearn.datasets import make_regression

从 sklearn.预处理导入 MinMaxScaler

from numpy import array

# 生成回归数据集

# 训练最终回归模型的示例

X, y = make_regression(n_samples=100, n_features=2, noise=0.1, random_state=1)

scalarX, scalarY = MinMaxScaler(), MinMaxScaler()

scalarX.fit(X)

scalarY.fit(y.reshape(100,1))

X = scalarX.transform(X)

X = scalar.transform(X)

model = Sequential()

# 定义并拟合最终模型

model.add(Dense(4, input_shape=(2,), activation='relu'))

y = scalarY.transform(y.reshape(100,1))

model.add(Dense(1, activation='linear'))

model.compile(loss='mse', optimizer='adam')

# 对分类问题进行新的类别预测的示例

相同的函数也可以用来为单个数据实例进行预测，只要它被适当地包装在周围的列表或数组中。

# 进行预测

Xnew = scalarX.transform(Xnew)

# 显示输入和预测输出

Xnew = array([[0.89337759, 0.65864154]])

Xnew = array([[0.29466096, 0.30317302]])

运行示例，对三个新的数据实例进行类别预测，然后将数据和预测一起打印出来。

X=[0.29466096 0.30317302], Predicted=[0.17333156]

1	运行示例，进行单个预测，并打印数据实例和预测以供查看。

进一步阅读

如果您想深入了解，本节提供了更多关于该主题的资源。

总结

X=[0.29466096 0.30317302], Predicted=[0.17333156]

具体来说，你学到了：

在本教程中，您将确切地了解如何使用 Keras Python 库，利用最终确定的深度学习模型进行分类和回归预测。
如何确定模型以使其可用于进行预测。
如何在 Keras 中进行分类和概率预测。

你有什么问题吗？
在下面的评论中提出你的问题，我会尽力回答。

为什么使用随机权重初始化神经网络？

最后机会：Stefan Krawcyzk 的“机器学习运维大师”现场课程

对《如何使用 Keras 进行预测》的 224 条回复

Nitin 2018年4月9日上午10:14 #

回复
- Jason，好文章。您是否推荐任何关于超参数调整以进一步提高准确性的文章？关于模型调整过程中常见问题及解决方案的文章呢？
  
  是的，请看这篇文章
  https://machinelearning.org.cn/grid-search-hyperparameters-deep-learning-models-python-keras/
  
  回复
- Jason Brownlee 2018年4月10日上午6:10 #
  
  Pierric 2018年6月8日上午2:11 #
  感谢教程。
  谢谢
  
  回复
  - 我的数据有一个问题，因为它们的维度不相同，所以软件无法正常工作。如果我用随机数填充空白以匹配维度，它就可以工作，但结果不正确。您能解释一下我该如何解决这个问题吗？
    
    也许这篇文章会有所帮助
    https://machinelearning.org.cn/handle-missing-timesteps-sequence-prediction-problems-python/
    
    回复
Jason Brownlee 2018年6月8日上午6:18 #

bekky 2018年4月10日晚上7:32 #

回复
- 感谢教程！如果我想构建一个同时具有分类和回归头的 CNN，我想我不能使用顺序模型。您知道这样的多头 CNN 的示例吗？谢谢。
  
  Jason Brownlee 2018年4月11日上午6:37 #
  https://machinelearning.org.cn/keras-functional-api-deep-learning/
  
  回复
  - 这里有一些多输出模型的例子。
    
    sakshi mangal 2020年6月25日晚上9:37 #
    
    回复
    - 嘿 Jason！您的教程非常有帮助。如果您能分享如何预测一个预训练模型是 pkl 文件的 Keras 模型，以及我们如何预测单个图像，那就太好了。
      
      谢谢！
      
      好的，请看这里：
      https://machinelearning.org.cn/how-to-use-transfer-learning-when-developing-convolutional-neural-network-models/
      
      还有这个。
      https://machinelearning.org.cn/save-load-keras-deep-learning-models/
      
      回复
Jason Brownlee 2020年6月26日上午5:34 #

Moustafa 2018年4月16日上午6:23 #
感谢您的解释。
您能否在代码旁边放上网络架构的照片？

回复
- 我认为这将有助于我们更好地理解架构。
  
  感谢您的建议。
  
  回复
  - Jason Brownlee 2018年4月16日上午6:27 #
    
    你好，杰森，
    sanjie 2018年5月10日上午1:42 #
    感谢您的文章。您确实帮了我们很多。
    
    我可以问一个问题吗？
    
    Keras 是否可用于构建聚类模型？
    
    keras.wrappers.scikit_learn 可用于构建 KerasClassifier 模型，Keras 是否可用于构建聚类模型？如果可以，是否有任何示例？
    
    回复
    - 您知道我想使用年龄、城市、教育、公司、职位等一些特征来将人们聚集成几组，并获取每组的关键特征。
      
      Jason Brownlee 2018年5月10日上午6:33 #
      
      回复
也许吧，我没见过。

Janne 2018年4月17日晚上11:38 #
嗨 Jason，感谢您的这篇博文。我有一个关于具有边界目标值回归的快速问题。

如果我的目标值总是在 [0,1] 之间，并且大部分值接近 0.5（即，值很少接近 0 或 1），那么使用 sigmoid 输出激活而不是线性激活是否有益？它有助于复杂模型的收敛或稳定性吗？不利用目标值属于有界区间的事实似乎是浪费。

所以，在您的代码中，您只需进行替换

回复
- `model.add(Dense(1, activation=’linear’))` -> `model.add(Dense(1, activation=’sigmoid’))`
  
  好问题。
  
  Jason Brownlee 2018年4月18日上午8:08 #
  
  是的，这是一个有趣的想法。它可能会改变用于拟合模型的损失函数，这可能导致优化错误的问题（例如 logloss 而不是 mse）。尽管如此，可以尝试一下，并比较两种方法之间的误差结果。
  
  回复
是的，这是代码更改。

olufemi 2018年4月23日上午11:22 #

回复
- 在 R 或 Python 中，使用 scikit-learn 而不是 Keras 进行分类问题的考虑因素是什么（反之亦然）？
  
  Jason Brownlee 2018年4月23日下午2:54 #
  
  scikit-learn 提供了一套通用的机器学习算法，Keras 则专注于神经网络算法。
  关于 Python 与 R，我在这里回答了。
  
  这有帮助吗？
  
  回复
Ali 2018年5月2日上午11:36 #

我正在尝试预测一个我用 emnist letters 训练的模型上的新图像。以下是尝试这样做的代码片段。

import matplotlib
# 强制 matplotlib 不使用任何 Xwindows 后端。
matplotlib.use(‘Agg’)
import keras
import matplotlib.pyplot as plt
from keras.models import load_model
from keras.preprocessing import image
from keras import backend as K
from scipy.misc import imread
from PIL import Image
import skimage.io as io
import skimage.transform as tr
import numpy as np
from keras.utils import plot_model
from keras.datasets import mnist
# 返回一个与之前模型相同的已编译模型
model = load_model(‘matLabbed.h5’)

print(“在我们自己的输入数据上测试模型”)

imgA = imread(‘A.png’)
imgA = tr.resize(imgA, (28, 28, 1)).astype(‘float32’)
imgA = imgA[np.newaxis, …]
y_classes = model.predict_classes(imgA)

当我尝试打印 y_classes 时，它会给我数值输出，例如 4、10。我想找出我的数据使用的标签，并将其与 y_classes 的输出进行比较。有什么建议吗？谢谢。

回复
- Jason Brownlee 2018年5月3日凌晨6:30 #
  
  整数将与您的训练数据中的一个类别相关联。
  
  回复
Rico 2018年5月15日晚上8:03 #

如何预测使用函数式 API 开发的模型类别？

回复
- Jason Brownlee 2018年5月16日凌晨6:02 #
  
  您可以调用 model.predict()，然后对生成的向量使用 argmax() 来获取类别索引。
  
  回复
Valentin 2018年5月31日凌晨7:56 #

你好 Jason，这个代码编辑器真的很烦人，请考虑换成别的或者直接用一些简单的文本。

回复
- Jason Brownlee 2018年5月31日下午2:11 #
  
  这里有更多关于如何从代码片段中复制代码的信息。
  https://machinelearning.org.cn/faq/single-faq/how-do-i-copy-code-from-a-tutorial
  
  这有帮助吗？
  
  回复
Vladislav Gladkikh 2018年5月31日下午3:42 #

分类和回归的网络差异很小（输出神经元的激活函数和损失函数），但在分类的情况下，通过 predict_proba 估算预测的概率非常容易，而对于像神经网络这样的非线性模型，回归的类比是预测区间，而预测区间很难计算。

为什么会有这样的差异？概率估计对于回归不应该像分类那样容易吗？我看到的直接（但可能很天真）的解决方案是分箱目标变量，进行分类，然后使用 predict_proba 来获取预测值落在某个区间的概率，然后从中构建预测区间。

可以这样做吗？还是说改变损失函数会让两个问题（分类和分箱目标变量的回归）变得如此不同，以至于一个问题的结果无法转移到另一个问题上？

回复
- Jason Brownlee 2018年6月1日凌晨8:14 #
  
  分箱方法也会是我的第一个/天真的想法。试试看。
  
  回复
  - Vladislav Gladkikh 2018年6月1日下午4:05 #
    
    好的，我为玩具一维回归任务尝试了它。
    
    几天前，我在 stackexchange 上问了这个问题。没有得到很多回复，所以我现在通过在 Keras 中实现我上面评论中概述的想法来回答了我自己的问题。
    
    看起来 it works。我仍然不确定我是否做得完全正确，以及它是否适用于真实的多元问题。如果你愿意，可以在这里看到：https://datascience.stackexchange.com/questions/31773/how-to-estimate-the-variance-of-regressors-in-scikit-learn/32486#32486
    
    回复
    - Jason Brownlee 2018年6月2日凌晨6:26 #
      
      这种方法让我感到紧张。
      
      回复
Cristian Cadar 2018年6月1日晚上7:23 #

嗨，Jason，

我构建了一个模型来对股票交易的金融时间序列进行分类，有 10 个输入和一个输出（“0”表示股票下跌，“1”表示上涨）。现在我有 1400 个这样的输入来训练模型，并且获得了 97% 的准确率！……

但当我向模型提供新输入时，分类准确率不会超过 30%！……在我看来，问题可能是

1. 过拟合
2. 时间序列不可预测？
等等…

您对可能的问题有什么想法，或者如何提高提供给模型的新数据的准确性吗？

谢谢

回复
- Jason Brownlee 2018年6月2日凌晨6:28 #
  
  低技能可能意味着欠拟合、模型错误、棘手的问题等。
  
  回复
Zoey 2018年6月5日凌晨7:21 #

如何获取回归模型的 RMSE？

回复
- Jason Brownlee 2018年6月5日下午3:04 #
  
  您可以计算 MSE，然后计算 MSE 的平方根。
  
  sklearn 在这里有一个实现
  https://scikit-learn.cn/stable/modules/generated/sklearn.metrics.mean_squared_error.html
  
  这有帮助吗？
  
  回复
Bayo 2018年6月8日凌晨6:33 #

非常有帮助。谢谢。

回复
- Jason Brownlee 2018年6月8日凌晨6:34 #
  
  很高兴它有帮助。
  
  回复
Alex 2018年6月21日凌晨7:31 #

你好，我正在处理一个多标签问题。我的 X_train 形状是（例如）[[0 1 0 0 1]……]。我想预测下一个，例如 [1 0 0 1 0]。我该怎么做？每个标签都是独立的。如何训练它？我可以在哪里找到一些信息来学习它？

谢谢！:)

回复
- Jason Brownlee 2018年6月21日下午4:49 #
  
  抱歉，我没有多标签预测的示例，只有多类别预测。
  
  回复
Narayan 2018年6月22日凌晨12:35 #

非常好！您能否也制作一个类似的 PyTorch 教程？

回复
- Jason Brownlee 2018年6月22日凌晨6:11 #
  
  感谢您的建议。
  
  回复
Abrar 2018年7月6日凌晨2:41 #

谢谢您的帖子，Jason。

当我们进行预测时，我们需要恢复到原始缩放。因为输入和输出似乎都经过了缩放，模型才能正确预测。

回复
- Jason Brownlee 2018年7月6日凌晨6:45 #
  
  正确，我们在评估回归误差时应将 yhat 返回到原始尺度。
  
  回复
Nijat 2018年7月7日晚上8:33 #

你好，感谢这篇很棒的文章。
我有一个关于回归问题的问题。
我正在尝试开发一个模型，该模型可以从 36 个输入变量中预测 3 个输出。为了清楚起见，我有 3 个输出参数和 36 个输入参数。这意味着输出层有 3 个神经元。当只有一个输出时，模型可以成功预测，但当涉及 3 个输出时，它会产生一些无用的东西。您有什么建议？顺便说一下，我使用了 keras mlp regressor。

回复
- Jason Brownlee 2018年7月8日凌晨6:21 #
  
  也许可以尝试调整模型，看看是否能找到最适合您特定问题的配置，这里有一些想法。
  https://machinelearning.org.cn/improve-deep-learning-performance/
  
  回复
chatra 2018年7月12日下午4:33 #

你好 Jason，感谢您对分类和回归架构的解释。

我正在使用 300 维向量进行回归模型。所以问题陈述是了解哪两个向量是相似的或不相似的。为此，我计算了两个相似向量和不相似向量之间的差值。我们将相似的差值向量标记为 0，不相似的差值向量标记为 1。并将其馈送到网络中，网络如下所示：
model = Sequential()
model.add(Dense(300, input_dim=301, activation=’relu’))
model.add(Dense(1, activation=’sigmoid’))
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['acc'])

训练损失：0.0171
训练准确率：0.9988

测试损失 = 0.6456110666
测试准确率 = 0.821831868464

我不确定为什么模型会出现过拟合，您能给我一些关于可能出错的见解吗？

回复
- Jason Brownlee 2018年7月13日凌晨7:31 #
  
  也许可以尝试一些不同的模型配置，看看它们是否会出现过拟合？例如，节点更少。
  
  回复
shivam sinha 2018年7月30日下午3:03 #

你好，
感谢您的解释。
我正在尝试在 Keras 中使用端到端的 Nvidia 模型用于自动驾驶汽车。这是一个回归问题，通过提供汽车前置摄像头拍摄的图像来预测转向角度。
这里我遇到的问题是，当我使用 model.predict() 预测角度时，对于所有输入，我都会得到一个恒定的值。即使在训练时我的模型也给出了非常小的误差，例如 –

Epoch 00001: val_loss improved from inf to 21.63187, saving model to drive/abc/weights.best6.hdf5
Epoch 2/30
283/283 [==============================] – 199s 702ms/step – loss: 18.0307 – val_loss: 16.9002

Epoch 00002: val_loss improved from 21.63187 to 16.90022, saving model to drive/abc/weights.best6.hdf5
Epoch 3/30
5/283 […………………………] – ETA: 25s – loss: 16.0846283/283 [==============================] – 199s 704ms/step – loss: 14.2439 – val_loss: 13.9543

Epoch 00003: val_loss improved from 16.90022 to 13.95434, saving model to drive/abc/weights.best6.hdf5
Epoch 4/30
283/283 [==============================] – 200s 708ms/step – loss: 11.9354 – val_loss: 12.1763

Epoch 00004: val_loss improved from 13.95434 to 12.17632, saving model to drive/abc/weights.best6.hdf5
Epoch 5/30
4/283 […………………………] – ETA: 25s – loss: 11.4636283/283 [==============================] – 201s 711ms/step – loss: 10.5595 – val_loss: 11.1414

Epoch 00005: val_loss improved from 12.17632 to 11.14141, saving model to drive/abc/weights.best6.hdf5
Epoch 6/30
283/283 [==============================] – 201s 711ms/step – loss: 8.3687 – val_loss: 0.7611

Epoch 00006: val_loss improved from 11.14141 to 0.76112, saving model to drive/abc/weights.best6.hdf5
Epoch 7/30
3/283 […………………………] – ETA: 26s – loss: 1.0417283/283 [==============================] – 199s 704ms/step – loss: 0.7403 – val_loss: 0.4893

Epoch 00007: val_loss improved from 0.76112 to 0.48934, saving model to drive/abc/weights.best6.hdf5
Epoch 8/30
283/283 [==============================] – 203s 716ms/step – loss: 0.5372 – val_loss: 0.3477

Epoch 00008: val_loss improved from 0.48934 to 0.34773, saving model to drive/abc/weights.best6.hdf5
Epoch 9/30
6/283 […………………………] – ETA: 26s – loss: 0.4749283/283 [==============================] – 216s 763ms/step – loss: 0.4332 – val_loss: 0.2760

Epoch 00009: val_loss improved from 0.34773 to 0.27596, saving model to drive/abc/weights.best6.hdf5
Epoch 10/30
283/283 [==============================] – 211s 744ms/step – loss: 0.3821 – val_loss: 0.2406

Epoch 00010: val_loss improved from 0.27596 to 0.24057, saving model to drive/abc/weights.best6.hdf5
Epoch 11/30
6/283 […………………………] – ETA: 25s – loss: 0.3903283/283 [==============================] – 207s 733ms/step – loss: 0.3565 – val_loss: 0.2229

Epoch 00011: val_loss improved from 0.24057 to 0.22293, saving model to drive/abc/weights.best6.hdf5
Epoch 12/30
283/283 [==============================] – 222s 784ms/step – loss: 0.3438 – val_loss: 0.2134

Epoch 00012: val_loss improved from 0.22293 to 0.21340, saving model to drive/abc/weights.best6.hdf5
Epoch 13/30
7/283 […………………………] – ETA: 25s – loss: 0.3331283/283 [==============================] – 205s 724ms/step – loss: 0.3331 – val_loss: 0.2076

Epoch 00013: val_loss improved from 0.21340 to 0.20755, saving model to drive/abc/weights.best6.hdf5
Epoch 14/30
283/283 [==============================] – 218s 771ms/step – loss: 0.3305 – val_loss: 0.2036

Epoch 00014: val_loss improved from 0.20755 to 0.20359, saving model to drive/abc/weights.best6.hdf5
Epoch 15/30
7/283 […………………………] – ETA: 26s – loss: 0.5313283/283 [==============================] – 211s 745ms/step – loss: 0.3295 – val_loss: 0.2006

Epoch 00015: val_loss improved from 0.20359 to 0.20061, saving model to drive/abc/weights.best6.hdf5
Epoch 16/30
283/283 [==============================] – 210s 743ms/step – loss: 0.3272 – val_loss: 0.1982

Epoch 00016: val_loss improved from 0.20061 to 0.19824, saving model to drive/abc/weights.best6.hdf5
Epoch 17/30
6/283 […………………………] – ETA: 27s – loss: 0.3350283/283 [==============================] – 220s 778ms/step – loss: 0.3236 – val_loss: 0.1963

Epoch 00017: val_loss improved from 0.19824 to 0.19628, saving model to drive/abc/weights.best6.hdf5
Epoch 18/30
283/283 [==============================] – 205s 726ms/step – loss: 0.3219 – val_loss: 0.1946

Epoch 00018: val_loss improved from 0.19628 to 0.19460, saving model to drive/abc/weights.best6.hdf5
Epoch 19/30
6/283 […………………………] – ETA: 28s – loss: 0.4911283/283 [==============================] – 215s 761ms/step – loss: 0.3180 – val_loss: 0.1932

Epoch 00019: val_loss improved from 0.19460 to 0.19320, saving model to drive/abc/weights.best6.hdf5
Epoch 20/30
283/283 [==============================] – 215s 761ms/step – loss: 0.3197 – val_loss: 0.1920

Epoch 00020: val_loss improved from 0.19320 to 0.19198, saving model to drive/abc/weights.best6.hdf5
Epoch 21/30
6/283 […………………………] – ETA: 31s – loss: 0.7507283/283 [==============================] – 207s 731ms/step – loss: 0.3188 – val_loss: 0.1910

Epoch 00021: val_loss improved from 0.19198 to 0.19101, saving model to drive/abc/weights.best6.hdf5
Epoch 22/30
283/283 [==============================] – 221s 781ms/step – loss: 0.3201 – val_loss: 0.1901

Epoch 00022: val_loss improved from 0.19101 to 0.19008, saving model to drive/abc/weights.best6.hdf5
Epoch 23/30
7/283 […………………………] – ETA: 27s – loss: 0.6471283/283 [==============================] – 207s 730ms/step – loss: 0.3198 – val_loss: 0.1893

Epoch 00023: val_loss improved from 0.19008 to 0.18925, saving model to drive/abc/weights.best6.hdf5
Epoch 24/30
283/283 [==============================] – 215s 758ms/step – loss: 0.3199 – val_loss: 0.1886

Epoch 00024: val_loss improved from 0.18925 to 0.18856, saving model to drive/abc/weights.best6.hdf5
Epoch 25/30
6/283 […………………………] – ETA: 26s – loss: 0.6787283/283 [==============================] – 218s 769ms/step – loss: 0.3197 – val_loss: 0.1879

Epoch 00025: val_loss improved from 0.18856 to 0.18787, saving model to drive/abc/weights.best6.hdf5
Epoch 26/30
283/283 [==============================] – 206s 727ms/step – loss: 0.3191 – val_loss: 0.1873

Epoch 00026: val_loss improved from 0.18787 to 0.18725, saving model to drive/abc/weights.best6.hdf5
Epoch 27/30
5/283 […………………………] – ETA: 26s – loss: 0.2300283/283 [==============================] – 221s 779ms/step – loss: 0.3175 – val_loss: 0.1868

Epoch 00027: val_loss improved from 0.18725 to 0.18680, saving model to drive/abc/weights.best6.hdf5
Epoch 28/30
283/283 [==============================] – 209s 740ms/step – loss: 0.3186 – val_loss: 0.1865

Epoch 00028: val_loss improved from 0.18680 to 0.18653, saving model to drive/abc/weights.best6.hdf5
Epoch 29/30
5/283 […………………………] – ETA: 28s – loss: 0.1778283/283 [==============================] – 213s 752ms/step – loss: 0.3165 – val_loss: 0.1864

Epoch 00029: val_loss improved from 0.18653 to 0.18639, saving model to drive/abc/weights.best6.hdf5
Epoch 30/30
283/283 [==============================] – 218s 771ms/step – loss: 0.3167 – val_loss: 0.1864

Epoch 00030: val_loss did not improve from 0.18639

那么我的问题是，为什么 model.predict() 总是给出恒定值？

谢谢，

回复
- Jason Brownlee 2018年7月31日凌晨5:58 #
  
  也许模型需要根据您的问题进行调整？
  
  回复
  - zzhulm 2020年10月21日下午4:06 #
    
    非常感谢您的教程，我现在遇到了一些可能未在此涵盖的问题，这里列出的问题是单个数据或一组数据，但由于我的网络后期有批量归一化和 LSTM，如果批量大小不同，会对输出结果产生影响，尤其对于时间序列预测问题，通常使用大批量大小来提高训练速度。训练后，使用是实时的输入模式，每分钟只有一项数据，问题是如何在实时中使用批量大小设置输入模式，以最小化批量的影响。
    当新数据到来时，我应该只输入一个数据吗？还是将其附加到一个大批量数据集中，然后向模型输入一个批次甚至多个批次？
    顺便说一句，我确实读了您关于 statefull lstm 模型的那篇文章。谢谢。
    
    回复
    - Jason Brownlee 2020年10月22日凌晨6:36 #
      
      我建议评估模型在单个输入与不同大小的批量下的性能，看看它是否会影响模型技能，然后使用最有效率的配置。
      
      回复
Rihana 2018年7月31日凌晨8:36 #

我有一个关于文本预测的问题。
由于我们在进行任何模型拟合之前使用不同的方法来枚举文本。我在逻辑上遇到了一个问题。
想象一下，在我的训练集中，我有 20 个唯一的标记，我这样枚举它们：“i”->1，“love”->2，“this”->3……。
训练模型并拟合数据后，我销毁了除模型之外的所有东西。所以我无法再跟踪这个字典了。
当我想预测一个完全是新词的新序列时，例如 [“we”, “went”, “to”, “Spain”]。
这个新词如何与旧字典关联起来？
我应该如何枚举它？

如果我使用一个新字典来枚举它，例如：“we”->1，“went”->2……。那么模型如何区分这个“We”与训练模型中的“i”不同？

提前感谢！

回复
- Jason Brownlee 2018年7月31日下午2:57 #
  
  您还必须保留用于将单词编码为整数的方法。
  
  回复
Feyza 2018年8月1日凌晨1:19 #

你好 Jason，我不明白程序如何预测 0 或 1？

回复
- Jason Brownlee 2018年8月1日凌晨7:46 #
  
  具体是哪个部分？
  
  回复
Atique 2018年8月3日下午4:54 #

很棒的文章。但有一件事令人困惑。对于回归预测，您在第一个示例中使用了 3 个实例，在下一个示例中使用了 1 个实例，第二个示例中的实例实际上是第一个示例中的第一个实例。那么为什么它们的结果不同呢？

回复
- Jason Brownlee 2018年8月4日凌晨6:01 #
  
  抱歉，我不明白。您能否提供更多上下文？
  
  回复
- Shooter 2018年8月4日晚上10:44 #
  
  因为除非您保存它，否则模型不会每次都以完全相同的方式运行，这就是原因。
  
  回复
Shooter 2018年8月4日晚上10:37 #

如何评估模型？此代码在评估时不起作用，如前一个示例所示。

scores = model.evaluate(X, y)
print(“\n%s: %.2f%%” % (model.metrics_names[1], scores[1]*100))

回复
- Jason Brownlee 2018年8月5日凌晨5:30 #
  
  本教程是关于进行预测的。
  
  我建议使用训练/测试分割或使用像 k 折交叉验证这样的重采样方法来评估模型性能。我在这两方面都有很多教程。
  
  也许从这里开始
  https://machinelearning.org.cn/faq/single-faq/how-do-i-evaluate-a-machine-learning-algorithm
  
  回复
  - Shooter 2018年8月5日晚上7:59 #
    
    我的意思是，不是关于训练/测试分割，如果我想在用于训练的相同数据上评估我的模型怎么办？
    
    我使用了命令
    
    scores = model.evaluate(X, y, verbose=2)
    print(scores)
    
    在 diabetes 示例中，当我打印 scores 时，
    输出是：[0.5047814001639684, 0.7513020833333334]
    这里的 score[1] 表示模型的准确率。
    
    在回归示例中，当我打印 scores 时。我得到 0.021803879588842393。这个数据是什么意思？我如何从中计算准确率？
    
    回复
    - Jason Brownlee 2018年8月6日凌晨6:27 #
      
      如果您评估的是回归模型，得分将是一个误差得分，例如在训练期间最小化的损失。例如 MSE。
      
      回复
      - Shooter 2018年8月6日下午2:40 #
        
        哦，好的，谢谢。我想我明白了。准确率仅用于分类，以检查模型是否将其正确分类。但在预测中是实际值，所以准确率没有意义。那么，如果有人问我的模型有多准确，我应该给他们误差得分吗？
      - Jason Brownlee 2018年8月6日下午2:56 #
        
        我们使用交叉验证或训练/测试分割来回答这个问题：“我的模型有多准确？”
        
        我们使用模型在新数据上进行预测，来回答这个问题：“这个观测值最可能的类别是什么？”
        
        这有帮助吗？
      - Shooter 2018年8月6日下午5:37 #
        
        谢谢，这很有帮助。我认为我需要更深入地研究这个主题。顺便说一句，您在这个网站上的内容很棒，几乎涵盖了使用 Python 进行深度学习的所有问题。
      - Jason Brownlee 2018年8月7日上午6:24 #
        
        谢谢！
Moritz 2018年9月18日上午5:17 #

感谢这篇精彩的博文！是否真的需要对地面真实值进行缩放？如果需要，为什么？

回复
- Jason Brownlee 2018年9月18日上午6:24 #
  
  在训练期间，对回归的输出进行缩放会有所帮助。这取决于模型和问题。
  
  回复
Franco Arda 2018年10月1日上午2:08 #

嗨，Jason，

我可以问一下你为什么不从保存的 h5 文件进行预测吗？
没有它，我们需要每次都运行模型。
是为了让解释更简单吗？

谢谢！Franco

回复
- Jason Brownlee 2018年10月1日上午6:26 #
  
  你可以这样做。我试图让本教程保持简单。
  
  本教程将向您展示如何保存/加载您的模型
  https://machinelearning.org.cn/save-load-keras-deep-learning-models/
  
  回复
Amit Chaudhary 2018年10月28日上午4:57 #

如果最后一层的激活是 softmax 或 sigmoid，model.predict(…) 和 model.predict_proba(…) 是否等效？

回复
- Jason Brownlee 2018年10月28日上午6:15 #
  
  不。我认为 predict() 会对 predict_proba 的结果执行 argmax 来得到一个整数。
  
  回复
  - ashok harnal 2021年2月6日下午12:45 #
    
    在 tensorflow 2.X 中，predict() 也返回概率
    
    回复
    - Jason Brownlee 2021年2月6日下午2:23 #
      
      同意，我认为上一条评论是关于 sklearn 的。Keras/TF 没有 predict_proba() 函数。
      
      回复
Akshat Jain 2018年11月3日上午4:56 #

有什么方法可以像这样获取带有概率的类别
类别 1：0.99，类别 2：0.8 等等。我有一个项目，我必须显示每个类别的输入置信度，该怎么做？

回复
- Jason Brownlee 2018年11月3日上午7:12 #
  
  是的，在上面的文章中已提及
  
  model.predict_proba()
  
  1
  
  model.predict_proba()
  
  回复
  - Md. Rony Ahmed 2018年11月10日上午4:34 #
    
    先生，我能获得任何关于使用 Keras 进行抽象文档摘要的帮助吗？
    
    回复
    - Jason Brownlee 2018年11月10日上午6:12 #
      
      当然，我这里有一些教程
      https://machinelearning.org.cn/start-here/#nlp
      
      回复
- habib 2019年6月18日上午9:13 #
  
  你好 Jason，我如何获得每个测试样本的预测概率？对于给定的一张图像，这可能吗？
  
  回复
  - Jason Brownlee 2019年6月18日下午2:22 #
    
    您可以使用 model.predict_proba()
    
    回复
Akshat Jain 2018年11月3日上午6:19 #

有没有办法像这样打印带有置信度的类别？例如，我正在做一个项目，对于一个输入，我需要在输出中打印带有置信度的类别。

回复
- Jason Brownlee 2018年11月3日上午7:14 #
  
  是的，用于置信区间
  https://machinelearning.org.cn/confidence-intervals-for-machine-learning/
  
  用于预测区间
  https://machinelearning.org.cn/prediction-intervals-for-machine-learning/
  
  回复
Faraz Malik Awan 2018年11月13日下午11:53 #

你好，
非常感谢你解释得如此清楚。我有一个问题。能否请您告诉我们，如果我们想对多个输出进行回归，需要进行哪些更改？例如，如果我们有特征 X=[x1,x2,x3]，我们想生成输出 Y=[y1,y2]。我们想为每个观测值生成多个输出。
[x1,x2,x3]>>>[y1,y2]。
谢谢

回复
- Jason Brownlee 2018年11月14日上午7:30 #
  
  当然，对于需要预测 2 个值的任务，您的网络输出层将需要 2 个节点。仅此而已。
  
  回复
irfan 2018年11月18日下午6:17 #

嗨，jason

是否有用于高光谱图像的模型？或者是否有提供高光谱图像训练模型的链接？

回复
- Jason Brownlee 2018年11月19日上午6:44 #
  
  也许可以谷歌搜索一下？
  
  回复
Steffen 2018年11月26日下午6:49 #

您好，X 和 y 是什么意思？
我假设 X 是输入，y 是某个输出。但是大写/小写的写法是什么意思？

回复
- Jason Brownlee 2018年11月27日上午6:33 #
  
  X 是一个矩阵，y 是一个向量。
  
  回复
Praveen 2018年12月17日下午11:33 #

嗨 Jason

是否有方法可以使用 Keras 获取变量/输入重要性？

或者如何确定在训练神经网络时哪些变量很重要。

回复
- Jason Brownlee 2018年12月18日上午6:03 #
  
  据我所知，没有。
  
  回复
prisilla 2019年1月8日下午5:17 #

嗨，Jason，

您为什么使用 scalar = MinMaxScaler()？

回复
- Jason Brownlee 2019年1月9日上午8:40 #
  
  用于标准化输入。
  
  回复
David 2019年1月12日上午6:58 #

你好，

我正在运行一个 CNN 来对标记为高或低的图像进行分类。在仅训练一个 epoch 后运行 predict_proba(img) 并预测一组相同的图像的预测结果时，我看到一组非常相似的值，例如

[[ 0.49511209]]
[[ 0.49458334]]
[[ 0.49470016]]

在 50 个 epoch 后，验证准确率约为 95%，predict_proba(img) 的输出与以下类似：

[[ 0.80663812]]
[[ 0.97021145]]
[[ 0.96050763]]

其中没有一个值低于 0.5

您能否告诉我我看到的基本上是什么？也就是说，我如何知道概率是指哪个类别（“高”或“低”）；为什么在最少训练时概率都低于 0.5，而在 50 个 epoch 时接近 1；为什么随着训练的增加，概率几乎均匀地增加？

感谢您的辛勤工作和免费分享知识的服务。

回复
- Jason Brownlee 2019年1月13日上午5:35 #
  
  这表明对于该图像，模型不确定它是什么，并且强烈认为它属于所有 3 个类别。
  
  回复
  - David 2019年1月13日上午5:57 #
    
    您好，感谢您的回复。这些准确率值分别是 1 个 epoch 和 50 个 epoch 的训练示例，用于三个不同的图像。了解这一点，您能否回答我最初的问题？谢谢！
    
    回复
    - Jason Brownlee 2019年1月14日上午5:22 #
      
      我明白了，“低”和“高”被映射到整数 0 和 1，那么类 1 的预测将在 0 到 1 之间。
      
      字符串到整数的映射将由您控制，例如 sklearn 中的 labelencoder，您可以检查它以确定 low 是 0 还是 1。
      
      这有帮助吗？
      
      回复
      - David 2019年1月15日上午2:18 #
        
        这确实有帮助，谢谢！可以肯定的是，当概率是 0.97 时，预测的类别是 1，但当概率是 0.494 时，预测的类别是 0 吗？
        
        诚挚地，
        
        大卫
      - Jason Brownlee 2019年1月15日上午5:54 #
        
        是的。
David 2019年1月15日上午8:24 #

好的，谢谢！

回复
Roi Ong 2019年1月29日下午6:56 #

对于二元文本分类，积极和消极情感。
为什么模型词汇表中找不到的单词总是给出相同的预测值？

例如，当我输入单个单词“extravagant”时，该单词在模型的词汇表中找不到，它会给我一个 0.165 的值，被归类为消极。当我输入新的单个不存在于词汇表中的词时，结果也一样。是什么原因导致这些词被预测为 0.165 或相同的预测值？

回复
- Jason Brownlee 2019年1月30日上午8:07 #
  
  未知单词被映射到零或“未知”输入。
  
  回复
  - Roi Ong 2019年1月30日下午3:48 #
    
    您好！非常感谢您的回复 Jason。
    我只想问另一个问题。如果未知输出被映射为零/未知，为什么输出也不为零？
    是因为模型本身吗？它根据其层在接收到 0 作为输入时始终生成的值来生成 0.165 的预测？
    
    回复
    - Jason Brownlee 2019年1月31日上午5:26 #
      
      我怀疑是因为将单个未知单词作为模型的输入是不寻常的——例如，在实践中不会发生这种情况。
      
      回复
      - Roi Ong 2019年1月31日下午1:58 #
        
        再次非常感谢您 Jason！我非常感谢您的帮助。
Rajat 2019年3月4日下午5:55 #

你好 Jason，
感谢这篇精彩的文章！
我有一个疑问，您使用了 Sequential() 来创建架构。当我们使用 Model() 创建架构时，如何进行预测？

回复
- Jason Brownlee 2019年3月5日上午6:32 #
  
  您可以在 Model 实例上使用 predict() 函数。
  
  如果您需要类值，可以使用类似
  
  yhat = model.predict()
  class_id = argmax(yhat[0])
  
  回复
Manos 2019年3月20日下午10:23 #

我构建了一个用于文本摘要的编码器-解码器模型，基于‘https://machinelearning.org.cn/encoder-decoder-models-text-summarization-keras/’。
我训练了模型，现在我想基于
测试数据集（为单个文档查找摘要），所以我为测试数据使用了与训练数据相同的结构。我在 model.predict() 命令上遇到了问题。输入是什么？
我尝试使用数组、numpy 数组列表来编码测试数据，但没有成功。是否有用于文本摘要预测的示例？

回复
- Jason Brownlee 2019年3月21日上午8:14 #
  
  predict 函数的输入是样本的数组，其结构/准备方式与 trainX 相同。
  
  回复
rachana patel 2019年3月23日上午9:38 #

我正在为我的项目进行使用图像预测房价，模型创建了 200 个 epoch 被扫描并显示平均价格，现在我想做的是使用四张图片来预测房价，即厨房、浴室、正面图像和邮政编码，
我该如何应用输入？以及如何调用 method.predict()，您能给我写下代码吗？

回复
- Jason Brownlee 2019年3月24日上午7:01 #
  
  非常酷的项目想法。
  
  或许可以比较一组单独的模型与一个将每张照片作为输入并行的模型——例如，一个多输入模型。
  
  回复
yao 2019年4月9日下午3:49 #

感谢您的努力和精彩的帖子！对于单个数据，Xnew = array([[0.89337759, 0.65864154]])，在将其馈送到模型进行预测之前，我们需要使用 MinMax scaler 进行预处理吗？这与 Class Prediction part2 相关，用于预测单个实例的类别。非常感谢！

回复
- Jason Brownlee 2019年4月10日上午6:09 #
  
  模型的新输入应与训练数据的准备方式相同。
  
  回复
ROOPAL 2019年4月9日下午8:23 #

我想问一下，如果我想使用 CNN 对简单的二元非图像分类数据进行分类，而不使用全连接层，该如何使用。

回复
- Jason Brownlee 2019年4月10日上午6:11 #
  
  除非输入是序列，否则它是不合适的。
  
  这里有一个例子
  https://machinelearning.org.cn/how-to-develop-convolutional-neural-network-models-for-time-series-forecasting/
  
  回复
Krati Dave 2019年4月16日下午3:30 #

感谢您的教程！！
我该如何通过网络摄像头实时预测图像？

回复
- Jason Brownlee 2019年4月17日上午6:51 #
  
  您所说的“预测图像”是什么意思？
  
  回复
Roya 2019年4月19日上午10:48 #

我有自己的数据集和图像及标签文件，如何将它们加载到 Keras 并将它们输入网络？
感谢这个教程

回复
- Jason Brownlee 2019年4月19日下午3:04 #
  
  这是一个很好的入门教程，您可以根据您的项目进行调整
  https://machinelearning.org.cn/tutorial-first-neural-network-python-keras/
  
  回复
Danial 2019年4月23日下午7:56 #

您好 Jason..
我看到您正在使用 keras。上面的代码是否使用 BP 算法来优化权重，而我们在代码中看不到后台？这是否可能？

回复
- Jason Brownlee 2019年4月24日上午7:57 #
  
  Keras 使用反向传播来更新模型权重。
  
  回复
simran kalra 2019年6月9日下午4:14 #

我有多个类别，如何为每个类别生成概率？

回复
- Jason Brownlee 2019年6月10日上午7:36 #
  
  model.predict()
  
  回复
zeinab 2019年7月8日上午3:49 #

我在文本相似性问题上运行了多通道 cnn 模型。

每次运行模型时，我都会得到不同的结果（损失、准确率）。

每次运行代码时获得不同的损失和准确率结果是否正常？

回复
- Jason Brownlee 2019年7月8日上午8:44 #
  
  这是意料之中的，请看这里
  https://machinelearning.org.cn/faq/single-faq/why-do-i-get-different-results-each-time-i-run-the-code
  
  回复
tawsin 2019年8月4日下午1:17 #

model.predict() 给我一个 0 和 1 的数组，而不是概率。

回复
- Jason Brownlee 2019年8月5日上午6:45 #
  
  或许可以确认您使用的是 sigmoid 激活函数和交叉熵损失。
  
  回复
Suraj Pawar 2019年8月13日上午8:09 #

model.predict() 的输出的数据类型是什么？我的训练数据集是 float64 数据类型。但是 model.predict() 给了我 float32 的输出。Keras 是否以 float32 格式存储学习到的权重和偏差？
谢谢你。

回复
- Jason Brownlee 2019年8月13日下午2:36 #
  
  据我所知，通常是 float32。
  
  回复
  - Nikita Saxena . 2020年6月3日上午12:50 #
    
    那么是否无法使模型预测 float64 类型？
    
    回复
    - Jason Brownlee 2020年6月3日上午8:02 #
      
      我看不出为什么不。
      
      回复
zeinab 2019年8月13日下午12:29 #

嗨，Jason，
为什么每次运行模型时，损失和准确率值都会变化。但是我上传了训练、验证和测试数据集

回复
- Jason Brownlee 2019年8月13日下午2:37 #
  
  这是我在这里回答的一个常见问题
  https://machinelearning.org.cn/faq/single-faq/why-do-i-get-different-results-each-time-i-run-the-code
  
  回复
Wang Xing Yang 2019年8月18日下午9:58 #

您好，这可能是一个愚蠢的问题，但我想知道 Keras 的 Sequential 模型与为同一个预测问题创建自编码器有什么区别。我只是在寻找对两者的简单或清晰的定义。keras 文档没有对这个 sequential 模型说太多。提前感谢。

回复
- Jason Brownlee 2019年8月19日上午6:07 #
  
  预测模型将输入映射到给定的输出，例如数字或类别标签。
  
  自编码器提供输入的压缩表示，例如投影。
  
  回复
  - Mikhail 2019年8月19日下午8:38 #
    
    您好，Jason 先生。
    你好吗？
    我有一个问题。
    我构建了一个用于 OCR 的模型，但无法获得概率结果。
    在构建模型时，我的激活函数是 softmax。
    我试图获取概率结果以使用预测函数，但没有成功。
    您能解释一下吗？
    
    回复
    - Jason Brownlee 2019年8月20日上午6:26 #
      
      调用 model.predict() 以获取概率预测。
      
      你到底遇到了什么问题？
      
      回复
Mikhail 2019年8月21日下午5:49 #

谢谢您的回答
顺便说一下，我的训练结果是 [0.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,0.0]
但我想要类似 [0.01,0.03, 0.91,0.07,0.10, …] 这样的概率结果
我现在使用的是 model.predict() 函数。
但结果不是概率值。
我想知道如何获得概率值
此致。
谢谢您，先生。

回复
- Jason Brownlee 2019年8月22日上午6:20 #
  
  也许您没有使用适当的损失函数来训练模型，或者模型输出层没有使用适当的激活函数？
  
  也许这会有帮助。
  https://machinelearning.org.cn/how-to-choose-loss-functions-when-training-deep-learning-neural-networks/
  
  回复
  - Mikhail 2019年8月26日下午6:29 #
    
    感谢您的好意。
    
    回复
    - Jason Brownlee 2019年8月27日上午6:37 #
      
      不客气。
      
      回复
Prem 2019年8月22日下午12:22 #

嗨，Jason，

sklearn 分类器使用目标名称作为字符串（Good, Bad），但 Keras sklearn 建模要求将其映射为（0,1）。有没有办法直接使用字符串，以便与 Keras 模型的 LIME 解释相匹配？

回复
- Jason Brownlee 2019年8月22日下午2:00 #
  
  不，通常您需要用一些自定义代码自己将整数映射到字符串。
  
  回复
  - Prem 2019年8月22日下午2:21 #
    
    谢谢 Jason，
    Keras 顺序模型如下返回一个类的概率
    
    pred = Keras_model.predict_proba(testData_for_model)
    pred
    Out[73]: array([[0.6559619]], dtype=float32)
    
    pre.argmax(axis=-1)[0] 给出类 0
    
    所以我要将 1-pred 写成类 1 的概率
    
    是这样工作的吗？
    
    回复
    - Jason Brownlee 2019年8月23日上午6:17 #
      
      一次只使用一个样本进行一次预测。
      
      您可以通过 argmax 将概率转换为类别，或者直接调用 predict_classes()。
      
      回复
      - Prem 2019年8月23日上午11:06 #
        
        谢谢 Jason，我有点困惑，不知道下面的哪个类属于哪个类别。
        
        keras_model.predict_proba(test_for_model)
        Out[30]: array([[0.77143025]], dtype=float32)
        
        keras_model.predict_classes(test_for_model)
        Out[32]: array([[1]])
        
        keras_model.predict_proba(test_for_model).argmax(axis=-1)
        Out[33]: array([0], dtype=int64)
        
        当我调用 predict_classes 时，它显示 1，而使用 argmax 时它显示 0。请问，我能否知道它属于哪个类别？
      - Jason Brownlee 2019年8月23日下午2:09 #
        
        对单元素向量执行 argmax 是无效的。
        
        相反，您必须四舍五入结果，这将是类别 1。
ziko 2019年8月27日下午8:57 #

你好 Jason，一如既往，我发现你的教程对我学习和更好地理解非常有帮助！谢谢！对于回归系统，你能否解释一下如何实际提取权重并获得真实的（非缩放的）预测值？

回复
- Jason Brownlee 2019年8月28日上午6:34 #
  
  谢谢。
  
  您可以在缩放数据上拟合模型，然后对预测值进行缩放反转 – 这是很常见的。
  
  回复
Atena 2019年9月19日上午4:24 #

亲爱的 Jason，您好。感谢您提供的好网站和内容，这有助于我们开始编写机器学习模型。
我有一个包含一些活动的数据集。该数据集包含不同传感器的状态和活动的标签。我使用以下架构在 Keras 中训练了一个模型来建模活动。

model = Sequential()
model.add(Embedding(max_features+1, embedding_vector_dim))
model.add(LSTM(64, dropout=0.2, recurrent_dropout=0.2, return_sequences = True))
model.add(Dense(1, activation=’sigmoid’))

现在，我需要分别为每种活动制作一个不同的基于 LSTM 的模型。然后，计算每个模型创建序列的概率。我可以用 Keras 做到这一点吗？我应该如何设计模型的架构？移除密集层并分别为每个活动标签创建单独的模型是否正确？

回复
- Jason Brownlee 2019年9月19日上午6:09 #
  
  我相信是的。
  
  抱歉，我没有能力为您审查/设计自定义模型。也许可以从这里的免费教程开始。
  https://machinelearning.org.cn/start-here/#deep_learning_time_series
  
  回复
Suraj Pawar 2019年9月20日下午2:04 #

我想知道当我将一些测试样本输入到 model.predict() 进行预测时，模型是按顺序处理每个样本吗？还是模型一次性处理所有样本并给出预测输出？有没有办法以矢量化的方式进行预测？谢谢。

回复
- Jason Brownlee 2019年9月21日上午6:42 #
  
  是的，输入样本是按顺序处理的。
  
  这意味着第一个预测将是输入的第一行。
  
  这有帮助吗？
  
  回复
Omri 2019年10月21日上午8:57 #

你好 Jason。谢谢你的教程。我已经从之前的教程中制作了模型（model.yaml /model.h5）。现在如何使用此文件在输入新数据时预测输出？

回复
- Jason Brownlee 2019年10月21日下午1:41 #
  
  加载模型并调用 predict()
  
  回复
  - Omri 2019年10月21日下午3:30 #
    
    谢谢。举个例子，这是正确的吗？
    
    from keras.models import load_model
    model = load_model(‘model.h5’)
    print(model.predict([1,0,0,1,0,5849,0,200,360,1,0]))
    
    回复
    - Jason Brownlee 2019年10月22日上午5:41 #
      
      看起来是个不错的开始。
      
      回复
Adela 2019年10月29日上午5:37 #

我有一个问题。我想做一个预测，但它不是基于数字，而是基于文本数据。有没有有效的方法可以做到？
输入是日期、时间、地点。输出是 1 到 35 的标签。可能有成千上万个标签。
训练文件有数万个日期、时间、地点和 1-35 个标签的字段。
我需要将所有内容转换为数字才能进行回归吗？还是 nltk 能以某种方式帮助我？
我可以用数字做回归，但如何使用文本？
非常感谢您的帮助。

回复
- Jason Brownlee 2019年10月29日下午1:42 #
  
  听起来像是一个分类任务，其中输入数据将被转换为数字。
  
  对于文本数据，您可以从简单的词袋模型表示开始。
  
  我有很多教程可以帮助您入门。
  https://machinelearning.org.cn/start-here/#nlp
  
  回复
Markus Buchholz 2019年12月17日下午9:50 #

嗨，Jason，

您的工作、书籍和帖子对计算机科学爱好者、科学家和研究人员的深度学习理解产生了巨大影响。太棒了！谢谢

目前我正在研究机器人逆运动学，其解将通过神经网络（NN）近似。数据集来自正向运动学。我的数据集包含 50000 条记录（每条记录包含 7 个值）– 7 个输入（末端执行器位置 X、Y、Z 和方向 * 4 = 7）。NN 的输出是电机/机器人角度 => 6。我定义了许多不同的架构（扁平/深/宽而窄），但质量仍然存在问题（角度预测质量很差，MSE = 0.3）。
我猜问题直接与 NN 的架构有关。如果您有机会，请给我一些关于如何改进预测（更改 NN 架构或其他）的建议，那将是很好的。

详情

输入 = 7 (x,y,x + 方向*4 )
输出 = 6 个机器人电机角度

我使用的是 Keras 的顺序 NN。神经元配置如下（部署的 NN 架构）： 7 – 32 -128 – 256 – 256 -128 – 32 – 6。我还尝试增加隐藏层或使 NN 完全扁平，但没有取得积极成果。
我还使用了（例如）7-256-512-1024-1024-1024-512-256-6 等变体，但没有成功（batch_size = 从 32 到 512；epoch 从 1000 到 500。数据集已预处理 – 我使用了 MinMaxScaler (0,1)。神经元具有 RELU 激活函数。

我想知道 Jason 你能否帮助我？

谢谢。

此致，
Markus Buchholz

回复
- Jason Brownlee 2019年12月18日上午6:06 #
  
  谢谢 Markus！
  
  我相信这里的教程将有助于从一般意义上诊断给定模型的学习动态并提出改进建议。
  https://machinelearning.org.cn/start-here/#better
  
  回复
  - Markus Buchholz 2019年12月19日上午7:54 #
    
    太棒了。谢谢，祝您好运！
    
    回复
    - Jason Brownlee 2019年12月19日下午12:48 #
      
      谢谢。
      
      回复
Mohamed Abdullah 2020年3月16日上午3:39 #

你好，Jason。

如果有一种方法可以将预测值仅作为整数输出（而不是浮点数）。

回复
- Jason Brownlee 2020年3月16日上午5:57 #
  
  您可以调用 predict_classes() 来获取类整数。
  
  回复
liu sheng 2020年3月22日下午6:56 #

您好，先生。我想做一个作物推荐。有许多种作物，与土壤特性（pH、N、P、K…）有关。通过预测各种作物的产量来推荐作物。但我不知道如何用 keras 实现。你能给我一些想法吗？

回复
- Jason Brownlee 2020年3月23日上午6:13 #
  
  也许这个过程将有助于作为第一步。
  https://machinelearning.org.cn/start-here/#process
  
  回复
Hector 2020年3月31日下午1:04 #

你好，谢谢这个，那么我有一个问题，如何使用这个例子获得 2 个或更多输出？然后，如何打印这些输出？

回复
- Jason Brownlee 2020年3月31日下午1:37 #
  
  您可以提供一个包含两个输入样本的数组来制作两个预测。
  
  您可以使用 print() 函数打印预测。
  
  回复
Patrick Lai 2020年5月2日上午2:32 #

谢谢，我真的很感激您的分步方法。我已经学习了许多深度学习课程，我了解很多理论，但如何应用它们，很少有文章像您的那样清晰。

继续做好工作！

回复
- Jason Brownlee 2020年5月2日上午5:49 #
  
  谢谢！
  
  回复
Mousheng Xu 2020年5月22日下午1:00 #

嗨，Jason，

很棒的帖子！我一直在关注您的许多帖子，它们都很棒！

关于“predict_proba(..)”的一个问题：它是否适用于 VGG 模型？似乎它不存在。如果我只使用“predict(..)”，它只返回一个类似“[[7.090991e-05]]”的数组。这是类 1 的概率（因此类 0 的概率是 7.090991e-05）？

回复
- Jason Brownlee 2020年5月22日下午1:25 #
  
  对分类模型调用 predict() 将返回概率。
  
  回复
ahmad 2020年5月31日上午9:29 #

感谢您的教程！我构建了 DNN 模型来预测乳腺癌患者的存活率（死亡（1）或存活（0）），如何为新病例预测类标签（0 或 1）？“不直接进行训练过程”我只想插入特征值并使用 DNN 模型进行预测？

回复
- Jason Brownlee 2020年5月31日下午1:23 #
  
  不客气！
  
  您可以创建一个数组并将其传递给 predict() 函数。上面的教程向您展示了如何操作。
  
  回复
  - ahmad 2020年6月1日上午9:14 #
    
    Xnew = array([[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]])
    
    ynew = model.predict_classes(Xnew)
    
    我有 33 个特征，我想在拟合模型后预测新病例（0 或 1）！
    
    但是显示此错误！
    
    检查输入时出错：expected input_2 to have shape (33,) but got array with shape (2,)
    
    回复
    - Jason Brownlee 2020年6月1日下午1:41 #
      
      这很令人惊讶，也许请仔细检查您模型的期望。
      
      回复
nkm 2020年8月16日上午3:56 #

Jason先生您好，

感谢您的支持。

我有一个疑问。当使用 sigmoid 计算二元分类的混淆矩阵时，我会得到错误的混淆矩阵，准确率为 50%。我的代码是

y_true = test_it.classes
Y_pred = model.predict(test_it, STEP_SIZE_TEST)
Y_pred = model.predict(test_it, STEP_SIZE_TEST)
y_pred1 = np.argmax(Y_pred, axis=1, out=None)
cm = confusion_matrix(y_true, y_pred1)

我找到的一个可能的解决方案是

y_pred1 = np.where(Y_pred>=0.5, 1, 0)

但是，这仍然与测试准确率不匹配，尽管它非常接近。

请就此问题给予指导。

谢谢和问候
NKM

回复
- Jason Brownlee 2020年8月16日上午5:58 #
  
  您的问题原因对我来说不明显，抱歉。
  
  回复
nkm 2020年8月31日下午2:58 #

嗨，Jason，

感谢您的支持。

我想问一下，对于灰度图像的二元分类，最后一层的激活函数应该是 sigmoid 还是 softmax？理论上两者应该给出相同的结果，但实际上两者都不匹配。甚至测试准确率也不同。请指导。

回复
- Jason Brownlee 2020年9月1日上午6:25 #
  
  sigmoid。
  
  回复
  - nkm 2020年9月1日下午2:00 #
    
    谢谢你的快速回复。我观察到了同样的事情。
    
    回复
    - nkm 2020年9月1日下午2:16 #
      
      在此情况下，在预测过程中，我使用了
      
      predictedClasses = np.where(predictions>0.5, 1, 0) 而不是 np.argmax(Y_pred, axis=1)，因为在这种情况下 np.argmax 总是输出 0，因为它是一个列向量。
      
      np.where(predictions>0.5, 1, 0) 如果 prediction > 0.5 则返回 1，否则返回 0。
      
      但是，通过这种方法（np.where）得到的准确率与 model.evaluate 步骤的准确率不匹配（相差约 2-3%）。
      
      恳请指导。
      
      回复
      - Jason Brownlee 2020年9月2日上午6:21 #
        
        argmax 是一个好的默认选项。
        https://machinelearning.org.cn/argmax-in-machine-learning/
        
        否则，您可以使用阈值移动。
        https://machinelearning.org.cn/threshold-moving-for-imbalanced-classification/
Valentin 2020年8月31日下午9:49 #

嗨，Jason，

我开发了一个基于 https://machinelearning.org.cn/multivariate-time-series-forecasting-lstms-keras/ 的漂亮时间序列预测模型。
现在我的机器学习经验不足了：我保存了模型，然后想根据 2 行新数据进行预测。
“yhat = model.predict(X)”。结果是缩放过的，对吗？所以我想通过“scaler.inverse_transform(yhat)”来反转它。
我得到了一个“ValueError: non-broadcastable output operand with shape (2,1) doesn’t match the broadcast shape (2,8)”。
该操作数是“yhat”，而期望的形状似乎需要所有特征（数量为 8）用于 inverse_transform 函数。
我相信我遗漏了一些基本的东西，但我不知道如何填补这个空白。也许我在您的书籍和其他帖子中错过了这一点……

再次感谢！

Valentin

回复
- Jason Brownlee 2020年9月1日上午6:30 #
  
  好问题。
  
  要使用 transform 对象来反转缩放，输入到 transform 对象必须具有相同的形状，例如，当执行 transform 时，具有相同的列和相同的顺序。
  
  回复
Gabriele Simonetta 2020年9月24日下午7:57 #

早上好，
我想知道如何重新处理并获得超出 0-1 范围的预测值。
关于激活函数的一个解决方案是使用“relu”函数，但无论如何，我不明白为什么预测值仍然等于 1。

回复
- Jason Brownlee 2020年9月25日上午6:36 #
  
  您可以使用线性输出来作为您的模型，然后编写代码将输出缩放到您需要的任何范围。
  
  回复
Logan 2020年10月17日上午9:11 #

嗨，Jason，

很棒的文章！我正在使用您的代码和我的数据集，但我有大约 70 个输入。预测概率远低于应有水平，我想知道您是否有任何建议如何解决这个问题。我是神经网络的新手，我认为我可能需要大量更改架构。

回复
- Jason Brownlee 2020年10月17日下午1:43 #
  
  谢谢！
  
  是的，这里有一些关于改进神经网络性能的建议。
  https://machinelearning.org.cn/start-here/#better
  
  回复
HSA 2020年10月26日上午3:23 #

为什么我用 predict_proba 得到一个输出？
X=[0.98656553]

回复
- HSA 2020年10月26日上午5:46 #
  
  鉴于我需要两个值，因为我需要它们作为函数的输入
  
  回复
- Jason Brownlee 2020年10月26日上午6:52 #
  
  如果您提供一个样本作为输入，您将得到一个输出。
  
  回复
HSA 2020年11月5日上午4:26 #

我有一个估计器，它返回两个值
(predicted_labels, log_probs) = create_model( is_predicting, input_ids, input_mask, segment_ids, label_ids, num_labels)
log_probs 应该返回每个类的概率，为什么我得到这个结果
array([-6.2299333e+00, -1.9715650e-03], dtype=float32)

回复
- Jason Brownlee 2020年11月5日上午6:39 #
  
  它们是接近零的小值。
  
  回复
HSA 2020年11月5日下午7:10 #

是的，但我期望得到类似 [0.70, 0.30] 这样的每个类的概率，它们的总和为 1……

回复
- Jason Brownlee 2020年11月6日上午5:53 #
  
  只有在使用输出层中的 softmax 激活函数时，您才会得到每个类的概率 – 例如，用于多类分类，而不是二元分类。
  
  回复
Ankit Singh 2020年11月28日上午7:26 #

先生，我们如何使用 ELM 和 F 分数进行测谎？您能解释或帮助我吗？

回复
- Jason Brownlee 2020年11月28日上午7:47 #
  
  也许这个过程会帮助您完成您的项目
  https://machinelearning.org.cn/start-here/#process
  
  回复
Peyman 2021年2月24日下午3:30 #

你好 Jason，
我有一个问题。我为回归目的训练了 1d-CNN。我在输出密集层使用了 sigmoid 激活函数，以将结果限制在 0 到 1 之间。但是当我进行预测时，我的模型只有在第一次运行时才能给出准确的结果。当我第二次使用它时，准确率会下降。每次我运行时，准确率都会以一种模式下降（可能是 2% 或 3%）。
我训练模型时使用了 seeding。
有什么关于问题来源的想法吗？谢谢

回复
- Jason Brownlee 2021年2月25日上午5:24 #
  
  对于回归问题，Sigmoid 激活不适合输出层，您必须使用线性激活。
  
  此外，准确率不是回归的适当指标，您必须使用误差，如 RMSE 或 MAE。
  
  回复
  - Peyman 2021年2月25日下午2:16 #
    
    感谢您的回复。我更改了激活函数。但每次我在相同输入上运行模型时，结果都会越来越差（这次我使用 R2 和 RMSE 测试了它）。只有我第一次运行模型时，我才能得到好的结果。
    谢谢
    
    回复
    - Jason Brownlee 2021年2月26日凌晨4:54 #
      
      也许可以尝试替代的数据准备、替代的模型配置或替代的模型。
      
      回复
Carlos Meza 2021年3月13日凌晨1:27 #

这太有用了。我想知道是否可以根据您在此处展示的示例计算F1分数、精确率和召回率。我正在用我的数据重现您的示例，但我一直在努力弄清楚如何获得这些值。我想知道您是否能为此提供建议。

诚挚的问候，

回复
- Jason Brownlee 2021年3月13日凌晨5:34 #
  
  好的，请看这里：
  https://machinelearning.org.cn/how-to-calculate-precision-recall-f1-and-more-for-deep-learning-models/
  
  回复
joshep 2021年5月15日下午2:30 #

您使用的是哪种神经网络？深度神经网络还是人工神经网络？我不知道DNN和ANN的区别

回复
- Jason Brownlee 2021年5月16日凌晨5:31 #
  
  没有区别。
  
  回复
Viren 2021年5月20日凌晨3:44 #

我使用了您的代码进行预测，每次运行代码时，对于相同的输入数据，我都会得到不同的预测结果，如何解决这个问题？

回复
- Jason Brownlee 2021年5月20日凌晨5:49 #
  
  好问题，请看这个
  https://machinelearning.org.cn/faq/single-faq/why-do-i-get-different-results-each-time-i-run-the-code
  
  回复
Ray 2021年8月19日凌晨3:55 #

嗨，Jason，
我正在使用keras和tensorflow版本2.6.0，在执行‘predict_classes’时遇到以下错误：AttributeError: ‘Sequential’ object has no attribute ‘predict_classes’。您知道如何解决这个问题吗？

回复
- Adrian Tam 2021年8月19日凌晨5:42 #
  
  在这种情况下，您需要使用argmax与predict结果，例如np.argmax(y_pred, axis=1)
  
  回复
Muhammad Putra 2021年11月17日下午3:25 #

你好，我想问你，我们能预测nan/缺失值数据吗？如果可以，如何预测nan/缺失值数据，谢谢

回复
- Adrian Tam 2021年11月18日凌晨5:33 #
  
  技术上来说不能。但如果你是指从某个地方收集数据，并且你想预测是否会看到nan或缺失值，那么这是一个二元分类问题。在这种情况下，你可以构建一个模型来预测它。
  
  回复
  - Putra 2021年11月27日晚上10:46 #
    
    好的Adrain，我的意思是，用缺失数据训练神经网络是否可行？因为我已经尝试过，结果显示损失值且结果也是nan。
    
    回复
    - Adrian Tam 2021年11月29日凌晨8:49 #
      
      神经网络基于可微分函数和矩阵乘法。因此，不应该有NaN值输入到神经网络中。你要么用某个值替换它们，要么不要用神经网络来处理。
      
      回复
Putra 2021年11月29日下午1:22 #

好的，Adrian，谢谢你的回答。我已经运行了我的神经网络，训练和测试数据的比例是0.1（训练数据）和0.9（测试数据），结果显示相关系数为0.9。为什么会这样呢？因为所有人都说，如果你训练数据量很少，结果一定会很糟糕。

回复
- Adrian Tam 2021年12月2日凌晨12:26 #
  
  不一定糟糕，但更有可能糟糕。在你的情况下，也许你只是运气好（或者数据集的性质非常适合）。
  为了理解发生了什么，可以想想线性回归（最简单的机器学习模型）——如果所有点都完美地在线上，你只需要数据集中的两个点就可以得到一个完美的模型。
  
  回复
  - Muhammad Putra 2021年12月11日下午2:05 #
    
    如果我们想预测一些NaN值，应该使用没有NaN值的训练数据吗？或者我们可以使用有NaN值的训练数据？
    
    回复
    - Adrian Tam 2021年12月15日凌晨5:48 #
      
      将其作为一个二元分类模型，判断是否为NaN。
      
      回复
William Booth 2021年12月16日晚上9:31 #

感谢您 Jason 的这篇文章。

我想知道是否可以打印出模型进行的预测，以及该预测达到的概率。

例如，模型预测将是75-251之间的整数——那么我如何看到这个结果的概率呢？

要生成这个初始预测（75-251），输出层有1个神经元，没有Sigmoid/Softmax函数。

由于最后一层没有Sigmoid/Softmax函数，因此无法标准化以进行概率预测。但是，如果我添加了它们，我就无法进行初始预测。

我猜想它会是predict_和predict_proba的组合，但我已经把自己搞糊涂了，甚至不确定这是否可能？

任何建议/指导都将不胜感激。

谢谢你

下面的一个简单示例

model1 = Sequential()
model1.add(Dense(250, input_dim=5))
model1.add(BatchNormalization())
model1.add(Activation(‘relu’))
model1.add(Dense(1))
model1.compile(loss=’mse’, optimizer=’Adam’)
model1.fit(X, y, validation_split=0.25, epochs=10, batch_size=32, verbose=1)

Xnew = array([[118,1,1,0,0]])
ynew = model1(Xnew)
print(ynew)

输出: 158.35785

回复
- Adrian Tam 2021年12月17日凌晨7:25 #
  
  在这种情况下，您如何定义概率？
  
  回复
William Booth 2021年12月17日晚上8:22 #

你好Adrian。我想要定义的概率是输出158.35785发生的可能性。模型是否可能做出预测（在本例中为158.35785），同时预测其发生的概率？

回复
- Adrian Tam 2021年12月19日下午1:40 #
  
  我会说概率为零。这是任何连续变量的性质。但即便如此，与线性回归不同的是，神经网络本身并不能自然地提供结果的误差范围。
  
  回复
Putra 2021年12月21日凌晨1:47 #

我已经尝试过，但结果仍然是NaN值，我无法预测NaN值。

回复
- Muhammad Putra 2021年12月21日凌晨1:48 #
  
  此消息回复您“将其作为一个二元分类模型，判断是否为NaN。”您之前的信息是“如果我们想预测一些NaN值，应该使用没有NaN值的训练数据吗？或者我们可以使用有NaN值的训练数据？”
  
  回复
Fatimah Aloraini 2022年11月24日凌晨5:13 #

你好Adrian Tam，
感谢您提供如此精彩的内容，

我正在处理一个二元分类问题（IDS，具有正常和恶意数据包），我正在使用序列模型
来自keras的模型。我的问题是如何在每个单个样本中获得两个类别的概率预测，例如，一个函数

predict (x)，
它返回 - > [0:（类别0的概率），1:（类别1的概率）]

回复
- James Carmichael 2022年11月24日早上7:33 #
  
  Fatimah，非常欢迎！如果您有任何我们可以帮助您的问题，请告诉我们！
  
  回复
Fatimah Aloraini 2022年11月26日凌晨5:33 #

谢谢你，
我正在处理一个二元分类问题（IDS，具有正常和恶意数据包），我正在使用序列模型
来自keras的模型。我的问题是如何在每个单个样本中获得两个类别的概率预测，例如，一个函数

predict (x)，
它返回 - > [0:（类别0的概率），1:（类别1的概率）]

回复
AmBG 2023年9月22日下午6:49 #

你好@Jason！
首先，非常感谢您发布的所有精彩文章！！

我的问题是：当您要预测一个先前已训练好的模型（最终选定的模型）时，用于预测输出变量的输入数据是否必须以与训练数据相同的方式进行预处理（清理异常值、选择重要特征……）？

非常感谢！

回复
- James Carmichael 2023年9月23日下午1:07 #
  
  你好AmBG……非常欢迎！以下资源可能对您感兴趣
  
  https://machinelearning.org.cn/what-is-generalization-in-machine-learning/
  
  回复

导航

如何使用 Keras 进行预测

教程概述

回归预测

您现在必须在所有可用数据上训练一个最终模型。您可以在此处了解更多关于如何训练最终模型的信息。

使用最终确定的模型，我们可能需要进行两种类型的分类预测：类别预测和概率预测。

运行示例，打印单个实例和预测的类别。

因此，您可能希望在拟合最终模型时保存（pickle）用于编码 `y` 值的 LabelEncoder。

如果您的应用程序需要将概率呈现给用户进行专家解读，这将很有帮助。

进一步阅读

总结

关于此主题的更多信息

最后机会：Stefan Krawcyzk 的“机器学习运维大师”现场课程

发表回复点击此处取消回复。

导航

教程概述

回归预测

您现在必须在所有可用数据上训练一个最终模型。您可以在此处了解更多关于如何训练最终模型的信息。

使用最终确定的模型，我们可能需要进行两种类型的分类预测：类别预测和概率预测。

运行示例，打印单个实例和预测的类别。

因此，您可能希望在拟合最终模型时保存（pickle）用于编码 `y` 值的 LabelEncoder。

如果您的应用程序需要将概率呈现给用户进行专家解读，这将很有帮助。

进一步阅读

总结

关于此主题的更多信息

最后机会：Stefan Krawcyzk 的“机器学习运维大师”现场课程

发表回复 点击此处取消回复。

发表回复点击此处取消回复。