Keras 是一个深度学习库，它封装了高效的数值计算库 Theano 和 TensorFlow。
在本帖中，您将了解如何使用 Keras 为回归问题开发和评估神经网络模型。
完成本分步教程后，您将了解
- 如何加载 CSV 数据集并使其可供 Keras 使用
- 如何使用 Keras 为回归问题创建神经网络模型
- 如何使用 scikit-learn 和 Keras 通过交叉验证评估模型
- 如何进行数据准备以提高 Keras 模型的性能
- 如何使用 Keras 调整模型的网络拓扑结构
立即开始您的项目，阅读我的新书《Python 深度学习》，其中包含分步教程和所有示例的Python 源代码文件。
让我们开始吧。
- 2016 年 6 月：首次发布
- 2017 年 3 月更新：更新至 Keras 2.0.2、TensorFlow 1.0.1 和 Theano 0.9.0
- 更新于 2018 年 3 月：由于原始数据集下载链接已失效，已添加备用下载链接。
- 更新于 2018 年 4 月：将 nb_epoch 参数更改为 epochs。
- 2019 年 9 月更新：更新至 Keras 2.2.5 API
- 更新于 2022 年 7 月：使用 SciKeras 更新 TensorFlow 2.x 语法。
使用 Python Keras 深度学习库进行回归教程
照片由 Salim Fadhley 拍摄，保留部分权利。
1. 问题描述
本教程将要解决的问题是 波士顿房价数据集。
您可以下载此数据集并将其保存在当前工作目录中，文件名为 housing.csv (更新：在此处下载数据)。
该数据集描述了波士顿郊区房屋的 13 个数值属性，旨在对这些郊区房屋的价格进行建模，单位为千美元。因此，这是一个回归预测建模问题。输入属性包括犯罪率、非零售商业用地面积比例、化学浓度等。
这是机器学习中一个经过充分研究的问题。它易于处理，因为所有输入和输出属性都是数值型的，并且有 506 个样本可供使用。
使用均方误差 (MSE) 评估的模型，合理的性能目标约为 20（千美元的平方）（或取平方根为 4500 美元）。这是我们神经网络模型的一个不错的目标。
Python 深度学习需要帮助吗？
参加我的免费为期两周的电子邮件课程，发现 MLP、CNN 和 LSTM（附代码）。
立即点击注册，还将免费获得本课程的 PDF 电子书版本。
2. 开发基线神经网络模型
在本节中，您将为回归问题创建一个基线神经网络模型。
让我们开始包含本教程所需的所有函数和对象。
|
1 2 3 4 5 6 7 8 9 |
import pandas as pd from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense from scikeras.wrappers import KerasRegressor from sklearn.model_selection import cross_val_score from sklearn.model_selection import KFold from sklearn.preprocessing import StandardScaler from sklearn.pipeline import Pipeline ... |
您现在可以从本地目录中的文件中加载数据集。
UCI 机器学习库中的数据集实际上不是 CSV 格式。属性由空格分隔。您可以使用 pandas 库轻松加载它。然后分割输入 (X) 和输出 (Y) 属性，以便更容易地使用 Keras 和 scikit-learn 进行建模。
|
1 2 3 4 5 6 7 |
... # 加载数据集 dataframe = pd.read_csv("housing.csv", delim_whitespace=True, header=None) dataset = dataframe.values # 分割为输入 (X) 和输出 (Y) 变量 X = dataset[:,0:13] Y = dataset[:,13] |
您可以使用 Keras 库提供的便捷包装器对象来创建 Keras 模型并使用 scikit-learn 进行评估。这是可取的，因为 scikit-learn 在评估模型方面表现出色，并且允许您使用强大的数据准备和模型评估方案，只需几行代码。
Keras 包装器需要一个函数作为参数。您必须定义的此函数负责创建要评估的神经网络模型。
下面，您将定义创建要评估的基线模型所需的函数。它是一个简单的模型，具有一个完全连接的隐藏层，其神经元数量与输入属性（13 个）相同。该网络使用了良好的实践，例如用于隐藏层的整流器激活函数。输出层不使用激活函数，因为这是一个回归问题，您有兴趣直接预测数值，而无需进行转换。
该模型使用了高效的 ADAM 优化算法，并优化了均方误差损失函数。这将是您用来评估模型性能的相同指标。这是一个理想的指标，因为它的平方根可以给出您可以直接理解的问题背景（千美元）下的误差值。
如果您不熟悉 Keras 或深度学习，请参阅此 Keras 教程。
|
1 2 3 4 5 6 7 8 9 10 |
... # 定义基本模型 def baseline_model(): # 创建模型 model = Sequential() model.add(Dense(13, input_shape=(13,), kernel_initializer='normal', activation='relu')) model.add(Dense(1, kernel_initializer='normal')) # 编译模型 model.compile(loss='mean_squared_error', optimizer='adam') return model |
在 scikit-learn 中用作回归估计器的 Keras 包装器对象称为 KerasRegressor。您创建一个实例，并将创建神经网络模型的函数名以及要稍后传递给模型 fit() 函数的一些参数（如 epochs 和 batch size）传递给它。这两者都设置为合理的默认值。
最后一步是评估此基线模型。您将使用 10 折交叉验证来评估模型。
|
1 2 3 4 |
... kfold = KFold(n_splits=10) results = cross_val_score(estimator, X, Y, cv=kfold, scoring='neg_mean_squared_error') print("Results: %.2f (%.2f) MSE" % (results.mean(), results.std())) |
将以上所有内容整合在一起，完整的示例如下。
|
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 |
# 使用波士顿数据集的回归示例：基线 from pandas import read_csv from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense from scikeras.wrappers import KerasRegressor from sklearn.model_selection import cross_val_score from sklearn.model_selection import KFold # 加载数据集 dataframe = read_csv("housing.csv", delim_whitespace=True, header=None) dataset = dataframe.values # 分割为输入 (X) 和输出 (Y) 变量 X = dataset[:,0:13] Y = dataset[:,13] # 定义基本模型 def baseline_model(): # 创建模型 model = Sequential() model.add(Dense(13, input_shape=(13,), kernel_initializer='normal', activation='relu')) model.add(Dense(1, kernel_initializer='normal')) # 编译模型 model.compile(loss='mean_squared_error', optimizer='adam') return model # 评估模型 estimator = KerasRegressor(model=baseline_model, epochs=100, batch_size=5, verbose=0) kfold = KFold(n_splits=10) results = cross_val_score(estimator, X, Y, cv=kfold, scoring='neg_mean_squared_error') print("Baseline: %.2f (%.2f) MSE" % (results.mean(), results.std())) |
运行此代码可估算模型在未知数据上的问题表现。
注意：您的 结果可能因算法或评估程序的随机性，或数值精度的差异而有所不同。请尝试运行示例几次并比较平均结果。
注意：均方误差为负，因为 scikit-learn 会将其反转，以便最大化度量而不是最小化。您可以忽略结果的符号。
结果报告了均方误差，包括交叉验证评估的十个折叠的平均值和标准差（平均方差）。
|
1 |
基线：-32.65 (23.33) MSE |
3. 标准化数据集建模
波士顿房价数据集中一个重要的考虑因素是输入属性的尺度各不相同，因为它们度量不同的量。
在通过神经网络模型进行建模之前，准备数据几乎总是最佳实践。
在上述基线模型的基础上，您可以使用标准化版本的数据集重新评估相同的模型。
您可以使用 scikit-learn 的 Pipeline 框架在交叉验证的每个折叠的模型评估过程中执行标准化。这确保了每个交叉验证测试集都没有数据泄露到训练数据中。
以下代码创建了一个 scikit-learn 管道，该管道首先标准化数据集，然后创建并评估基线神经网络模型。
|
1 2 3 4 5 6 7 8 9 |
... # 使用标准化数据集评估模型 estimators = [] estimators.append(('standardize', StandardScaler())) estimators.append(('mlp', KerasRegressor(model=baseline_model, epochs=50, batch_size=5, verbose=0))) pipeline = Pipeline(estimators) kfold = KFold(n_splits=10) results = cross_val_score(pipeline, X, Y, cv=kfold, scoring='neg_mean_squared_error') print("Standardized: %.2f (%.2f) MSE" % (results.mean(), results.std())) |
将以上所有内容整合在一起，完整的示例如下。
|
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 |
# 使用波士顿数据集的回归示例：标准化 from pandas import read_csv from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense from scikeras.wrappers import KerasRegressor from sklearn.model_selection import cross_val_score from sklearn.model_selection import KFold from sklearn.preprocessing import StandardScaler from sklearn.pipeline import Pipeline # 加载数据集 dataframe = read_csv("housing.csv", delim_whitespace=True, header=None) dataset = dataframe.values # 分割为输入 (X) 和输出 (Y) 变量 X = dataset[:,0:13] Y = dataset[:,13] # 定义基本模型 def baseline_model(): # 创建模型 model = Sequential() model.add(Dense(13, input_shape=(13,), kernel_initializer='normal', activation='relu')) model.add(Dense(1, kernel_initializer='normal')) # 编译模型 model.compile(loss='mean_squared_error', optimizer='adam') return model # 使用标准化数据集评估模型 estimators = [] estimators.append(('standardize', StandardScaler())) estimators.append(('mlp', KerasRegressor(model=baseline_model, epochs=50, batch_size=5, verbose=0))) pipeline = Pipeline(estimators) kfold = KFold(n_splits=10) results = cross_val_score(pipeline, X, Y, cv=kfold, scoring='neg_mean_squared_error') print("Standardized: %.2f (%.2f) MSE" % (results.mean(), results.std())) |
注意：您的 结果可能因算法或评估程序的随机性，或数值精度的差异而有所不同。请尝试运行示例几次并比较平均结果。
运行该示例，性能相比未经标准化的基线模型有所提高，误差有所下降。
|
1 |
标准化：-29.54 (27.87) MSE |
本节的进一步扩展是将输出变量也进行类似地重缩放，例如将其归一化到 0-1 范围，并在输出层使用 Sigmoid 或类似激活函数，将输出预测限制在同一范围内。
4. 调整神经网络拓扑
神经网络模型可以优化许多方面。
也许最重要的杠杆点是网络结构本身，包括层数和每层的神经元数量。
在本节中，您将评估两种额外的网络拓扑，以期进一步提高模型性能。您将同时考察更深层和更宽的网络拓扑。
4.1. 评估更深的网络拓扑
提高神经网络性能的一种方法是增加层数。这可能允许模型提取和重组数据中嵌入的高阶特征。
在本节中，您将评估在模型中增加一个隐藏层的效果。这就像定义一个新函数来创建这个更深层的模型一样容易，该函数复制了上面您基线模型。您可以将新的一行插入到第一个隐藏层之后——在本例中，神经元数量大约是原来的一半。
|
1 2 3 4 5 6 7 8 9 10 11 |
... # 定义模型 def larger_model(): # 创建模型 model = Sequential() model.add(Dense(13, input_shape=(13,), kernel_initializer='normal', activation='relu')) model.add(Dense(6, kernel_initializer='normal', activation='relu')) model.add(Dense(1, kernel_initializer='normal')) # 编译模型 model.compile(loss='mean_squared_error', optimizer='adam') return model |
您的网络拓扑现在看起来像这样
|
1 |
13 个输入 -> [13 -> 6] -> 1 个输出 |
您可以像上面一样评估此网络拓扑，同时还可以使用上述数据集的标准化来提高性能。
|
1 2 3 4 5 6 7 8 |
... estimators = [] estimators.append(('standardize', StandardScaler())) estimators.append(('mlp', KerasRegressor(model=larger_model, epochs=50, batch_size=5, verbose=0))) pipeline = Pipeline(estimators) kfold = KFold(n_splits=10) results = cross_val_score(pipeline, X, Y, cv=kfold, scoring='neg_mean_squared_error') print("Larger: %.2f (%.2f) MSE" % (results.mean(), results.std())) |
将以上所有内容整合在一起，完整的示例如下。
|
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 |
# 使用波士顿数据集的回归示例：标准化和更深层 from pandas import read_csv from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense from scikeras.wrappers import KerasRegressor from sklearn.model_selection import cross_val_score from sklearn.model_selection import KFold from sklearn.preprocessing import StandardScaler from sklearn.pipeline import Pipeline # 加载数据集 dataframe = read_csv("housing.csv", delim_whitespace=True, header=None) dataset = dataframe.values # 分割为输入 (X) 和输出 (Y) 变量 X = dataset[:,0:13] Y = dataset[:,13] # 定义模型 def larger_model(): # 创建模型 model = Sequential() model.add(Dense(13, input_shape=(13,), kernel_initializer='normal', activation='relu')) model.add(Dense(6, kernel_initializer='normal', activation='relu')) model.add(Dense(1, kernel_initializer='normal')) # 编译模型 model.compile(loss='mean_squared_error', optimizer='adam') return model # 使用标准化数据集评估模型 estimators = [] estimators.append(('standardize', StandardScaler())) estimators.append(('mlp', KerasRegressor(model=larger_model, epochs=50, batch_size=5, verbose=0))) pipeline = Pipeline(estimators) kfold = KFold(n_splits=10) results = cross_val_score(pipeline, X, Y, cv=kfold, scoring='neg_mean_squared_error') print("Larger: %.2f (%.2f) MSE" % (results.mean(), results.std())) |
注意：您的 结果可能因算法或评估程序的随机性，或数值精度的差异而有所不同。请尝试运行示例几次并比较平均结果。
运行此模型显示性能进一步提高，从 28 降至 24 千美元的平方。
|
1 |
更深层：-22.83 (25.33) MSE |
4.2. 评估更宽的网络拓扑
增加模型表示能力的另一种方法是创建更宽的网络。
在本节中，您将评估保持浅层网络结构并将隐藏层中的神经元数量几乎翻倍的效果。
同样，您需要做的就是定义一个新函数来创建您的神经网络模型。在这里，您将增加隐藏层中的神经元数量，与基线模型相比，从 13 个增加到 20 个。
|
1 2 3 4 5 6 7 8 9 10 |
... # 定义更宽的模型 def wider_model(): # 创建模型 model = Sequential() model.add(Dense(20, input_shape=(13,), kernel_initializer='normal', activation='relu')) model.add(Dense(1, kernel_initializer='normal')) # 编译模型 model.compile(loss='mean_squared_error', optimizer='adam') return model |
您的网络拓扑现在看起来像这样
|
1 |
13 个输入 -> [20] -> 1 个输出 |
您可以使用与上述相同的方案评估更宽的网络拓扑
|
1 2 3 4 5 6 7 8 |
... estimators = [] estimators.append(('standardize', StandardScaler())) estimators.append(('mlp', KerasRegressor(model=wider_model, epochs=100, batch_size=5, verbose=0))) pipeline = Pipeline(estimators) kfold = KFold(n_splits=10) results = cross_val_score(pipeline, X, Y, cv=kfold, scoring='neg_mean_squared_error') print("Wider: %.2f (%.2f) MSE" % (results.mean(), results.std())) |
将以上所有内容整合在一起，完整的示例如下。
|
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 |
# 使用波士顿数据集的回归示例：标准化和更宽 from pandas import read_csv from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense from scikeras.wrappers import KerasRegressor from sklearn.model_selection import cross_val_score from sklearn.model_selection import KFold from sklearn.preprocessing import StandardScaler from sklearn.pipeline import Pipeline # 加载数据集 dataframe = read_csv("housing.csv", delim_whitespace=True, header=None) dataset = dataframe.values # 分割为输入 (X) 和输出 (Y) 变量 X = dataset[:,0:13] Y = dataset[:,13] # 定义更宽的模型 def wider_model(): # 创建模型 model = Sequential() model.add(Dense(20, input_shape=(13,), kernel_initializer='normal', activation='relu')) model.add(Dense(1, kernel_initializer='normal')) # 编译模型 model.compile(loss='mean_squared_error', optimizer='adam') return model # 使用标准化数据集评估模型 estimators = [] estimators.append(('standardize', StandardScaler())) estimators.append(('mlp', KerasRegressor(model=wider_model, epochs=100, batch_size=5, verbose=0))) pipeline = Pipeline(estimators) kfold = KFold(n_splits=10) results = cross_val_score(pipeline, X, Y, cv=kfold, scoring='neg_mean_squared_error') print("Wider: %.2f (%.2f) MSE" % (results.mean(), results.std())) |
注意：您的 结果可能因算法或评估程序的随机性，或数值精度的差异而有所不同。请尝试运行示例几次并比较平均结果。
构建模型显示误差进一步降至约 21 千美元的平方。对于这个问题来说，这算是不错的结果。
|
1 |
更宽：-21.71 (24.39) MSE |
也许很难猜到更宽的网络会比更深的网络在此问题上表现更好。结果证明了经验测试在开发神经网络模型中的重要性。
总结
在本帖中，您了解了用于对回归问题进行建模的 Keras 深度学习库。
通过本教程，您学会了如何开发和评估神经网络模型，包括：
- 如何加载数据并开发基线模型
- 如何通过数据准备技术（如标准化）来提升性能
- 如何在问题上设计和评估具有不同拓扑结构的神经网络
您对 Keras 深度学习库或本帖有任何疑问吗？请在评论中提问，我将尽力回答。
您好，您在 cross_val_score 模块中处理过字符串变量吗？
数据集是数值型的，没有字符串值。
我们如何处理字符串值？
好问题，我有一个关于这个主题的完整章节。
https://machinelearning.org.cn/start-here/#nlp
出于某种原因，我的 MSE 是负数。为什么？
sklearn 会反转 MSE，以便可以最大化它。
One hot encoder 是一个选项。
你好，
我有
2 个输入集（即 2 列），而不是这个问题中的 13 列
8 个输出（8 列），而不是这个问题中的 1 列
506 个训练集中的 192 个，而不是这个问题中的 506 个
所以是多输入多输出预测建模
这段代码是否足够？还是我需要更改任何内容？
这是深度学习吗？因为我听说深度学习需要数千个训练集。
请原谅我，我对深度学习一无所知，并且将从这段代码开始。
我正在等待您的回复
如果您预测的是 8 个实值变量（而不是 8 个类别），您可以将输出层的节点数更改为 8。
感谢您的快速回复。
所以，我只需要更改输出层，对吗？
现在，我还有一些问题。
如果我使用此代码获得结果，我需要知道一些详细信息。
1）我猜这是最新的深度神经网络。这种神经网络叫什么名字？（例如，循环神经网络、多层感知机、玻尔兹曼机等）
2）在深度学习中，需要通过调整参数来调整参数。
这里的参数有哪些是我需要调整的？
3）您能否发送一张图片，显示神经网络的完整架构，包括输入层、隐藏层、输出层、传输函数等？
4）因为我将使用这段代码，所以我需要在要写的期刊中引用它。
我应该直接引用这个网站还是您建议我引用的任何论文？
为了帮助您调整模型，我建议从这里开始。
https://machinelearning.org.cn/start-here/#better
您可以在此处总结您模型的架构，了解更多信息。
https://machinelearning.org.cn/visualize-deep-learning-neural-network-model-keras/
我在这里展示了如何引用帖子或书籍。
https://machinelearning.org.cn/faq/single-faq/how-do-i-reference-or-cite-a-book-or-blog-post
布朗利先生，
如果我有一个多输入多输出的回归问题，例如 4 个输入和 4 个输出，那么我该如何处理？
模型可以定义为接受 4 个输入，然后您可以在输出层拥有 4 个节点。
非常感谢您的善意和及时的回复，Jason 先生。
不客气。
另外，在多输出的情况下，我们在 keras 中进行预测和准确率的方式与单输出情况相同吗？我刚接触深度学习，所以很抱歉我的问题可能有些天真。
您可以为所有输出以及/或每个单独的输出计算一个分数。
训练时，keras 将使用单个损失函数，但您的项目利益相关者在评估最终模型时可能有更多要求。
Jason 先生，如果我在我的系统上运行您的代码，我会收到一个错误。
TypeError: (‘Keyword argument not understood:’, ‘acitivation’)
您能解释一下为什么吗？
Ganesh
很抱歉听到这个消息，我在这里有一些建议。
https://machinelearning.org.cn/faq/single-faq/why-does-the-code-in-the-tutorial-not-work-for-me
您应该键入“activation”，而不是在“c”后面加上“i”。
# 使用波士顿数据集的回归示例：标准化和更宽
import pandas as pd
来自 keras.models import Sequential
from keras.layers import Dense
from keras.wrappers.scikit_learn import KerasRegressor
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import KFold
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
# 加载数据集
dataset = pd.read_csv(‘train1.csv’)
testthedata = pd.read_csv(‘test1.csv’)
# 分割为输入 (X) 和输出 (Y) 变量
X = dataset.drop(columns = [“Id”, “SalePrice”, “Alley”, “MasVnrType”, “BsmtQual”, “BsmtCond”, “BsmtExposure”,
“BsmtFinType1”, “BsmtFinType2”, “Electrical”, “FireplaceQu”, “GarageType”,
“GarageFinish”, “GarageQual”, “GarageCond”, “PoolQC”, “Fence”, “MiscFeature”])
y = dataset[‘SalePrice’].values
testthedata = testthedata.drop(columns = [“MSZoning”, “Utilities”, “Id”, “Alley”, “MasVnrType”, “BsmtQual”, “BsmtCond”, “BsmtExposure”,
“Exterior1st”, “Exterior2nd”, “BsmtFinType1”, “BsmtFinType2”, “Electrical”, “FireplaceQu”, “GarageType”,
“KitchenQual”, “SaleType”, “Functional”, “GarageFinish”, “GarageQual”, “GarageCond”, “PoolQC”, “Fence”, “MiscFeature”])
from sklearn.preprocessing import LabelEncoder, OneHotEncoder
le = LabelEncoder()
le1 = LabelEncoder()
X[‘MSZoning’] = le.fit_transform(X[[‘MSZoning’]])
X[‘Street’] = le.fit_transform(X[[‘Street’]])
X[‘LotShape’] = le.fit_transform(X[[‘LotShape’]])
X[‘LandContour’] = le.fit_transform(X[[‘LandContour’]])
X[‘LotConfig’] = le.fit_transform(X[[‘LotConfig’]])
X[‘LandSlope’] = le.fit_transform(X[[‘LandSlope’]])
X[‘Utilities’] = le.fit_transform(X[[‘Utilities’]])
X[‘Neighborhood’] = le.fit_transform(X[[‘Neighborhood’]])
X[‘Condition1’] = le.fit_transform(X[[‘Condition1’]])
X[‘Condition2’] = le.fit_transform(X[[‘Condition2’]])
X[‘BldgType’] = le.fit_transform(X[[‘BldgType’]])
X[‘HouseStyle’] = le.fit_transform(X[[‘HouseStyle’]])
X[‘RoofStyle’] = le.fit_transform(X[[‘RoofStyle’]])
X[‘RoofMatl’] = le.fit_transform(X[[‘RoofMatl’]])
X[‘Exterior1st’] = le.fit_transform(X[[‘Exterior1st’]])
X[‘Exterior2nd’] = le.fit_transform(X[[‘Exterior2nd’]])
X[‘ExterQual’] = le.fit_transform(X[[‘ExterQual’]])
X[‘ExterCond’] = le.fit_transform(X[[‘ExterCond’]])
X[‘Foundation’] = le.fit_transform(X[[‘Foundation’]])
X[‘Heating’] = le.fit_transform(X[[‘Heating’]])
X[‘HeatingQC’] = le.fit_transform(X[[‘HeatingQC’]])
X[‘KitchenQual’] = le.fit_transform(X[[‘KitchenQual’]])
X[‘Functional’] = le.fit_transform(X[[‘Functional’]])
X[‘PavedDrive’] = le.fit_transform(X[[‘PavedDrive’]])
X[‘SaleType’] = le.fit_transform(X[[‘SaleType’]])
X[‘SaleCondition’] = le.fit_transform(X[[‘SaleCondition’]])
#testing[‘MSZoning’] = le1.fit_transform(testing[[‘MSZoning’]])
testthedata[‘Street’] = le1.fit_transform(testthedata[[‘Street’]])
testthedata[‘LotShape’] = le1.fit_transform(testthedata[[‘LotShape’]])
testthedata[‘LandContour’] = le1.fit_transform(testthedata[[‘LandContour’]])
testthedata[‘LotConfig’] = le1.fit_transform(testthedata[[‘LotConfig’]])
#testthedata[‘LandSlope’] = le1.testthedata(testthedata[[‘LandSlope’]])
#testing[‘Utilities’] = le1.fit_transform(testing[[‘Utilities’]])
testthedata[‘Neighborhood’] = le1.fit_transform(testthedata[[‘Neighborhood’]])
testthedata[‘Condition1’] = le1.fit_transform(testthedata[[‘Condition1’]])
#testthedata[‘Condition2’] = le1.fit_transform(testthedata[[‘Condition2’]])
testthedata[‘BldgType’] = le1.fit_transform(testthedata[[‘BldgType’]])
testthedata[‘HouseStyle’] = le1.fit_transform(testthedata[[‘HouseStyle’]])
testthedata[‘RoofStyle’] = le1.fit_transform(testthedata[[‘RoofStyle’]])
#testthedata[‘RoofMatl’] = le1.fit_transform(testthedata[[‘RoofMatl’]])
#testing[‘Exterior1st’] = le1.fit_transform(testing[[‘Exterior1st’]])
#testing[‘Exterior2nd’] = le1.fit_transform(testing[[‘Exterior2nd’]])
testthedata[‘ExterQual’] = le1.fit_transform(testthedata[[‘ExterQual’]])
#testthedata[‘ExterCond’] = le1.fit_transform(testthedata[[‘ExterCond’]])
testthedata[‘Foundation’] = le1.fit_transform(testthedata[[‘Foundation’]])
testthedata[‘Heating’] = le1.fit_transform(testthedata[[‘Heating’]])
#testthedata[‘HeatingQC’] = le1.fit_transform(testthedata[[‘HeatingQC’]])
#testing[‘KitchenQual’] = le1.fit_transform(testing[[‘KitchenQual’]])
#testing[‘Functional’] = le1.fit_transform(testing[[‘Functional’]])
testthedata[‘PavedDrive’] = le1.fit_transform(testthedata[[‘PavedDrive’]])
#testing[‘SaleType’] = le1.fit_transform(testing[[‘SaleType’]])
testthedata[‘SaleCondition’] = le1.fit_transform(testthedata[[‘SaleCondition’]])
X[‘MSZoning’] = pd.to_numeric(X[‘MSZoning’])
ohe = OneHotEncoder(categorical_features = [1])
X = ohe.fit_transform(X).toarray()
对于这段代码，出现了错误，如何纠正它，先生？
File “”, line 1, in
X = ohe.fit_transform(X).toarray()
File “/Users/p.venkatesh/opt/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/_encoders.py”, line 629, in fit_transform
self._categorical_features, copy=True)
File “/Users/p.venkatesh/opt/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/base.py”, line 45, in _transform_selected
X = check_array(X, accept_sparse=’csc’, copy=copy, dtype=FLOAT_DTYPES)
File “/Users/p.venkatesh/opt/anaconda3/lib/python3.7/site-packages/sklearn/utils/validation.py”, line 496, in check_array
array = np.asarray(array, dtype=dtype, order=order)
File “/Users/p.venkatesh/opt/anaconda3/lib/python3.7/site-packages/numpy/core/_asarray.py”, line 85, in asarray
返回数组(a, dtype, copy=False, order=order)
ValueError: could not convert string to float: ‘Y’
也许这会有帮助。
https://machinelearning.org.cn/faq/single-faq/can-you-read-review-or-debug-my-code
如何衡量一个输出为连续变量的神经网络的性能，因为我显然不能使用准确率？
您可以使用误差指标。
https://machinelearning.org.cn/regression-metrics-for-machine-learning/
嗨，Jason，
很棒的教程（们），到目前为止它们对我来说非常有帮助，就像一个快速入门课程。
有没有办法让模型输出这个例子中的估计 Y 值？我想在我仍在学习 Keras 的时候更直接地评估模型。
谢谢！
你好 Paul，您可以通过调用 model.predict() 来进行预测。
嘿 Paul，
您是如何将 model.predict() 函数插入到上面的代码中以在测试数据上运行的？请告诉我。
你好，
这就是您插入 predict 并从模型中获取预测值的方式吗？
def mymodel()
model = Sequential()
model.add(Dense(13, input_dim=13, kernel_initializer=’normal’, activation=’relu’))
model.add(Dense(6, kernel_initializer=’normal’, activation=’relu’))
model.add(Dense(1, kernel_initializer=’normal’))
model.compile(loss='mean_squared_error', optimizer='adam')
model.fit(X,y, nb_epoch=50, batch_size=5)
predictions = model.predict(X)
return model
我实际上想将预测值写入文件？
DataScientistPM，
他正在使用 Scikit-Learn 的交叉验证框架，该框架必须在内部调用 fit。
正确。
你好，
但是如何获得单个 X 值的预测呢？
如果我尝试这样做
y_predict = mymodel.predict(x)
我收到此错误
AttributeError: ‘function’ object has no attribute ‘predict’。
我猜是因为我们调用了 Scikit-Learn，但不知道如何预测新值。
这是使用 sklearn 模型进行预测的方法。
https://machinelearning.org.cn/make-predictions-scikit-learn/
这是使用 Keras 模型进行预测的方法。
https://machinelearning.org.cn/how-to-make-classification-and-regression-predictions-for-deep-learning-models-in-keras/
您好，非常棒的帖子，谢谢！您能否提供一个如何使用 Keras LSTM 层来考虑此数据集上的时间影响的示例？
谢谢
谢谢你，Chris。
您可以在此处看到此数据集上 LSTM 的示例。
https://machinelearning.org.cn/time-series-prediction-lstm-recurrent-neural-networks-python-keras/
那太棒了，谢谢你 Jason。
不客气，Chris。
你好，
感谢教程。我有一个回归问题，输出有界（0-1）。是否有最佳方法来处理这个问题？
谢谢！
Marc
你好 Marc，我认为在线性激活函数上使用输出层就足够了。
这是一个很好的例子。但是，当考虑过拟合时，它与神经网络无关。为了监控过拟合状态，应将验证过程包含在 fit() 函数中。此外，可以基于内部验证步骤使用早停法。此示例仅适用于数据量相对于输入和隐藏节点总权重较大的情况。
非常感谢 James 的反馈，我同意。
它的目的是展示如何为回归开发网络，但数据集确实有点小。
感谢 Jason 和 James！有几个问题（以及如何在 python 中实现）
1) 如何监控深度学习中的过拟合状态？
2) 如何将交叉验证过程包含在 fit() 函数中以监控过拟合状态？
3) 如何基于内部验证步骤使用早停法？
4) 为什么这个示例仅适用于大型数据集？如果数据集很小，我们该怎么办？
Amir，这些都是很好的问题！
1. 监控模型在训练集和独立验证集上的性能。（甚至绘制这些学习曲线）。当验证集上的技能下降而训练集上的技能上升或持续上升时，您就过拟合了。
2. 交叉验证只是用于估算模型在未知数据上性能的一种方法。它封装了您准备数据和模型的所有操作，它不包含在 fit 中。
3. 如 1 所述，监控验证集上的技能，当验证集上的技能停止改进时，就停止训练。
4. 一般来说，神经网络需要比其他方法更多的数据来训练。
这是一个关于检查点的教程，您可以使用它来保存“早停”模型。
https://machinelearning.org.cn/check-point-deep-learning-models-keras/
你好，
如何在构建模型时使用 sklearn 对训练数据进行标准化，之后预测新数据点？
您可以保存用于标准化数据的对象，并在进行预测之前重用它来标准化新数据。这可能是 MinMaxScaler，例如。
您能举个例子说明如何做到这一点吗？
看这里
https://machinelearning.org.cn/standardscaler-and-minmaxscaler-transforms-in-python/
还有这个。
https://machinelearning.org.cn/how-to-save-and-load-models-and-data-preparation-in-scikit-learn-for-later-use/
你好，
我没有使用您所示的自动数据归一化，而是简单地计算训练数据中每个特征（数据列）的均值和标准差，然后手动执行 zscore（(data – mean) / stdev）。通过归一化，我的意思是将数据处理成均值为 0，标准差为 1。我知道这个过程有几种名称，但为了便于讨论，我们称之为“归一化”。
所以我有 2 个问题：
1) 我也应该对输出列进行归一化吗？或者只是将其保留在我的训练/测试数据中？
2) 我取训练数据的均值和标准差，并用它们来归一化测试数据。但似乎它并没有使我的数据居中；无论我如何分割数据，也无论每个小批量如何平衡（具有相同的输出值分布），情况都是如此。我遗漏了什么/我能做什么？
你好 Guy，是的，这通常称为标准化。
通常，您可以从对输出列应用相同的转换中获得良好的结果。尝试一下，看看它如何影响您的结果。如果 MSE 或 RMSE 是性能度量，您可能需要小心解释结果，因为这些分数的尺度也会改变。
是的，这是一个常见问题。理想情况下，您需要一个非常大的训练数据集来有效估算这些值。您可以尝试使用 bootstrap 对训练数据集（或交叉验证的折叠内）进行操作，以创建更稳健的这些项的估算。Bootstrap 只是对数据集进行重复的子采样并估算统计量，然后取所有估算的平均值。它效果很好。
希望这能有所帮助。
你好 Jason，
如何将多个指纹图像加载到 keras 中。
您能否进一步指导？
此致，
Pranith
你好 Jason，教程很棒。是免费中最好的。
我可以使用 R² 作为我的指标吗？如果可以，如何使用？
此致
谢谢 Luciano。
您可以使用 R^2，请参阅此指标列表，您可以使用这些指标。
https://scikit-learn.cn/stable/modules/model_evaluation.html
results.mean() 应该打印准确率而不是误差，对吗？
我们为回归问题总结误差而不是准确率（x/y 正确）。希望这有帮助。
你好，
如果我有一个新的数据集 X_new，并且想进行预测，model.predict(X_new) 会显示错误 “NameError: name model is not defined”，而 estimator.predict(X_test) 会显示错误消息 ‘KerasRegressor object has no attribute model’。
您有什么建议吗？谢谢。
你好 David，这篇帖子将帮助您入门 Keras 模型生命周期。
https://machinelearning.org.cn/5-step-life-cycle-neural-network-models-keras/
嗨，Jason，
该页面不使用 KerasRegressor。如何从本教程的代码中保存模型及其权重？
谢谢！
我通过使用相同的种子标准化数据集时遇到了更多错误。这可能是什么原因？
同样，更深层的网络拓扑似乎没有帮助。它增加了 MSE。
没有标准化的更深层网络能产生更好的结果。标准化在某种程度上增加了更多噪声。
嘿，教程很棒。我尝试了 Theano 和 Tensorflow 后端，但对于 larger_model 我得到了非常不同的结果。使用 Theano 我得到了与您非常相似的结果，但使用 Tensorflow 我得到了大于 100 的 MSE。
您有什么线索吗？
Michele
Michele，这个问题很棒。
我初步猜测，这很可能是由于我们在 Python 深度学习堆栈中看到的重现性问题。要获得可重复的结果，几乎不可能固定使用的随机数生成器。
我不会排除某个实现中的错误，但对于如此简单的网络来说，这会让我非常惊讶。
您好，我有一个关于 sklearn 接口的问题。
尽管我们将 NN 模型发送到 sklearn 并评估了回归性能，但我们如何获得输入数据的确切预测值，就像我们通常使用 Keras 时可以调用 model.predict(X) 函数一样？顺便问一下，我的意思是模型在 sklearn 中，对吗？
你好 Kenny，
您可以使用 sklearn 的 model.predict() 函数以相同的方式对新输入数据进行预测。
嗨 Jason
我买了《Python 深度学习》这本书。感谢您出色的工作！
我经常看到关于“model.predict()”的问题。我也有这个问题。在上面的代码中，“model”是未定义的。那么哪个变量包含训练过的模型呢？我尝试了“estimator.predict()”，但遇到了以下错误：
‘KerasRegressor’ object has no attribute ‘model’
我认为这将帮助许多读者。
Silvan，感谢您的支持。
对于 keras 模型，您可以训练模型，将其分配给一个变量，然后调用 model.predict()。请参阅此帖子。
https://machinelearning.org.cn/5-step-life-cycle-neural-network-models-keras/
在上面的示例中，我们使用了管道，它也是一个 sklearn 估计器。我们可以直接调用 estimator.predict()（函数名相同，API 不同），更多信息请参见此处。
https://scikit-learn.cn/stable/modules/generated/sklearn.pipeline.Pipeline.html#sklearn.pipeline.Pipeline.predict
这有帮助吗？
嗨，Jason，
您是否能为本帖所示的示例提供一个直接使用 model.predict() 的示例？我关注您的帖子已经有几个月了，并且对 Keras 越来越熟悉了。但是，我仍然似乎无法在此示例中使用 .predict()。
谢谢！
你好 Dee，
此处有关 predict 函数的信息。
https://machinelearning.org.cn/5-step-life-cycle-neural-network-models-keras/
这篇帖子中有一个调用 predict 的示例。
https://machinelearning.org.cn/tutorial-first-neural-network-python-keras/
这有帮助吗？
你好 Dee，
Jason，如果我没理解错，上面的示例*不*提供训练过的模型作为输出。所以您将无法立即使用 .predict() 函数。
相反，您必须训练管道。
pipeline.fit(X,Y)
之后您才能进行预测。
pipeline.predict(numpy.array([[ 0.0273, 0. , 7.07 , 0. , 0.469 , 6.421 ,
78.9 , 4.9671, 2. , 242. , 17.8 , 396.9 ,
9.14 ]]))
# 将返回 array(22.125564575195312, dtype=float32)
是的，感谢您的更正。
抱歉造成混淆。
嘿 Silvan，
感谢您的提示！我曾认为 SciKit 的 crossval 并没有输出拟合的模型，而只是交叉验证成本函数的 RMSE 或 MSE。
我将尝试使用 .fit()！
谢谢！
Jason 和 Silvan，您好，
您能否告诉我“pipeline.fit(X,Y)”是否放置在正确的位置？
如果我错了，请纠正我。
numpy.random.seed(seed)
estimators = []
estimators.append(('standardize', StandardScaler()))
estimators.append((‘mlp’, KerasRegressor(build_fn=larger_model, nb_epoch=50, batch_size=5, verbose=0)))
pipeline = Pipeline(estimators)
pipeline.fit(X,Y)
kfold = KFold(n_splits=10, random_state=seed)
results = cross_val_score(pipeline, X, Y, cv=kfold)
print(“Larger: %.2f (%.2f) MSE” % (results.mean(), results.std()))
谢谢！
不需要 pipeline.fit，因为您正在使用 kfold 交叉验证来评估管道。
亲爱的 Jason,
我有几个问题。我正在对一个数据集运行更宽的神经网络，该数据集对应于更准确地模拟商店进出人数。我得到 Wider: 24.73 (7.64) MSE。<– 您能准确解释这些值是什么意思吗？
此外，您能否建议其他改进神经网络的方法？我是否必须根据不同的拓扑方法不断迭代和调整？
另外，您使用什么确切的函数来预测没有真实值的新数据？是 sklearn 的 model.predict(X)，其中 X 是新数据集，维度少一维，因为没有输出？您能否详细阐述并解释？我将非常感激。
谢谢你
你好 Rahul，
该模型报告均方误差 (MSE)。它同时报告了 10 个交叉验证折的性能的平均值和标准差。这可以让你了解新数据上性能结果的预期范围。
我建议尝试不同的网络配置，直到找到适合您问题的设置。对于网络配置没有好的规则。
您可以使用 model.predict() 进行新预测。您说得对。
嘿！Jason。
在机器学习方面做得很好。我在这里学到了一切。
一个问题。
当我们说必须先训练模型，然后进行预测时，我们是否试图确定有多少层和多少神经元，以及其他 Keras 属性，以获得最佳拟合……然后将相同的属性用于预测数据集？
根本问题：我们是否试图在训练模型时确定哪些 Keras 属性适合我们的模型？
一般来说，我们想要一个能在新数据上做出良好预测的模型，而我们不知道答案。
我们会在测试数据上评估不同的模型和模型配置，以了解模型在进行新数据预测时会有何表现，这样我们就可以挑选出我们认为会表现良好的一个或几个模型。
这有帮助吗？
嗨，Jason，
感谢您提供的出色教程。
我在 Ubuntu 机器上重新运行了代码，并在 TITAN X GPU 上运行。虽然我在第 4.1 节的实验中得到了类似的结果，但第 4.2 节的结果与您的不同。
Larger: 103.31 (236.28) MSE
no_epoch 为 50，batch_size 为 5。
这种情况可能会发生，很难控制 Keras 中的随机数生成器。
请看这篇文章
https://machinelearning.org.cn/randomness-in-machine-learning/
嗨，Jason，
感谢分享这些有用的教程。两个问题：
1) 如果回归模型计算误差并将其作为结果返回（对此无疑），那么当“verbose=1”时，每个 epoch 打印出的“准确率”值是什么？
2) 使用那些预测值（fit.predict() 或 cross_val_predict），计算最接近预测结果的值并计算准确率是否有意义？（这样，可以计算多个准确率：最接近 2 个、最接近 3 个... 的准确率）
你好 A. Batuhan D.，
1. 对于回归问题，您不能打印准确率，这没有意义。它应该是损失或误差。
2. 同样，准确率对于回归没有意义。听起来您描述的是一个基于实例的回归模型，例如 kNN？
你好 jason,
1. 我知道，计算回归问题的准确率没有意义，但是在使用 Keras 库并设置 verbose=1 时，函数会与损失值一起打印准确率值。我想问一下这种情况的原因。这令人困惑。在您的示例中，verbose 参数设置为 0。
2. 我所做的是计算一些向量。作为输入，我使用向量（例如短语的嵌入词向量），并尝试计算一个向量（下一个词预测）作为输出（可能不属于字典中的任何已知向量，而且很可能不是）。之后，我通过余弦距离方法搜索字典中最接近网络计算出的向量。我个人认为，计算模型预测向量中与真实词向量（例如下一个词向量）最相似的向量比字典中的其他向量，可能可以得到合理的准确率。这是我的做法的简要总结。我认为这与基于实例的回归模型无关。
谢谢。
对于回归问题打印准确率非常奇怪。我从未见过，也许是 Keras 的一个新 bug？
您能否粘贴一个简短的代码+输出示例？
你好，
我尝试了这个教程 - 但它崩溃了，错误如下：
回溯（最近一次调用）
File “Riskind_p1.py”, line 132, in
results = cross_val_score(estimator, X, Y, cv=kfold)
File “C:\Python27\lib\site-packages\sklearn\model_selection\_validation.py”, line 140, in cross_val_score
for train, test in cv_iter)
File “C:\Python27\lib\site-packages\sklearn\externals\joblib\parallel.py”, line 758, in __call__
while self.dispatch_one_batch(iterator)
File “C:\Python27\lib\site-packages\sklearn\externals\joblib\parallel.py”, line 603, in dispatch_one_batch
tasks = BatchedCalls(itertools.islice(iterator, batch_size))
File “C:\Python27\lib\site-packages\sklearn\externals\joblib\parallel.py”, line 127, in __init__
self.items = list(iterator_slice)
File “C:\Python27\lib\site-packages\sklearn\model_selection\_validation.py”, line 140, in
for train, test in cv_iter)
File “C:\Python27\lib\site-packages\sklearn\base.py”, line 67, in clone
new_object_params = estimator.get_params(deep=False)
TypeError: get_params() got an unexpected keyword argument ‘deep’
有人在 StackOverflow 上发帖问了同样的问题。
任何帮助不胜感激。
听到这个消息我很难过。
您正在使用哪个版本的sklearn、Keras和tensorflow或theano？
在更新到Keras 1.2.1后，我也遇到了同样的问题。对我来说：theano是0.8.2，sklearn是0.18.1。
我可能是错的，但这可能是Keras最新版本的一个问题……
好的，我认为我已经解决了这些问题。我认为问题出在不同版本的包之间发生了冲突。解决所有问题的方法是创建一个环境。我已经在stack overflow上发布了一个解决方案，@Partha，在这里：http://stackoverflow.com/questions/41796618/python-keras-cross-val-score-error/41832675#41832675
我的版本分别是theano的0.8.2、sklearn的0.18.1和keras的1.2.1。
我在另一台机器上进行了新的anaconda安装，并在那里奏效了。
谢谢，
谢谢David，我会看看那篇文章。
你好David，我已经重现了该故障并了解了原因。
该错误是由Keras 1.2.1中的一个bug引起的，我有两个潜在的修复方案。
我在这里写了问题和解决方案
http://stackoverflow.com/a/41841066/78453
谢谢，我会调查并尝试重现。
你好，
是的，Jason的解决方案是正确的。我的解决方案之所以有效，是因为在环境中安装的Keras版本是1.1.1，而不是带有bug的版本（1.2.1）。
很棒的教程，非常感谢！
只是想知道如何训练一个标准化数据集（如第3节所示），但使用scikit-learn Pipeline生成实际的（即非标准化的）预测？
好问题Andy，
标准化发生在pipeline内部，它可以根据需要反转变换。这是使用sklearn Pipeline的好处之一。
很棒的教程，非常感谢！
如何在第3节中使用pipeline进行拟合后（pipeline.fit(X,Y)），恢复实际（非标准化）的预测？我相信pipeline.predict(testX)会产生一个标准化的预测Y？
我看到Pipeline有一个inverse_transform方法，但它似乎只用于还原转换后的X。
谢谢你的帖子……
我目前在回归问题上遇到一些麻烦，就像你这里描述的一样。
你似乎同时对输入和输出进行了归一化，但如果输出需要被另一个组件使用，你该怎么做？……取消归一化？如果是这样，误差是否也会按比例放大？
我目前正在进行将帧音频映射到MFCC特征的工作。
我尝试了许多不同的网络结构……CNN，多层……
我最近尝试在最后添加一个线性层……哇……效果惊人……它一直在下降，为什么？……你有什么想法吗？
你好James，是的，在输出被使用之前必须对其进行反归一化（反转任何数据预处理过程）。
如果数据预处理过程是分开的，你可以跟踪Python对象（或系数），并对预测进行临时反过程。
有没有办法使用pipeline，同时还能绘制kerasregressor的MSE随epoch变化的曲线？
据我所知Sarick没有。如果你找到了方法，请告诉我。
你能告诉我如何进行卷积神经网络回归吗？
好问题Aritra。
您可以使用标准的CNN结构，并通过修改示例来使用线性输出函数和合适的回归损失函数。
你好 Jason，
我假设如果您使用CNN，是否必须重塑输出，或者不呢？
如果数据是表格型数据，例如像Excel那样的表格，那么CNN就不合适了。
如果是序列数据，例如时间序列，那么本教程将向您展示如何操作。
https://machinelearning.org.cn/how-to-develop-convolutional-neural-network-models-for-time-series-forecasting/
嗨，Jason，
您能否告诉我如何决定batch_size？有没有什么经验法则？
好问题kono。
通常，我将其视为一个需要为问题优化的参数，就像学习率一样。
这些帖子可能会有帮助
随机梯度下降的批次大小应该有多大？
http://stats.stackexchange.com/questions/140811/how-large-should-the-batch-size-be-for-stochastic-gradient-descent
神经网络中的批次大小是什么？
http://stats.stackexchange.com/questions/153531/what-is-batch-size-in-neural-network
嗨，Jason，
我看到有些人使用fit_generator来训练MLP。您能否告诉我何时使用fit_generator()，何时使用fit()？
你好kono，当使用Data Generator时，例如图像增强，就会使用fit_generator()。
https://machinelearning.org.cn/image-augmentation-deep-learning-keras/
嗨，Jason，
感谢您的帖子。我使用了您的两个帖子，以及一个关于GridSearchCV的帖子，以获得带有Pipeline的keras回归工作流程。
我的问题是如何在pipeline上获取已拟合的keras regressor的权重矩阵和偏置向量？
(我的帖子不断被拒绝/消失，我是否违反了该网站的某些协议/规则？)
评论是经过审核的，这就是为什么您似乎没有立即看到它们。
要访问权重，我建议训练一个独立的Keras模型，而不是使用KerasClassifier和sklearn Pipeline。
你好，
感谢您提供的优秀示例！作为一个初学者，这是最好的开始。
但我有一些问题
在更宽的拓扑结构中，拥有更多的神经元意味着什么？
例如，在我的输入层我“接收”150个维度/特征（input_dim），并输出250个维度（output_dim）。那100个“额外”的神经元（它们会传播到下一个隐藏层）是什么？
祝好，
Pedro
你好Pedro，
神经元是单个学习单元。一层由神经元组成。
输入层的大小必须与输入变量的数量匹配。输出层的大小必须与输出变量的数量匹配，如果是分类问题，则匹配输出类的数量。
隐藏层的数量可以变化，隐藏层中神经元的数量也可以变化。这就是为特定问题配置神经网络的艺术。
这有帮助吗？
你好，
在您的更宽泛的示例中，输入层与输出的输入变量/特征数量不匹配
model.add(Dense(20, input_dim=13, init=’normal’, activation=’relu’))
所以我的问题是：除了13个输入特征之外，这个（输入）层输出的7个神经元里有什么？
你好Pedro，我不确定我是否理解，抱歉。
该示例将13个特征作为输入。输入层（input_dim）期望13个输入值。第一个隐藏层将这些加权输入组合20次或20种不同的方式（层中有20个神经元），每个神经元输出一个值。这些被组合成一个神经元（可怜的家伙！）它输出一个预测。
你好，
是的，我现在明白了（我不确定输入层也是隐藏层）。再次感谢
输入层与第一个隐藏层是分开的。Keras API会让人混淆，因为它们都在同一行上指定。
嗨，Jason，
你说激活函数不是必需的，因为我们想要一个数值作为我们网络的输出。我一直在看循环网络，特别是这个指南：https://deeplearning4j.org/lstm。它建议在输出处使用恒等激活函数。我想知道你的方法：使用Dense(1)作为输出层，与在网络输出处添加恒等激活函数：Activation(‘linear’)之间有什么区别？我应该在什么情况下使用恒等激活层？你能详细说明一下吗？
对于本教程，网络将具有身份函数
model = Sequential()
model.add(Dense(13, input_dim=13, init=’normal’, activation=’relu’))
model.add(Dense(6, init=’normal’, activation=’relu’))
model.add(Dense(1, init=’normal’))
model.add(Activation(‘linear’))
此致，
Bartosz
确实，示例默认使用线性激活函数。
嗨，Jason，
我目前的理解是，我们只在训练集上拟合+转换缩放，而在测试集上只转换不拟合。如果我们像您一样在CV中使用pipeline。我们是否确保对于每个CV，缩放只针对9个训练集进行拟合，而转换在没有拟合的情况下应用于测试集？
非常感谢！
绝佳的问题。
Pipeline为我们做了这件事。在每个CV折叠中，它会被拟合然后应用于训练集，然后拟合变换被应用于测试集以评估模型在折叠上的表现。这是sklearn内置的一个很棒的自动模式。
嗨！我运行了您的代码和您的数据，我们得到了不同的MSE。我应该担心吗？谢谢帮忙！
一般来说不应该担心，机器学习算法是随机的。
更多细节在此
https://machinelearning.org.cn/randomness-in-machine-learning/
嗨 Jason
运行上述代码时，我发现错误是
Y = dataset[:,25]
IndexError: index 25 is out of bounds for axis 1 with size 1
我已经声明了X和Y
X = dataset[:,0:25]
Y = dataset[:,25]
请帮我解决这个问题
嗨Jason，感谢您的精彩文章！
我正在处理相同的问题[样本数：460000，特征数：8]，但是我的目标列输出具有非常大的值，例如在20000到90000之间！
我尝试了不同的NN架构[从大到小]，使用了不同的批次大小和epoch，但仍然没有获得良好的准确性！
我需要标准化我的目标列吗？请帮我解决这个问题！
感谢您的时间！
是的，您必须对输入和输出数据进行重新缩放。
嗨Jason，感谢您的回复！
是的，我尝试了各种方法来重新缩放我的数据，使用了
https://machinelearning.org.cn/prepare-data-machine-learning-python-scikit-learn/
url但我仍然只获得了20%的准确率！
我尝试了不同的NN拓扑结构，使用了不同的批次大小和epoch，但没有取得好结果！
我的代码
inputFilePath = “path-to-input-file”
dataframe = pandas.read_csv(inputFilePath, sep=”\t”, header=None)
dataset = dataframe._values
# 分割为输入 (X) 和输出 (Y) 变量
X = dataset[:,0:8]
Y = dataset[:,8]
scaler = StandardScaler().fit(X)
X = scaler.fit_transform(X)
maxnumber = max(Y) #我找到的最大数字是：79882.0
Y=Y / maxnumber
# 创建模型
model = Sequential()
model.add(Dense(100, input_dim=8, init=’normal’, activation=’relu’))
model.add(Dense(100, init=’normal’, activation=’relu’))
model.add(Dense(80, init=’normal’, activation=’relu’))
model.add(Dense(40, init=’normal’, activation=’relu’))
model.add(Dense(20, init=’normal’, activation=’relu’))
model.add(Dense(8, init=’normal’, activation=’relu’))
model.add(Dense(6, init=’normal’, activation=’relu’))
model.add(Dense(6, init=’normal’, activation=’relu’))
model.add(Dense(1, init=’normal’,activation=’relu’))
model.compile(loss=’mean_absolute_error’, optimizer=’adam’, metrics=[‘accuracy’])
# 检查点
model.fit(X, Y,nb_epoch=100, batch_size=400)
# 4. 评估网络
loss, accuracy = model.evaluate(X, Y)
print(“\nLoss: %.2f, Accuracy: %.2f%%” % (loss, accuracy*100))
我尝试了MSE和MAE作为损失函数，以及adam和rmsprop优化器，但仍然没有获得准确率！
请帮帮我！谢谢
对于如此深的网络，100个epoch是不够的。可能需要数百万个。
你好Jason，感谢您的回复！
如何在数百万个epoch后确保获得输出，因为在10000个epoch后准确率仍然是0.2378！
如何动态决定神经网络的层数和神经元大小？有没有办法？
我已经使用了神经网络检查点机制来确保其在验证集上的准确性！
我的代码如下
model.compile(loss=’mean_absolute_error’, optimizer=’adam’, metrics=[‘accuracy’])
checkpoint = ModelCheckpoint(save_file_path, monitor=’val_acc’, verbose=1, save_best_only=True, mode=’max’)
callbacks_list = [checkpoint]
model.fit(X_Feature_Vector, Y_Output_Vector,validation_split=0.33, nb_epoch=1000000, batch_size=1300, callbacks=callbacks_list, verbose=0)
如果我遗漏了什么，请告诉我！
看起来不错。
有神经网络增长和修剪算法，但我没有教程，抱歉。
请看书：《神经网络史密斯》http://amzn.to/2oOfXOz
嗨，Jason，
感谢这篇很棒的教程。
我认为有一个小的错误，在提供epoch数量作为参数时，文档显示它应该提供为
estimator = KerasRegressor(build_fn=baseline_model, epochs=100, batch_size=5, verbose=0)。
当提供
estimator = KerasRegressor(build_fn=baseline_model, nb_epoch=100, batch_size=5, verbose=0)
时，函数不识别该参数，只是忽略它。
你能确认吗？
我正在使用您的“如何在Python中使用Keras进行深度学习模型的超参数网格搜索”教程，并在调整epoch数量时遇到问题。如果我通过一个简单的交叉验证检查网格搜索CV的结果，我得到的折叠次数相同，结果完全不同。那里可能有一个类似的错误？
感谢您的时间！
您可以传递任何您想要的参数
https://keras.org.cn/scikit-learn-api/
您每次运行都会得到不同的结果，因为神经网络的行为是随机的。这篇文章会有帮助。
https://machinelearning.org.cn/randomness-in-machine-learning/
https://keras.org.cn/scikit-learn-api/ 准确说明了epoch的数量应该通过epochs=n给出，而不是nb_epoch=n。当给出后者时，函数会忽略该参数。例如
np.random.seed(seed)
estimators = []
estimators.append(('standardize', StandardScaler()))
estimators.append((‘mlp’, KerasRegressor(build_fn=baseline_model, nb_epoch=’hi’, batch_size=50, verbose=0)))
pipeline = Pipeline(estimators)
kfold = KFold(n_splits=10, random_state=seed)
results = cross_val_score(pipeline, X1, Y, cv=kfold)
print(“Standardized: %.5f (%.2f) MSE” % (results.mean(), results.std()))
不会引发任何错误。
我是否错过了什么？
我得到的结果差异很大，而且我认为这不能归因于神经网络行为的随机性。
谢谢Charlotte，这看起来是Keras 2.0的一个近期更改。我将很快更新示例。
谢谢！
嗨，Jason，
我尝试了第一部分，并且基线得到了不同的结果。
我发现
estimator = KerasRegressor(build_fn=baseline_model, nb_epoch=100, batch_size=5, verbose=0)
对我来说不起作用，因为它默认取10个epoch。当我将其更改为epochs=100时，它就能工作。
我刚读了上面的评论，似乎他们在API中更改了这一点。
神经网络是一种随机算法，每次运行时都会产生不同的结果（除非您固定种子并使其他所有内容都相同）。
请看这篇文章
https://machinelearning.org.cn/randomness-in-machine-learning/
嗨，Jason，
我如何获得回归系数？
使用优化算法来“找到它们”。
随机梯度下降与线性回归可能是个开始
https://machinelearning.org.cn/simple-linear-regression-tutorial-for-machine-learning/
嗨，Jason，
如果不是线性回归，我该如何找到回归系数？以及如何推导出输入属性和输出之间的关系，而不一定是线性的关系？
只有对于线性回归等线性算法，您才有回归系数。
亲爱的 Jason,
感谢您的教程！！
我在一个粒子物理学项目中实现了它，我有2个问题。
1）假设我的目标是T=a/b（T=true_value/reco_value）。如果我同时将“a”和“b”作为特征输入回归模型，那么它应该能每次都找到正确的解决方案，对吧？或者是否有某种避免过度拟合的程序，不允许获得100%精确的结果？我问是因为我尝试了，并且获得了“良好”的表现，而不是我期望的最优表现（如果它有“a”和“b”，它应该能在测试集中也以100%的精度找到正确的T）。如果我移除了b，并添加其他特征，那么y_hat/y_test的值会达到0.75，这意味着回归模型存在偏差。你能帮我理解这两件事吗？
2）我想保存回归模型以便以后使用。训练后，我执行：a）estimator.model.save_weights 和 b）open(‘models/’+model_name, ‘w’).write(estimator.model.to_json())。
Estimator是“estimator = KerasRegressor(build_fn=baseline_model, nb_epoch=100, batch_size=50, verbose=1)”。我如何稍后使用这两个文件直接进行预测？
非常感谢，
Luca
抱歉，我不确定我是否理解您第一个问题，也许您可以简要重述一下？
请参阅这篇关于保存和加载keras模型的帖子。
https://machinelearning.org.cn/save-load-keras-deep-learning-models/
嗨，Jason，
我的观点是这样的。回归模型是在一组特征（一组浮点数）上训练的，它提供一个单一的输出（一个浮点数），即目标。在训练过程中，回归模型会学习如何根据特征来猜测目标。
当然，目标不应该是特征的函数，否则问题就太简单了，但我尝试测试这种情况作为初步检查。我所做的是（作为测试）定义一个目标，它就是两个特征的除法，即我将“a”和“b”提供给回归模型，并告知要找到的目标是a/b。在这种简单的情况下，回归模型应该足够聪明，在训练过程中就能理解我的目标就是a/b。所以，在测试中，它应该能够以100%的精度找到正确的值，即通过除以两个特征。我发现回归模型找到的值（y_hat）接近a/b，但并非完全等于a/b。所以我很想知道为什么回归模型的行为是这样的。
谢谢，
Luca
这是一个很棒的问题。
最多，机器学习可以近似一个函数，有些近似比其他近似更好。
这是我能给出的最好的答案。
嗨，Jason，
感谢您的帖子，我真的很喜欢它们。我有一个快速的问题：如果我想使用sklearn的GridSearchCV和
model.compile(loss=’mean_squared_error’
在我的模型中，最高的分数是否对应于具有*最高*MSE的组合？
如果是这样，我想 GridSearchCV 中有一个方法可以反转评分？
使用MSE时，您将希望找到导致最低误差的配置，即最低的均方误差。
亲爱的Jason
我有一个数据文件，包含7个变量，6个输入和一个输出
#from sklearn.cross_validation import train_test_split
#rain, test = train_test_split(data2, train_size = 0.8)
#train_y= train[‘Average RT’]
#train_x= train[train.columns.difference([‘Average RT’])]
##test_y= test[‘Average RT’]
#est_x= test[test.columns.difference([‘Average RT’])]
x=data2[data2.columns.difference([‘Average RT’])]
y=data2[‘Average RT’]
print x.shape
print y.shape
(1035, 6)
(1035L,)
# 定义基本模型
def baseline_model()
# 创建模型
model = Sequential()
model.add(Dense(7, input_dim=7, kernel_initializer=’normal’, activation=’relu’))
model.add(Dense(1, kernel_initializer=’normal’))
# 编译模型
model.compile(loss='mean_squared_error', optimizer='adam')
return model
# 设置随机种子以保证结果可复现
#seed = 7
#numpy.random.seed(seed)
# 使用标准化数据集评估模型
estimator = KerasRegressor(build_fn=baseline_model, nb_epoch=100, batch_size=5, verbose=0)
kfold = KFold(n_splits=5, random_state=seed)
results = cross_val_score(estimator, x,y, cv=kfold)
print(“Results: %.2f (%.2f) MSE” % (results.mean(), results.std()))
但遇到了以下错误
ValueError: Error when checking input: expected dense_15_input to have shape (None, 7) but got array with shape (828, 6)
我也尝试更改
model.add(Dense(7, input_dim=7, kernel_initializer=’normal’, activation=’relu’))
推广到
model.add(Dense(6, input_dim=6, kernel_initializer=’normal’, activation=’relu’))
因为总共有7个变量，其中6个是输入，第7个Average RT是输出。
你能帮帮我吗？
你能帮帮我吗？
输出和输入之间也存在非线性关系，因为我正在尝试使用Keras神经网络自行开发这种非线性关系。
如果您有6个输入和1个输出，您将有7行。
您可以这样分离您的数据：
然后，您可以配置神经网络的输入层，使其期望6个输入，方法是将“input_dim”设置为6。
这有帮助吗？
亲爱的Jason
如果我有2个输出，可以这样写吗？
y = data[:, 0:6]
y = data[:, 6:7]
?
不太对。
您可以从矩阵中检索2列并将其分配给y，使y现在是2列和n行。
也许先熟悉一下numpy数组切片？
先生，请给我一份“使用反向传播技术和Simodal激活函数进行成本估算”的代码。
请看这篇文章
https://machinelearning.org.cn/implement-backpropagation-algorithm-scratch-python/
嗨，Jason，
我是深度学习的新手，感谢这个令人印象深刻的教程。但是，我有一个关于深度学习方法的重要问题。
我们如何像Lasso或其他特征选择方法一样解释这些特征？
在我的项目中，我有大约20000个特征，并且我想使用深度学习方法选择或排名这些特征。我们该怎么做？
谢谢！
很好的问题。
我建议将特征选择作为预处理步骤。
以下是有关特征选择的更多信息。
https://machinelearning.org.cn/an-introduction-to-feature-selection/
你好，
非常感谢您的帖子。
在这个框架中是否有办法实现Tweedie回归？
A
抱歉，我没听说过“Tweedie回归”。
你好，
谢谢分享。
我遇到了一个问题，不知道如何处理。
当进入“results = cross_val_score(estimator, X, Y, cv=kfold)”时，我收到以下警告
C:\Program Files\Anaconda3\lib\site-packages\ipykernel\__main__.py:11: UserWarning: Update your
Densecall to the Keras 2 API:Dense(13, input_dim=13, kernel_initializer="normal", activation="relu")C:\Program Files\Anaconda3\lib\site-packages\ipykernel\__main__.py:12: UserWarning: Update your
Densecall to the Keras 2 API:Dense(1, kernel_initializer="normal")C:\Program Files\Anaconda3\lib\site-packages\keras\backend\tensorflow_backend.py:2289: UserWarning: Expected no kwargs, you passed 1
kwargs passed to function are ignored with Tensorflow backend
warnings.warn(‘\n’.join(msg))
我尝试更新Anaconda及其所有包，但无法修复。
嗨，Jason，
我有一个关于神经网络回归的经典问题，但我还没有找到明确的答案。我见过神经网络在图像分类等方面表现出的出色性能，但仍然对其在回归中的性能持怀疑态度。事实上，我测试了两种数据情况：线性和非线性，2个输入和1个输出，带有随机偏差，但性能不如SVM或Gradient Boosting等其他经典机器学习方法……那么，对于回归，我们应该应用哪种数据类型的神经网络？数据的复杂性越高，其性能是否会更好？
提前感谢您的回答。祝您有美好的一天🙂
深度学习在回归方面效果很好，但需要更大/更难的问题以及更多的数据。
对于小问题，更适合传统的线性甚至非线性方法。
谢谢你，Jason。
回到您的示例，我有一个关于每个隐藏层中神经元数量和隐藏层数量的问题。我读到了一些建议，例如隐藏层神经元的数量是输入层大小的2/3，并且神经元数量应该是（a）介于输入层和输出层大小之间，（b）设置为接近（输入+输出）* 2/3，或者（c）不超过输入层大小的两倍以防止过拟合。我对这些约束表示怀疑，因为我没有找到任何数学证明。
在您的示例中，我将层数增加到7层，并且在每层中使用大量神经元（大约300-200），在5000个epoch中得到了MSQ为0.1394。那么，您在构建网络时是否对这些数字有任何条件？
不，通常神经网络的配置是反复试验，并有一个强大的测试平台。
嗨Jason。我可以在Autoencoders上应用回归吗？
是的，但我没有示例，抱歉。
嗨 Jason
感谢您出色的教程代码！我有一些关于正则化和核初始化器的问题。
我想在更新权重时添加L1/L2正则化。我应该在哪里放置命令？
我还有一个关于分配“kernel_initializer=’normal’”的问题，有必要初始化正态核吗？
谢谢！
KK
这是一个关于权重正则化的例子
https://machinelearning.org.cn/use-weight-regularization-lstm-networks-time-series-forecasting/
我建议在您的项目上评估不同的权重初始化方案。
谢谢 Jason。
我还有一个问题。我将使用convolution2D和dropout。如果我的模型中有dropout，我还需要使用L1/L2正则化吗？
谢谢！
KK
尝试有和没有，并比较性能。
尊敬的博士，
我需要您帮忙，关于如何使用预训练的Keras顺序模型进行NER，输入文本。
例如，如果“word1 word2 word3.”是一个包含三个单词的句子，我如何将其转换为Keras期望的numpy数组，以便从加载的预训练Keras模型中为每个单词的NE标签集进行预测。
此致，
首先将单词转换为整数。
我每次都得到一个大于58的比率。
这是使用的确切代码
#Dependencies
from numpy.random import seed
seed(1)
import pandas
来自 keras.models import Sequential
from keras.layers import Dense
from keras.wrappers.scikit_learn import KerasRegressor
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import KFold
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
# 加载数据集
dataframe = pandas.read_csv(“housing.csv”, delim_whitespace=True, header=None)
dataset = dataframe.values
# 分割为输入 (X) 和输出 (Y) 变量
X = dataset[:,0:13]
Y = dataset[:,13]
# Basic NN model using Keras
def baseline_model()
# 创建模型
model = Sequential()
model.add(Dense(13, input_dim=13, kernel_initializer=’normal’, activation=’relu’))
model.add(Dense(1, kernel_initializer=’normal’))
# 编译模型
model.compile(loss='mean_squared_error', optimizer='adam')
return model
#seed = 1
# 使用标准化数据集评估模型
estimator = KerasRegressor(build_fn=baseline_model, nb_epoch=100, batch_size=5, verbose=0)
#kfold = KFold(n_splits=10, random_state=seed)
results = cross_val_score(estimator, X, Y, cv=10)
print(“Results: %.2f (%.2f) MSE” % (results.mean(), results.std()))
您说的“大于58的比率”是什么意思？
非常感谢，
如果我们想使用CNN，我们不能用CNN代替Dense层吗？如果我想使用CNN，我应该使用conv2d还是简单的conv？
在使用深度架构的回归问题中，我们可以像使用图像一样使用AlexNet、VGGNet等吗？
我将非常感谢您能在此方面提供示例。
此致
我不推荐CNN用于回归。我推荐MLP。
您的输入数据的形状（1D，2D，…）将决定使用哪种类型的CNN。
为什么你推荐MLP而不是CNN？
CNN用于序列数据或图像数据。
很棒的教程！我喜欢保存训练调整过的权重，我该如何做？
本教程将向您展示如何保存网络权重。
https://machinelearning.org.cn/save-load-keras-deep-learning-models/
非常感谢。
我有一个问题。
此教程是否适用于风速预测？
试试看吧。
嗨，感谢您的教程。这里有几个问题。
1. 当我们使用
KerasRegressor(build_fn=baseline_model, nb_epoch=100, batch_size=5, verbose=0)
和
model.fit(x_train, y_train, batch_size=batch_size,epochs=epochs,verbose=1,validation_data=(x_test, y_test))？据我所知，使用KerasRegressor时，我们可以进行CV，而在model.fit时不能。我说的对吗？两者都会导致相同的MSE等结果吗？
2. 如何使用Keras创建一个预测两个连续输出的神经网络？这里，我们只预测一个输出，那么两个或更多输出呢？如何实现？（多输出回归问题？）
正确，使用sklearn包装器可以让我们对小型模型使用CV等工具。
您可以通过更改输出层中的节点数来获得两个输出。
谢谢您的回复。
这是否意味着，在sklearn包装模型和model.fit（不带sklearn）模型中，如果它们接收相同训练、验证和测试数据集，都能获得相同的mse（假设sklearn包装器只运行第一个折叠）？或者模型背后存在一些差异？
我读了Keras Model类（函数式API）（https://keras.org.cn/models/model/）。Model类的实现，
model = Model(inputs=a1, outputs=[output1, output2])
与在输出层添加一个节点相同吗？如果不是，有什么区别？
底层是相同的keras模型。
from keras.layers.core import Dense,Activation,Dropout
from json import load,dump
from sklearn.metrics import mean_squared_error
from sklearn.metrics import mean_absolute_error
来自 keras.models import Sequential
from keras2pmml import keras2pmml
from pyspark import SparkContext,SparkConf
from pyspark.mllib.linalg import Matrix, Vector
from elephas.utils.rdd_utils import to_simple_rdd,to_labeled_point
from elephas import optimizers as elephas_optimizers
from elephas.spark_model import SparkModel
from CommonFunctions import DataRead,PMMLGenaration,ModelSave,LoadModel,UpdateDictionary,ModelInfo
from keras import regularizers
from sklearn.metrics import r2_score
from keras.optimizers import SGD
#from keras.models import model_from_config
#from keras.utils.generic_utils import get_from_module
class SNNReg
def train(self,sc,xml,data,hdfs_path)
## Variable initialization ##
hActivation = xml.HiddenActivation
#print hActivation
nodeList = map(int,(xml.NodeList.split(“,”)))
#print nodeList
Accuracy = xml.Accuracy
#print Accuracy
lossFn = xml.LossFunction
#print nodeList
optimi = xml.Optimizer
#print optimi
hCount = int(xml.HiddenNodeCount)
#print hCount
inputDim = int(xml.InputDimension)
opNodes = int(xml.OutputNodes)
print (‘opNodes’,opNodes)
nbEpoch = int(xml.NumEpoch)
batchSize = int(xml.BatchSize)
#settings default paramerters if not the provided the values for it
if hActivation==””
hActivation=”relu”
if lossFn==””
lossFn=”mean_squared_error”
if optimi==””
optimi=”adam”
if Accuracy==””
Accuracy=”Accuracy”
print “now going to read ”
#print(“lossFn”,lossFn)
X,Y = DataRead(self,xml.NeuralNetCategory,xml.NeuralNetType,data,xml.ColumnNames,xml.TargetColumnName,xml.InputDimension)
# Creating a sequential model for simple neural network
model=Sequential()
model.add(Dense(nodeList[0],input_dim = inputDim,init=’normal’,activation =hActivation ))
# Creating hidden model nodes based on the hidden layers count
if hCount > 1
for x in range(1,hCount)
model.add(Dense(nodeList[x],init=’normal’,activation = hActivation))
model.add(Dense(opNodes,activation=’linear’))
# 编译模型
print “model complilation stage”
model.compile(loss = lossFn, optimizer=optimi)
rdd =to_simple_rdd(sc,X,Y)
print rdd
#adam= elephas_optimizers.Adam()
adam = elephas_optimizers.Adam()
#adagrad = elephas_optimizers.Adagrad()
#adadelta = elephas_optimizers.Adadelta()
#print (“type of rdd”,type(rdd))
print “now going to create spark model using elphass”
# Creating Spark elephas model from the spark model
print(“no of workers”,int(sc._conf.get(‘spark.pangea.ae.workers’)))
sparkModel = SparkModel(sc,
model,
optimizer=adam,
frequency=’epoch’,
mode=’asynchronous’,
master_loss=lossFn,
num_workers=int(sc._conf.get(‘spark.pangea.ae.workers’)))
# Train Spark model
print “now it is going to run train fucntion”
sparkModel.train(rdd,nb_epoch=nbEpoch, batch_size=batchSize)
我试图以分布式方式在Python中使用elphas和keras在神经网络中实现回归，但在训练过程中，我得到了过高的损失值，我该怎么办，请给我任何建议。
抱歉，我无法帮助分布式Keras模型。
两个小点
1. 请在文本中注明需要安装TensorFlow。
2. CSV表示逗号分隔文件，但文件中的数据不是用逗号分隔的。不过这不是什么大问题。
感谢您的建议。
感谢您提供的精彩教程！在帖子中，您使用了“relu”，但我很好奇如何自定义激活函数？
如果您愿意，可以使用 sigmoid 或 tanh。
嗨，Jason，
感谢这个很棒的教程！
深度学习库Keras（假设以TensorFlow为后端）与sklearn的神经网络函数MLPRegressor相比有什么优势？在两种情况下，过程（输入）都非常相似，您需要决定使用哪种架构、激活函数和求解器。
谢谢，
Don
开发速度和社区规模。
感谢您的快速回复！
您能否进一步阐述一下？
当您提到开发速度时，您能举几个实际的例子说明何时重要或您具体指的是什么吗？当您提到社区规模时，您是指Keras/TensorFlow社区比sklearn的更大吗？如果不是，您的意思是什么？
此外，您能否谈谈epochs和batch_size参数？为什么使用epochs而不是公差，这对我来说更有意义？当增加epochs值时，分数有时会降低，这是否合理？
非常感谢！
Don
是的，我相信用Keras开发模型比目前可用的其他工具更容易/更快。
我相信Keras社区非常活跃，这对于保持库的更新和有用非常重要。Keras与sklearn、tensorflow和theano是互补的。
一个epoch是遍历所有训练样本一次。一个epoch由一个或多个批次组成。一个批次涉及在更新网络权重之前遍历一个或多个样本。
我有点困惑。如果你定义x为
X = dataset[:,0:13]
那么X中的最后一列与Y相同。X不应该是
X = dataset[:,0:12]
然后
Y = dataset[:,13]
如果你定义X包含输出，为什么它不会将dataset[0:12]的所有权重设置为零，然后完美地拟合数据，因为它已经知道答案了？
> X = [0,1,2,3,4]
> print(X[0:3])
[0, 1, 2]
结束索引不包含在内。
是的。我收到的类似这样的问题越多，我就越觉得需要一个关于基本numpy语法的帖子。
有哪些方法可以在keras中验证回归模型？您能否帮我一下？
您可以使用拟合模型时的验证数据集来估计模型在未见过的数据上的技能。
请参阅fit()函数的validation_split和validation_data参数。
https://keras.org.cn/models/sequential/
我们如何通过代码来识别keras回归模型和分类模型？
通过输出层激活函数和节点数的选择。
回归将使用线性激活，具有一个输出，并且可能使用mse损失函数。
分类将使用softmax、tanh或sigmoid激活函数，具有每个类一个节点（或二元分类一个节点），并使用log loss函数。
感谢您的教程，我觉得很有帮助。但是，我有一个问题。
当我使用 estimator.fit 中的 checkpoint 回调时，它会保存一个训练最佳的权重，作为一个 hd5 文件。
但我无法加载这个预训练的权重，因为 estimator 没有 keras 模型中的 load_weights 方法。我该怎么办，谢谢！！！
您必须将权重加载为 Keras 模型。
在此教程中了解更多信息
https://machinelearning.org.cn/check-point-deep-learning-models-keras/
你好，Jason
感谢精彩的教程！我从您的博客中学到了很多。
我有一个关于 np.random.seed 的问题。
‘np.random.seed’ 到底做了什么？
您在上面解释了它是为了可复现性，但我不太明白这是什么意思……
谢谢，希望您一切顺利！
祝好，
保罗
许多机器学习算法在设计上是随机的
https://machinelearning.org.cn/randomness-in-machine-learning/
我们可以通过确保每次运行代码时都有相同的随机性来消除教程中的随机性（纯粹为了演示目的）
https://machinelearning.org.cn/reproducible-results-neural-networks-keras/
这不推荐用于实际评估模型
https://machinelearning.org.cn/evaluate-skill-deep-learning-models/
这能帮到 Paul 吗？
您能推荐一下除 relu 之外用于回归神经网络的隐藏激活函数吗？
是的，在 relu 出现之前，sigmoid 和 tanh 已经使用了几十年了。
我给 keras 的回归模型使用了 tanh，但结果不理想，您说 tanh 也支持回归，请您给我一些建议。
不，回归问题请在输出层使用“线性”激活。
当然，输出层我只使用了线性激活函数，但说的是隐藏激活函数，我使用了 relu，如果我使用 tanh 结果就不理想。
很遗憾听到您遇到的问题。我在本帖中列出了一些尝试的建议。
https://machinelearning.org.cn/improve-deep-learning-performance/
嗨，Jason，
现在 Keras 和 Tensorflow 在 R (RStudio) 中可用了，您是否有计划用 R 来做上述教程？我在您的书中看到了您使用 cubist 处理波士顿房价数据集，我很想看到/运行直接的比较，以了解可能改进的空间。
也许将来会的，谢谢 Wayne 的建议。
我的问题是所有东西都隐藏在 Pipeline 对象中。我该如何提取出组件，比如模型的 predict 方法，然后提取出预测值来绘制输入值呢？
不要使用 Pipeline，而是手动传递对象之间的数据。
我已经训练了 keras 模型，我需要 model.predict() 的逻辑，我们如何预测测试数据的值，我有 predict_classes 的逻辑，但没有 predict 的逻辑，您能告诉我 model.predict 的逻辑吗？
def predict_proba(self, X)
a = X
for i in range(self._num_layers)
g = self._activations[i]
W = self._weights[i]
b = self._biases[i]
a = g(np.dot(a, W.T) + b)
print(len(a))
return a
def predict_classes(self, X)
probs = self.predict_proba(X)
print(np.argmax(probs,1))
return np.argmax(probs,1)
predict_classes 是用于分类的。
我需要回归的 predict 逻辑。
您可以使用 predict() 函数
嗨，Jason，
感谢您的博客。我尝试将示例用于我的案例，我尝试构建模型并为音频数据进行评估。我只使用频谱数据。原始数据是 .wav 格式的。
但是，我收到一个错误
“TypeError: can’t pickle NotImplementedType objects”
在 line results = cross_val_score(pipeline, X, Y, cv=kfold)
我的数据非常少，只有 5 个样本。
您对此错误有什么想法吗？
祝好，
Mustafa
我建议您与您获取被序列化数据的人员沟通。
您好 Mustafa，
您的 pipeline 是如何初始化/定义的？我遇到了完全相同的错误消息，是在使用 cross_val_score 和 KerasRegressor 估算器时。当您使用类似
estimator = KerasRegressor(build_fn=myModel, nb_epoch=100, batch_size=5, verbose=0)
与 Keras 模型“myModel”而不是一个名为“myModel”的函数来在编译后返回模型（如教程开头所示），您应该会遇到相同的 Pickle 错误。您可以通过 myModel=baseline_model() 来复现它。
希望这有帮助…
此致，
Heringsalat
为什么我们在回归问题中计算误差而不是准确率？为什么准确率在回归中没有意义？请解释一下。
我们没有使用准确率。我们计算的是误差，特别是均方误差（MSE）。
为什么我们在回归中计算 MSE 而不是准确率呢，先生？
因为这是一个回归问题，准确率只适用于分类问题。
在计算损失和 MSE 时，我在回归中得到的值是相同的，这是因为损失和 MSE 在回归中是相同的还是不同的？如果不同，它们有何不同？请解释一下。
损失是网络最小化的目标。如果您使用 MSE 作为损失，那么您就不需要将 MSE 跟踪为指标。它们将是同一件事。
你好！
我正在尝试训练一个 PPG 信号来估计心率，即 BPM。
您认为遵循此结构是否合适？
如果不合适，能否请您提供建议？
谢谢！
也许吧。也可以考虑时间序列的表述。评估您能想到的所有框架。
您好 Jason！🙂
感谢您发布的精彩帖子！🙂 我有一个关于 StandardScaler 和 Normalization 的问题。
它们有什么区别？另外，我可以使用 Min Max 缩放器而不是 StandardScaler 吗？
提前感谢。
祝好，
保罗
MinMaxScaler 的归一化将数据缩放到 0-1 之间。StandardScaler 的标准化减去均值，使分布的均值为 0，标准差为 1。
标准化适用于高斯分布，而归一化适用于其他情况。
啊哈！谢谢您的回复！🙂
我将尝试 MinMaxScaler()
祝好，
保罗
祝您好运 Paul。
嗨，Jason，
感谢教程，非常有意思。
您能否进一步解释一下为什么使用标准化而不是归一化？
特征是否具有高斯分布？您如何知道特征是否具有高斯分布？
我目前正在处理 Ames Housing 数据集的房价预测：您建议我使用标准化还是归一化？
不客气。
是的，请看这个
https://machinelearning.org.cn/standardscaler-and-minmaxscaler-transforms-in-python/
特征不一定具有高斯分布，但数据是高斯分布时使用标准化是个好主意。
嗨，Jason，
再次，这是一篇非常有信息量的博客。我正在 R 中实现 keras，但找不到 keras regressor 来拟合模型。您是否有解决方案，或者您能推荐一个替代方案吗？
抱歉，我不知道 R 中的 Keras。
嘿 Jason – 感谢这篇帖子。
我很想了解 Keras 提供的其他回归模型以及您对它们用例的看法。
谢谢，
James
James，您是什么意思？您有例子吗？
嗨 David，
感谢教程。这些对实现方面以及了解机器学习在各领域的可能性都非常有帮助。
我尝试运行第 2 部分的代码时遇到了以下错误
………………….
回溯（最近一次调用）
File “regression.py”, line 48, in
results = cross_val_score(estimator, X, Y, cv=kfold)
File “/home/mjennet/anaconda2/lib/python2.7/site-packages/sklearn/model_selection/_validation.py”, line 321, in cross_val_score
pre_dispatch=pre_dispatch)
File “/home/mjennet/anaconda2/lib/python2.7/site-packages/sklearn/model_selection/_validation.py”, line 195, in cross_validate
for train, test in cv.split(X, y, groups))
File “/home/mjennet/anaconda2/lib/python2.7/site-packages/sklearn/externals/joblib/parallel.py”, line 779, in __call__
while self.dispatch_one_batch(iterator)
File “/home/mjennet/anaconda2/lib/python2.7/site-packages/sklearn/externals/joblib/parallel.py”, line 625, in dispatch_one_batch
self._dispatch(tasks)
File “/home/mjennet/anaconda2/lib/python2.7/site-packages/sklearn/externals/joblib/parallel.py”, line 588, in _dispatch
job = self._backend.apply_async(batch, callback=cb)
File “/home/mjennet/anaconda2/lib/python2.7/site-packages/sklearn/externals/joblib/_parallel_backends.py”, line 111, in apply_async
result = ImmediateResult(func)
File “/home/mjennet/anaconda2/lib/python2.7/site-packages/sklearn/externals/joblib/_parallel_backends.py”, line 332, in __init__
self.results = batch()
File “/home/mjennet/anaconda2/lib/python2.7/site-packages/sklearn/joblib/parallel.py”, line 131, in __call__
return [func(*args, **kwargs) for func, args, kwargs in self.items]
File “/home/mjennet/anaconda2/lib/python2.7/site-packages/sklearn/model_selection/_validation.py”, line 437, in _fit_and_score
estimator.fit(X_train, y_train, **fit_params)
File “/home/mjennet/anaconda2/lib/python2.7/site-packages/keras/wrappers/scikit_learn.py”, line 137, in fit
self.model = self.build_fn(**self.filter_sk_params(self.build_fn))
File “regression.py”, line 35, in baseline_model
model.add(Dense(13, input_dim=13, kernel_initializer=’normal’, activation=’relu’))
File “/home/mjennet/anaconda2/lib/python2.7/site-packages/keras/layers/core.py”, line 686, in __init__
super(Dense, self).__init__(**kwargs)
File “/home/mjennet/anaconda2/lib/python2.7/site-packages/keras/engine/topology.py”, line 307, in __init__
assert kwarg in allowed_kwargs, ‘Keyword argument not understood: ‘ + kwarg
AssertionError: Keyword argument not understood: kernel_initializer
……………….
我试图深入了解问题，发现 Mr. Partha 描述的问题与我的类似，因此我检查了 Keras 的版本。我使用的 Keras 版本是 1.1.1，后端是 tensorflow(1.2.1)。您能帮我解决这个问题吗？
我叫 Jason。
看起来您需要更新到 Keras 2。
抱歉，Jason 先生
我尝试升级 Keras 和其他依赖项，但仍然出现相同的错误。我目前正在使用 Keras 2.1.1，Numpy 1.13.3 和 scipy 1.0.0。
我很惊讶，因为您的错误表明 Keras 版本较旧。
我在这里列出了 Keras 的一些好用的求助渠道，您可以尝试一下。
https://machinelearning.org.cn/get-help-with-keras/
嗨，Jason，
感谢示例。我也遇到了同样的错误。Keras/Theano/sklearn: 2.1.2/0.90/0.19.1。Mohit，您能调试好吗？
很遗憾听到您遇到这个问题，我通常认为这是版本问题，但您看起来是最新的。
我没有什么好主意，如果您有新发现请告诉我？
你好 Jason，
我在上面的代码上使用了 r2 指标，并发现更宽的模型比更深的模型的得分更好。这是否意味着更宽的模型比更深的更好？r2 分数在这种情况下是否是一个评估回归模型的好指标？
一般来说，神经网络模型是随机的，这意味着它们每次运行的结果可能不同。
https://machinelearning.org.cn/randomness-in-machine-learning/
我通常推荐这种方法来有效评估神经网络。
https://machinelearning.org.cn/evaluate-skill-deep-learning-models/
您好 Jason，我正在使用您在第...
”
import numpy
import pandas
…
”
到这一节的代码
”
kfold = KFold(n_splits=10, random_state=seed)
results = cross_val_score(estimator, X, Y, cv=kfold)
print(“Results: %.2f (%.2f) MSE” % (results.mean(), results.std()))
”
但均值和标准差值总是高于您的结果。
”
结果：60.40 (41.96) MSE
”
问题出在哪里？？
机器学习算法是随机的，这可能只是在不同硬件/库版本上的不同结果。
请看这篇文章
https://machinelearning.org.cn/randomness-in-machine-learning/
cross_val_score 的结果
”
[ 10.79553125, 7.68724794, 11.24587975, 27.62757629,
10.6425943 , 8.12384602, 4.93369368, 91.03362441,
13.37441713, 21.56249909]
”
是“均方误差”吗？？还是其他什么？
如果是的话，
这个预测模型很糟糕，是吗？
分数是 MSE。您可以取平方根将其转换为 RMSE。
得分好坏取决于基线模型的技能（例如，它们是相对的），以及领域知识（例如，它们的解释）。
我在 cross_val_score 上遇到了问题。每次运行代码时，我都会收到错误
#TypeError: The added layer must be an instance of class Layer. Found
有什么建议吗？
谢谢！
完整输出
回溯（最近一次调用）
File “Y:\Tutorials\Keras_Regression_Tutorial\Keras_Regression_Tutorial\module1.py”, line 39, in
results = cross_val_score(estimator, X, Y, cv=kfold)
File “C:\Users\Gabby\y35\lib\site-packages\sklearn\model_selection\_validation.py”, line 321, in cross_val_score
pre_dispatch=pre_dispatch)
File “C:\Users\Gabby\y35\lib\site-packages\sklearn\model_selection\_validation.py”, line 195, in cross_validate
for train, test in cv.split(X, y, groups))
File “C:\Users\Gabby\y35\lib\site-packages\sklearn\externals\joblib\parallel.py”, line 779, in __call__
while self.dispatch_one_batch(iterator)
File “C:\Users\Gabby\y35\lib\site-packages\sklearn\externals\joblib\parallel.py”, line 625, in dispatch_one_batch
self._dispatch(tasks)
File “C:\Users\Gabby\y35\lib\site-packages\sklearn\externals\joblib\parallel.py”, line 588, in _dispatch
job = self._backend.apply_async(batch, callback=cb)
File “C:\Users\Gabby\y35\lib\site-packages\sklearn\externals\joblib\_parallel_backends.py”, line 111, in apply_async
result = ImmediateResult(func)
File “C:\Users\Gabby\y35\lib\site-packages\sklearn\externals\joblib\_parallel_backends.py”, line 332, in __init__
self.results = batch()
File “C:\Users\Gabby\y35\lib\site-packages\sklearn\joblib\parallel.py”, line 131, in __call__
return [func(*args, **kwargs) for func, args, kwargs in self.items]
File “C:\Users\Gabby\y35\lib\site-packages\sklearn\joblib\parallel.py”, line 131, in
return [func(*args, **kwargs) for func, args, kwargs in self.items]
File “C:\Users\Gabby\y35\lib\site-packages\sklearn\model_selection\_validation.py”, line 437, in _fit_and_score
estimator.fit(X_train, y_train, **fit_params)
File “C:\Users\Gabby\y35\lib\site-packages\tensorflow\contrib\keras\python\keras\wrappers\scikit_learn.py”, line 157, in fit
self.model = self.build_fn(**self.filter_sk_params(self.build_fn))
File “Y:\Tutorials\Keras_Regression_Tutorial\Keras_Regression_Tutorial\module1.py”, line 25, in baseline_model
model.add(Dense(13, input_dim=13, kernel_initializer=’normal’, activation=’relu’))
File “C:\Users\Gabby\y35\lib\site-packages\tensorflow\contrib\keras\python\keras\models.py”, line 460, in add
‘Found: ‘ + str(layer))
TypeError: 添加的层必须是 Layer 类的实例。找到
Press any key to continue . . .
抱歉，我以前没有见过这个错误。
确认您的 Python 库（包括 Keras 和 sklearn）是最新的。
确认您已复制了示例中的所有代码。
您好！非常感谢您的精彩教程。非常有帮助！
但我的问题是：您知道如何在使用 CNN 和 2D 图像时，在 pipeline 中使用 StandardScaler 吗？我的 X 数据形状例如是 (39, 256, 256, 1)。
在没有 StandardScaler 的情况下，它工作得很好，但使用 StandardScaler 时，我会得到以下错误
ValueError: Found array with dim 4. StandardScaler expected <= 2。
您知道如何转换我的输入数据以及在哪里转换才能与 CNN、2D 图像和 StandardScaler 一起使用吗？
我建议使用 Keras 内置的图像数据缩放功能。
https://machinelearning.org.cn/image-augmentation-deep-learning-keras/
非常感谢您的快速回复！很高兴知道 Keras 已经有了用于增强图像的 ImageDataGenerator。
我还有一个问题，您知道如何将神经网络的输出恢复到原始尺度吗？我的意思是，如果 ImageDataGenerator 有类似 sci-kit learn 的 StandardScaler.inverse_transform() 的功能？
我不确定，我认为没有。
如果图像是输入，为什么需要反转操作？
在我的例子中，我的网络输出是基于实际像素值的。我想，在这种情况下，我将直接省略标准化。但感谢您提到 ImageDataGenerator，它在其他情况下对我很有帮助 🙂
你好，
非常感谢您的帖子
我使用了您上传的数据。
但是，当我打印 MSE 时，我注意到：Found input variables with inconsistent numbers of sample [506, 1]。这是数据中的最后一个样本。
请帮帮我
非常感谢
抱歉，我不明白，您能重述一下问题吗？
在第 2 步评估基线模型时，我无法打印，因为出现了那个错误
” Found input variables with inconsistent numbers of sample [506, 1]。这是数据中的最后一个样本。”
也许您应该仔细检查一下是否复制了所有代码？
我的错。我已经用 Excel 中的“文本到列”功能将数据分割成了列。
非常感谢您 🙂
非常感谢您提供的这些文章。有两个问题
1) 您提到“使用了均方误差损失函数……这将是我们用来评估模型性能的相同指标。”我看到了‘mean_squared_error’作为‘loss’传递，但没有传递‘metrics=[…]’参数。如果 Keras 没有指定指标，它是否会自动将‘loss’函数用作指标？
2) 我重新进行了这个实验，并在 KFold 函数中添加了“shuffle=True”参数。这似乎提高了性能，下降到 13.52 (6.99) MSE（更宽的模型）。您对此潜在的优化有什么看法？这似乎“好得不真实”。
谢谢！
是的，Keras 在训练期间会报告损失和指标，这篇帖子可能有助于您理解正在发生的事情。
https://machinelearning.org.cn/custom-metrics-deep-learning-keras-python/
做得很好。
结果可能不是真实的（例如，没有统计学意义），请考虑这种方法来评估深度学习模型的技能。
https://machinelearning.org.cn/evaluate-skill-deep-learning-models/
你好
您创建的 NN 模型包含 1 个输出。
我有一个关于超过 1 个输出的问题。
我想通过修改它来应用此代码。可以吗？
您能提供一些解决方案或注意事项来解决这个问题吗？
非常感谢
是的，您可以更改输出的数量。
你好 Jason，
对于多个输出，我是否仍然使用“model.compile(loss=’mean_squared_error’, optimizer=’adam’)”来编译模型？在多个输出的情况下，代码如何计算均方误差？
谢谢
是的。
您可以选择为每个时间步的输出计算误差，或者为所有时间步一起计算。我在这里对此有所介绍。
https://machinelearning.org.cn/multi-step-time-series-forecasting-long-short-term-memory-networks-python/
如果每个时间步的输出具有不同的单位（或者在简单的密集前馈网络的情况下，在最后有多个输出，每个输出具有不同的测量单位？）。在这种情况下，由于单位不同且输出的数量级范围可能不同，简单地取 RMSE 等可能没有意义。您会建议如何将这些不同的输出合并到一个损失函数中？
我建议在拟合模型之前将输出重新缩放到有意义的范围（例如 0-1）。
嗨，Jason，
我运行此代码时遇到错误。我安装了 karas 2 和 scikit learn .17。我一直收到这个错误
Connected to pydev debugger (build 172.3968.37)
使用 TensorFlow 后端。
回溯（最近一次调用）
File “/home/b/pycharm-community-2017.2.3/helpers/pydev/pydevd.py”, line 1599, in
globals = debugger.run(setup[‘file’], None, None, is_module)
File “/home/b/pycharm-community-2017.2.3/helpers/pydev/pydevd.py”, line 1026, in run
pydev_imports.execfile(file, globals, locals) # 执行脚本
File “/home/b/PycharmProjects/ANN1a/ANN2-Keras1a”, line 6, in
from sklearn.model_selection import cross_val_score
ImportError: No module named model_selection
Backend TkAgg is interactive backend. Turning interactive mode on.
这是说我没有 Sklearn 模块，是因为我只有 .17 而不是当前版本（我认为是 .19）吗？我在更新我的 scikit-learn 包时遇到了很多麻烦。
您需要将 sklearn 更新到 0.18 或更高版本。
嘿 Jason，我需要一些关于这个错误消息的帮助。我不确定它是什么意思。
‘ValueError: could not convert string to float: Close’
我认为它可能指的是我的 dataset.csv 文件中的一个列，名为‘Close’。
代码如下：
import numpy
import pandas
来自 keras.models import Sequential
from keras.layers import Dense
from keras.wrappers.scikit_learn import KerasRegressor
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import KFold
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
# 加载数据集
dataframe = pandas.read_csv(“PTNprice.csv”, delim_whitespace=True, header=None, usecols=[1,2,3,4])
dataset = dataframe.values
# 分割为输入 (X) 和输出 (Y) 变量
X = dataset[:,0:4]
Y = dataset[:,1]
# 定义模型
def larger_model()
# 创建模型
model = Sequential()
model.add(Dense(100, input_dim=4, kernel_initializer=’normal’, activation=’relu’))
model.add(Dense(50, kernel_initializer=’normal’, activation=’relu’))
model.add(Dense(1, kernel_initializer=’normal’))
# 编译模型
model.compile(loss='mean_squared_error', optimizer='adam')
return model
# 设置随机种子以保证结果可复现
seed = 7
numpy.random.seed(seed)
# 使用标准化数据集评估模型
numpy.random.seed(seed)
estimators = []
estimators.append(('standardize', StandardScaler()))
estimators.append((‘mlp’, KerasRegressor(build_fn=larger_model, epochs=50, batch_size=5, verbose=0)))
pipeline = Pipeline(estimators)
kfold = KFold(n_splits=10, random_state=seed)
results = cross_val_score(pipeline, X, Y, cv=kfold)
print(“Standardized: %.2f (%.2f) MSE” % (results.mean(), results.std()))
您是否使用了教程中的代码和数据？
您是否精确地复制了所有内容，包括缩进？
Jason，
不，我的代码已修改，以尝试处理新的文本数据。我认为数据与原始数据集非常相似。我实际上已经成功运行了，没有错误。我只是将 header=none 改为了 header=1。
代码
# 加载数据集
dataframe = pandas.read_csv(“PTNprice.csv”, delim_whitespace=True, header=1, usecols=[1,2,3,4])
dataset = dataframe.values
# 分割为输入 (X) 和输出 (Y) 变量
X = dataset[:,0:4]
Y = dataset[:,1]
脚本完成时间比预期要长。我正在尝试让它也进行预测，但我的输出不太令人满意。这是它给我的结果。您认为这意味着什么？
输出
Larger: 0.00 (0.00) MSE
[ 0.78021598 0.79241288 0.81000006 …, 3.64232779 3.59621549
3.79605269]
我的数据只是十年期间的股票价格，例如：0.75674 0.9655 3.753 1.0293
列的设置如下。
您可能需要为您的特定问题调整模型，这里有一些关于如何获得更好技能的建议。
https://machinelearning.org.cn/improve-deep-learning-performance/
嗨，Jason，
非常感谢，这些课程很棒，非常有帮助！
我写了代码，跟着您的思路，但唯一的区别是我没有使用 Pipeline，而是单独处理了缩放。
seed = 7
np.random.seed(seed)
X = (X – X.mean(axis=0))/X.std(axis=0)
estimator = KerasRegressor(build_fn=baseline_model, nb_epoch = 100, batch_size=5,verbose=0)
kfold = KFold(n_splits=10,random_state=seed)
results = cross_val_score(estimator, X, y, cv=kfold)
出于某些原因，我无法理解，您的方法总是产生更好的结果。有什么想法为什么它表现更好吗？
非常感谢
这可能是一个统计上的巧合，尝试改变随机种子并重复实验 10 到 30 次，然后取每个模型的平均得分。
这篇帖子提供了更多关于有效评估随机算法的思路。
https://machinelearning.org.cn/evaluate-skill-deep-learning-models/
非常感谢，我会这样做的。
Jason，
只是想来感谢您！
这三天来我一直在调整我的学习模型，这是我的成果
Larger: 0.12 (0.36) MSE
这已经相当不错了吧？我使用的是与您不同的数据集，但结构非常相似。我曾有一个模型欠拟合的问题，错误率高达 500%(500%)。我意识到我需要让它变得更复杂一些。所以我把特征数量增加了三倍，让层更深更宽，并将 epoch 数量增加到 50000，batch size 增加到 10000。我还将分割数量从 10 增加到 25。
问题：我能否获得更低的错误率，或者“Larger: 0.12 (0.36) MSE”是最低的预期值了吗？
再次感谢 Jason，
Brence
干得不错。
我不确定这个问题的极限，只要您有时间和兴趣，就继续尝试吧。在实践中，“好”是相对于您之前取得的成就而言的。这是应用机器学习的一个好教训！
尊敬的先生。
我应用了您的代码并成功用于预测。
与我上一个问题一样。我想再添加一个输出：房屋的年龄：例如，建于 5 年前、7 年前、10 年前……。价格和年龄是独立的。
据我所知，这不是一个分类问题。
所以，您会建议代码还是我下一步该怎么做来解决这个问题，请？
非常感谢
这个回归模型是否可以进行递归多步预测？
我不确定这段代码如何适应这一点。
prediction(t+1) = model(obs(t-1), obs(t-2), …, obs(t-n))
prediction(t+2) = model(prediction(t+1), obs(t-1), …, obs(t-n))
是的，也许这篇帖子可以作为模板。
https://machinelearning.org.cn/multi-step-time-series-forecasting-long-short-term-memory-networks-python/
嗨，Jason，
感谢您的教程。我刚刚尝试运行您第 2 部分的示例代码，但不幸的是得到了负 MSE，这显然没有意义。
结果：-57.82 (42.31) MSE
有什么想法吗？
代码完全相同，只有微小的改动，我不得不更改
model.compile(loss=’mean_square_error’,optimizer=’adam’)
推广到
model.compile(loss=’mse’,optimizer=’adam’)
谢谢
Toby
是的，sklearn 会反转最小化分数以使其最大化以便优化。只需取绝对值即可。
太感谢了。是的，我在提问后就知道了。
不错。
嗨，Jason，
感谢这个精彩的教程。我只想知道有什么方法可以预测神经网络对某些特定 X 值的输出，并通过绘制预测值和实际值来比较性能。
谢谢
Mohit
关于如何以及绘制什么，这确实取决于具体的应用。
嗨，Jason，
首先：感谢您和您所有其他精彩的教程。作为初学者，获得实际有用的建议对我帮助很大。
但是，我遇到了一个需要进一步建议的阶段——希望您能帮助我！
我理解回归和 MSE 的概念——在我的例子中，我试图根据各种其他参数预测两个值。这真的很简单，值之间的相关性也很清楚，所以我不认为这会是一个问题。
现在，当有一个预测值时，我不想知道 MSE，而是想知道预测值是否在原始值的一个特定范围内。
例如
‘可接受’范围：y +/- 0.1
y = 1
y^ = 1.08
y – y^ = |0.08| —> OK，因为它在 y +/- 0.1 范围内。
有没有办法在 Python 或 KERAS 中做到这一点？我刚刚开始使用它，所以任何建议都会有帮助。谢谢！
您可以为线性模型计算置信区间。
我在时间序列的线性回归示例可以为您提供一些思路。
https://machinelearning.org.cn/time-series-forecast-uncertainty-using-confidence-intervals-python/
谢谢！我会看看的。
嗨，Jason，
感谢您的教程。
我想知道
如果一个回归问题数据集有 10000 个特征，input_dim 如此之大……但所有特征都有意义（它是过程数据）且不能删除。
如何修改这个示例来处理我的问题，以及我应该注意什么，有什么技巧吗？
也许您可以使用投影，例如 PCA？SVD？或其他方法？
您好 Jason – 感谢所有这些教程。这些太棒了！！
由于 NN 架构是黑箱。是否有办法访问隐藏层数据进行调试？当我运行回归代码（如上）时，我得到的结果略有不同。再次感谢！
您每次在相同数据上运行相同算法时都会得到不同的数字，Steve。这是特性，不是 bug。
https://machinelearning.org.cn/randomness-in-machine-learning/
我认为您可以访问模型上的层，它们是一个数组：model.layers。
嗨，Jason，
调用 model.predict() 时，预测值在房屋价格方面没有意义。
例如，房价数据集的第 15 行
0.63796 0.00 8.140 0 0.5380 6.0960 84.50 4.4619 4 307.0 21.00 380.02 10.26 18.20
最后一个值 (18.20) 是房屋价格（以千美元为单位）。
Xnew= array([[ 0.63796, 0.00, 8.140, 0, 0.5380, 6.0960, 84.50, 4.4619, 4, 307.0, 21.00, 380.02, 10.26]])
ynew=model.predict(Xnew)
ynew
Out[114]: array([[-0.09053693]], dtype=float32)
-0.09053693 是什么意思？
您能否提供 predict 函数的完整代码？
也许您运行的示例在建模之前缩放了数据，如果是这样，您可以对预测值进行反向缩放，将其恢复到原始单位。
嗨，Jason，
是否可以为数据集中使用的每一列获取预测输出？例如，数据集由
12 1 22 45
2 34 55 8 组成。我能否让它为数据集中每一列输出一个数字？
是的，您可以调用 model.predict()。
但如何为数据集中多于一列进行预测？我的数据集有 6 列，我的输出总是只有 5 列。这让我认为它只是预测了一个列而不是全部 6 列。我能否通过将输出层设置为更多神经元来完成此操作？
您可以通过输出层中的神经元数量来配置模型以预测向量。
您可以通过编码器-解码器模型将模型输出一次一个列。
我在博客上有这两者的示例。
这正是我想要的。我在博客上找到了您的示例。非常感谢您 Jason。
很高兴听到这个消息。
嗨，Jason，
感谢您的教程！我不是程序员，事实上，我一生中从未写过一行代码。但我发现您的教程非常有帮助。
最近我遇到了一个回归问题，并尝试使用深度学习来解决它。所以我按照这篇文章一步一步地让 Keras 运行起来并得到结果。问题是我不知道如何调整和优化神经网络。我得到的结果远不能令人满意。我是否需要逐一调整模型的参数并观察结果，还是有更快捷的方法来优化神经网络？
另外，我看到这里有一个迷你课程，我尝试注册但没有收到邮件。也许是因为我来自中国或其他原因，我不知道。有没有什么速成班可以让我参加？因为我什么都不知道 Python……
干得好！
这篇帖子将向您展示如何调整网络。
https://machinelearning.org.cn/improve-deep-learning-performance/
您可以在这里访问迷你课程。
https://machinelearning.org.cn/applied-deep-learning-in-python-mini-course/
感谢您的回复。但我还有另一个问题。涉及‘estimator’的行是用于训练模型的，对吧？如何保存模型并用于预测？
请看这篇文章
https://machinelearning.org.cn/save-load-keras-deep-learning-models/
非常感谢！我学到了很多。在这个例子中，我可以使用 pipeline.fit(X,Y) 来训练模型，并使用 pipeline.predict(X) 进行预测，对吗？我认为教程中的‘pipeline’包括了标准化过程。所以当我使用 pipeline.predict(X) 时，我只需要输入原始数据就可以得到预测，而预测将是反标准化后的结果。我理解正确吗？
我相信是的。
您好，我需要询问关于这行 X = dataset[:,0:13]，从数据集中可以看出它有 14 列（0 到 13），最后一列是标签列，那么这行代码应该是 X = dataset [:,0:12]。我说的对吗？
不。您可以在这里了解更多关于数组切片的信息。
https://machinelearning.org.cn/index-slice-reshape-numpy-arrays-machine-learning-python/
嗨，Jason，
我正在尝试将本教程中的代码应用于我的时间序列预测。但是从一开始，当我尝试将数据分割为 X 和 Y 时，我就会收到错误“TypeError: unhashable type: ‘slice’”。不幸的是，我找不到它的来源。
你能帮我吗？
提前感谢！
runfile(‘D:/LOCAL_DROPBOX/MasterArbeit_Sammlung_V01/Python/MasterArbeit/ARIMA/Test/BaselineRegressionKNN.py’, wdir=’D:/LOCAL_DROPBOX/MasterArbeit_Sammlung_V01/Python/MasterArbeit/ARIMA/Test’)
[[‘3,6’ ‘20,3’ ‘0’ …, 173 1136 0]
[‘11,4’ ‘18,8’ ‘15,2’ …, 105 1676 0]
[‘8,9’ ‘15,3’ ‘1,4’ …, 372 733 0]
……,
[‘-2,3’ ‘4,5’ ‘0’ …, 0 0 0]
[‘0,2’ ‘7,9’ ‘0’ …, 0 0 0]
[‘-3,5’ ‘4,4’ ‘0’ …, 0 0 0]]
回溯（最近一次调用）
File “”, line 1, in
runfile(‘D:/LOCAL_DROPBOX/MasterArbeit_Sammlung_V01/Python/MasterArbeit/ARIMA/Test/BaselineRegressionKNN.py’, wdir=’D:/LOCAL_DROPBOX/MasterArbeit_Sammlung_V01/Python/MasterArbeit/ARIMA/Test’)
File “C:\Users\Tanya\Anaconda3\lib\site-packages\spyder\utils\site\sitecustomize.py”, line 710, in runfile
execfile(filename, namespace)
File “C:\Users\Tanya\Anaconda3\lib\site-packages\spyder\utils\site\sitecustomize.py”, line 101, in execfile
exec(compile(f.read(), filename, 'exec'), namespace)
File “D:/LOCAL_DROPBOX/MasterArbeit_Sammlung_V01/Python/MasterArbeit/ARIMA/Test/BaselineRegressionKNN.py”, line 25, in
X = dataset[:,0:8]
File “C:\Users\Tanya\Anaconda3\lib\site-packages\pandas\core\frame.py”, line 2139, in __getitem__
return self._getitem_column(key)
File “C:\Users\Tanya\Anaconda3\lib\site-packages\pandas\core\frame.py”, line 2146, in _getitem_column
return self._get_item_cache(key)
File “C:\Users\Tanya\Anaconda3\lib\site-packages\pandas\core\generic.py”, line 1840, in _get_item_cache
res = cache.get(item)
TypeError: unhashable type: ‘slice’
您可以在这里了解更多关于数组切片的信息。
https://machinelearning.org.cn/index-slice-reshape-numpy-arrays-machine-learning-python/
你好，
关于“本节的进一步扩展将是类似地对输出变量应用重缩放，例如将其归一化到 0-1 的范围”。
我不知道如何让 StandardScaler 对象也对输出变量 Y 应用变换，而不是只对 X 应用。我做了以下操作。
results = cross_val_score(pipeline, preprocessing.scale(X), preprocessing.scale(Y), cv=kfold)
但是，这样预处理步骤是在 kfold 交叉验证之前完成的，而不是在您的先前示例中那样在每个折叠执行。
是的，数据准备必须在交叉验证之前进行。
我们如何绘制预期值与预测值之间的关系？
我推荐使用 matplotlib。
还有一个问题，如何将 k-fold 交叉验证与 CNN 模型一起使用？
与任何模型一样。您具体遇到什么问题？
我正在使用CNN来处理回归问题，并将数据分割为训练集、验证集和测试集，但我遇到了过拟合问题。所以，我正在考虑使用交叉验证，但我不知道如何操作。
我在这里展示了如何评估深度学习模型。
https://machinelearning.org.cn/evaluate-skill-deep-learning-models/
嗨，Jason
我在谷歌上搜索一些教程时，如果出现您的帖子，我总是先查看您的博客。
非常感谢。
我希望它们能帮到您。
嗨，Jason
输出层的激活函数是什么？您没有写。
谢谢。
线性，这是默认的。
你好 Jason，
我使用了您的代码，但得到了不同的结果。
结果：-114.64 (82.76) MSE
标准化：-29.57 (27.85) MSE
更大：-23.46 (27.29) MSE
更宽：-22.91 (29.25) MSE
为什么它们是负数？
干得不错。负数结果是由sklearn反转损失函数引起的。这是一个相对较新的功能。
这很令人困惑。结果差异很大！
如何以百分比形式解释这个错误？有办法吗？
我学习了Ng在deeplearning_dot_ai的课程，但他只介绍了分类问题。
如何理解回归问题中的误差好坏？对于向量回归（输出是向量）问题，与您的示例会有区别吗？
谢谢你。
是的，将模型的性能与基线模型（如零规则算法）进行比较。
改进是相对的，不是绝对的。
嗨，Jason，
在使用管道和k-fold cv时，如何获得用于绘图的预测y值？另外，假设有一个单独的X_test，如何从中预测y_hat？所以，我设想一个场景，您有一个训练集和一个单独的测试集（就像在Kaggle竞赛中一样）。您在训练集上构建管道和k-fold cv，并在测试集上进行预测。但是，您的训练集作为管道的一部分进行了缩放。如何将相同的缩放应用于X_test？
我们不使用CV进行预测，它只是一种估计模型技能的方法。在此了解更多。
https://machinelearning.org.cn/train-final-machine-learning-model/
嗨，Jason；
如何设计一个返回多个输出（例如4个）而不是单个输出的Keras模型用于回归问题？
您可以在输出层中使用多个单元来输出一个向量。
您的意思是，我应该通过编辑编译前的最后一行来更改模型设计：
model.add(Dense(1, kernel_initializer=’normal’))
推广到
model.add(Dense(4, kernel_initializer=’normal’))
?
是的。
我得到了与WonderingStranger类似的结果。我是深度学习新手。所以我不太明白您的回复是什么意思。如果能详细解释一下，我将不胜感激。
你好，我该如何保存权重？我查看了您关于保存的链接，但您在那个链接中没有使用管道方法。
我尝试了kfold.save_weigths，但出现了一个错误。
您可能需要保留对模型的引用（某种方式？）并使用Keras API来保存权重。
嗨，Jason，
有没有办法将标准化后的数据输入到lstm模型 (create_model) 中？原因是lstm的输入形状只允许3D。然而，标准化只能接受2D形状。希望得到您的回复……谢谢。
在重塑之前进行标准化。
谢谢Jason的回复……我很感激。
嗨，Jason，
我在这方面还是新手。
感谢您一步一步的解释。
我想询问housing.csv的详细信息以及如何进行预测。
例如，我们想预测数据集中最后一个属性的值。
通过使用estimator.predict。
谢谢你
您可以使用
yhat = model.predict(X)
这有帮助吗？
嗨，Jason，
感谢您精彩的教程。您的网站让我看起来更年轻了：)
有没有办法打印/导出实际房屋价格和预测房屋价格。
另外，您能否为R2提供一个可视化建议？
谢谢！
你可以按如下方式进行预测
yhat = model.predict(X)
X = dataset[:,0:11]
Y = dataset[:,11]
回溯（最近一次调用）
File “”, line 5, in
Y = dataset[:,11]
IndexError: index 11 is out of bounds for axis 1 with size 1
请帮助解决此问题。
感谢Jason发表这篇精彩的帖子。
请确保您复制了示例中的所有代码。
嗨，Jason！
感谢这篇很棒的教程。
我做了上面所有的例子，然后我尝试用
“baseline_model.fit(X,Y, nb_epoch=50, batch_size=5)”这个命令来拟合baseline_model，我收到了“AttributeError: ‘function’ object has no attribute ‘fit’”这个错误消息。问题出在哪里？
我搜索了完全相同的消息，但没有找到关于model.fit错误的任何信息。
您是在函数上调用了函数。模型的变量名为“model”。请对它调用函数。
你好Jason，我遇到了一个问题，但不确定原因。这是一个有7列（6个输入和1个输出）的数据集。
代码
错误
感谢，任何帮助都将不胜感激！
看起来您的数据形状与模型期望的形状不匹配。
更改模型或更改数据。
谢谢Jason，这是一个很好的教程。
但我有一个问题，我们在compile函数中只指定了一个损失函数‘mse’，这意味着我们只能在结果中看到MSE。有没有办法在结果中同时看到多个准确率？谢谢。
您可以使用Keras API并指定metrics，在此了解更多。
https://machinelearning.org.cn/custom-metrics-deep-learning-keras-python/
嗨，Jason，
感谢教程！我有一个问题：如果您使用StandardScaler对数据集进行缩放，这是否会影响交叉验证分数（MSE）的单位（$）？谢谢。
是的，我们必须在估计模型技能之前对预测进行逆变换，以确保单位与原始数据相同。
但看起来您没有这样做，仍然提到交叉验证分数（MSE）的单位是“千美元”，是不是我漏了什么？
是的，我没有转换回原始单位（美元），所以我提到的是“平方美元”，例如 $^2$。
你好Jason，我有以下两个问题：
如何使用MAE而不是MSE？以及
如何计算Spearman的秩相关系数？
您可以将损失或指标指定为‘mae’。
您可以保存预测，然后使用scipy计算您的预测与预期结果之间的spearman相关系数。
我正在尝试使用以下方法保存模型的预测和预期结果：
代码
for test in kfold.split(X, Y)
print (model.predict(X[test]))
print (Y[test])
这样可以吗？
我建议训练一个最终模型并使用它进行预测，更多关于这方面的内容请看这里。
https://machinelearning.org.cn/train-final-machine-learning-model/
你好，
感谢您提供实用、有用且易于理解的博文。
我使用了这篇帖子来评估我的MLP模型，但是否可以使用此方法来评估LSTM？
谢谢
对于序列预测，通常需要不同的模型评估方法。例如向前验证。
https://machinelearning.org.cn/backtest-machine-learning-models-time-series-forecasting/
谢谢Jason的精彩帖子。
我在理解MSE和MAE的含义方面有困难。我无法理解这个数字的含义！对于这个特定的例子，‘mse’或‘mae’的范围是多少？
因为我处理的是一个大型数据集，我的mae在400到800之间，我无法弄清楚这意味着什么。您能帮帮我吗？
谢谢
好问题。
您可以对MSE取平方根，将其单位恢复到用于预测的变量的相同单位。
MAE的单位与输出变量的单位相同。
误差值可以根据输出变量的分布来解释。
您可以将模型的性能与基线方法的误差分数进行比较来确定模型的性能是否良好，例如，对测试集上的每次预测都预测训练集的平均结果。
这有帮助吗？
所以，‘mse’和‘mae’不是百分比，它们可以是任何数字（甚至很大，取决于输出变量），对吗？
我的意思是，如果我们预测的是房价，而我们的输出是1000美元，那么mae等于100意味着我们在预测价格时有大约一百美元的误差。我理解得对吗？
再次感谢
正确。
我真的很感激。
你好Jason，非常感谢您的帖子。
我有一个问题，补充Sarah的：我是否应该对“results.std()”也应用平方根，以便更接近地了解误差与数据之间的关系？
在文章中，您获得了MSE=20，标准差约为22，但如果我们计算MSE的平方根，我有点理解我们也应该对标准差这样做，对吗？
然而，如果是这样，如果我们计算平方根，原始值不就是方差吗？换句话说，“results.std()”在下一行实际上是标准差还是方差？
谢谢
不。对原始MSE值取平方根，然后计算均值和标准差等汇总统计量。
请注意，KerasRegressor中的nb_epoch已被弃用，在所有情况下都应使用epochs。https://github.com/keras-team/keras/issues/6521
谢谢，已修正。
嗨，Jason，
很棒的博文。对我的工作帮助很大。我为学习和预测冲击物理数据集（11个输入参数和时间序列输出）创建了一个类似的多层模型。
我想知道如何获得不确定性信息以及从估计器中获得预测输出？您是否有博文或Keras代码片段可以让我开始？
非常感谢。
基本上，我的模型是这样的：
# 定义基线模型
def baseline_model_full()
# 创建模型
model = Sequential()
model.add(Dense(numOfParams, input_dim=numOfParams, kernel_initializer=’normal’, activation=’relu’))
model.add(Dense(900, kernel_initializer=’normal’))
# 编译模型
model.compile(loss='mean_squared_error', optimizer='adam')
return model
我用训练输入和输出数据拟合了这个模型，然后为它的预测提供了一个新输入。我想知道，除了预测输出之外，我是否也能获得模型的不确定性。
谢谢
好问题。您可以使用predict_proba()来获得概率输出。
这有帮助吗？
嗨，Jason，
感谢您的快速回复！是的，我能够使用predict_proba()来获取概率值。我注意到，概率值相当小，尽管预测质量很好。
我有200个测试输入，形状为(200,11)，预测输出的形状为(200,900)。输出概率的形状也是(200,900)，该预测概率的最大值为0.024。那么，关于如何解释这些概率值有什么建议吗？
再次感谢。
也许模型不够自信。
仔细查看后，我发现predict()和predict_proba()实际上给出了相同的数组作为输出；它们是预测值，而不是概率。您见过这种情况吗？
谢谢
抱歉，我没见过，也许可以联系Keras支持。
https://machinelearning.org.cn/get-help-with-keras/
我查看了这一点，看起来这两个函数是相同的。
https://github.com/keras-team/keras/blob/master/keras/models.py
我认为这可能是我得到相同输出的原因。但是，与其他一些互联网上的评论建议我们应该为两个函数都获得概率作为输出不同，我认为我在这两种情况下都得到了预测值。
您对此有什么建议吗？
为什么您在某些情况下使用50个epochs，而在其他情况下使用100个epochs？
这似乎是您发现“更宽”（200个epochs）比“更大”（50个epochs）更好的最佳解释。
果然，我发现“更大”（100个epochs）比“更宽”（100个epochs）效果更好。
更大（100个epochs）：22.28 (26.54) MSE
是的，我当时是在演示如何系统地进行模型配置，而不是为了找到这个问题的最佳模型。
Jason，
我正在尝试将CNN用于信号处理。
想知道是否可行？您能给我一些参考吗？
具体例子：
我有一个长度为100个样本的音频信号。
我想找到一个滤波器，从我的信号中产生一个delta尖峰。
换句话说，用我的信号进行训练应该输出[1, 0, 0, …… 0, 0 ] – delta尖峰。
非常感谢，
保罗
也许可以尝试在Google Scholar上搜索。
也许可以看看LSTMs，我见过它们更多地用于处理信号数据，例如语音识别问题的音频数据。例如。
https://machinelearning.org.cn/start-here/#lstm
希望这能作为一些初步的指引。
epochs的数量是否取决于我拥有的数据量？
例如，我有大约400,000+的数据，那么epochs的数量应该是多少？
更多数据可能需要更多的学习/epochs。
谢谢Jason，您的博客是初学者学习机器学习的绝佳场所。
谢谢，听到这个我很高兴。
Jason，我在学习神经网络时遇到了“死神经元”的问题，在用Keras训练时如何识别死神经元？
以及如何消除它们，我非常想知道。
预先感谢您！
谢谢，这是一个很好的话题。抱歉，我没有相关资料。也许我以后会介绍。
Jason，我真的很想知道神经网络背后的数学原理，你能分享一个我可以学习的地方吗？我想知道它如何在线性回归中进行预测。
神经网络和线性回归是两种不同的方法。
在此书中了解神经网络的数学原理。
https://amzn.to/2KuhGPP
在此书中了解线性回归的数学原理。
https://amzn.to/2wM6Jr4
谢谢Jason，这是一个很好的资源。
你好 Jason-
感谢您的精彩分享。
我正在使用以下代码来预测波士顿房价。
# Artificial Neural Network
# 使用波士顿数据集的回归示例：基线
# Importing the libraries
import numpy
from pandas import read_csv
来自 keras.models import Sequential
from keras.layers import Dense
from keras.wrappers.scikit_learn import KerasRegressor
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import KFold
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
import matplotlib.pyplot as plt
# 导入数据集
dataframe = read_csv(“housing.csv”, delim_whitespace=True, header=None)
dataset = dataframe.values
# Split into input (X) and output (Y) variables
X = dataset[:,0:13]
y = dataset[:,13]
# 创建模型
model = Sequential()
model.add(Dense(13,input_dim=13, init=’normal’, activation=’relu’))
model.add(Dense(1, init=’normal’))
# 编译模型
model.compile(loss=’mean_squared_error’, optimizer=’adam’, metrics=[‘accuracy’])
# 拟合模型
history = model.fit(X, y, validation_split=0.20, epochs=150, batch_size=5, verbose=0)
# 进行预测
predictions = model.predict(X)
# 列出历史中的所有数据
print(history.history.keys())
# 总结准确率的历史记录
plt.plot(history.history[‘acc’])
plt.plot(history.history[‘val_acc’])
plt.title(‘model accuracy’)
plt.ylabel(‘accuracy’)
plt.xlabel('epoch')
plt.legend([‘train’, ‘test’], loc=’upper left’)
plt.show()
然而，从图表中可以看出，我的准确率非常低。这是为什么？
您不能为回归问题测量准确率。在此了解更多。
https://machinelearning.org.cn/faq/single-faq/how-do-i-calculate-accuracy-for-regression
那么我该如何将预测值和实际值可视化在图表中呢？
您可以通过调用predict()进行预测，在此了解更多。
https://machinelearning.org.cn/how-to-make-classification-and-regression-predictions-for-deep-learning-models-in-keras/
您可以使用matplotlib的plot()函数创建图表。
谢谢您的回复。我已经解决了可视化问题。现在我正在尝试缩放输入。
但是，当我尝试缩放数据集时，它显示：“请重塑您的数据，如果数据只有一个特征，请使用array.reshape(-1, 1)，如果数据只包含一个样本，请使用array.reshape(1, -1)。”
我该如何解决？
这是我使用的代码：
from sklearn.preprocessing import StandardScaler
sc_X = StandardScaler()
X_train = sc_X.fit_transform(X_train)
X_test = sc_X.transform(X_test)
sc_y = StandardScaler()
y_train = sc_y.fit_transform(y_train)
y_test = sc_y.transform(y_test)
错误表明您提供的是一个1D数组，您必须将其更改为2D数组，可能是包含多行的单列（n，1）。
您可以在这里了解更多关于重塑numpy数组的信息。
https://machinelearning.org.cn/index-slice-reshape-numpy-arrays-machine-learning-python/
你好Jason！做得好，谢谢！我是ML新手。我尝试重复您的测试，但进行了一些小改动。此外，我没有使用CSV数据集，而是使用了Keras内置的数据集，并由Keras作者进行了分割。我没有使用CV。所以我有一个问题。我在测试数据上得到了MSE=12，在训练数据上得到了MSE=3。这种情况正常吗？还是我的错误？这比MSE=21少得多。代码如下：
batch_size = 32
epochs = 1000
model_name = ‘model_proba.h5′
(x_train, y_train), (x_test, y_test) = boston_housing.load_data()
scaler = StandardScaler()
scaler.fit(x_train)
x_train = scaler.transform(x_train)
x_test = scaler.transform(x_test)
input_shape = x_train.shape
model = Sequential()
model.add(Dense(100, input_dim=input_shape[1], activation=’relu’))
model.add(Dropout(0.3))
model.add(Dense(20, activation=’relu’))
model.add(Dropout(0.1))
model.add(Dense(1))
model.compile(loss=’mean_squared_error’, optimizer=’adadelta’, metrics=[‘accuracy’])
earlystopper = EarlyStopping(patience=100, verbose=1)
checkpointer = ModelCheckpoint(model_name, verbose=1, save_best_only=True)
history = model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs,verbose=1,
callbacks=[earlystopper, checkpointer])
scoret = model.evaluate(x_train, y_train, verbose=0)
score = model.evaluate(x_test, y_test, verbose=0)
print(‘Train loss:’, scoret[0])
print(‘Train accuracy:’, scoret[1])
print(‘Test loss:’, score[0])
print(‘Test accuracy:’, score[1])
听起来您的模型在训练数据集上可能有些过拟合。
感谢您的回答。我同意关于训练数据集的看法。但是我的测试数据集上的MSE很低，只有12（通常是21）。这意味着什么？这是过拟合模型吗？
低错误率是好事。测试集上的低错误率不是过拟合。这可能意味着模型很好，或者结果是一个统计上的巧合。
1. 嘿，当你进行 results.mean() 时，这会给你 K 折交叉验证分数的平均值，难道你不希望在微调模型时，平均值能够更高吗？
results.std() 应该会降低，因为我们希望方差很小，但为什么平均值降低是好的呢？
2. 当你使用 pipeline 应用 K 折交叉验证时，它是否会独立地标准化每个训练集？
3. 与其追加估计器和标准缩放器，我们能否直接将它们作为列表或字典输入？
理想情况下，我们希望平均值更高，标准差更小，如果可能的话。
是的，pipeline 中的任何转换器都会在训练集上拟合，并在测试集上应用。
是的，你可以将一个列表提供给 Pipeline。
你好 Jason，我是 Keras 的新手，你的博客对我帮助很大。
我正在尝试两个代码片段 1. 使用 sklearn 2. 使用 Keras。
第一个模型给了我一个很好的预测 (diabetes_y_pred)。
第二个模型给了我一个非常糟糕的预测 (diabetes_y_pred)。
你能告诉我为什么吗？只有当我增加 Keras 中 model.fit 的 epoch 大小时，diabetes_y_pred 的值才会变好。
sklearn : 代码
import matplotlib.pyplot as plt
import numpy as np
from sklearn import datasets, linear_model
from sklearn.metrics import mean_squared_error, r2_score
# 加载 diabetes 数据集
diabetes = datasets.load_diabetes()
# print (diabetes.keys())
# #print (diabetes.data)
# print (diabetes.DESCR)
# print (diabetes.feature_names)
#print (diabetes.target)
# 只使用一个特征
diabetes_X = diabetes.data[:, np.newaxis, 2]
# print (diabetes_X.shape)
# print (diabetes.data)
# print (diabetes_X)
# 将数据分割成训练/测试集
diabetes_X_train = diabetes_X[:-20]
diabetes_X_test = diabetes_X[-20:]
print (len(diabetes_X_train))
# 将目标分割成训练/测试集
diabetes_y_train = diabetes.target[:-20]
diabetes_y_test = diabetes.target[-20:]
# 创建线性回归对象
regr = linear_model.LinearRegression()
# 使用训练集训练模型
regr.fit(diabetes_X_train, diabetes_y_train)
# 使用测试集进行预测
diabetes_y_pred = regr.predict(diabetes_X_test)
print (“predict”,diabetes_y_pred)
# 系数
print(‘Coefficients: \n’, regr.coef_)
# 均方误差
print(“Mean squared error: %.2f”
% mean_squared_error(diabetes_y_test, diabetes_y_pred))
# 方差得分：1 是完美预测
print(‘Variance score: %.2f’ % r2_score(diabetes_y_test, diabetes_y_pred))
# 绘制输出
plt.scatter(diabetes_X_test, diabetes_y_test, color=’black’)
plt.plot(diabetes_X_test, diabetes_y_pred, color=’blue’, linewidth=3)
plt.xticks(())
plt.yticks(())
plt.show()
Keras : 代码
import matplotlib.pyplot as plt
import numpy as np
from sklearn import datasets, linear_model
来自 keras.models import Sequential
from keras.layers.core import Dense, Activation
# 加载 diabetes 数据集
diabetes = datasets.load_diabetes()
diabetes_X = diabetes.data[:, np.newaxis, 2]
diabetes_X_train = diabetes_X[:-20]
diabetes_X_test = diabetes_X[-20:]
diabetes_y_train = diabetes.target[:-20]
diabetes_y_test = diabetes.target[-20:]
model = Sequential()
#model.add(Dense(2,1,init=’uniform’, activation=’linear’))
model.add(Dense(1, input_dim=1, kernel_initializer=’uniform’, activation=’linear’))
model.compile(loss='mse', optimizer='rmsprop')
model.fit(diabetes_X_train, diabetes_y_train, epochs=10000, batch_size=16,verbose=1)
#model.fit(diabetes_X_train, diabetes_y_train, epochs=1, batch_size=16,verbose=1)
score = model.evaluate(diabetes_X_test, diabetes_y_test, batch_size=4)
diabetes_y_pred = model.predict(diabetes_X_test,verbose=1)
print (“predict”,diabetes_y_pred)
# 绘制输出
plt.scatter(diabetes_X_test, diabetes_y_test, color=’black’)
plt.plot(diabetes_X_test, diabetes_y_pred, color=’blue’, linewidth=3)
plt.xticks(())
plt.yticks(())
plt.show()
这篇文章会给你一些关于如何调整模型的思路。
https://machinelearning.org.cn/machine-learning-performance-improvement-cheat-sheet/
谢谢 Jason，我通过在 Keras 中更改以下内容，能够获得更好的预测并降低损失。然而，在 Sklearn 中完成相同的任务只需要不到 5 秒，而在 Keras + TF 中，我需要运行 epoch=10000 并且 batch_size=64，为什么呢？
model = Sequential()
#model.add(Dense(2,1,init=’uniform’, activation=’linear’))
model.add(Dense(1, input_dim=1, kernel_initializer=’glorot_uniform’, activation=’linear’))
sgd = SGD(lr=0.5, momentum=0.9, nesterov=True)
model.compile(loss=’mse’, optimizer=’sgd’)
model.fit(diabetes_X_train, diabetes_y_train, epochs=10000, batch_size=64,verbose=1)
这只是一个用于回归的示例，而不是演示如何最好地解决特定问题。
嗨，Jason，
感谢您在这里提供的众多教程！我有两个问题。
1) StandardScaler() 只缩放输入 X 吗？输出不缩放是否常见？
2) 我在使用 KerasRegressor 包装器时遇到了回调（例如损失历史）和验证数据（获取验证损失）的问题。您知道如何做到这一点吗？
祝您有美好的一天。
对于回归，缩放输出变量也是个好主意。
我建议不要在回调中使用包装器。
谢谢 Jason。这是构建自己应用程序的一个很好的起点。
谢谢，我很高兴这能有所帮助。
你好，
非常好的解释，谢谢！
我应用了相同的逻辑，并根据我的数据调整了初始化，交叉验证分数给出了巨大的数字。您能告诉我原因以及如何获得正确的准确率（0.0-1.0）范围吗？
输出
结果：-99691729670.42 (106055766245.87) MSE
(我的程序旨在根据过去的数据预测交易金额，因此它是分类数据转换为独热表示)
也许在建模之前重新缩放你的数据？
也许为你的具体问题调整模型？
这里有一些更多想法
https://machinelearning.org.cn/improve-deep-learning-performance/
嗨 Jason，如何使用回调函数和验证损失作为监控来选择神经网络的最佳权重？
干得不错。
Jason，
这是很棒的东西。谢谢。
我有一个问题。对于基础模型，
print(“Results: %.2f (%.2f) MSE” % (results.mean(), results.std()))
我得到
结果：-27.40 (13.92) MSE
如何解释负数？
此致
忽略符号。
sklearn 会反转损失函数，以便能够最大化它们。
谢谢你，Jason。
你好 Jason，我正在处理一个回归相关的问题，我的训练集有 39998 行和 20 列，目标数据集的大小相同（39998x20），所以我想在不同的架构上找到 MSE，我尝试编写代码，但它会给出一些错误或者无法给出正确的 MSE 值，能否请您帮忙，我刚接触这个领域，已经卡了两周了。我的代码部分如下：
来自 keras.models import Sequential
from keras.layers import Dense,Activation
import numpy as np
import tensorflow as tf
from matplotlib import pyplot
from sklearn.datasets import make_regression
from sklearn.metrics import mean_squared_error
from keras.wrappers.scikit_learn import KerasRegressor
from sklearn.preprocessing import StandardScaler
from keras import models
from keras import layers
import matplotlib as plt
from sklearn.neural_network import MLPRegressor
seed = 7
np.random.seed(seed)
from scipy.io import loadmat
dataset = loadmat(‘matlab2.mat’)
Bx=basantix[:, 50001:99999]
Bx=np.transpose(Bx)
Fx=fx[:, 50001:99999]
Fx=np.transpose(Fx)
from sklearn.cross_validation import train_test_split
Bx_train, Bx_test, Fx_train, Fx_test = train_test_split(Bx, Fx, test_size=0.2, random_state=0)
scaler = StandardScaler() # 类被创建为 Scaler
scaler.fit(Bx_train) # 然后创建对象或将数据拟合到其中
Bx_train = scaler.transform(Bx_train)
Bx_test = scaler.transform(Bx_test)
def build_model()
model = models.Sequential()
model.add(layers.Dense(20, activation=’tanh’, input_shape=(Bx.shape[1],)))
model.add(layers.Dense(10, activation=’relu’))
model.add(layers.Dense(20))
model.compile(optimizer=’sgd’, loss=’mean_squared_error’)
return model
model = build_model()
model.fit(Bx_train, Fx_train,epochs=1000, batch_size=20, verbose=0)
test_mean_squared_error_score = model.evaluate(Bx_test, Fx_test)
什么错误？
你好 Jason，我正在进行效价和唤醒度检测。所以 MLP 需要两个输出，一个用于唤醒度，一个用于效价。我想计算效价和唤醒度 R 方得分的交叉验证。我能够使用具有一个输出的两个单独的 MLP 模型进行训练，但无法使用具有两个输出的一个 MLP 进行训练。load() 函数中 X 和 Y 的大小分别为 (2232 ,160) 和 (2232, 2)。
X, Y = load()
kfold = StratifiedKFold(n_splits=10, shuffle=True, random_state=seed)
cvscores = []
for train, test in kfold.split(X, Y)
model = Sequential()
model.add(Dense(150, input_dim=160, kernel_initializer=’normal’, activation=’tanh’))
model.add(Dropout(0.5))
model.add(Dense(90, input_dim=160, kernel_initializer=’normal’, activation=’tanh’))
model.add(Dropout(0.5))
model.add(Dense(17,kernel_initializer=’normal’,activation = ‘tanh’))
model.add(Dropout(0.5))
model.add(Dense(10,kernel_initializer=’normal’,activation = ‘tanh’))
model.add(Dropout(0.5))
model.add(Dense(2, kernel_initializer=’normal’, activation = ‘tanh’))
model.compile(loss=’mse’, optimizer=’adam’, metrics = [‘mse’])
checkpointer = ModelCheckpoint(filepath=”model.h5″, verbose=1, save_best_only=True)
earlystopping = EarlyStopping(patience=50)
history = model.fit(X[train], Y[train], epochs=300, batch_size=100, verbose=1,callbacks=[earlystopping,checkpointer])
scores = model.predict(X[test])
accuracy = r2_score(Y[test], scores)
cvscores.append(accuracy* 100)
#print(“%.2f%% (+/- %.2f%%)” % (numpy.mean(cvscores), numpy.std(cvscores)))
print(‘the r-squared score for each fold’,cvscores)
print(“the mean of 10 fold cross validation is”, numpy.mean(cvscores))
print(“the maximum accuracy is “,max(cvscores))
但是，我在 for 循环中收到错误：for train, test in kfold.split(X,Y)
错误消息是：cls_test_folds = test_fold[y==cls] IndexError: too many indices for array。
提前感谢
也许你可以使用多输出模型，如这里所述。
https://machinelearning.org.cn/keras-functional-api-deep-learning/
嗨，我是深度学习的新手，从 wider_model 学习，代码如下
def wider_model()
# 创建模型
model = Sequential()
model.add(Dense(20, input_dim=X_train.shape[1], kernel_initializer=’normal’, activation=’relu’))
model.add(Dense(15, kernel_initializer=’normal’, activation=’relu’))
model.add(Dense(15, kernel_initializer=’normal’, activation=’relu’))
model.add(Dense(10, kernel_initializer=’normal’, activation=’relu’))
model.add(Dense(10, kernel_initializer=’normal’, activation=’relu’))
model.add(Dense(1, kernel_initializer=’normal’))
# 编译模型
model.compile(loss='mean_squared_error', optimizer='adam')
return model
下面是三个训练数据示例：
1,0.0,7,1,37.0,3,15.0,110106014000.0,110108004000.0,10,17721,2111,1160,2340,106,14115,699,2198
1,1.0,5,11,34.0,3,46.0,500108101000.0,500112012000.0,11,18615,2161,292,2188,407,15728,368,2246
1,0.0,5,19,35.0,3,37.0,120104003000.0,120105002000.0,11,5900,1251,209,469,87,5135,131,1222
让我困惑的是，我所有的测试数据预测结果都相同，你能给我一些建议吗？谢谢。
也许模型需要进一步训练或调整？
是的，谢谢你的回复。我将 epoch 从 500 改为 1500，这确实产生了不同（预测输出不再相同），但效果不明显。
你好 Jason，如果这个问题已经被问过了，我很抱歉，但我找不到：你用 KerasRegressor 而不是 .fit() 方法的理由是什么？谢谢！
好问题。
如果你愿意，也可以直接使用 Keras API。
对于初学者来说，使用 sklearn 的包装器会很有帮助，这样可以利用所有的 sklearn 工具，例如数据准备、网格搜索、度量等。
你好，Jason，这是一个很好的教程。我想知道如何用深度学习进行多输出回归？在这里，简单的回归问题输出值是一个，而当输出中有更多目标变量时，为了进行某种质量分析，该怎么做？
我的意思是我想构建一个 CNN 网络，它接受图像作为输入并产生多个输出值，如尺寸、深度、颜色值或其他数值特征，所以这就像 CNN 使用多输出回归。
将输出层的节点数更改为所需的输出数。
不，它们是两个完全不同的输出。对于相同的输入，中间层的神经元需要增加一个输出的权重值，而另一个输出需要减少权重更新。还有一点，输入是图像矩阵，不是统计数据。
所以我不确定该怎么做？
您必须将输入矩阵展平成一个向量，才能将其输入 MLP。
有没有什么好的文章……因为我必须使用深度神经网络进行多输出回归，以衡量性能参数作为连续值，而输入是二维图像，例如，如果我将电风扇的图像作为输入……它会产生电压、电流容量、风速等输出……就像那样
您好 Jason 先生，感谢您的教程。
我正在尝试做一个回归模型，它预测多个输出（3 个或更多），使用 9 个输入。问题是我的输入具有相同的尺度（在 0 和 1 之间），但我的输出不。你能告诉我如何构建一个标准化我的多个输出的模型，或者有必要吗？
先谢谢您了。
也许可以尝试数据缩放与不缩放，并比较结果模型的性能？
嗨 Jason，在上面的例子中，我只需要将数据分割成训练集和测试集，而不用担心将数据分割成验证集，对吗？然后我使用这行代码
results = cross_val_score(pipeline, X_test, Y_test, cv=kfold)
其中 X_test 是输入的测试数据
Y_test 是要与训练数据进行比较的输出测试数据。
或者我不需要分割训练/测试数据？
提前感谢。
这行代码执行 k 折交叉验证。
https://machinelearning.org.cn/k-fold-cross-validation/
哦，所以这意味着在执行 k 折交叉验证后，我就可以使用
scores = model.evaluate(X_test, Y_test) 来评估模型在测试数据上的表现？
这是一个方法。
嗨，Jason。
我使用之前的数据来预测当前的地块用途。训练数据和测试数据的准确率为 0.8。然而，当我打算使用当前数据来预测未来的土地用途时，在 model.predict 之后，预测结果全是负数，这与实际情况大相径庭。
如何解决这个问题？谢谢！
也许要确保用于预测的数据与用于训练模型的数据的准备方式完全相同，例如任何标准化、归一化等。
我有点困惑。用哪个变量来评估？
model.evaluate(X_test, Y_test)
不起作用，因为模型是在函数内部定义的。所以，在 k 折交叉验证之后，用哪个变量来评估模型或预测数据？
谢谢，
模型在测试数据集上进行评估。
您可以在此处了解更多关于测试数据集的信息。
https://machinelearning.org.cn/difference-test-validation-datasets/
我的意思是应该使用哪个变量。我在你的一条评论中找到了答案。也许是
estimator.model.evaluate
谢谢。
在第 3 部分，你说进一步的扩展是规范化输出变量。然而，直观地这对我来说没有意义。
当然，目标变量的非线性变换会损害模型的训练过程，因为模型正在最小化的损失会被低估。我预计在对归一化目标进行训练后，模型预测的值在通过归一化函数的反函数与真实结果进行比较后，会产生更大的损失。
此外，归一化不会将预测限制在目标变量在训练数据中取到的最大值和最小值之间吗？如果你使用这种方法，你必须确信你的样本能够准确地表示人口的任何极端情况。
归一化是一个线性变换。
许多算法更喜欢处理相同尺度的变量，例如 0-1。例如，使用加权和或距离度量的算法。
你说得对——事后看来，我为说归一化是 것입니다非线性变换而感到愚蠢！
经过进一步思考，我发现如果你的目标变量非常大（例如房价），这可能会导致你的搜索空间出现非常陡峭的梯度，这可能会导致数值不稳定或梯度下降算法的过冲。
感谢您的回复！
你好 Jason，感谢您付出努力为我们提供如此精彩的示例。
根据文档，cross_val_score 返回一个“每次交叉验证运行的估计器分数数组”。
这些分数具体是什么？为什么只取平均值（参见：results.mean）就能提供均方误差？
是的，这个数组是每个模型在每个保留的折叠上评估的结果。
你好，如何计算每个样本的平方误差百分比并求出平均值？
例如，一个样本的预测百分比误差和对应的真实值……对于所有样本，取差值的平均值。在输出中有 4 个神经元，所以我预测 4 个连续值。对于每个输出，我想分别找到误差百分比，最后是所有 4 个输出值所有误差的平均值。
你可以直接计算一个样本的误差。
嗨，Jason，
非常感谢您的教程。我有几个问题。我在其他教程中看到人们定义了一个模型，然后调用 model.fit 来训练。这与您在这里所做的有什么不同？另外，如果我想保存这个模型及其所有的权重、偏差和架构，我该如何做到？
谢谢！
我们在这里使用的是 sklearn 包装器，而不是直接使用 Keras API。
您可以直接使用 Keras API，然后保存您的模型，这里有一个例子。
https://machinelearning.org.cn/save-load-keras-deep-learning-models/
谢谢！如果我直接使用 keras API 来创建这个模型，会有什么不同？
我有一系列教程，你可以从这里开始。
https://machinelearning.org.cn/start-here/#deeplearning
嗨 Jason，我从你的教程中学到了很多。非常感谢你的努力！
我有一个回归问题：我发现几乎我设计的任何神经网络的表现都不如线性回归。因此，我从这里采用了你的代码，并将结果与 scikit-learn 的 linear_model.LinearRegression 的结果进行了比较。我也使用了线性回归器的交叉验证（10 折），得到的“neg_mean_squared_error”得分为 -34.7（45.57）MSE。
我发现很难将这些结果与你的神经网络结果进行比较，因为神经网络的结果变化很大。不同的实验运行（使用 10 折交叉验证）得到的平均 MSE 值从 31 到 39。我哪里做错了吗？
总的来说，神经网络适合回归吗？
我是一个新手，非常感谢你的任何建议。预先感谢！
这真的取决于问题。有些问题是线性的，用线性方法解决更好。
神经网络适用于有噪声的非线性回归问题。
谢谢 Jason，也许我应该澄清一下，我展示的比较是基于波士顿房价数据集。
因此，我从这里采用了你的代码，并将神经网络在波士顿房价数据集上的结果与 scikit-learn 的 linear_model.LinearRegression 的结果进行了比较。我也使用了线性回归器的交叉验证（10 折），得到的“neg_mean_squared_error”得分为 -34.7（45.57）MSE。
这个特定的值似乎比你报告的神经网络性能稍差，但并非总是如此。其他实验运行得到的平均 MSE 值从 31 到 39，其中一些与神经网络结果相当。这是你预期的吗，还是你怀疑我在这里做错了什么？
再次感谢你的努力，以及花时间回答所有评论！
性能取决于所选的模型、其配置、数据的准备以及更多因素。
永远不要假设一种方法比另一种方法对某个数据集更好，要通过实验来发现什么有效，然后使用它。
嗨，Jason，
如果我没理解错的话，每次 epoch 运行后，算法都会尝试通过调整权重来减少损失，对吗？那么，我猜最终的 epoch 显示的是与最优化权重集对应的损失结果。为什么这些特定的、最终的交叉验证损失值不在“results”数组中？
看起来“results”包含每个 epoch 损失值对应的平均值（或类似值）。为什么会这样？
不完全是，模型可能会过拟合训练数据，导致在保留集上性能变差。
很难获得“最优”权重。该领域的几乎所有工作都集中在不同模型类型的这种优化问题上。
嗨，我使用“tanh”激活函数得到相同的预测值，所有测试样本都一样……但如果我使用 relu 函数，预测值会随所有测试样本而改变。这是什么原因？是梯度消失问题导致网络为每个测试样本预测相同的值吗？
例如……使用“tanh”时 y1_pred=0.8, y2_pred=0.8 y3_pred=0.8，对所有样本都是恒定的预测值。
但是如果我使用“relu”，y1_pred=0.8 y2_pred=0.87,y3_pred=0.9，这根据我的数据是没问题的。
我不太清楚你在问什么？
我建议你使用能为你的模型带来最佳性能的激活函数。
我问的是……对所有测试样本使用“tanh”激活函数会得到相同的恒定预测值。
当我使用“relu”函数时，我得到的是正确的连续变化的数值，而不是对所有测试样本的恒定预测。
这是什么原因？是“tanh”的梯度消失问题吗？
抱歉，我不知道你在做什么或看到什么。
我怀疑你看到了梯度消失问题，因为你看到了连续的输出。
非常好的教程 Jason。你对以下几点有什么看法？
– 何时修改层中的神经元数量？
– 何时修改网络中的层数？
谢谢。
始终为你的具体问题调整神经元和层的数量。更多内容请看这里。
https://machinelearning.org.cn/faq/single-faq/how-many-layers-and-nodes-do-i-need-in-my-neural-network
嗨，Jason，
我得到的平均 MSE 是负值。我做得有什么不对吗？
结果：-5.76 (7.16) MSE
标准化后：-1.81 (4.37) MSE
我们可以只将输出变量重新缩放到 (0-1) 吗？还是应该在标准化后重新缩放整个数据集？
是的，sklearn 会反转 mse。我在哪里有更详细的解释。
https://machinelearning.org.cn/faq/single-faq/why-are-some-scores-like-mse-negative-in-scikit-learn
嗨 Jason。
我的因变量是分类的。
我使用 LabelEncoder() 将它们转换为数字 [1, 2, ….18]。然后，我有 18 个类别。
在我的 ANN 模型（Keras）中，我使用了：
———————————————
# 添加输入层和第一个隐藏层
classifier.add(Dense(output_dim = 6, init = ‘uniform’, activation = ‘relu’, input_dim = 1094))
# 添加第二个隐藏层
classifier.add(Dense(output_dim = 6, init = ‘uniform’, activation = ‘relu’))
# 添加输出层
classifier.add(Dense(output_dim = 18, init = ‘uniform’, activation = ‘sigmoid’))
# 编译 ANN
classifier.compile(optimizer = ‘adam’, loss = ‘sparse_categorical_crossentropy’, metrics = [‘accuracy’])
# 将 ANN 拟合到训练集
classifier.fit(X_train, y_train, batch_size = 10, nb_epoch = 100)
# In[预测测试集结果]
y_pred = classifier.predict(X_test)
# In[实际结果转换为 y_pred2]
y_prd2 = np.argmax(y_pred, axis=1)
———————————————
y-pred 在 [0,1] 之间，列数等于我的类别数 18。
我使用 np.argmax 来提取一个类别（返回沿轴最大值的索引）。
你觉得我的激活函数（relu, relu 和 sigmoid）怎么样？我可以在输出层使用“softmax”吗？
如果你的因变量（目标变量）是分类的，那么你有一个分类问题。
我推荐这个教程
https://machinelearning.org.cn/tutorial-first-neural-network-python-keras/
谢谢！
是的，我知道我有一个分类问题，我有 18 个类别。
但不是二元类别。
你把我导向了二元输出的教程！！！
我已经开发了我的模型，我只是在搜索，看看是否有错误或者其他什么。
这是一个多类分类 Keras 示例。
https://machinelearning.org.cn/multi-class-classification-tutorial-keras-deep-learning-library/
我在 Kaggle 上找到了相同的代码，但似乎没有注明出处。
https://www.kaggle.com/hendraherviawan/regression-with-kerasregressor/notebook
那太糟糕了。
你好 Jason，
谢谢。我有 2 个问题。
1) 你有更多关于回归的帖子或案例研究吗？你能提供链接给我吗？我认为在你大量的教程中，关于逻辑回归和多类分类的帖子比纯回归的帖子多。
2) 在模型对应的最后一个输出层，一个密集层，当你省略 activation 参数时，它默认等于“linear”吗？是否有其他有用的激活函数，或者在回归分析的情况下它们是否总是等于“linear”？
非常感谢
非常感谢您的帮助
我没有太多关于回归的内容，这是我需要更多关注的领域。我确实有更多关于时间序列（回归）的内容，而不是关于普通回归的内容。
对于回归，它总是线性的。有时是 sigmoid 或 tanh，如果你需要有界域内的实数输出。
你好，杰森，
我有两个问题想问您。
1. 在上面的例子中，我们得到一个输出列，我的问题是如何同时得到两列输出？
2. http://archive.ics.uci.edu/ml/datasets/Wine+Quality……对于这种数据集，如何在同一个模型中实现回归和分类？
感谢您所有的教程。
要获得两列输出，请将输出层更改为具有 2 个节点。
也许你会有两个输出子模型，一个用于回归，一个用于分类。我还没有尝试过，所以不知道是否会起作用。
也许先拟合一个回归模型，然后拟合另一个模型来解释第一个模型作为分类输出。
我的基线模型得到了负值，有问题吗？我不明白为什么！！
没问题，API 自帖子发布以来已经更改，更多内容请看这里。
https://machinelearning.org.cn/faq/single-faq/why-are-some-scores-like-mse-negative-in-scikit-learn
你好，
首先，感谢您发布这篇帖子。
我的问题是：如果我有（例如）两个输出，我应该只更改 Y 定义中的列数和输出层中的神经元数量为 2 吗？
提前感谢。
正确。
你好，
我尝试了这段用于回归的代码，有两个输出，执行时没有出现错误，但最后我得到了
结果：nan (nan) MSE？？？
很遗憾听到这个消息，也许可以尝试更新你的 Python 库？
也许可以尝试重新运行示例几次？
你解决 nan 问题了吗？我得到了相同的结果。这是我的库版本
scipy: 1.3.1
numpy: 1.16.4
matplotlib: 3.1.1
pandas: 0.25.1
statsmodels: 0.10.1
sklearn: 0.21.2
Theano:1.0.4
tensorflow 2.0.0
keras: 2.3.1
好的，我找到了问题。当你下载房价数据时，不要在 excel 中打开它，只需将数据原样复制粘贴到记事本文本文件中，然后保存为 csv。如果你在 excel 中做了什么（文本到列），那么数据中就会引入 nan。
我明白了，谢谢分享！
你在上面的教程中的哪个例子得到了 nan？
你好，
非常感谢您提供这个优秀的教程！
我有一个关于字符串输入神经网络模型的问题。
我有 6 个不同的分类输入列（A、B、C、D、E、F），其中四个有 5 个不同的输入值，两个有 4 个不同的输入值。例如，输入 A 可以有值 A1、A2、A3、A4 和 A5。类似地，对于输入 B、C 和 D。输入 E 可以有值 E1、E2、E3 和 E4。类似地，对于输入 F。我使用 LabelEncoder 对它们进行编码，然后使用 OnehotEncoder，如您在帖子中所述（https://machinelearning.org.cn/how-to-one-hot-encode-sequence-data-in-python/）。所以，在进行独热编码后，我的输入 numpy 数组中有 28 列（4 个输入，每个有 5 个设置，2 个输入，每个有 4 个设置，使用独热编码进行编码）。我的问题是，model.add(Dense(layers, input_dim)) 命令的输入维度和层应该是多少？由于您有 13 个输入，您将 input_dim 指定为 13，而在我的情况下，在进行独热编码后，我有 28 个输入列。它会是 28 吗？我需要向模型指定它已经被独热编码了吗？您能给我一些建议吗？
如果每个样本都经过编码并且有 28 个值，那么输入形状就是 28。
你好，
谢谢您的回复。
例如，如果我的一个样本 [‘A2’ ‘B5’ ‘C5’ ‘D4’ ‘E5’ ‘F1’] 编码后看起来像这样 [0. 1. 0. 0. 0. 0. 0. 0. 0. 1. 0. 0. 0. 0. 1. 0. 0. 0. 1. 0. 0. 0. 0. 1. 1. 0. 0. 0.]。所以实际上它代表了 28 个二进制输入，但它代表了 6 个独热编码的输入。如果模型认为这是 28 个二进制输入，它的预测会错误吗？
我不知道你的模型在你的数据上能有多好。
你的表示是正确的，28 个输入特征/变量。
你也可以尝试其他表示，例如整数编码和嵌入。
嗨 Jason，均方根误差（RMSE）也是理解问题上下文（涉及数千美元）的一个好方法吗？我很久以前读过你的另一篇文章，但我敢肯定它是 RMSE……什么时候使用 MSE 与 RMSE 来报告结果？谢谢。
通常 MSE 用于损失，而 RMSE 用于报告模型的估计性能，主要是因为 RMSE 采用的是原始单位，而 MSE 采用的是原始单位的平方。
嗨 Jason，在报告结果时，MSE 和 RSME 总是按 epoch 记录，并且是第一个 epoch 到最后一个 epoch 的平均值，对吗？
MSE 每个 epoch 都会报告。
你可以通过取平方根来从 MSE 计算 RMSE。
抱歉啰嗦。所以 MSE 在每个 epoch 都会报告并存储在 python 列表中。然后，当训练完成时，计算所有 MSE 的平均值，然后计算所有 MSE 的平方根以计算总体 RSME。对吗？谢谢 Jason。
RSME = math.sqrt(statistics.mean(MSEs))
与其计算平均 MSE 然后取平方根，不如直接计算平均 RMSE 值会更好/更正确。
或者，你也可以将 RMSE 作为每个 epoch 的指标进行跟踪。
https://machinelearning.org.cn/custom-metrics-deep-learning-keras-python/
谢谢 Jason 的链接。你能给我一个提示，如何使用 KerasRegressor 方法并传递一个函数来绘制这个博客文章中的代码的损失图吗？使用 history = model.fit() 方法绘制损失图似乎更容易，但这里的代码不使用 model.fit()。
我建议直接使用 Keras API 来检索和绘制历史。
嗨 Jason，如果我想计算 RSME 从你代码的最后一行
print("Standardized: %.2f (%.2f) MSE" % (results.mean(), results.std()))我需要做
print("RMSE", math.sqrt(results.mean()))或者
print("RMSE", math.sqrt(results.std()))?你可以通过取平方根来从 MSE 计算 RMSE。
我正在使用与波士顿房价不同的数据集。对于这些参数有什么建议吗？
batch_size=5, verbose=0或者这些只是需要通过实验来获得最佳结果的附加参数？
感谢你出色的教程……
verbose 参数控制训练期间打印的内容。
有关 batch size 的更多信息，请参阅此帖子。
https://machinelearning.org.cn/how-to-control-the-speed-and-stability-of-training-neural-networks-with-gradient-descent-batch-size/
总的来说，这是一个很棒的教程。但我一直遇到错误，并最终卡在了这个错误上。
‘TypeError: zip() argument after * must be an iterable, not KerasRegressor’
你能帮我解决这个问题吗？在 `pipeline = Pipeline(estimators)` 这行代码中是不是有什么问题？
谢谢！
很遗憾听到这个消息，我有一些建议作为第一步
https://machinelearning.org.cn/faq/single-faq/why-does-the-code-in-the-tutorial-not-work-for-me
我得到了负的MSE。这正常吗？？？
是的，这是一个常见问题，我在这里回答了
https://machinelearning.org.cn/faq/single-faq/why-are-some-scores-like-mse-negative-in-scikit-learn
如果我说错了，请纠正我！在上面的问题中，我们使用的是RELU激活函数和MSE作为损失函数，对吗？？
但是，我的问题是为什么不使用线性激活函数呢？
另外，我的第二个问题可能超出了以上文章的范围——
在这篇论文 https://medium.com/the-theory-of-everything/understanding-activation-functions-in-neural-networks-9491262884e0 中，对于线性激活函数，提到了几个问题，例如：
1) 输出值未绑定（这在我的情况下不是问题）
2) 堆叠多个输入层没有意义……因为它理想情况下只会导致一个线性函数。此外，梯度始终保持不变！！
我是这方面的初学者……有什么建议/学习资料可以帮助我更好地理解使用线性激活函数的问题，如何克服这个问题，RELU与房屋预测问题有什么关系，我可以在我的案例中应用它吗？？
非常感谢！
具体来说，我正在开发一个预测多个目标/目标变量的模型，这些变量应该是连续值！
不正确。该模型在输出层使用线性激活。
总的来说，这是一个非常好的教程。但我一直从一开始就得到负的MSE，使用的是相同的数据和代码。有什么建议吗？
scikit-learn库会反转MSE，您可以忽略符号。
我有5个实值输出（在16个参数中，11个是输入，5个是连续变量的输出）。我该如何训练神经网络？哪种优化算法最好？这种网络的性能评估指标是什么？非常感谢
可以尝试一系列的模型配置，并调整学习率和容量。
我在这里提供了一些想法
https://machinelearning.org.cn/start-here/#better
您能否帮助我将遗传算法与反向传播神经网络集成，以预测真实数值（解决回归问题），输入为8个，输出为4个。如果我能获得Python代码和示例数据集，我将非常感激。非常感谢
抱歉，我没有使用遗传算法来寻找神经网络权重的例子。我希望将来能提供一个例子。
非常感谢！
不客气。
正在寻找用于回归问题的神经网络预测模型的反向传播Python代码。实际上，对于分类问题，您已经给了我们很多样本。对于使用反向传播方法的神经网络回归问题，有什么神经网络样本吗？谢谢
是的，上面的教程在回归中使用了反向传播。
嗨，Jason，
非常感谢您的所有教程，它们确实很有帮助。
我有一个问题，是否存在某种类型的ANN，它接受多个输入并预测多个输出，其中每个输出与不同的输入相关。例如，假设输出y1与x1、x2和x3相关，而y2与x1和x4相关。
提前非常感谢
是的，所有神经网络都可以做到这一点。
可以从简单的MLP开始，并将所需的输出数量指定为输出层中的节点数。
先生您好。我有两个.mat文件的数据集。
我的项目是使用dnn从mfcc预测音高。
mfcc值是独立值，音高是依赖值。
mfcc是nx26矩阵，pitch是nx1矩阵。
我已经将数据分为训练集和测试集，然后我又将训练集分为训练集和验证集。
我正在使用具有4个隐藏层（每个隐藏层包含256个神经元）的顺序模型。我已经训练了模型，一切进展顺利。但是，我得到了非常高的rmse值，为53.77。
我该如何降低rmse值？
这是我的代码
from scipy.io import loadmat
from sklearn.cross_validation import train_test_split
import numpy as np
import sys
import math
来自 keras.models import Sequential
from keras.layers import Dense,Flatten
from keras.callbacks import EarlyStopping
df=loadmat(“mfcc.mathandles1”)
df1=loadmat(“pitch.mathandles1”)
x=df[‘list1’]
y=df1[‘list1′]
#split into train and test
xtrain,xtest,ytrain, ytest = train_test_split(x,y,test_size=0.3,random_state=10)
#split into validation
xtrain,xval,ytrain, yval = train_test_split(xtrain,ytrain,test_size=0.3,random_state=10)
#sequential model
model=Sequential()
#input layer
model.add(Dense(26,input_shape=(26,)))
#hidden layers
model.add(Dense(256,activation=’relu’))
model.add(Dense(256,activation=’relu’))
model.add(Dense(256,activation=’relu’))
model.add(Dense(256,activation=’relu’))
#output layers
model.add(Dense(1,activation=’linear’))
#now our model is trained
#compile the model
model.compile(optimizer=’adam’,loss=’mae’,metrics=[‘mse’])
#set earlyy stopping monitor so the model stops training when it wont improve anymore
earlystopmonitor=EarlyStopping(monitor=’val_loss’,mode=’min’,verbose=1,patience=3)
validset=([xval,yval])
#训练模型
model.fit(xtrain,ytrain,nb_epoch=50,validation_data=validset,callbacks=[earlystopmonitor])
#prediction on test data
predictions=model.predict(xtest)
print “predictions:”,predictions
#find error i.e find how much loss
error=predictions-ytest
sqr=error**2
#print “sqr:”,sqr
#find mse for test data
mse=np.mean(sqr)
print “mse for test data is:”,mse
#find rmse
rmse=math.sqrt(mse)
print “rmse of test data:”,rmse
#get loss and accuracy
val_loss,val_acc=model.evaluate(xtest,ytest)
print “val_loss:”,val_loss
print “val_acc:”,val_acc
请帮帮我。
我在这里有一些建议
https://machinelearning.org.cn/start-here/#better
感谢Jason提供的教程。我有一个快速的问题。
我想构建一个模型来预测遥控车的转向角。模型的输入将是从树莓派摄像头收集的图像，目标输出信号值范围在1000到2000之间。目标输出值不是连续的。它们的形式是：1000, 1004, 1008, 1012…
那么，我应该将此视为分类问题还是回归问题？我是否需要重新缩放输出并将其映射到较小的值，例如1000–>0, 1004–>1, 1008–>2, 1012–> 3…换句话说，我应该应用什么样的预处理技术来目标输出，以使我的模型更有效？
提前感谢…
听起来很棒。
这听起来像回归，但可以尝试将其建模为回归和分类问题，看看哪种效果更好/最佳。
测试一系列预处理方法，看看哪种方法适合您选择的问题框架和算法。例如，角度、整数、浮点数、有序类别等。
Hi Jason，这太棒了！我希望学习如何将神经网络回归纳入我的工作中，这将对我大有帮助。
我有一个关于分类和回归神经网络之间差异的问题；据我理解，分类神经网络中的输出激活函数（例如sigmoid）会产生0到1之间的值，然后我们可以将其转换为一个类（通过softmax的概率，或仅仅选择具有最高输出的输出神经元）。
但是，我对于这种方法与回归应用之间的区别感到困惑。由于我们试图预测的连续值超出了[0,1]的范围，在我看来，激活函数是不合适的。回归方法如何处理这个问题？
感谢您的时间！
Surendra
好问题，我在这里回答
https://machinelearning.org.cn/faq/single-faq/how-can-i-change-a-neural-network-from-regression-to-classification
这有帮助吗？
是的，它做到了，谢谢！
我看到输出函数设置为“linear”，并且keras文档将其称为“identity”——这是否仅指最后一个隐藏层加权输出的总和？所以实际上没有输出激活函数？
谢谢！
Surendra
Identity表示乘以1（即不变）。它直接输出加权和，正如您所说。
太棒了，我非常感激！
你好，这是一个很好的教程，
你有没有关于Keras中残差连接的教程？
是的，这会有帮助
https://machinelearning.org.cn/how-to-implement-major-architecture-innovations-for-convolutional-neural-networks/
嗨，Jason，
很棒的教程。即使过了这么多年，学习机器学习过程仍然很有益。
1）我扩展了您的代码以实现“MinMaxScaler”模块，但结果比“StandardScaler”差（例如，42.7的平均“mse” vs 21.7）
为什么？什么时候推荐使用一个而不是另一个模块？
2）我扩展了代码以实现dropout层和/或“l1_l2”Keras正则化器，但结果略差（例如，38.5的平均“mse” vs 21.7 9（此外，计算或网络更复杂）。
很明显，这里提出的网络非常简单（例如，大约几千个权重或参数需要训练），但数据集也很小（506个实例，13个特征）。所以似乎没有过拟合的需要，因此不需要实现l1_l2、dropout层等正则化器。好的。
我想提出一个关于模型复杂度和数据集大小之间关系的新简单定义（或速率9），该定义将权重量除以输入样本量和/或输入特征量？以便预测何时会发生过拟合（或不发生）。你读过或知道关于它的什么吗？我不是第一个…
2.1）为了克服过拟合，有一个名为“数据增强”的概念，适用于图像数据集。它似乎通过“扭曲”原始图像来生成额外的图像。好的。
但是，当我们拥有像BostonHouses等数据集时，会怎样？对于非图像预处理，我们是否有类似的Keras工具？
我唯一要探索的是应用GAN（向数据添加高斯噪声），但我不确定是否还有其他工具，或者它是否对这些类型的数据（例如Boston Houses Prices）具有与数据增强相同的效果。
3）顺便说一下，我还扩展了代码以手动实现一个与您标题为“更宽”的网络完全相同的网络模型，以便通过.fit方法的历史函数绘制训练和验证学习曲线，但我很困惑，因为我获得了非常小的值，例如“val_mean_squared_error”参数为“0.01”，而使用sklearn kfold工具和pipeline获得的“mse”的平均值为“21.8”。但其余结果非常相似…
对此有任何想法吗？我是否在比较不相似的参数？
Jason，感谢您的出色工作，继续为我们所有人开辟道路。
JG
一如既往的好问题，JG！
我一直很重视您的评论。
标准化是一个不错的默认选择，当数据呈高斯分布时，标准化效果很好。尽管如此，请始终同时测试两者（以及不缩放）并使用效果最佳的方法。
https://machinelearning.org.cn/how-to-improve-neural-network-stability-and-modeling-performance-with-data-scaling/
设置节点/层数的理论/启发式方法是不可靠的，而且已经几十年了。将其视为超参数并进行调整。或者，提供过多的容量并使用正则化来解决过拟合。
https://machinelearning.org.cn/how-to-control-neural-network-model-capacity-with-nodes-and-layers/
是的，我们可以向现有样本添加高斯噪声作为一种数据增强，这可能很有效
https://machinelearning.org.cn/train-neural-networks-with-noise-to-reduce-overfitting/
更多信息在这里
https://machinelearning.org.cn/how-to-improve-deep-learning-model-robustness-by-adding-noise/
如果您使用的是带有缩放的sklearn pipeline，我相信报告的错误将在缩放后的数据上。
感谢您的反馈，Jason！
我继续阅读您广泛、深入且结构良好的机器学习教程。
谢谢 JG。
你好，
我能说什么呢……您拯救了我的一天。精彩的教程。
我正在处理一个包含约6300万行和17个特征的数据集……并将尝试进行子采样，在我的PC（32GB RAM）上它变得无法处理。
您的教程帮助我解决了我的许多疑问。
谢谢，很高兴对您有帮助。
为你的进步喝彩！
你好，先生
我有一个问题。
我构建了模型但无法获得概率结果
在构建模型时，我将softmax作为激活函数。
我尝试获取概率结果以使用预测函数，但没有成功。
你能解释一下吗？
也许这篇帖子中的例子会有帮助
https://machinelearning.org.cn/how-to-make-classification-and-regression-predictions-for-deep-learning-models-in-keras/
谢谢您，先生！
我已经阅读了上述文章，但没有找到答案。
我构建的模型遵循
def build_model(input_shape=(28, 28, 1), classes=charset_size)
img_input = Input(shape=input_shape)
x = Conv2D(32, (3, 3), activation=’relu’, padding=’same’,name=’block1_conv1′
(img_input)
x = Conv2D(64, (3, 3), activation=’relu’, padding=’same’,
name=’block1_conv3′)(x)
x = Conv2D(64, (3, 3), activation=’relu’, padding=’same’,
name=’block1_conv4′)(x)
x = MaxPooling2D((2, 2), strides=(2, 2), name=’block2_pool’)(x)
x = Dropout(0.1)(x)
x = Flatten(name=’flatten’)(x)
conv_out = (Dense(128, activation=’relu’, kernel_constraint=max_norm(3)))(x)
x1 = Dense(charset_size, activation=’softmax’)(conv_out)
lst = [x1]
model = Model(inputs=img_input, outputs=lst)
return model
def train(model)
train_datagen = ImageDataGenerator(
rescale=1. / 255,
rotation_range=0,
width_shift_range=0.1,
height_shift_range=0.1
)
test_datagen = ImageDataGenerator(rescale=1. / 255)
train_generator = train_datagen.flow_from_directory(
train_data_dir,
target_size=(img_width, img_height),
batch_size=128,
color_mode=”grayscale”,
class_mode='categorical')
validation_generator = test_datagen.flow_from_directory(
test_data_dir,
target_size=(img_width, img_height),
batch_size=128,
color_mode=”grayscale”,
class_mode='categorical')
model.summary()
model.compile(loss=keras.losses.categorical_crossentropy,
optimizer=keras.optimizers.Adam(),
metrics=['accuracy'])
model.fit_generator(train_generator,
steps_per_epoch=nb_samples_per_epoch,
epochs=nb_nb_epoch,
validation_data=validation_generator,
validation_steps=nb_validation_samples)
# — get prediction —
img = cv2.imread(filepath)
x = img_to_array(img)
x = x.reshape((-1,) + x.shape)
prediction = model.predict(x)
有什么问题吗？
你能更确切地告诉我吗？
这是我在这里回答的一个常见问题
https://machinelearning.org.cn/faq/single-faq/can-you-read-review-or-debug-my-code
嗨，Jason，
感谢您提供有用的教程。我是一个完全的初学者，似乎摔了很多跤！我正在尝试在我的数据集上运行此代码，该数据集也有12个输入变量和一个输出变量。当我运行代码时，要么什么也没发生，要么我收到以下错误消息
Y = dataset[:,13]
IndexError: index 13 is out of bounds for axis 1 with size 1
您有什么想法我在做什么错？
非常感谢，Amy
如果您有12个变量，请将13更改为12。
有关Python中数组索引的工作方式，请参阅此
https://machinelearning.org.cn/index-slice-reshape-numpy-arrays-machine-learning-python/
谢谢Jason先生。
不客气。
你好，
我有一个回归问题（Keras/TF），需要预测的值可以是正数或负数。
在我的情况下，符号错误是一个很大的错误。
所以我想知道是否有什么标准的损失函数或机制可以考虑到这一点，或者是否需要自定义损失？
此致
也许在拟合模型之前缩放数据。这会产生很大的不同。
您好，我已经这样做了。
但是这里的重点是，例如，如果目标值是-0.1，我宁愿模型预测-0.25而不是+0.05（正目标值也是如此）。
抱歉，我不明白。
我正在构建一个具有43个预测变量的深度网络。我将epoch值设置为2000时，模型取得了不错的结果。这个值可以接受吗？？
使用能产生最佳结果的任何配置。
感谢您的回复。Keras是否可以拟合非线性方程？我有一个方程：y = a*exp(-b*x) + c*(1-exp(-b*x))，其中a,b,c是我想要估计的系数。x是预测变量，y是预测变量
当然，将数据分成输入和输出的示例，然后拟合模型！
是否有合适的示例？我找到了这个-https://www.kaggle.com/vsunday/polynomial-regression-with-keras-just-for-fun
但是很难解释，因为它没有得到适当的解释
抱歉，我没有示例，您可以改编上面教程中的示例。
你好 Jason，
是否可以将回调函数插入KerasRegressor或执行类似操作？
我尝试了如下操作，并收到了错误。
monitor_valloss_6= EarlyStopping(monitor=’val_loss’, patience=3)
…
regression_classifiers2.append((‘mlp’, KerasRegressor(build_fn=big_regression,
epochs=25, batch_size=1000, verbose=0,
callbacks=[monitor_valloss_6])))
RuntimeError: Cannot clone object , as the constructor either does not set or modifies parameter callbacks
不是真的。使用独立的Keras API可能会更容易。
非常感谢您的回答。
不客气。
您好，我正在使用您的教程来帮助我的本科论文。
我有一个关于变压器功率的每日聚合值的数据集。
我总共有434天的数据。我加载文件没有问题（将X设为第1天到第434天，将Y设为聚合值）并运行了您的代码。我唯一的改动是
model.add(Dense(434, input_dim=1, kernel_initializer=’normal’, activation=’relu’))
因为我只有一个输入和434个实例。
我想使用您给出的回归示例来预测例如第1500天聚合值是多少。我已经运行了您的示例，并得到了以下输出
Baseline: -20.80 (22.63) MSE
在您的代码中，出口在哪里定义？我很抱歉，我是一名机器学习新手。
如果我想知道第1500天的输出会是多少，我该怎么做？
提前感谢
这听起来像您正在处理时间序列预测问题。
我建议从这里的基础开始
https://machinelearning.org.cn/start-here/#timeseries
然后或许可以探索使用神经网络来解决您的问题
https://machinelearning.org.cn/start-here/#deep_learning_time_series
您好，首先，感谢您提供如此出色的教程和整个网站的大量有用信息。
我有一个类似的任务，但有2个输入变量和3个输出变量（目标）。其中2个目标值很高（约1000~10000），而第三个目标值非常低（约0.1~0.9）。
当我运行我的代码时，我从一开始就得到了一个非常高的mse值，大约1000万，在几个epochs后很快下降到大约50000。这是否可能与我的输出变量之间的幅度差异有关？并且与指标有关，您建议在回归问题中使用哪一个？
谢谢。
可能是。我建议在建模之前缩放数据。
嗨，Jason，
感谢您提供出色的教程！我正在尝试使用您的示例，但是
results = cross_val_score(pipeline, X,Y, cv=kfold) 总是产生一个错误
TypeError: can’t pickle _thread._local objects
您知道如何修复它吗？
谢谢！
这是一个奇怪的错误。我在这里有一些建议
https://machinelearning.org.cn/faq/single-faq/why-does-the-code-in-the-tutorial-not-work-for-me
你好，
我非常感谢这篇教程。我想知道这个模型是否可以通过独热编码来改进，或者对于这个问题是否不需要独热编码。
谢谢。
独热编码用于分类变量，输入或输出。我不认为此数据集中有任何分类变量。
我的数据集中包含几个“?”值和列标题。如何将此代码集成到此类数据集中？谢谢
删除列标题。
“?”可能代表缺失值，这会有帮助
https://machinelearning.org.cn/handle-missing-data-python/
嗨，Jason，
在Keras中进行回归时，如何处理非常大的数据集。我的数据大约有3000多万行，在这种情况下，您会建议什么策略？
谢谢！
好问题，我在这里回答
https://machinelearning.org.cn/faq/single-faq/how-to-i-work-with-a-very-large-dataset
如何保存拟合到数据的最终模型？
好问题，请看本教程
https://machinelearning.org.cn/save-load-keras-deep-learning-models/
你好，
我在这个数据集上尝试了一个ANN
https://www.kaggle.com/c/house-prices-advanced-regression-techniques/overview
奇怪的是，对于7个条目，我没有得到预测——所以我不得不填充预测中的缺失值。
你能告诉我可能的原因吗？
如果有兴趣，这是模型
i = Input(shape=(D,))
x = BatchNormalization()(i)
x = Dense(500, activation=’relu’)(x)
x = BatchNormalization()(x)
x = Dense(300, activation=’relu’)(x)
x = BatchNormalization()(x)
x = Dense(100, activation=’relu’)(x)
x = BatchNormalization()(x)
x = Dense(1)(x)
model = Model(inputs=i, outputs=x)
model.compile(
loss=’mean_squared_error’,
optimizer=’adam’
)
r = model.fit(X_train_ss, y_train_ss, epochs=1000, batch_size=32)
基本上是这样的
这个可能会有帮助
https://machinelearning.org.cn/faq/single-faq/can-you-read-review-or-debug-my-code
嗨，Jason，
1) MLP回归可以用于预测4个不同的连续值吗？训练这种网络是否可行？
2) 我知道有必要对训练和测试数据集进行归一化。对于回归，我对属性/特征X进行归一化，但我想知道：是否也需要对目标输出Y进行归一化？
我将非常感谢您的答复。非常感谢您的知识分享！
当然。为每个样本所需的预测数量设置输出层中的节点数。
是的，对目标变量进行归一化是个好主意。
嗨，Jason，
感谢您的答复。在我的应用中，实际值（归一化之前）的输出很重要，因为它们是系数，稍后将在我的系统中用到。因此，通过归一化，我会丢失系数的实际值。有什么办法可以解决这个问题吗？
是的，您可以使用相同的缩放器对象来事后反转缩放，例如 scaler.inverse_transform()。
另外，这可能会有帮助
https://machinelearning.org.cn/how-to-transform-target-variables-for-regression-with-scikit-learn/
也许是这个
https://machinelearning.org.cn/machine-learning-data-transforms-for-time-series-forecasting/
使用KerasRegressor包装器时如何冻结层？
您必须直接在Keras模型上冻结层。
我一直在努力处理这个例子——遇到了一个无法解决的错误，但最终找到了问题所在。为了帮助其他人可能遇到的问题
截至今天（2020年1月23日），如果您尝试使用MLFlow，KerasRegressor将无法运行，并返回错误
‘ValueError: epochs is not a legal parameter’
这是由MLFlow中的autolog函数（‘mlflow.keras.autolog()’）引起的。我不确定具体原因，但如果您禁用它，该示例将按预期工作。
mlflow是什么？
为什么不使用教程中描述的独立keras？
MLFlow是一个用于跟踪实验参数和结果的开源工具，是自动化的。其思想是，当使用数据集进行实验时，您将尝试各种参数和设置，但可能没有理想的解决方案来存储您尝试过的所有不同组合。MLFlow为比较实验提供了一个干净的UI。
使用独立的keras工作正常——我只是尝试将其与MLFlow集成，看看它能多容易地集成进去。
真有趣，谢谢。
您能否告诉我如何使用pipeline对测试数据进行预测？
yhat = pipeline.predict(newInput)
更多信息请参阅此
https://machinelearning.org.cn/make-predictions-scikit-learn/
嗨，Jason，
精彩的作品。
在传统的回归问题中，我们需要确保我们的时间序列是平稳的。
我们还需要确保残差是平稳的，并且残差中没有自相关。
在使用神经网络进行回归时，我们也需要确保我们的时间序列是平稳的，并且我们的残差是平稳且非自相关的吗？
谢谢！
Boris
谢谢。
是的，通常这是一个好主意。测试有和没有。
你好，
感谢您的教程。这是一项很好的工作。
伙计，您对多输入多输出回归问题有什么建议？我一直在努力提高准确率和降低损失函数，但似乎什么都不起作用。模型的准确率无法从40%提高，损失函数卡在44左右。
有什么建议吗？我尝试了所有方法，改变了ANN结构，尝试了不同的优化器、损失函数、epochs、激活函数，使用keras对输入数据进行预处理（但没有对输出数据进行预处理）。我做的一件事是关于输出数据：输出在负轴或正轴上都没有阈值，所以我通过取绝对值来处理数据，并通过引入每个输出标签的符号来增加输出节点，（0表示负，1表示零，2表示正），所以最初我的输出标签是6个，现在有12个输出标签。什么都没有奏效。建议？
当前架构：[Dense(32, input_shape(1, 6), activation =’relu’),
Dense(32, activation =’relu’),
Dense(32, activation =’relu’),
Dense(12, )]
我愿意接受建议。
谢谢。
也许从这里开始
https://machinelearning.org.cn/multi-output-regression-models-with-python/
那么，可以尝试MLP来查看它们是否能做得更好——通常不能。
谢谢！
不客气。
嗨，Jason，
我是您作品的忠实粉丝，很喜欢您的作品。奇怪的问题，当我用Keras构建一个MLP回归器时，其大小和深度与您这里相似，我将使用MSE作为损失函数（也尝试过MAE和MAPE）进行训练，它会收敛到一个非常低的损失值。我将对我的测试数据（约3000个条目）进行前向传播，并计算平均误差，这将非常低，例如0.03%。所以我认为我的模型非常棒。然后我查看前向传播的预测，每一个都是相同的。无论我输入什么，它的输出都将是相同的数值预测，恰好非常接近我输入的平均目标向量。
基本上，看起来我的MLP正在学习均值，然后为每次传递输出均值，而与输入无关。我尝试了几件事
– 数据缩放（MinMaxScaler）
– 尝试其他优化函数（我更喜欢Adam，有递减的学习率，我也尝试过但没有成功）
– 修改MLP的深度和宽度；如果我使网络变浅，它将无法收敛，并且在添加2个以上的层后，它又开始执行这种均值近似。
有什么想法吗？
谢谢！
也许模型过拟合了，这可以帮助诊断问题
https://machinelearning.org.cn/learning-curves-for-diagnosing-machine-learning-model-performance/
我也考虑过这一点——我为每个训练epoch输出验证集的MSE（使用，训练误差略高于验证误差，但如果我绘制它们，看起来就像您帖子中的“良好拟合”图，但问题是每个输出都是一个相同的标量值，与输入向量中的数量无关。验证集误差从不高于训练集误差。
另外，我看到了一个使用Keras的validation_split命令的帖子，我使用sklearn将数据分为测试集和验证集。问题是，来自验证集的每个输入都会产生网络相同的输出值。
也许验证集不能代表整个数据集？也许可以尝试50/50拆分或获取更多数据？
嗨，Jason，
感谢您提供简洁而信息丰富的教程。顺便说一句，关于多输出，语法应该是怎样的？
我的代码是
Y = dataset[:,13:14]
…
model.add(Dense(2, kernel_initializer=’normal’))
…
kfold = KFold(n_splits=10)
results = cross_val_score(estimator, X, Y, cv=kfold)
我收到错误
ValueError: Error when checking model target: the list of Numpy arrays that you are passing to your model is not the size the model expected. Expected to see 3 array(s), but instead got the following list of 1 arrays: [array([[ 0.69945297, 0.13296847, 0.06292328],
…
我尝试将Y更改为
results = cross_val_score(estimator, X, [Y[:,0],Y[:,1]], cv=kfold)
但也有错误
Found input variables with inconsistent numbers of samples: [72963, 3]
那么多输出的正确语法是什么？
再次感谢。
请参阅此处关于多输出时间序列的LSTM示例
https://machinelearning.org.cn/how-to-develop-lstm-models-for-time-series-forecasting/
以及此处关于MLP的示例
https://machinelearning.org.cn/how-to-develop-multilayer-perceptron-models-for-time-series-forecasting/
当然，谢谢这些链接！
不客气。
非常感谢！
不客气。
亲爱的 Jason,
我能否在NLP任务中使用此回归模型，其中我想使用某些文档来预测一个值？
是的，但也许这些教程会是一个更好的开始
https://machinelearning.org.cn/start-here/#nlp
您是否建议将此用于时间序列回归，还是会使用其他机器学习方法？
我建议测试一系列线性、ML和深度学习方法，以发现哪种最有效，请遵循此框架
https://machinelearning.org.cn/how-to-develop-a-skilful-time-series-forecasting-model/
嘿Jason，非常感谢您的工作！我的问题是，为什么在训练神经网络之前您没有进行特征选择？提前感谢！
为了将教程的重点放在神经网络上——保持简单。
好的，感谢您的回答Jason！那么……如果我想训练一个类似的神经网络，但用于一个具有4个特征的线性模型，我是否只需要更改神经元的数量和第二个model.add()语句中的“input_dim”参数？例如
model.add(Dense(4, input_dim = 4, kernel_initializer = ‘normal’, activation = ‘relu’)) # input_dim = nb d’inputs = nombre de noeuds dans le réseau
提前感谢（抱歉提出这些问题，我仍然是NN初学者）！！
是的，除了第一个隐藏层中的节点数与输入特征的数量无关。
您只需要设置input_dim参数。
好的，非常感谢！所以我在我的3个NN中保持与您相同的节点数。
最后一个问题Jason，是否有办法显示成本函数图？我尝试了几种方法但都不起作用…
提前感谢！
也许这会有帮助。
https://machinelearning.org.cn/display-deep-learning-model-training-history-in-keras/
你好，第一个基线模型大约需要多长时间运行？
提前感谢
我想是几秒钟。
你好 Jason，
我想构建一个预测音频（.wav）文件和文本字符串是否相同（接近匹配）的模型。但我找不到任何关于这方面的帖子。
任何帮助都将不胜感激。
谢谢
这听起来是一个很棒的项目。
也许你可以使用一个模型将音频转换为文本，然后直接比较文本。
嗨，Jason，
非常感谢您的精彩教程！
我在波士顿住房数据上运行了回归代码，并在测试数据上绘制了神经网络预测图。看起来预测值偏移了。令人惊讶的是，训练数据也是如此……请告诉我您的想法。
谢谢，
您是指时间序列预测吗？
如果是的话，这是一个常见问题。
https://machinelearning.org.cn/faq/single-faq/why-is-my-forecasted-time-series-right-behind-the-actual-time-series
谢谢。你是一位大师！！！又一个精彩的教程。
谢谢！
我能用RFE选择特征，然后用深度学习进行回归吗？
当然可以。
嗨，Jason，
您是否有关于使用复数进行回归的帖子或示例。我的输入数据是复数，输出是实数。目前我通过将复数拆分为实部和虚部来处理，但不确定其有效性。
抱歉，我没有。
Jason，我目前正在对800个特征和1个输出进行回归。我想知道应该使用多少层和多少神经元才能达到最佳结果？如何进行调整？谢谢！
好问题，这会有帮助
https://machinelearning.org.cn/faq/single-faq/how-many-layers-and-nodes-do-i-need-in-my-neural-network
嗨，Jason，
非常感谢您又一篇精彩的文章。我已经成功构建了一个ANN，我想知道如何提取描述模型的数学公式。
我阅读了一些科学论文，解释了他们使用的输入、超参数和ANN的架构，他们通常会通过提供直接从ANN提取的数学方程（包括输入变量）来得出结论。我还没有找到如何使用Python提取/公式化这样的公式。
任何指针和帮助都将不胜感激！
非常感谢，
Iasonas
无法从模型中提取有用的公式。
你好，我有一个单特征（input_dim=1）的数据集，大约有500个样本。我如何修改代码，特别是epoch、batch size和kfold计数，以获得良好的拟合，因为我注意到MSE非常高。
这些教程将为您提供有关如何调整神经网络模型的想法。
https://machinelearning.org.cn/start-here/#better
亲爱的 Jason,
您在文章中提到，与更深的架构相比，更宽的架构会产生更好的结果。如果我错了，请纠正我，但我相信文章是这样的，因为您运行了更宽架构的代码100个epoch，而更深的架构运行了50个epoch。在我进行测试时，当两个架构以相同的epoch数（50或100）进行训练时，更深的架构会产生更好的结果。
例如
50个epoch
更深的模型：-23.22 (25.95) MSE
更宽的模型：-24.30 (23.43) MSE
100个epoch
更深的模型：-21.67 (23.85) MSE
更宽的模型：-22.50 (23.00) MSE
干得好！
我得到了这个错误
File “C:\Users\Eng Maha\Regression_DL.py”, line 39, in
results = cross_val_score(estimator, X, Y, cv=kfold)
NameError: name ‘estimator’ is not defined
我怀疑您不小心跳过了一些代码行，也许这可以帮助您复制粘贴示例。
https://machinelearning.org.cn/faq/single-faq/how-do-i-copy-code-from-a-tutorial
嗨，Jason！
不错的教程！我是Keras回归问题的新手。如果我的输入是两个形状为10*41*81的矩阵，而我的输出是两个标量，该怎么办？我不知道如何处理它们……
我期待您的回复！
也许您可以将输入展平成向量？
也许您可以使用支持更多输入维度的模型，如LSTM或CNN-LSTM？
非常感谢您的快速回复！！我将尝试查找一些关于这些模型的教程！
不客气。
你好，
我正在尝试在6维输入上运行这个，但我遇到了这个错误
ValueError: Input 0 of layer sequential_181 is incompatible with the layer: expected axis -1 of input shape to have value 6 but received input with shape (None, 1)
可能是什么问题？
谢谢！
也许检查一下您加载数据的方式是否符合预期，并且模型是否配置为期望您的数据。
嗨，Jason！
我能否在所有密集层之前添加一些CNN层？我有130w个输入和3个输出，并且我希望有一个CNN层来以某种方式减少参数？
除非您的输入数据是序列，否则一维CNN不适用于回归问题。
嗯，我的数据是油田的。它们有151*72*64的形状。我曾想，也许我可以取151作为宽度，72作为高度，64作为通道……？但我不知道怎么做……二维CNN能处理我的数据吗？
您可以为CNN模型的输入层指定首选形状。
也许从这里开始
https://machinelearning.org.cn/start-here/#dlfcv
WARNING:tensorflow:7 out of the last 12 calls to <function Model.make_test_function..test_function at 0x7f9390119400> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://tensorflowcn.cn/guide/function#controlling_retracing and https://tensorflowcn.cn/api_docs/python/tf/function for more details.
当我更改模型以输入21个输入时，我收到了这个警告。我按如下方式更改了代码：
X = dataset[:,0:21]
Y = dataset[:,21]
model.add(Dense(21, input_dim=21, kernel_initializer=’normal’, activation=’relu’))
CSV中的示例数据是：
0 0 1 0 0 0 0 0 0 0 0 0 1 0 1 0 0 1 0 0 1 5
有任何想法吗？
看起来像个警告，也许可以暂时安全地忽略它？
也许可以在stackoverflow上搜索/发帖？
第一章中的链接（波士顿房价数据集）不起作用。
ICS的工作链接
https://archive.ics.uci.edu/ml/machine-learning-databases/housing/housing.data
既然您已经有一个有效的链接了，您可以删除第一个链接。
感谢您的工作。非常有帮助！
谢谢。
嗨，Jason，
您能否告诉我如何保存这个回归模型并加载该模型并用特定输入进行测试？
是的，请参阅本教程，了解如何保存和加载模型。
https://machinelearning.org.cn/save-load-keras-deep-learning-models/
你好，Jason，感谢您的教程。我有一个问题。为什么这段代码是一个深度网络，而模型只有一个隐藏层？通常，深度网络至少有三个隐藏层。
现在所有神经网络都被称为深度学习。
https://machinelearning.org.cn/what-is-deep-learning/
亲爱的 Jason,
当我运行第3节的示例时，输出是“Baseline: nan (nan) MSE”。我将CSV数据简单地复制到一个文本文件中，并将其保存为CSV（这在评论部分之前已被建议）。我在变量中看到的数据框似乎还可以。
运行代码时确实会收到一个错误，但这个错误并没有阻止代码运行。
2021-06-11 11:40:42.737123: I tensorflow/core/platform/cpu_feature_guard.cc:142] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN)to use the following CPU instructions in performance-critical operations: AVX AVX2
To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.
2021-06-11 11:40:42.738253: I tensorflow/core/common_runtime/process_util.cc:146] Creating new thread pool with default inter op setting: 2. Tune using inter_op_parallelism_threads for best performance.
您是否可能知道导致NaN输出的原因？
在此先感谢，
William
这非常奇怪，我以前从未见过。
也许这些提示会有所帮助
https://machinelearning.org.cn/faq/single-faq/why-does-the-code-in-the-tutorial-not-work-for-me
感谢您的回复，我会对此进行研究。
> 使用均方误差（MSE）评估的模型性能，其结果约为20（平方千美元）（如果取平方根，则为4500美元）。这是我们神经网络模型的一个不错的目标。
正如这里提到的，我们如何确定结果的有效性？
许多评估指标，如MSE，都说明“越小越好”，这对于比较两个模型来说很好，但我认为如果有一个指标说明什么值可以被认为是有效结果，那就更容易向他人解释。
我将结果与一个简单的模型进行了比较。
看这里
https://machinelearning.org.cn/faq/single-faq/how-to-know-if-a-model-has-good-performance
感谢您的回答。
我看到它已经在问答中列出了。
抱歉我没有检查。
您的这篇文章回答了我的问题。
https://machinelearning.org.cn/how-to-know-if-your-machine-learning-model-has-good-performance/
我将仔细阅读。
对于基线模型，我参考了这一点。
https://machinelearning.org.cn/implement-baseline-machine-learning-algorithms-scratch-python/
对于回归模型（我目前正在做），我了解到我可以比较这些。
1. 使用中心趋势（例如，均值或中位数、众数等）作为预测器的模型（基线模型）的评估值（例如MSE）。
2. 您创建的模型（待评估的模型）的值（例如，MSE）。
当评估值为RMSE时，“更小（由2计算）比（由1计算）”更优。
这就是我的意思。对吗？
如果您的模型在同一数据集和测试环境中比一个简单的/基线模型具有更好的性能，那么该模型就有技能。
没问题！
我遇到了这个错误
C:\Anaconda\lib\site-packages\keras\engine\input_spec.py:250 assert_input_compatibility
raise ValueError(
ValueError: Input 0 of layer sequential_9 is incompatible with the layer: expected axis -1 of input shape to have value 13 but received input with shape (None, 10)
warnings.warn(“Estimator fit failed. The score on this train-test”
我不知道是哪个代码导致了这个问题，但错误信息已经说明了一切。很可能是模型中的某些配置错误，或者您的输入形状不正确。
嗨，布朗利，
解释非常简洁清晰。
我有一个问题，将设备的信号强度质量（3,4,5,6,7,8）作为目标变量。
但是需要准备一个回归模型。
输出变量的类型显示为整数。但这些是类别，对吧？
现在要准备一个神经网络，
我需要使用one hot encoder更改其类型吗？
输出层需要多少个神经元？
请帮助我
对于回归模型，如果输出（3,4,5,6,7,8）确实是指其值（而不是类别标签），那么输出层只需要一个神经元。如果它是类别标签，3不一定比4更好或更差（即没有排序关系），那么您需要6个神经元，因为有6个类别（并且您没有进行回归）。
使用此模型，我们如何实际访问/查看包含13个特征但没有价格列的数据集的预测值？
您是在寻找model.predict()函数吗？
是的，但是当我用代码
y_predict = model.predict(x_no_target) 来预测这个数据集（我的原始数据集的一个子集，其中缺少目标值）的目标值时，我会在“predict”这个词上看到一个黄色的警告，说“Cannot find reference ‘predict’ in ‘function’ “。
我做过的其他神经网络教程没有像您这样将模型定义在一个函数中，并且model.predict()函数在那些教程中工作得很好，但在这里它会给我一个警告，然后当我插入以下内容时什么也吐不出来：
# Make a prediction
y_predict = baseline_model.predict(x_no_target)
# 显示输入和预测输出
for i in range(len(x_no_target))
print(“X=%s, Predicted=%s” % (x_no_target[i], y_predict[i]))
然后在Python控制台中，我得到“AttributeError: ‘function’ object has no attribute ‘predict'”。
我认为您的“baseline_model”并不是一个真正的模型。请检查代码前面的行，了解它是如何创建的。很可能您遗漏了什么。
你好！很棒的教程！
我该如何修改代码，以便我知道神经网络预测的值？
我需要将每个实际输出与模型计算的输出进行比较。
你好 Marc……您可能会发现以下内容很有趣。
https://machinelearning.org.cn/regression-metrics-for-machine-learning/
你好 Jason，
如何使用训练好的模型预测新的房价？
你好 Viktoriia……您描述的是迁移学习。
https://machinelearning.org.cn/transfer-learning-for-deep-learning/
亲爱的Jason。
如果基线模型提供了最佳结果（就像我的数据集那样），那么我应该使用它吗？我的意思是，如果基线模型给出了更好的结果，那会不会是因为列之间的不同尺度只让模型考虑了其中一些，因为它们（错误地？）具有更大的权重？仅仅因为基线模型具有最佳结果（接近0）就应该认为它是最好的，还是在使用不同数量级的列时，总是需要使用缩放器？在我看来，使用基于树的机器学习技术不需要缩放数据，但对于基于距离的技术则需要。我说对了吗？神经网络的情况如何？
谢谢你。
亲爱的Jason，可以堆叠NN回归吗？
使用您在此处使用的相同概念？
‘Stacking Ensemble for Deep Learning Neural Networks in Python’
你好 Chucks……以下内容可能对您有兴趣
https://towardsdatascience.com/just-keep-stacking-implement-stacking-regression-in-python-using-mlxtend-3250ff327ee5
非常感谢您提供如此有用的教程。
如您所知，BaggingRegressor函数中有base_estimator超参数。
我们可以定义一个使用Keras的MLP Regressor模型，并将其传递给BaggingRegressor的base_estimator，以提高准确性并降低损失和误差吗？
你好 Mossi……我看不出这个方法有什么问题，但是很难预测这是否真的会提高准确性。继续您的建议实现，并告诉我们您的发现！
嗨
在这种情况下，我们应该如何绘制每个epoch的训练和验证损失曲线？
感谢您的帮助和评论。
你好 Faraz……以下内容可能对您有兴趣。
https://machinelearning.org.cn/learning-curves-for-diagnosing-machine-learning-model-performance/
嗨，
我用R写了一段代码，它会检查不同参数的组合来找到最佳模型（我的意思是，我检查了不同的输入节点数、dropout、batch size……）。我将其并行化以加快速度。在R中，我使用了“mclapply”进行并行化，并在GPU上运行了它。
现在我想用Python编写完全相同的代码。
那么您是否有与我的工作相关的主题？我的意思是并行化、测试不同的参数、保存最佳模型……
提前感谢任何帮助，
你好 Shamim……以下资源可能对您有兴趣
https://towardsdatascience.com/parallelization-w-multiprocessing-in-python-bd2fc234f516
嗨，Jason，
我是神经网络的新手，您的教程对我很有帮助，谢谢！
我逐字复制了您的代码，并观察到类似的最小误差。
标准化：-21.88 (24.81) MSE，
并且当我绘制损失与epoch图时，误差肯定在被最小化……
所以，到这里一切都很好。
但是，我总是在寻找“健全性检查”，当我绘制模型预测时，
model.predict(X) 与实际值（Y）叠加
我注意到模型预测（model.predict(X)）和实际值（Y）的相对比例（和符号）完全不同（在我举的例子中是-12倍的因子），并且这个比例因子似乎在每次代码执行时随机波动。
我记得我们在预处理中必须标准化数据……我们需要取消标准化才能在model.predict(X)中使用它吗？
或者我可能错过了一行复制/粘贴的代码？
您提供的任何建议都将非常棒。
非常感激，
-Kevin
你好 Kevin……以下资源应能增加清晰度。
https://machinelearning.org.cn/how-to-improve-neural-network-stability-and-modeling-performance-with-data-scaling/
你好 James，我想创建一个角度预测模型，我将输入像素坐标（x，y）和真实角度。它们应该经过训练并预测角度。这是否可以使用回归模型实现？请提出您的想法。我将非常感激。
你好 Arshad……这将是一个回归模型。在用坐标和角度进行训练后，给定新的坐标，模型就能预测新的角度。不确定这有多实用或准确。让我们知道您发现了什么！
你好 Jason，我遇到了错误
ValueError 回溯 (最近一次调用)
in ()
28 pipeline = Pipeline(estimators)
29 kfold = KFold(n_splits=10)
—> 30 results = cross_val_score(pipeline, X, Y, cv=kfold, scoring=’neg_mean_squared_error’)
31 print(“Standardized: %.2f (%.2f) MSE” % (results.mean(), results.std()))
2 帧
/usr/local/lib/python3.10/dist-packages/sklearn/model_selection/_validation.py in cross_val_score(estimator, X, y, groups, scoring, cv, n_jobs, verbose, fit_params, pre_dispatch, error_score)
513 scorer = check_scoring(estimator, scoring=scoring)
514
–> 515 cv_results = cross_validate(
516 estimator=estimator,
517 X=X,
/usr/local/lib/python3.10/dist-packages/sklearn/model_selection/_validation.py in cross_validate(estimator, X, y, groups, scoring, cv, n_jobs, verbose, fit_params, pre_dispatch, return_train_score, return_estimator, error_score)
283 )
284
–> 285 _warn_or_raise_about_fit_failures(results, error_score)
286
287 # For callabe scoring, the return type is only know after calling. If the
/usr/local/lib/python3.10/dist-packages/sklearn/model_selection/_validation.py in _warn_or_raise_about_fit_failures(results, error_score)
365 f”Below are more details about the failures:\n{fit_errors_summary}”
366 )
–> 367 raise ValueError(all_fits_failed_message)
368
369 else
ValueError
所有10次拟合都失败了。
很可能你的模型配置错误。
你可以尝试将error_score='raise'设置为调试错误。
以下是有关故障的更多详细信息
——————————————————————————–
7 fits failed with the following error
回溯（最近一次调用）
File “/usr/local/lib/python3.10/dist-packages/sklearn/model_selection/_validation.py”, line 686, in _fit_and_score
estimator.fit(X_train, y_train, **fit_params)
File “/usr/local/lib/python3.10/dist-packages/sklearn/pipeline.py”, line 401, in fit
Xt = self._fit(X, y, **fit_params_steps)
File “/usr/local/lib/python3.10/dist-packages/sklearn/pipeline.py”, line 359, in _fit
X, fitted_transformer = fit_transform_one_cached(
File “/usr/local/lib/python3.10/dist-packages/joblib/memory.py”, line 353, in __call__
return self.func(*args, **kwargs)
File “/usr/local/lib/python3.10/dist-packages/sklearn/pipeline.py”, line 893, in _fit_transform_one
res = transformer.fit_transform(X, y, **fit_params)
File “/usr/local/lib/python3.10/dist-packages/sklearn/utils/_set_output.py”, line 140, in wrapped
data_to_wrap = f(self, X, *args, **kwargs)
File “/usr/local/lib/python3.10/dist-packages/sklearn/base.py”, line 881, in fit_transform
return self.fit(X, y, **fit_params).transform(X)
File “/usr/local/lib/python3.10/dist-packages/sklearn/preprocessing/_data.py”, line 824, in fit
return self.partial_fit(X, y, sample_weight)
File “/usr/local/lib/python3.10/dist-packages/sklearn/preprocessing/_data.py”, line 861, in partial_fit
X = self._validate_data(
File “/usr/local/lib/python3.10/dist-packages/sklearn/base.py”, line 565, in _validate_data
X = check_array(X, input_name=”X”, **check_params)
File “/usr/local/lib/python3.10/dist-packages/sklearn/utils/validation.py”, line 940, in check_array
raise ValueError(
ValueError: Found array with 0 feature(s) (shape=(11670, 0)) while a minimum of 1 is required by StandardScaler.
——————————————————————————–
3 fits failed with the following error
回溯（最近一次调用）
File “/usr/local/lib/python3.10/dist-packages/sklearn/model_selection/_validation.py”, line 686, in _fit_and_score
estimator.fit(X_train, y_train, **fit_params)
File “/usr/local/lib/python3.10/dist-packages/sklearn/pipeline.py”, line 401, in fit
Xt = self._fit(X, y, **fit_params_steps)
File “/usr/local/lib/python3.10/dist-packages/sklearn/pipeline.py”, line 359, in _fit
X, fitted_transformer = fit_transform_one_cached(
File “/usr/local/lib/python3.10/dist-packages/joblib/memory.py”, line 353, in __call__
return self.func(*args, **kwargs)
File “/usr/local/lib/python3.10/dist-packages/sklearn/pipeline.py”, line 893, in _fit_transform_one
res = transformer.fit_transform(X, y, **fit_params)
File “/usr/local/lib/python3.10/dist-packages/sklearn/utils/_set_output.py”, line 140, in wrapped
data_to_wrap = f(self, X, *args, **kwargs)
File “/usr/local/lib/python3.10/dist-packages/sklearn/base.py”, line 881, in fit_transform
return self.fit(X, y, **fit_params).transform(X)
File “/usr/local/lib/python3.10/dist-packages/sklearn/preprocessing/_data.py”, line 824, in fit
return self.partial_fit(X, y, sample_weight)
File “/usr/local/lib/python3.10/dist-packages/sklearn/preprocessing/_data.py”, line 861, in partial_fit
X = self._validate_data(
File “/usr/local/lib/python3.10/dist-packages/sklearn/base.py”, line 565, in _validate_data
X = check_array(X, input_name=”X”, **check_params)
File “/usr/local/lib/python3.10/dist-packages/sklearn/utils/validation.py”, line 940, in check_array
raise ValueError(
ValueError: Found array with 0 feature(s) (shape=(11671, 0)) while a minimum of 1 is required by StandardScaler.
您能帮我解决这个问题吗？非常感谢！
你好……您正在引用什么代码？这将使我们能更好地提供建议。
谢谢您的回复
我使用的代码与上面几乎相同
from pandas import read_csv
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from scikeras.wrappers import KerasRegressor
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import KFold
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
# 加载数据集
dataframe = read_csv(“train-v3.csv”, delim_whitespace=True, header=None)
dataset = dataframe.values
# 分割为输入 (X) 和输出 (Y) 变量
X = dataset[1:,5:23]
Y = dataset[1:,1:2]
# 定义基本模型
def baseline_model()
# 创建模型
model = Sequential()
model.add(Dense(13, input_shape=(18,), kernel_initializer=’normal’, activation=’relu’))
model.add(Dense(1, kernel_initializer=’normal’))
# 编译模型
model.compile(loss='mean_squared_error', optimizer='adam')
return model
# 使用标准化数据集评估模型
estimators = []
estimators.append(('standardize', StandardScaler()))
estimators.append((‘mlp’, KerasRegressor(model=baseline_model, epochs=50, batch_size=5, verbose=0)))
pipeline = Pipeline(estimators)
kfold = KFold(n_splits=10)
results = cross_val_score(pipeline, X, Y, cv=kfold, scoring=’neg_mean_squared_error’)
print(“Standardized: %.2f (%.2f) MSE” % (results.mean(), results.std()))
使用不同的.csv和X Y
(X = dataset[1:,5:23]
Y = dataset[1:,1:2])
顺便说一句，我在colab上运行它。