使用 Keras 深度学习库的二元分类教程

作者 Jason Brownlee 于 2022年8月5日发布在深度学习 198

Keras是一个用于深度学习的Python库，它封装了高效的数值库TensorFlow和Theano。

Keras允许您快速简单地设计和训练神经网络和深度学习模型。

在这篇文章中，您将通过一个逐步进行的二元分类项目，学习如何在机器学习项目中有效地使用Keras库。

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

如何加载训练数据并使其可供Keras使用
如何为表格数据设计和训练神经网络
如何在Keras中评估神经网络模型在未见过的数据上的性能
如何进行数据准备以提高使用神经网络时的技能
如何在Keras中调整神经网络的拓扑结构和配置

通过我的新书 《Python深度学习》开启您的项目，其中包括分步教程以及所有示例的Python源代码文件。

让我们开始吧。

2016 年 6 月：首次发布
更新 2016年10月：更新至Keras 1.1.0和scikit-learn v0.18。
更新 2017年3月：更新至Keras 2.0.2、TensorFlow 1.0.1和Theano 0.9.0。
更新 2019年9月：更新至Keras 2.2.5 API。
更新 2022年7月：更新至TensorFlow 2.x语法

Binary Classification Worked Example with the Keras Deep Learning Library

使用Keras深度学习库的二元分类工作示例
照片由 Mattia Merlo 拍摄，保留部分权利。

1. 数据集描述

本教程中使用的数据集是 Sonar数据集。

这是一个描述声纳信号在不同表面反弹的数据集。60个输入变量是不同角度的回波强度。这是一个二元分类问题，需要模型来区分岩石和金属圆柱体。

您可以在 UCI机器学习库上了解更多关于这个数据集的信息。您可以免费下载数据集，并将其保存到工作目录中，文件名为sonar.csv。

这是一个经过充分理解的数据集。所有变量都是连续的，通常在0到1的范围内。输出变量是字符串“M”代表矿山（Mine），“R”代表岩石（Rock），需要将其转换为整数1和0。

使用此数据集的一个好处是它是一个标准的基准问题。这意味着我们对一个好模型的预期性能有一些了解。通过交叉验证，一个神经网络应该能够达到大约84%的性能，定制模型的准确率上限约为88%。

Python 深度学习需要帮助吗？

参加我的免费为期两周的电子邮件课程，发现 MLP、CNN 和 LSTM（附代码）。

立即点击注册，还将免费获得本课程的 PDF 电子书版本。

2. 基线神经网络模型性能

让我们为这个问题创建一个基线模型和结果。

您将首先导入所有需要的类和函数。

import pandas as pd
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from scikeras.wrappers import KerasClassifier
from sklearn.model_selection import cross_val_score
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import StratifiedKFold
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
...

import pandas as pd

from tensorflow.keras.models import Sequential

from tensorflow.keras.layers import Dense

from scikeras.wrappers import KerasClassifier

from sklearn.model_selection import cross_val_score

from sklearn.preprocessing import LabelEncoder

from sklearn.model_selection import StratifiedKFold

from sklearn.preprocessing import StandardScaler

from sklearn.pipeline import Pipeline

...

现在，您可以使用 pandas 加载数据集，并将列分为60个输入变量（X）和一个输出变量（Y）。使用pandas加载数据，因为它可以轻松处理字符串（输出变量），而直接使用NumPy加载数据会更困难。

...
# load dataset
dataframe = pd.read_csv("sonar.csv", header=None)
dataset = dataframe.values
# split into input (X) and output (Y) variables
X = dataset[:,0:60].astype(float)
Y = dataset[:,60]

...

# 加载数据集

dataframe = pd.read_csv("sonar.csv", header=None)

dataset = dataframe.values

# 分割为输入 (X) 和输出 (Y) 变量

X = dataset[:,0:60].astype(float)

Y = dataset[:,60]

输出变量是字符串值。您必须将它们转换为整数值0和1。

您可以使用scikit-learn中的LabelEncoder类来实现这一点。这个类通过fit()函数来建模所需的编码，然后通过transform()函数应用编码来创建新的输出变量。

...
# encode class values as integers
encoder = LabelEncoder()
encoder.fit(Y)
encoded_Y = encoder.transform(Y)

...

# 将类别值编码为整数

编码器 = LabelEncoder()

encoder.fit(Y)

encoded_Y = encoder.transform(Y)

现在您已准备好使用Keras创建您的神经网络模型。

您将使用scikit-learn通过分层k折交叉验证来评估模型。这是一种重采样技术，可以提供模型性能的估计。它通过将数据分成k个部分，然后训练模型使用除一个部分以外的所有部分，该部分被保留为测试集以评估模型的性能。这个过程重复k次，并使用所有构建模型的平均分数作为性能的稳健估计。它是分层的，意味着它会查看输出值并尝试在数据的k折分割中平衡属于每个类的实例数量。

要将Keras模型与scikit-learn一起使用，您必须使用SciKeras模块中的KerasClassifier包装器。这个类接受一个创建并返回神经网络模型的函数。它还接受将传递给fit()调用的参数，例如训练的轮数和批次大小。

让我们从定义创建基线模型的函数开始。您的模型将有一个单一的、全连接的隐藏层，其神经元数量与输入变量的数量相同。这是创建神经网络的一个很好的默认起点。

权重使用小的随机高斯数进行初始化。使用Rectifier激活函数。输出层包含一个神经元以进行预测。它使用sigmoid激活函数以生成0到1范围内的概率输出，该输出可以轻松自动转换为清晰的类别值。

最后，您将在训练期间使用对数损失函数（binary_crossentropy），这是二元分类问题的首选损失函数。该模型还使用高效的Adam优化算法进行梯度下降，并在模型训练时收集准确率指标。

# baseline model
def create_baseline():
	# create model
	model = Sequential()
	model.add(Dense(60, input_shape=(60,), activation='relu'))
	model.add(Dense(1, activation='sigmoid'))
	# Compile model
	model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
	return model

# 基线模型

def create_baseline():

# 创建模型

model = Sequential()

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

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

# 编译模型

model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])

return model

现在，是时候在scikit-learn框架中使用分层交叉验证来评估这个模型了。

将训练的轮数传递给KerasClassifier，同样使用合理的默认值。由于为进行10折交叉验证将创建模型十次，因此也禁用了详细输出。

...
# evaluate model with standardized dataset
estimator = KerasClassifier(model=create_baseline, epochs=100, batch_size=5, verbose=0)
kfold = StratifiedKFold(n_splits=10, shuffle=True)
results = cross_val_score(estimator, X, encoded_Y, cv=kfold)
print("Baseline: %.2f%% (%.2f%%)" % (results.mean()*100, results.std()*100))

...

# 使用标准化数据集评估模型

estimator = KerasClassifier(model=create_baseline, epochs=100, batch_size=5, verbose=0)

kfold = StratifiedKFold(n_splits=10, shuffle=True)

results = cross_val_score(estimator, X, encoded_Y, cv=kfold)

print("基线: %.2f%% (%.2f%%)" % (results.mean()*100, results.std()*100))

将所有内容整合后，完整的示例列在下面。

# Binary Classification with Sonar Dataset: Baseline
from pandas import read_csv
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from scikeras.wrappers import KerasClassifier
from sklearn.model_selection import cross_val_score
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import StratifiedKFold
# load dataset
dataframe = read_csv("sonar.csv", header=None)
dataset = dataframe.values
# split into input (X) and output (Y) variables
X = dataset[:,0:60].astype(float)
Y = dataset[:,60]
# encode class values as integers
encoder = LabelEncoder()
encoder.fit(Y)
encoded_Y = encoder.transform(Y)
# baseline model
def create_baseline():
	# create model
	model = Sequential()
	model.add(Dense(60, input_shape=(60,), activation='relu'))
	model.add(Dense(1, activation='sigmoid'))
	# Compile model
	model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
	return model
# evaluate model with standardized dataset
estimator = KerasClassifier(model=create_baseline, epochs=100, batch_size=5, verbose=0)
kfold = StratifiedKFold(n_splits=10, shuffle=True)
results = cross_val_score(estimator, X, encoded_Y, cv=kfold)
print("Baseline: %.2f%% (%.2f%%)" % (results.mean()*100, results.std()*100))

# 使用Sonar数据集进行二元分类：基线

from pandas import read_csv

from tensorflow.keras.models import Sequential

from tensorflow.keras.layers import Dense

from scikeras.wrappers import KerasClassifier

from sklearn.model_selection import cross_val_score

from sklearn.preprocessing import LabelEncoder

from sklearn.model_selection import StratifiedKFold

# 加载数据集

dataframe = read_csv("sonar.csv", header=None)

dataset = dataframe.values

# 分割为输入 (X) 和输出 (Y) 变量

X = dataset[:,0:60].astype(float)

Y = dataset[:,60]

# 将类别值编码为整数

编码器 = LabelEncoder()

encoder.fit(Y)

encoded_Y = encoder.transform(Y)

# 基线模型

def create_baseline():

# 创建模型

model = Sequential()

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

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

# 编译模型

model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])

return model

# 使用标准化数据集评估模型

estimator = KerasClassifier(model=create_baseline, epochs=100, batch_size=5, verbose=0)

kfold = StratifiedKFold(n_splits=10, shuffle=True)

results = cross_val_score(estimator, X, encoded_Y, cv=kfold)

print("基线: %.2f%% (%.2f%%)" % (results.mean()*100, results.std()*100))

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

运行此代码将生成以下输出，显示模型在未见过的数据上的估计准确率的平均值和标准差。

Baseline: 81.68% (7.26%)

1	基线: 81.68% (7.26%)

这是一项非常出色的分数，而且无需付出太多努力。

3. 使用数据准备重新运行基线模型

在建模之前准备数据是一个好习惯。

神经网络模型尤其适合具有一致的输入值，无论是在尺度还是分布上。

标准化是构建神经网络模型时，表格数据的有效数据准备方案。这是将数据重新缩放，使得每个属性的平均值为0，标准差为1。这可以保留高斯和类高斯分布，同时使每个属性的中心趋势归一化。

您可以使用scikit-learn通过 StandardScaler 类对您的sonar数据集执行标准化。

与其对整个数据集执行标准化，不如在交叉验证运行的传递过程中，在训练数据上训练标准化过程，并使用训练好的标准化来准备“未见过”的测试折。这使得标准化成为交叉验证过程中模型准备的一个步骤。它防止算法在评估期间拥有“未见过”数据的知识，这些知识可能会像更清晰的分布一样，通过数据准备方案传递。

您可以在scikit-learn中使用 Pipeline 来实现这一点。Pipeline是一个包装器，可以在交叉验证过程的传递中执行一个或多个模型。在这里，您可以定义一个包含StandardScaler然后是神经网络模型的Pipeline。

...
# evaluate baseline model with standardized dataset
estimators = []
estimators.append(('standardize', StandardScaler()))
estimators.append(('mlp', KerasClassifier(model=create_baseline, epochs=100, batch_size=5, verbose=0)))
pipeline = Pipeline(estimators)
kfold = StratifiedKFold(n_splits=10, shuffle=True)
results = cross_val_score(pipeline, X, encoded_Y, cv=kfold)
print("Standardized: %.2f%% (%.2f%%)" % (results.mean()*100, results.std()*100))

...

# 使用标准化数据集评估基线模型

estimators = []

estimators.append(('standardize', StandardScaler()))

estimators.append(('mlp', KerasClassifier(model=create_baseline, epochs=100, batch_size=5, verbose=0)))

pipeline = Pipeline(estimators)

kfold = StratifiedKFold(n_splits=10, shuffle=True)

results = cross_val_score(pipeline, X, encoded_Y, cv=kfold)

print("标准化: %.2f%% (%.2f%%)" % (results.mean()*100, results.std()*100))

将所有内容整合后，完整的示例列在下面。

# Binary Classification with Sonar Dataset: Standardized
from pandas import read_csv
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from scikeras.wrappers import KerasClassifier
from sklearn.model_selection import cross_val_score
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import StratifiedKFold
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
# load dataset
dataframe = read_csv("sonar.csv", header=None)
dataset = dataframe.values
# split into input (X) and output (Y) variables
X = dataset[:,0:60].astype(float)
Y = dataset[:,60]
# encode class values as integers
encoder = LabelEncoder()
encoder.fit(Y)
encoded_Y = encoder.transform(Y)
# baseline model
def create_baseline():
	# create model
	model = Sequential()
	model.add(Dense(60, input_shape=(60,), activation='relu'))
	model.add(Dense(1, activation='sigmoid'))
	# Compile model
	model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
	return model
# evaluate baseline model with standardized dataset
estimators = []
estimators.append(('standardize', StandardScaler()))
estimators.append(('mlp', KerasClassifier(model=create_baseline, epochs=100, batch_size=5, verbose=0)))
pipeline = Pipeline(estimators)
kfold = StratifiedKFold(n_splits=10, shuffle=True)
results = cross_val_score(pipeline, X, encoded_Y, cv=kfold)
print("Standardized: %.2f%% (%.2f%%)" % (results.mean()*100, results.std()*100))

# 使用Sonar数据集进行二元分类：标准化

from pandas import read_csv

from tensorflow.keras.models import Sequential

from tensorflow.keras.layers import Dense

from scikeras.wrappers import KerasClassifier

from sklearn.model_selection import cross_val_score

from sklearn.preprocessing import LabelEncoder

from sklearn.model_selection import StratifiedKFold

from sklearn.preprocessing import StandardScaler

from sklearn.pipeline import Pipeline

# 加载数据集

dataframe = read_csv("sonar.csv", header=None)

dataset = dataframe.values

# 分割为输入 (X) 和输出 (Y) 变量

X = dataset[:,0:60].astype(float)

Y = dataset[:,60]

# 将类别值编码为整数

编码器 = LabelEncoder()

encoder.fit(Y)

encoded_Y = encoder.transform(Y)

# 基线模型

def create_baseline():

# 创建模型

model = Sequential()

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

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

# 编译模型

model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])

return model

# 使用标准化数据集评估基线模型

estimators = []

estimators.append(('standardize', StandardScaler()))

estimators.append(('mlp', KerasClassifier(model=create_baseline, epochs=100, batch_size=5, verbose=0)))

pipeline = Pipeline(estimators)

kfold = StratifiedKFold(n_splits=10, shuffle=True)

results = cross_val_score(pipeline, X, encoded_Y, cv=kfold)

print("标准化: %.2f%% (%.2f%%)" % (results.mean()*100, results.std()*100))

运行此示例将提供以下结果。

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

您现在可以看到平均准确率有微小但非常好的提升。

Standardized: 84.56% (5.74%)

1	标准化: 84.56% (5.74%)

4. 调整模型中的层和神经元数量

神经网络有很多方面可以调整，例如权重初始化、激活函数、优化过程等。

可能产生重大影响的一个方面是网络本身的结构，称为网络拓扑。在本节中，您将通过两个实验来考察网络结构：缩小网络和扩大网络。

这些是调整神经网络以适应您问题的良好实验。

4.1. 评估一个更小的网络

请注意，此问题中的输入变量很可能存在大量冗余。

数据描述了来自不同角度的相同信号。也许其中一些角度比其他角度更相关。因此，您可以通过限制第一个隐藏层的表示空间来强制网络进行特征提取。

在本次实验中，您将采用基线模型，其隐藏层中有60个神经元，并将其减少一半到30个。这将迫使网络在训练期间提取输入数据中最重要的结构来建模。

您还将像上一个数据准备实验一样对数据进行标准化，并尝试利用性能的微小提升。

...
# smaller model
def create_smaller():
	# create model
	model = Sequential()
	model.add(Dense(30, input_shape=(60,), activation='relu'))
	model.add(Dense(1, activation='sigmoid'))
	# Compile model
	model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
	return model
estimators = []
estimators.append(('standardize', StandardScaler()))
estimators.append(('mlp', KerasClassifier(model=create_smaller, epochs=100, batch_size=5, verbose=0)))
pipeline = Pipeline(estimators)
kfold = StratifiedKFold(n_splits=10, shuffle=True)
results = cross_val_score(pipeline, X, encoded_Y, cv=kfold)
print("Smaller: %.2f%% (%.2f%%)" % (results.mean()*100, results.std()*100))

...

# 更小的模型

def create_smaller():

# 创建模型

model = Sequential()

model.add(Dense(30, input_shape=(60,), activation='relu'))

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

# 编译模型

model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])

return model

estimators = []

estimators.append(('standardize', StandardScaler()))

estimators.append(('mlp', KerasClassifier(model=create_smaller, epochs=100, batch_size=5, verbose=0)))

pipeline = Pipeline(estimators)

kfold = StratifiedKFold(n_splits=10, shuffle=True)

results = cross_val_score(pipeline, X, encoded_Y, cv=kfold)

print("更小: %.2f%% (%.2f%%)" % (results.mean()*100, results.std()*100))

将所有内容整合后，完整的示例列在下面。

# Binary Classification with Sonar Dataset: Standardized Smaller
from pandas import read_csv
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from scikeras.wrappers import KerasClassifier
from sklearn.model_selection import cross_val_score
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import StratifiedKFold
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
# load dataset
dataframe = read_csv("sonar.csv", header=None)
dataset = dataframe.values
# split into input (X) and output (Y) variables
X = dataset[:,0:60].astype(float)
Y = dataset[:,60]
# encode class values as integers
encoder = LabelEncoder()
encoder.fit(Y)
encoded_Y = encoder.transform(Y)
# smaller model
def create_smaller():
	# create model
	model = Sequential()
	model.add(Dense(30, input_shape=(60,), activation='relu'))
	model.add(Dense(1, activation='sigmoid'))
	# Compile model
	model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
	return model
estimators = []
estimators.append(('standardize', StandardScaler()))
estimators.append(('mlp', KerasClassifier(model=create_smaller, epochs=100, batch_size=5, verbose=0)))
pipeline = Pipeline(estimators)
kfold = StratifiedKFold(n_splits=10, shuffle=True)
results = cross_val_score(pipeline, X, encoded_Y, cv=kfold)
print("Smaller: %.2f%% (%.2f%%)" % (results.mean()*100, results.std()*100))

# 使用Sonar数据集进行二元分类：标准化更小

from pandas import read_csv

from tensorflow.keras.models import Sequential

from tensorflow.keras.layers import Dense

from scikeras.wrappers import KerasClassifier

from sklearn.model_selection import cross_val_score

from sklearn.preprocessing import LabelEncoder

from sklearn.model_selection import StratifiedKFold

from sklearn.preprocessing import StandardScaler

from sklearn.pipeline import Pipeline

# 加载数据集

dataframe = read_csv("sonar.csv", header=None)

dataset = dataframe.values

# 分割为输入 (X) 和输出 (Y) 变量

X = dataset[:,0:60].astype(float)

Y = dataset[:,60]

# 将类别值编码为整数

编码器 = LabelEncoder()

encoder.fit(Y)

encoded_Y = encoder.transform(Y)

# 更小的模型

def create_smaller():

# 创建模型

model = Sequential()

model.add(Dense(30, input_shape=(60,), activation='relu'))

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

# 编译模型

model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])

return model

estimators = []

estimators.append(('standardize', StandardScaler()))

estimators.append(('mlp', KerasClassifier(model=create_smaller, epochs=100, batch_size=5, verbose=0)))

pipeline = Pipeline(estimators)

kfold = StratifiedKFold(n_splits=10, shuffle=True)

results = cross_val_score(pipeline, X, encoded_Y, cv=kfold)

print("更小: %.2f%% (%.2f%%)" % (results.mean()*100, results.std()*100))

运行此示例将提供以下结果。您可以看到平均估计准确率略有提升，并且模型准确率的标准差（平均分散度）显着降低。

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

这是一个很好的结果，因为您使用一个尺寸减半的网络，其性能略好，而训练时间也减半。

Smaller: 86.04% (4.00%)

1	更小: 86.04% (4.00%)

4.2. 评估一个更大的网络

具有更多层的神经网络拓扑为网络提供了更多机会来提取关键特征并以有用的非线性方式进行重组。

您可以通过对用于创建模型的函数进行另一个小调整来轻松评估向网络添加更多层是否会提高性能。在这里，您将网络添加一个新层（一行），该层在第一个隐藏层之后引入了另一个具有30个神经元的隐藏层。

您的网络现在具有拓扑结构

60 inputs -> [60 -> 30] -> 1 output

1	60个输入 -> [60 -> 30] -> 1个输出

这里的想法是，网络有机会在瓶颈化并被迫将表示能力减半之前对所有输入变量进行建模，这与您在上面使用更小网络的实验中做的那样。

而不是挤压输入本身的表示，您还有一个额外的隐藏层来帮助这个过程。

...
# larger model
def create_larger():
	# create model
	model = Sequential()
	model.add(Dense(60, input_shape=(60,), activation='relu'))
	model.add(Dense(30, activation='relu'))
	model.add(Dense(1, activation='sigmoid'))
	# Compile model
	model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
	return model
estimators = []
estimators.append(('standardize', StandardScaler()))
estimators.append(('mlp', KerasClassifier(model=create_larger, epochs=100, batch_size=5, verbose=0)))
pipeline = Pipeline(estimators)
kfold = StratifiedKFold(n_splits=10, shuffle=True)
results = cross_val_score(pipeline, X, encoded_Y, cv=kfold)
print("Larger: %.2f%% (%.2f%%)" % (results.mean()*100, results.std()*100))

...

# 更大的模型

def create_larger():

# 创建模型

model = Sequential()

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

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

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

# 编译模型

model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])

return model

estimators = []

estimators.append(('standardize', StandardScaler()))

estimators.append(('mlp', KerasClassifier(model=create_larger, epochs=100, batch_size=5, verbose=0)))

pipeline = Pipeline(estimators)

kfold = StratifiedKFold(n_splits=10, shuffle=True)

results = cross_val_score(pipeline, X, encoded_Y, cv=kfold)

print("更大: %.2f%% (%.2f%%)" % (results.mean()*100, results.std()*100))

将所有内容整合后，完整的示例列在下面。

# Binary Classification with Sonar Dataset: Standardized Larger
from pandas import read_csv
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from scikeras.wrappers import KerasClassifier
from sklearn.model_selection import cross_val_score
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import StratifiedKFold
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
# load dataset
dataframe = read_csv("sonar.csv", header=None)
dataset = dataframe.values
# split into input (X) and output (Y) variables
X = dataset[:,0:60].astype(float)
Y = dataset[:,60]
# encode class values as integers
encoder = LabelEncoder()
encoder.fit(Y)
encoded_Y = encoder.transform(Y)
# larger model
def create_larger():
	# create model
	model = Sequential()
	model.add(Dense(60, input_shape=(60,), activation='relu'))
	model.add(Dense(30, activation='relu'))
	model.add(Dense(1, activation='sigmoid'))
	# Compile model
	model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
	return model
estimators = []
estimators.append(('standardize', StandardScaler()))
estimators.append(('mlp', KerasClassifier(model=create_larger, epochs=100, batch_size=5, verbose=0)))
pipeline = Pipeline(estimators)
kfold = StratifiedKFold(n_splits=10, shuffle=True)
results = cross_val_score(pipeline, X, encoded_Y, cv=kfold)
print("Larger: %.2f%% (%.2f%%)" % (results.mean()*100, results.std()*100))

# 使用Sonar数据集进行二元分类：标准化更大

from pandas import read_csv

from tensorflow.keras.models import Sequential

from tensorflow.keras.layers import Dense

from scikeras.wrappers import KerasClassifier

from sklearn.model_selection import cross_val_score

from sklearn.preprocessing import LabelEncoder

from sklearn.model_selection import StratifiedKFold

from sklearn.preprocessing import StandardScaler

from sklearn.pipeline import Pipeline

# 加载数据集

dataframe = read_csv("sonar.csv", header=None)

dataset = dataframe.values

# 分割为输入 (X) 和输出 (Y) 变量

X = dataset[:,0:60].astype(float)

Y = dataset[:,60]

# 将类别值编码为整数

编码器 = LabelEncoder()

encoder.fit(Y)

encoded_Y = encoder.transform(Y)

# 更大的模型

def create_larger():

# 创建模型

model = Sequential()

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

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

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

# 编译模型

model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])

return model

estimators = []

estimators.append(('standardize', StandardScaler()))

estimators.append(('mlp', KerasClassifier(model=create_larger, epochs=100, batch_size=5, verbose=0)))

pipeline = Pipeline(estimators)

kfold = StratifiedKFold(n_splits=10, shuffle=True)

results = cross_val_score(pipeline, X, encoded_Y, cv=kfold)

print("更大: %.2f%% (%.2f%%)" % (results.mean()*100, results.std()*100))

运行此示例将生成以下结果。

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

您可以看到模型性能没有提升。这可能是统计噪声，也可能是需要进一步训练的迹象。

Larger: 83.14% (4.52%)

1	更大: 83.14% (4.52%)

通过进一步调整诸如优化算法和训练轮数等方面，有望实现进一步的改进。在这个数据集上你能达到的最佳分数是多少？

总结

在这篇文章中，您了解了Python中的Keras深度学习库。

您学会了如何逐步处理Keras中的二元分类问题，特别是：

如何加载和准备数据以在Keras中使用
如何创建基线神经网络模型
如何使用scikit-learn和分层k折交叉验证来评估Keras模型
数据准备方案如何提升模型的性能
调整网络拓扑的实验如何提升模型性能

您对深度学习与Keras或本文有任何疑问吗？请在评论区提问，我将尽力回答。

关于此主题的更多信息

使用Keras的深度学习模型中的Dropout正则化

在Python中使用Keras进行深度学习模型学习率调度

198条对使用Keras深度学习库的二元分类教程的回复

Matt 2016年6月15日 12:21 下午 #

很棒的文章，例子也很简单明了。谢谢分享，Jason！

回复
- Jason Brownlee 2016年6月15日 1:41 下午 #
  
  不用谢，Matt。
  
  回复
Shanky SHarma 2016年7月11日 4:11 下午 #

嗨，Jason，

这里如何使用测试数据集？我对机器学习是新手，到目前为止，我只遇到过用于准确率测量的k折方法，但我想在测试集上进行预测，你能分享一个例子吗。

谢谢你。

回复
- Jason Brownlee 2016年7月12日 5:24 上午 #
  
  你好 Shanky，
  
  这里有一个在模型拟合过程中在手动验证数据集上评估神经网络的例子
  https://machinelearning.org.cn/evaluate-performance-deep-learning-models-keras/
  
  您可以使用 model.evaluate() 函数在新数据上评估您的拟合模型，在此深度学习教程的最后有一个例子
  https://machinelearning.org.cn/tutorial-first-neural-network-python-keras/
  
  您可以在这里了解更多关于评估机器学习算法的测试选项
  https://machinelearning.org.cn/how-to-choose-the-right-test-options-when-evaluating-machine-learning-algorithms/
  
  回复
Paul 2016年7月12日上午9:08 #

嗨，Jason，

在成功地按照本教程操作后，我开始玩弄模型以学到更多东西。

最终，我达到了在基线中添加 model.predict() 的地步。

但是，当我打印预测的 Y 值时，它们被缩放了。有什么方法可以使用 StandardScaler 然后将预测值恢复为二元值吗？

谢谢

回复
- Jason Brownlee 2016年8月15日上午11:19 #
  
  你好 Paul，我建议你提前对数据进行缩放，并保留用于缩放的系数，然后稍后使用它们来反向缩放预测。
  
  回复
Cedric 2016年8月8日上午3:06 #

嗨，Jason，

很棒的文章！对于 Keras 中的二元分类这是一个非常有用的介绍。

我想知道，在这个例子中，如何打印 Keras 通常显示的模型的训练进度？

回复
- Jason Brownlee 2016年8月8日上午5:49 #
  
  谢谢 Cedric。
  
  您可以通过在 model.fit() 调用中设置 verbose=1 来按 epoch 打印进度。通过设置 verbose=2 并将 verbose=0 关闭输出来查看跨 epoch 的进度。
  
  这里的进度被关闭了，因为我们使用了 k 折交叉验证，这会产生更多模型，从而导致非常嘈杂的输出。
  
  回复
Aakash Nain 2016年8月10日上午3:51 #

你好 Jason，
优秀的教程。考虑一个情况。假设您加载的数据集是训练集，而测试集是单独提供的。我按照您描述的方式创建了模型，但现在我想预测测试数据的输出，并检查测试数据的预测分数。我该如何做到？

回复
- Jason Brownlee 2016年8月15日上午11:18 #
  
  您可以使用 model.predict() 来进行预测，然后将结果与已知结果进行比较。
  
  本文提供了一个您想要的示例
  https://machinelearning.org.cn/5-step-life-cycle-neural-network-models-keras/
  
  回复
Sally 2016年10月26日上午4:14 #

亲爱的 Jason,

感谢这个优秀的教程，我想问一下关于这个网络模型；它属于哪种深度学习模型？是深度信念网络、CNN、堆叠自编码器还是其他？

提前感谢

回复
- Jason Brownlee 2016年10月26日上午8:32 #
  
  这是一个深度神经网络。
  
  请注意，DBN 和自编码器对于此类分类问题通常不再是主流。
  
  CNN 是最先进的，并用于图像数据。
  
  希望这有帮助。
  
  回复
  - Partha Shankar Nayak 2018年9月28日下午3:21 #
    
    布朗利博士您好，
    
    抱歉，我没有理解您关于“...DBN和自编码器对于分类问题通常不再是主流...”的说法。我在一篇论文中读到他们使用DBN来预测电影的成功。他们提到他们使用了2层DBN，取得了最佳准确率。
    
    回复
    - Jason Brownlee 2018年9月29日上午6:32 #
      
      是的，我的理解是 CNN 目前在文本分类方面是最先进的。
      
      这并不妨碍关于旧方法的论文的出现。
      
      回复
Sally 2016年11月7日晚上11:33 #

Jason，谢谢您的回复，我还有关于这个例子的一个问题。如何知道在使网络变小时减少的特征，就像在第 4.1 节中一样，您迫使隐藏层中的特征从 60 减少到 30？如何知道在此步骤之后选择了哪些特征？另外，能否知道每个特征在分类过程中所占的权重？

回复
- Jason Brownlee 2016年11月8日上午9:53 #
  
  你好 Sally，
  
  特征是加权的，但由于有多层，加权是复杂的。仅凭输入权重就确定特征重要性或哪些特征是必需的，这是不准确的。
  
  隐藏层神经元与输入特征不同，我希望这一点很清楚。也许我误解了你的问题，你能详细说明你的意思吗？
  
  回复
Sally 2016年11月8日晚上9:51 #

嗨，Jason，

我的情况如下：我有一个类似于您的例子。我有一个深度神经网络，有 11 个特征。我使用一个隐藏层将 11 个特征减少到 7 个，然后将其馈送到二元分类器以将值分类为 A 类或 B 类。我首先需要知道的是，这 7 个特征是哪 7 个？我能否在代码中以某种方式列出它们？第二件事是我需要知道在将记录分类为 A 类或 B 类时每个特征的平均值。更详细地说；当特征 1 的平均值为 0.5，特征 2 的平均值为 0.2，特征 3 的值为 0.3... 等等，那么该记录就被分类为 A 类。我需要这样的东西；如何获得这样的值？

回复
- Jason Brownlee 2016年11月9日上午9:51 #
  
  你好 Sally，
  
  隐藏层中的节点数量并不是输入特征的子集。它们是输入数据的全新非线性重组。您无法列出隐藏层中的节点与哪些特征相关，因为它们是与所有输入特征相关的新特征。这有意义吗？
  
  回复
Sally 2016年11月9日下午6:20 #

哦，是的！我以为这是一种通过隐藏层完成的特征选择！所以，如果我想进行特征选择，我必须在创建模型之前进行。我没有得到第二个问题的答案，那就是我如何衡量每个特征在预测中的贡献？换句话说；如何获取“_features_importance_”？我在代码中尝试过，但它不适用于第 16 行的“pipeline”模型。我在哪里可以使用“features_importance”函数来查看每个特征在预测中的贡献？

回复
- Jason Brownlee 2016年11月10日上午7:39 #
  
  你好 Sally，你也许可以用神经网络计算特征重要性，我不知道。抱歉，你可能需要自己研究这个问题。
  
  回复
Sally 2016年11月10日上午8:40 #

我搜了一下，但很遗憾我没有找到🙁 .. 感谢您的合作

回复
Sunil Manikani 2016年11月16日晚上10:47 #

嗨，Jason，
确实是优秀的教程！！！

在使用 eclipse 中的 PyDev 时，我在以下导入时遇到了麻烦……

来自 keras.models import Sequential
from keras.layers import Dense

我从 git 下载了最新的 keras-master 并执行了
sudo python setup.py install，因为我最新的 PIP 安装的 keras 出现了导入错误。[不得不删除它。]

希望这对某人有所帮助。我的两分钱，为您的精彩帖子做贡献。

非常感谢！再一次。

致以最诚挚的问候，
Sunil M

回复
- Jason Brownlee 2016年11月17日上午9:53 #
  
  感谢 Sunil 的评论。
  
  我本人不是 IDE 用户，全程使用命令行。
  
  回复
Sally 2017年1月5日下午12:47 #

亲爱的 Jason,

我还有一个关于这个例子的其他问题。如您所知；深度学习在大型数据集上表现良好，在小型数据集上经常过拟合。本例中的数据集只有 208 条记录，深度模型取得了相当不错的结果。这如何满足深度学习与大型数据集的理念？

回复
- Jason Brownlee 2017年1月6日上午9:04 #
  
  你好 Sally，
  
  不要过度解读。这是 MLP 在小型二元分类问题上的演示。
  
  MLP 是可以扩展的。如果问题足够复杂，我们有 1000 倍的数据，模型性能会继续提高。
  
  回复
Sally 2017年1月7日上午8:12 #

Jason，谢谢您的回复，但是您能解释一下您是如何发现数据是 1000 倍的吗？您有 208 条记录，每条记录有 60 个输入值？您是把它们相乘得到这个数字的吗？这样我们就可以确定数据是复杂的还是不复杂的？另外，您能用发表的文章来证明 MLP 在复杂问题上可以扩展吗？抱歉问了这么多问题，但我正在处理与此相关的项目，需要进行论证和引用。

回复
- Jason Brownlee 2017年1月7日上午8:42 #
  
  不，我指的是如果我们有千倍的数据量。
  
  回复
Sidharth Kumar 2017年2月3日上午12:01 #

在多类别分类（如 MNIST）中，我们有 0 到 9 的 10 个输出。
为什么在二元分类中只有一个输出？我们应该有 0 和 1 各一个输出。你能解释一下吗？

回复
- Jason Brownlee 2017年2月3日上午10:01 #
  
  很好的问题 Sidharth。
  
  我们可以使用两个输出神经元进行二元分类。
  
  或者，因为只有两种结果，我们可以简化并使用一个输出神经元，并带有输出二元响应的激活函数，如 sigmoid 或 tanh。
  
  它们通常是等效的，尽管更简单的方法更受欢迎，因为需要训练的权重更少。
  
  最后，如果您愿意，也可以为多类分类使用一个输出神经元，并设计一个自定义激活函数或将线性输出值解释为类别。这种方法通常无法捕捉问题中足够的复杂性——例如，网络想要建议输入可能属于多个类别（一个令人困惑的输入模式），并且它假设类别之间存在通常无效的序数关系。
  
  回复
  - Pablo 2017年3月18日上午3:02 #
    
    我不明白，你是怎么在哪里做的。
    
    你使用的是 1 个输出节点，如果 sigmoid 输出是 =0.5，就被认为是 B 类吗？？
    
    对吗？在代码的哪个地方做的？
    
    回复
- KUNDAN KUMAR 2019年9月26日上午12:35 #
  
  伙计，你说什么呢，如果你要测试灯泡是开还是关来测试电路规则，你必须用两个不同的灯泡来测试，还是一个就够了？
  
  回复
SYKim 2017年2月6日晚上10:47 #

嗨 Jason。谢谢。您的教程真的很有帮助！

我制作了一个小的网络（2-2-1）来拟合 XOR 函数。

我发现如果没有 numpy.random.seed(seed)，准确率结果可能会有很大差异。

有时它能很快学习，但在大多数情况下，它的准确率仅停留在 0.25、0.50、0.75 等附近……

所以我需要尝试几次才能找到一个能带来高准确率的合适种子值。

直到成功才尝试几次相同的模型是常见的吗？

还有一个情况是它陷入了局部最优，但经过很长时间后它会从中出来，准确率达到 1.0。

如果有一个非常大的网络，需要 2-3 周才能训练完成怎么办？

人们是否会开始训练，如果一段时间内没有多大改进就重新开始？

人们是否会在不同的机器上运行相同的模型，使用不同的初始化值？

有什么方法可以知道它的准确率是否会在一周后提高吗？

谢谢！

回复
- Jason Brownlee 2017年2月7日上午10:16 #
  
  很好的问题，请看这篇关于随机性和机器学习的文章
  https://machinelearning.org.cn/randomness-in-machine-learning/
  
  希望这些能作为一个开始有所帮助。
  
  回复
Mark 2017年2月8日下午4:26 #

嗨 Jason。谢谢你的教程。

我想实现自编码器来进行图像相似度测量。你能给我一些如何解决这个问题的提示/方向/建议吗？谢谢

回复
- Jason Brownlee 2017年2月9日上午7:21 #
  
  抱歉，我没有使用自编码器的例子。
  
  回复
Chan 2017年2月9日晚上10:13 #

嗨 Brownlee

如何保存和加载 KerasRegressor 模型。

estimator = KerasRegressor(…)

我使用 estimator.model.save()，它有效，
但它必须先调用 estimator.fit(X, Y)，否则会抛出“no model”错误。

此外，我不知道如何加载模型到 estimator。

使用 Keras 的普通模型来保存/加载模型更容易，而使用 scikit_learn 的 Keras wrapper 来保存/加载模型对我来说更困难。

您能否告诉我如何做到这一点。
非常感谢。

回复
- Jason Brownlee 2017年2月10日上午9:53 #
  
  嗨 Chan，你可以试试 pickle 吗？
  
  我觉得使用 KerasClassifier 来探索模型和调优更容易，然后使用原生 Keras 来保存/加载大型模型并完成模型。
  
  回复
Emerson 2017年2月10日下午4:23 #

精彩的教程，这是我第一个能够完整跟随的教程。

我很想看到一个使用这个模型进行实际预测的简短代码片段。我认为这就像使用 estimator.predict(X[0]) 一样简单，但我收到了关于数据形状不正确的错误（None, 60）vs（60, 1）。

回复
- Jason Brownlee 2017年2月11日上午4:54 #
  
  我很高兴听到 Emerson。
  
  是的，你可以使用
  
  yhat = model.predict(X)
  
  1
  
  yhat = model.predict(X)
  
  您可能需要将数据重塑为二维数组
  
  data = data.reshape(60, 1)
  
  1
  
  data = data.reshape(60, 1)
  
  回复
  - Carlos Castellanos 2017年7月3日上午7:24 #
    
    嗨 Jason，真是太棒了，恭喜！我有一些关于 Emerson 的问题和他答案的疑问。
    
    我想将交叉验证和预测分开执行，因为它们在不同的时间执行，为此，我需要接收一个非标准的输入向量 X，其中包含一个用于预测的样本。我能够使用回调函数保存模型，以便可以重新使用它进行预测，但我对如何在不加载整个数据集的情况下对输入向量进行标准化感到有些困惑，我曾尝试进行管道状态的 pickle，但没有好的结果，这可能吗？您有如何执行此操作的示例吗？谢谢！
    
    回复
    - Jason Brownlee 2017年7月6日上午9:56 #
      
      要标准化，您只需要每个变量的训练数据的均值和标准差。
      
      回复
Chris Cummins 2017年2月24日上午4:47 #

极好的教程 Jason，谢谢。这是我的 Jupyter 笔记本： https://github.com/ChrisCummins/phd/blob/master/learn/keras/Sonar.ipynb

回复
- Jason Brownlee 2017年2月24日上午10:12 #
  
  做得好 Chris。
  
  回复
Dmitri Levitin 2017年3月24日上午7:46 #

我有一个困难的问题。我拥有 NASDAQ 公司每周的搜索趋势数据，跨越两年时间，我试图根据财报发布后的搜索趋势来分类股价是上涨还是下跌，这导致了 104 周或特征。我运行了这些数据，但没有收到信号。结果：48.55% (4.48%)。

然而，在我的非机器学习实验中，我看到了信号。如果我取差值（第 n 周 - 第 n+1 周），创建一个包含 103 个差值的数组。然后我平均所有上涨的股票，并平均所有下跌的股票。当我预测同一两年时间段内的新股票时，我以投票方式将新股票的第 n 周与标记为上涨和下跌的股票的第 n 周进行比较。谁的投票更多，谁就赢了。在这个简单的方法中，我确实看到了信号。

有什么想法？

回复
- Jason Brownlee 2017年3月24日上午8:02 #
  
  据我所知，股市的短期波动是随机游走的。你能做的最好的就是持久预测。
  
  回复
  - Dmitri Levitin 2017年3月24日上午8:15 #
    
    但我不是在比较股票的变动，而是在财报发布后其日股价上涨或下跌的趋势，这被标记为数据，而两年的谷歌每周搜索趋势则成为神经网络的输入。这样它就成了一个分类问题。
    
    如上文第二段所述，我看到了信号，这是基于将财报发布后上涨的公司在每周的平均值与下跌的公司进行比较，然后将新的一周与这些平均值进行比较。我只是不确定如何将其解释为神经网络。
    
    顺便说一句，教程很棒，我将关注您的所有教程。
    
    回复
    - Dmitri Levitin 2017年3月24日上午8:19 #
      
      我的意思是，我取了所有标记为财报后上涨的公司在每周的平均值，形成一个平均值数组，对财报后下跌的公司也做了同样的处理。然后我将新股票在同一时间段内的周与每个先前数组进行比较。我看到了信号，但如何将其与神经网络结合起来。
      
      回复
Dmitri Levitin 2017年3月24日上午10:31 #

另一个问题。使用这种方法，但使用不同的数据集，我在每个 epoch 运行中都看到了准确率的提高。但最终我得到的结果是：52.64% (15.74%)。有什么想法为什么会这样？我认为结果与平均准确率有关。

第 1/10 纪元
0s – loss: 1.1388 – acc: 0.5130
第 2/10 纪元
0s – loss: 0.6415 – acc: 0.6269
第 3/10 纪元
0s – loss: 0.4489 – acc: 0.7565
第 4/10 纪元
0s – loss: 0.3568 – acc: 0.8446
第 5/10 纪元
0s – loss: 0.3007 – acc: 0.8808
第 6/10 纪元
0s – loss: 0.2611 – acc: 0.9326
第 7/10 纪元
0s – loss: 0.2260 – acc: 0.9430
第 8/10 纪元
0s – loss: 0.1987 – acc: 0.9689
第 9/10 纪元
0s – loss: 0.1771 – acc: 0.9741
第 10/10 纪元
0s – loss: 0.1556 – acc: 0.9741

结果：52.64% (15.74%)

回复
- Jason Brownlee 2017年3月25日上午7:30 #
  
  模型是否过度拟合了训练数据？
  
  考虑使用一些正则化方法（如 dropout）来减缓学习速度。
  
  回复
Michael 2017年4月21日上午6:05 #

嗨，Jason，

本教程中描述的这种分类器是否可以用于序数分类（二元分类）？

谢谢，

回复
- Jason Brownlee 2017年4月21日上午8:43 #
  
  我会按原样使用网络，或者将问题表述为回归问题然后进行四舍五入。
  
  回复
Ahmad 2017年5月18日晚上8:12 #

你好 Jason，

如何保存管道模型？
我的意思是，过去当我们只实现模型并对其进行拟合时很容易……
但现在如何保存它以便稍后加载并进行预测？

回复
- Jason Brownlee 2017年5月19日上午8:17 #
  
  我相信您无法保存管道模型。
  
  至少据我所知，您必须单独使用 Keras API 将模型保存到磁盘。
  
  回复
  - Mik 2018年6月11日晚上9:47 #
    
    嗨，Jason，
    
    “您必须单独使用Keras API将模型保存到磁盘” -> 有没有可能请您详细说明一下您的意思？我之前尝试使用pickle、您在此处解释的json方法：https://machinelearning.org.cn/save-load-keras-deep-learning-models/ ，以及您在此处解释的joblib方法：https://machinelearning.org.cn/save-load-machine-learning-models-python-scikit-learn/ 来保存上面示例中的模型。但它们都不起作用。Pickle给出了以下错误
    
    _pickle.PicklingError: Can’t pickle : attribute lookup module on builtins failed
    
    使用json会产生此错误
    
    AttributeError: ‘Pipeline’ object has no attribute ‘to_json’
    
    …对于joblib方法，我收到了错误消息
    
    TypeError: can’t pickle SwigPyObject objects
    
    我曾尝试在网上搜索SwigPyObject以获取更多信息，但没有找到有用的东西。如果您能提供任何建议，那将非常有帮助。
    
    提前感谢。
    
    回复
    - Jason Brownlee June 12, 2018 at 6:42 am #
      
      据我所知，我们无法保存被sklearn封装的keras模型。我们必须直接使用Keras API来保存/加载模型。
      
      回复
Rob June 20, 2017 at 8:03 am #

非常感谢这篇很棒的文章！我正在学习机器学习，您的博客给了我巨大的帮助。

您是否知道为什么在不使用k折交叉验证的情况下训练模型会得到截然不同的结果？例如，如果我运行

model = create_baseline() model.fit(X, encoded_Y, epochs=100, batch_size=5, validation_split=0.3)

它输出的val_acc大约是0.38。但如果我运行您代码中的k折交叉验证，我得到的准确率大约是75%。

完整代码片段在此 https://gist.github.com/robianmcd/e94b4d393346b2d62f9ca2fcecb1cfdf

您是否知道为什么会发生这种情况？

回复
- Jason Brownlee June 21, 2017 at 8:07 am #
  
  你好Rob，是的，神经网络是随机的。请参阅这篇帖子
  https://machinelearning.org.cn/randomness-in-machine-learning/
  
  请看这里了解如何更可靠地评估神经网络模型技能
  https://machinelearning.org.cn/evaluate-skill-deep-learning-models/
  
  回复
  - Rob June 22, 2017 at 7:15 am #
    
    我运行了很多次，在使用k折交叉验证时，我一直得到大约75%的准确率，而在不使用时则为35%。事实证明，在我没有使用k折交叉验证时，我没有对数组进行洗牌，因此验证目标集几乎全是1，而训练集主要是0。我添加了numpy.random.shuffle(dataset)，现在一切正常了。
    
    回复
    - Jason Brownlee June 23, 2017 at 6:37 am #
      
      很高兴听到你解决了问题，Rob！
      
      回复
Michael June 21, 2017 at 11:33 pm #

嗨，Jason，

在这篇文章中，您提到了具有比前一层神经元数量更少的神经元的隐藏层可以提取关键特征。
在Keras中是否有可能可视化或获取这些选定的关键特征列表？（例如，对于具有大量特征的网络）

谢谢，
Michael

回复
- Jason Brownlee June 22, 2017 at 6:06 am #
  
  你也许可以，抱歉我不知道有这样的例子。
  
  回复
joseph June 25, 2017 at 6:45 pm #

嗨，我很想看到用于识别对象位置和标记对象的对象定位/分割网络。

回复
- Jason Brownlee June 26, 2017 at 6:07 am #
  
  谢谢你的建议，joseph。
  
  回复
Parth July 19, 2017 at 1:58 am #

嗨Jason，我们如何知道哪种结构对神经网络最好？您能否为我提供一些资源？（我不介意深入研究数学）

回复
- Jason Brownlee July 19, 2017 at 8:27 am #
  
  不行。对此没有好的理论。
  
  模仿其他设计，进行试错。设计鲁棒的实验来测试多种结构。
  
  回复
Fan Feng August 5, 2017 at 7:43 pm #

感谢您的分享。

回复
- Jason Brownlee August 6, 2017 at 7:37 am #
  
  很高兴它有帮助！
  
  回复
Alex Mikhalev August 28, 2017 at 4:37 am #

感谢分享，但这还需要进一步讨论——
参见 http://www.cloudypoint.com/Tutorials/discussion/python-solved-can-i-send-callbacks-to-a-kerasclassifier/

回复
- Jason Brownlee August 28, 2017 at 6:51 am #
  
  很高兴听到这个消息。
  
  回复
Valentin September 19, 2017 at 7:15 pm #

嗨Jason！非常感谢这篇简洁易懂的教程！有一个问题：如果您调用原生的Keras model.fit(X,y)，您也可以提供validation_data，这样在训练期间（如果verbose=1）会打印验证分数。您知道如何在管道中启用此功能吗？sklearn会自动在cross_val_score步骤中进行拆分，但如何将其传递给Keras的fit方法呢？

非常感谢！

回复
- Jason Brownlee September 20, 2017 at 5:55 am #
  
  不知道，也不推荐这样做。我认为这会引起更多问题。
  
  回复
B G SINGH September 20, 2017 at 3:38 am #

嗨，Jason，

这个代码有办法使用class_weight参数吗？

谢谢，
Biswa

回复
- Jason Brownlee September 20, 2017 at 6:02 am #
  
  是的，在fit()函数中设置class_weight。
  
  更多帮助请点击此处
  https://keras.org.cn/models/sequential/
  
  回复
  - Don December 6, 2017 at 1:45 pm #
    
    感谢Jason的精彩文章！
    
    当我使用cross_val_score而不是像您在这篇文章中那样使用fit()时，如何使用class_weight？
    
    谢谢，
    Don
    
    回复
    - Jason Brownlee December 7, 2017 at 7:50 am #
      
      抱歉，我没有使用加权类的示例。
      
      回复
Luis Ernesto October 19, 2017 at 2:53 pm #

您好，有趣的帖子。我目前正在进行一项研究，这是一项对三种人工神经网络算法的比较研究：多层感知机、径向和循环神经网络。我已经完成了算法的工作，并且正在进行训练，一切正常，直到我开始这个阶段，不幸的是我无法泛化网络，并且尝试更改学习率和迭代次数等参数，但结果保持不变。输入的输入数据（数据集）是二元的，例如一个模式有（1,0,0,1,1,0,0,1,0,1,1,1），最后一个指示符是期望的输出。我还注意到，当权重收敛并且我在验证阶段使用它们时，所有结果几乎都相同，就像模式之间没有区别一样。现在我正在进行交叉验证，希望能解决这个问题或认识到我的错误可能是什么。我将非常感谢您的帮助或建议。

回复
- Jason Brownlee October 19, 2017 at 4:03 pm #
  
  一般来说，我推荐这个过程来评估我的模型
  https://machinelearning.org.cn/evaluate-skill-deep-learning-models/
  
  也许您可以计算训练集和验证集上的学习率等诊断指标？
  
  回复
Vivaldi Gut November 8, 2017 at 5:17 am #

你好Jason或这里任何活跃的人

请问对于二元分类，就精度和召回率而言，什么才算良好的性能？我得到了

class precision recall f1-score support

0 0.88 0.94 0.91 32438
1 0.80 0.66 0.72 11790

avg / total 0.86 0.86 0.86 44228
Accuracy: 0.864520213439

我想提高类别1的召回率。如果您能提供一些提示，我将不胜感激。

提前感谢。

回复
- Jason Brownlee November 8, 2017 at 9:30 am #
  
  “好的”结果实际上取决于具体问题，并且相对于您的问题的其他算法性能而言。
  
  回复
masoumeh November 24, 2017 at 7:53 pm #

谢谢 Jason，

实际上我有一个二元分类问题，我已经写了我的代码，我只能看到我的模型的准确率，所以如果我想看到我的模型的输出，我应该在我的代码中添加什么？我的意思是，当它接收到1或0时，最后它会显示给我它是1还是0？

回复
- Jason Brownlee November 25, 2017 at 10:17 am #
  
  您可以使用以下方法来预测您的最终模型
  
  X = ... yhat = model.predict(X)
  
  1
  2
  
  X = ...
  yhat = model.predict(X)
  
  这有帮助吗？
  
  回复
rakashi December 4, 2017 at 5:14 pm #

你好，

我正在尝试对图像进行分类。我使用了softmax作为分类器，categorical_crossentropy作为损失。在测试模型时，我得到了概率，但所有概率都等于1。但我想独立获得每个类的概率。我尝试了sigmoid和binary_crossentropy作为损失。在这里，我得到了85%的准确率，但它不像clarifai网站那样独立给出概率。

我该如何实现？您能建议一下吗？

回复
- Jason Brownlee December 5, 2017 at 5:41 am #
  
  也许可以看看这个教程
  https://machinelearning.org.cn/object-recognition-convolutional-neural-networks-keras-deep-learning-library/
  
  回复
Cody December 13, 2017 at 8:47 am #

感谢精彩的教程。我想提一下，对于Keras的某些新版本，上面的代码无法正确工作（由于Keras API的变化）。

对我来说，最显著的变化是“nb_epoch=100”必须更改为“epoch=100”，否则交叉验证步骤将只进行1个epoch，导致模型整体性能不佳（约为55%，而不是81%）。事实证明，“nb_epoch”已被弃用。希望这条评论能帮到一些人。

回复
- Jason Brownlee December 13, 2017 at 4:12 pm #
  
  对于Keras 2.1.2，它应该可以工作。
  
  回复
  - Vincenzo February 7, 2018 at 12:36 am #
    
    @Cody说得对，“b_epoch”必须更改为“epochs”，否则它将被忽略，并且训练将只进行每个折叠1个epoch（Keras 2.1.3）。
    
    回复
    - Jason Brownlee February 7, 2018 at 9:25 am #
      
      已修正，谢谢。
      
      回复
Nandini February 8, 2018 at 5:19 pm #

我的损失值一直保持不变，即使经过4个epoch也没有下降，准确率也没有提高，我应该更新哪些参数来调整RNN二元分类问题。

请帮忙。

model = Sequential()
model.add(LSTM(100, input_shape=(82, 1),activation=’relu’))
#model.add(Dense(60, input_dim=60, kernel_initializer=’normal’, activation=’relu’))
model.add((Dense(80,activation=’tanh’)))
model.add((Dense(40,activation=’tanh’)))
model.add((Dense(20,activation=’tanh’)))
model.add(Dense(1,activation=’sigmoid’))
model.compile(loss=’binary_crossentropy’, optimizer=’adam’,metrics=[“accuracy”])
#print(model.summary())

model.fit(trainX,trainY, nb_epoch=200, batch_size=4, verbose=2,shuffle=False)
请在此场景下给我建议。

回复
- Jason Brownlee February 9, 2018 at 9:00 am #
  
  也许可以尝试训练更长时间，训练100个epoch。
  
  也许可以在较少的数据上进行抽样检查。
  
  这里有更多可以尝试的想法
  https://machinelearning.org.cn/improve-deep-learning-performance/
  
  回复
  - Razvan July 8, 2022 at 2:24 pm #
    
    又一篇精彩的文章Jason 🙂 干得漂亮！
    
    回复
nandini February 9, 2018 at 6:35 pm #

对于二元分类，哪种优化器是合适的？我正在使用rmsprop。
我拥有的样本很少。
我能否通过更多的epoch和更小的batch size来训练，这是否适合提高模型的准确率？

回复
- Jason Brownlee February 10, 2018 at 8:55 am #
  
  也许可以尝试一下。
  
  回复
David February 28, 2018 at 3:13 am #

嗨Jason，在用训练好的二元分类模型测试新样本时，新样本是否需要先缩放才能输入模型？如果只有一个样本呢？谢谢David

回复
- Jason Brownlee February 28, 2018 at 6:09 am #
  
  是的，数据必须以完全相同的方式准备。即使是单个样本。
  
  回复
Vatsal March 31, 2018 at 7:29 pm #

嗨Jason！您能贡献这篇文章真是太好了。尽管如此，我该如何对新的数据集（60个特征）进行分类？我认为没有代码片段可以做到这一点。我的意思是真正地使用训练好的模型。

回复
- Jason Brownlee April 1, 2018 at 5:48 am #
  
  一旦你训练了你的最终模型，你就可以通过调用model.predict(X)来做出预测。
  
  也许这篇帖子会让你更清楚
  https://machinelearning.org.cn/train-final-machine-learning-model/
  
  回复
Ciaran May 11, 2018 at 9:43 pm #

非常感谢您！这对我来说是Keras的一个极好的介绍，我很快就成功地改编了这段代码。解释也很完美。非常感谢。

回复
- Jason Brownlee May 12, 2018 at 6:32 am #
  
  很高兴它有帮助。
  
  回复
Yannis June 27, 2018 at 9:48 pm #

很棒的文章，谢谢！

回复
- Jason Brownlee June 28, 2018 at 6:18 am #
  
  很高兴它有帮助。
  
  回复
youness mourtaji July 28, 2018 at 5:43 am #

嗨，Jason，

非常感谢您的精彩教程，它对我帮助很大。

请我有两个问题：
1-我有一个二元分类问题，请问有什么方法可以为神经网络选择合适的架构，RNN还是CNN还是……？
2-有什么方法可以将机器学习分类器如K-Means、DecisionTrees等显式地用于您上面的代码吗？因为您使用了KerasClassifier，但我不知道用于分类的算法是什么。

再次感谢

回复
- Jason Brownlee July 28, 2018 at 6:42 am #
  
  使用MLP，更多信息请参见此处
  https://machinelearning.org.cn/when-to-use-mlp-cnn-and-rnn-neural-networks/
  
  您可以使用sklearn来测试一系列其他算法，更多信息请参见此处
  https://machinelearning.org.cn/spot-check-classification-machine-learning-algorithms-python-scikit-learn/
  
  回复
youness mourtaji July 28, 2018 at 7:22 am #

再次非常感谢Jason先生。

回复
- Jason Brownlee July 28, 2018 at 7:37 am #
  
  不客气。
  
  回复
Lovish Batheja August 13, 2018 at 10:19 pm #

这篇文章非常有帮助！🙂

我有一个问题。在这篇文章中，您使用了所有连续变量来预测一个二元变量。如果输入是分类变量和连续变量的混合，该如何处理？

回复
- Jason Brownlee August 14, 2018 at 6:20 am #
  
  在建模之前，分类输入可以被整数编码、独热编码或进行其他编码。
  
  回复
Charanraj Mohan August 27, 2018 at 5:00 am #

你好，
我有一个问题。我正在使用keras的Functional API（使用dense层）并构建了一个单层全连接神经网络。我看到权重更新基于几个因素，如优化方法、激活函数等。假设，假设我正在使用一个真正的二元权重作为我的突触，并且我想使用一个二元权重函数来更新权重，这样我就可以在每次迭代中检查权重更新（delta w），当它是正的时，我决定增加权重，当它是负的时，我想减小权重。如何使用keras做到这一点？？

我读到keras在这方面非常有限。是真的吗？供您参考，我使用dense语法来定义我的层，并使用input来定义输入。是否可以将二进制权重决策函数与keras中的dense层一起添加？

提前感谢🙂

回复
Avi September 23, 2018 at 12:19 am #

嗨，Jason，

谢谢这篇文章。有几个问题。

1）数据有260行。如果我查看更深层网络的参数数量，它是6000+。行数不应该比参数数量多吗？

2）如何使用交叉验证的模型进行预测？我们是否只取最后一个模型并进行预测？

回复
- Jason Brownlee September 23, 2018 at 6:40 am #
  
  不，我们可以过度指定模型并仍然实现低泛化误差。通过使用正则化，这也适用于统计方法。
  
  我们不使用CV进行预测。CV仅用于估计模型的泛化误差。在此了解更多
  https://machinelearning.org.cn/faq/single-faq/how-do-i-make-predictions
  
  回复

Arjun.K October 3, 2018 at 2:44 am #

你好 Jason，
我是深度学习的新手，这是我的第一个深度学习程序，即使用keras处理Sonar数据，在拟合模型时我遇到了一个我无法理解的错误

‘ValueError: Error when checking input: expected dense_13_input to have shape (20,) but got array with shape (60,)’

您能帮我看看我哪里出错了……谢谢Jason……这是我的程序代码

import keras
import numpy
import pandas as pd
from keras.models import Sequential
from keras.layers import Dense,Activation,Dropout
from keras.optimizers import SGD
from keras.utils import np_utils
from sklearn.model_selection import train_test_split

sonar=pd.read_csv('C:\\Users\\sonar.all-data.csv',header=None)
sonar.head()

X=sonar.iloc[:,0:60]  #All the rows and 0 to 59 columns
Y=sonar.iloc[:,60]

Y=pd.get_dummies(Y)
Y.head()

#Split the dataset
x_train,y_train,x_test,y_test=train_test_split(X,Y,test_size=0.20,random_state=101)
print('x_train data: ',x_train.shape)
print('y_train data: ',y_train.shape)
print('x_test data: ',x_test.shape)
print('y_test data: ',y_test.shape)

#Building  the model
model = Sequential()

model.add(Dense(60,activation='relu',input_dim=20))
model.add(Dropout(0.20))

model.add(Dense(60,activation='relu'))
model.add(Dropout(0.20))

model.add(Dense(60,activation='relu'))
model.add(Dropout(0.20))

model.add(Dense(2,activation='softmax'))

# Compiling the  model
epochs = 10
lrate = 0.01
decay = lrate/epochs
sgd = SGD(lr=lrate, momentum=0.4, decay=decay, nesterov=False)
model.compile(loss='categorical_crossentropy', optimizer=sgd, metrics=['accuracy'])
print(model.summary())

model.fit(x_train, y_train,epochs=epochs, batch_size=10)

import keras

import numpy

import pandas as pd

from keras.models import Sequential

from keras.layers import Dense,Activation,Dropout

from keras.optimizers import SGD

from keras.utils import np_utils

from sklearn.model_selection import train_test_split

sonar=pd.read_csv('C:\\Users\\sonar.all-data.csv',header=None)

sonar.head()

X=sonar.iloc[:,0:60] #All the rows and 0 to 59 columns

Y=sonar.iloc[:,60]

Y=pd.get_dummies(Y)

Y.head()

#Split the dataset

x_train,y_train,x_test,y_test=train_test_split(X,Y,test_size=0.20,random_state=101)

print('x_train 数据: ',x_train.shape)

print('y_train 数据: ',y_train.shape)

print('x_test 数据: ',x_test.shape)

print('y_test 数据: ',y_test.shape)

# 构建模型

model = Sequential()

model.add(Dense(60,activation='relu',input_dim=20))

model.add(Dropout(0.20))

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

model.add(Dropout(0.20))

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

model.add(Dropout(0.20))

model.add(Dense(2,activation='softmax'))

# 编译模型

epochs = 10

lrate = 0.01

decay = lrate/epochs

sgd = SGD(lr=lrate, momentum=0.4, decay=decay, nesterov=False)

model.compile(loss='categorical_crossentropy', optimizer=sgd, metrics=['accuracy'])

print(model.summary())

model.fit(x_train, y_train,epochs=epochs, batch_size=10)

Jason Brownlee 2018年10月3日上午6:21 #

错误表明模型的预期与实际数据不同。您可以更改模型或更改数据。

回复

khalil ahmad 2018年12月2日上午5:19 #

你好，先生……
先生，是否有可能每一行都包含一些简短的解释，例如
import numpy （numpy是科学计算库等
这样我就可以轻松理解每一行的功能了。
谢谢。

回复
- Jason Brownlee 2018年12月2日上午6:24 #
  
  感谢您的建议。
  
  回复
JG 2018年12月6日上午10:44 #

你好杰森

谢谢。我没有足够的时间来学习您的教程，但从您其他的逻辑回归（二分类）教程中，我有一个普遍的问题

1）在多类分类中，我们将许多单元放在最后一层或输出层，作为类的数量，能否用输出层中的两个单元（带 softmax 激活）替换最后一层的单个单元，而不是 sigmoid，并将编译模型中的损失对应的参数设为 categorical_crossentropy 而不是 binary_cross entropy？

1.1）如果这种方法可行，它比“经典”的在输出层只有单个单元的方法更有效吗？

非常感谢

回复
- Jason Brownlee 2018年12月6日下午1:45 #
  
  是的，您可以用 2 个带有 softmax 的节点来进行二分类。
  
  这通常没有区别，而且我们使用单个节点会降低复杂性。
  
  回复
  - Priyanshu Kumar 2019年11月24日下午7:42 #
    
    神经网络最后一层的激活函数在两种情况下都发生了变化。因此，梯度的值在两种情况下都发生了变化。两种网络在给定数据集上的性能之间是否存在惊人的差异的可能性？
    
    回复
    - Jason Brownlee 2019年11月25日上午6:28 #
      
      有可能。
      
      回复
Pablo 2018年12月18日上午5:48 #

‘encoded_Y’ 是 ‘Y’ 吗？它之前没有定义。

回复
- Jason Brownlee 2018年12月18日上午6:06 #
  
  它在帖子的第 2 部分中定义。
  
  回复
Igor 2018年12月19日上午11:50 #

你好，Jason。

感谢您这篇有趣且内容丰富的文章。

我刚接触 ANN，也不是 Python 程序员，所以无法“深入了解”您使用的 Keras 函数。但我有一个关于您示例的普遍（而且我确定非常基础）的问题。

如果我理解正确，您构建了一个神经网络，其中输入层有 60 个节点（与预测变量的数量相同），一个隐藏层，以及一个只有一个节点用于预测二元变量的输出层。那么在我看来，您需要为数据集中的每个记录单独训练您的网络。并因此获得与数据集中记录数量（总共 208 条）相同的最优节点权重集。然后，您如何将它们集成到一个最终集合中？如果您像对每个节点进行所有 208 个权重的平均处理那样做，那么生成的网络如何表现良好？没有它，网络如何进行测试并在以后用于实际预测？我真的很困惑。

我的问题有道理吗？

谢谢你，

Igor

回复
- Jason Brownlee 2018年12月19日下午2:29 #
  
  不太对，训练期间只有一个权重集会被更新。
  
  也许这会使事情更清楚
  https://machinelearning.org.cn/implement-backpropagation-algorithm-scratch-python/
  
  回复
boukhari el mouatassem 2018年12月22日下午9:18 #

感谢您精彩的讲解
我该如何保存模型来创建基线？请回答我？

回复
- Jason Brownlee 2018年12月23日上午6:05 #
  
  是的，这篇帖子展示了如何保存模型
  https://machinelearning.org.cn/save-load-keras-deep-learning-models/
  
  回复
Nandini 2019年1月25日下午5:43 #

对于二分类，我们为什么要在输出层和 sigmoid 激活层中给出 1，有什么特别的原因吗？

回复
- Jason Brownlee 2019年1月26日上午6:10 #
  
  是的，它可以直接预测概率。它高效且有效。
  
  回复
saba 2019年1月30日下午5:36 #

嗨 Jason

感谢您这篇出色的帖子。

我想开始使用 Keras 进行 DNN。您能为我介绍一个实际的分类教程吗？

谢谢
S

回复
- Jason Brownlee 2019年1月31日上午5:29 #
  
  是的，你可以从这里开始
  https://machinelearning.org.cn/start-here/#deeplearning
  
  回复
Meriem 2019年2月27日上午2:48 #

嗨 Jason
感谢这个教程，但是测试阶段怎么样？

回复
- Jason Brownlee 2019年2月27日上午7:34 #
  
  您可以使用 model.evaluate() 来估计模型在未见过的数据上的性能。
  
  这有帮助吗？
  
  回复

Marco Sabatini 2019年2月27日上午8:07 #

先生，这段代码的结果约为 55%，而不是 81%，这是在没有优化神经网络的情况下。

这是我的代码用于检查错误或其他

import numpy
import pandas
from keras.models import Sequential
from keras.layers import Dense
from keras.wrappers.scikit_learn import KerasClassifier
from sklearn.model_selection import cross_val_score
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import StratifiedKFold

# fix random seed for reproducibility
seed = 7
numpy.random.seed(seed)
# load dataset
url = "https://archive.ics.uci.edu/ml/machine-learning-databases/undocumented/connectionist-bench/sonar/sonar.all-data"


dataframe = pandas.read_csv(url, header=None)
dataset = dataframe.values
dim = dataset.shape
raw = dim[0]
col = dim[1]
#len(dataset.columns)

# split into input (X) and output (Y) variables
X = dataset[:,0:col-1].astype(float)
Y = dataset[:,col-1]

# encode class values as integers
encoder = LabelEncoder()
encoder.fit(Y)
encoded_Y = encoder.transform(Y)
# baseline model
def create_baseline():
    # create model
    model = Sequential()
    model.add(Dense(60, input_dim=60, kernel_initializer='normal', activation='relu'))
    model.add(Dense(1, init= "normal" , activation= "sigmoid" ))
    model.compile(loss= "binary_crossentropy" , optimizer= "adam" , metrics=[ "accuracy" ])
    return model
# evaluate model with standardized dataset
estimator = KerasClassifier(build_fn=create_baseline, nb_epoch=100, batch_size=5, verbose=0)
kfold = StratifiedKFold(n_splits=10, shuffle=True, random_state=seed)
results = cross_val_score(estimator, X, encoded_Y, cv=kfold)
print("Baseline: %.2f%% (%.2f%%)" % (results.mean()*100, results.std()*100))

import numpy

import pandas

from keras.models import Sequential

from keras.layers import Dense

from keras.wrappers.scikit_learn import KerasClassifier

from sklearn.model_selection import cross_val_score

from sklearn.preprocessing import LabelEncoder

from sklearn.model_selection import StratifiedKFold

# 设置随机种子以保证结果可复现

seed = 7

numpy.random.seed(seed)

# 加载数据集

url = "https://archive.ics.uci.edu/ml/machine-learning-databases/undocumented/connectionist-bench/sonar/sonar.all-data"

dataframe = pandas.read_csv(url, header=None)

dataset = dataframe.values

dim = dataset.shape

raw = dim[0]

col = dim[1]

#len(dataset.columns)

# 分割为输入 (X) 和输出 (Y) 变量

X = dataset[:,0:col-1].astype(float)

Y = dataset[:,col-1]

# 将类别值编码为整数

编码器 = LabelEncoder()

encoder.fit(Y)

encoded_Y = encoder.transform(Y)

# 基线模型

def create_baseline():

# 创建模型

model = Sequential()

model.add(Dense(60, input_dim=60, kernel_initializer='normal', activation='relu'))

model.add(Dense(1, init= "normal" , activation= "sigmoid" ))

model.compile(loss= "binary_crossentropy" , optimizer= "adam" , metrics=[ "accuracy" ])

return model

# 使用标准化数据集评估模型

estimator = KerasClassifier(build_fn=create_baseline, nb_epoch=100, batch_size=5, verbose=0)

kfold = StratifiedKFold(n_splits=10, shuffle=True, random_state=seed)

results = cross_val_score(estimator, X, encoded_Y, cv=kfold)

print("基线: %.2f%% (%.2f%%)" % (results.mean()*100, results.std()*100))

Jason Brownlee 2019年2月27日下午2:36 #

我预计先对数据进行标准化会有所帮助。

回复
- Farah 2022年11月15日上午10:05 #
  
  我想问一下 lstm 用于二分类的 input_shape
  一些教程中，用于二分类的 lstm 是 (features,1) 而您的是 (features,)。请问能告诉我为什么吗？您有关于 lstm 输入形状的文章吗？
  
  回复
  - James Carmichael 2022年11月16日上午7:26 #
    
    你好 Farah……下面的资源可能你会感兴趣
    
    https://machinelearning.org.cn/reshape-input-data-long-short-term-memory-networks-keras/
    
    回复

Anista 2019年3月9日上午12:41 #

嗨，Jason，

我有一个二分类问题，其中类别不平衡。例如，72000 条记录属于一个类别，3000 条记录属于另一个类别。有没有办法在类别之间标记某种权重，以便给予较少见的类别更多的相关性？
我找到了 class_weights，但它不适用于 3D 数据。
您能给个解决问题的建议吗？

提前感谢！

回复
- Jason Brownlee 2019年3月9日上午6:29 #
  
  是的，我在那里有一些想法可能会有帮助
  https://machinelearning.org.cn/tactics-to-combat-imbalanced-classes-in-your-machine-learning-dataset/
  
  回复
  - Anista 2019年3月11日下午7:34 #
    
    谢谢你，Jason！
    
    回复
  - Anista 2019年3月13日下午8:15 #
    
    你好 Jason，
    我想知道您在上面的链接中提到的选项是否可以用于时间序列，因为其中一些选项会修改数据集的内容。我不确定该使用什么。
    谢谢你。
    
    回复
    - Jason Brownlee 2019年3月14日上午9:21 #
      
      不完全是，我预计您可能需要专门针对时间序列的方法。
      
      回复
      - Anista 2019年3月14日下午8:59 #
        
        我可以用什么专门的方法来解决时间序列的问题？
      - Jason Brownlee 2019年3月15日上午5:29 #
        
        抱歉，我没有太多关于时间序列分类的教程，我在那里有一些
        https://machinelearning.org.cn/start-here/#deep_learning_time_series
Archit Gupta 2019年3月27日上午8:17 #

你好 Jason，我喜欢您的教程来学习 ML，并且觉得您对我们非常有帮助。我注意到在这篇文章中您使用了 LabelEncoder。如果您使用这个，那么当您为类别标签分配值时，整数之间是否有意义，即模型会解释 0 < 1？

在其他地方阅读时，我看到当您拥有整数顺序不重要的标签时，您必须使用 OneHotEncoder。我不确定这是否有任何区别，如果您知道，请澄清。

https://medium.com/@contactsunny/label-encoder-vs-one-hot-encoder-in-machine-learning-3fc273365621

回复
- Jason Brownlee 2019年3月27日上午9:09 #
  
  是的，如果输入是整数编码的，模型可能会推断出值之间的顺序关系。
  
  如果不存在这种关系，则建议使用 OHE。
  
  回复
  - Archit Gupta 2019年3月28日上午4:20 #
    
    谢谢。:)
    
    回复
Jonathan 2019年4月4日下午8:15 #

嗨，Jason，

感谢您精彩的解释！

我有一个关于您代码中交叉验证部分的问题，它能很好地反映泛化误差。

使用交叉验证能否选择神经网络的正确权重？它是否类似于对逻辑回归使用 CV，从而选择正确的模型复杂度以达到偏差-方差权衡？ CV 对您的神经网络具体做了什么？

关于这个过程，我猜网络会在所有训练数据上进行训练。然后，网络可以在 10 个随机打乱的训练数据集（10 折 CV）上进行验证。我说对了吗？然后，我将获得分类性能的准确率分数及其标准差？

所以，如果我想在新数据上测试我的模型，那么我可以按照 Aakash Nain 和您之前提出的方法去做吗？

谢谢！

祝好，

Jonathan

回复
- Jason Brownlee 2019年4月5日上午6:16 #
  
  是的，我们可以使用 CV 来估计特定模型/配置的性能，就像我们对其他算法所做的那样。
  
  您可以在这里了解 CV 的工作原理
  https://machinelearning.org.cn/k-fold-cross-validation/
  
  如果您想进行预测，您必须先用所有可用数据来拟合模型
  https://machinelearning.org.cn/train-final-machine-learning-model/
  
  然后使用该模型进行预测
  https://machinelearning.org.cn/how-to-make-classification-and-regression-predictions-for-deep-learning-models-in-keras/
  
  回复
  - Jonathan 2019年4月5日下午7:04 #
    
    谢谢你，Jason。
    
    另一个问题，使用 75% 的数据进行训练和 CV，然后用剩余的 25% 来测试我的模型是否有意义？
    
    我正在为分类目的制作 MLP。在我的案例中，进行 CV 将评估性能。但是，如果我想将模型设为未见过的数据，使用单独的测试集会更好，对吗？
    
    谢谢！
    
    Jonathan
    
    回复
    - Jason Brownlee 2019年4月6日上午6:45 #
      
      也许吧。这 realmente 取决于问题以及 25% 的数据对更广泛问题的代表性如何。如果太少，可能会产生误导性/过于乐观的结果。
      
      回复
Radek 2019年4月27日上午12:41 #

你好，

为什么这里没有使用 .fit() 方法？

回复
- Jason Brownlee 2019年4月27日上午6:34 #
  
  我们正在使用 sklearn 包装器。
  
  回复
  - Radek 2019年4月27日上午9:52 #
    
    谢谢 :)。还有一个问题，因为可能是我眼花了。我看到数据集与模型相关联的唯一方式是通过交叉验证，它获取 X 和 encoded_Y。我在这里错过了什么？
    
    R
    
    回复
    - Jason Brownlee 2019年4月28日上午6:53 #
      
      模型学会将输入映射到输出。
      
      大多数模型通过获取输入、进行预测、将预测与期望值进行比较，然后更新模型使其预测更接近期望值来实现这一点。重复此过程。
      
      这有帮助吗？
      
      回复
Radek 2019年4月29日下午11:45 #

Jason，

确实如此——这个模型的内部工作原理很清楚。我想知道如果您有一个函数形式的模型，您将如何序列化它？

回复
- Jason Brownlee 2019年4月30日上午6:59 #
  
  您必须直接使用 Keras API 才能保存模型
  https://machinelearning.org.cn/save-load-keras-deep-learning-models/
  
  回复
erik 2019年6月27日上午11:58 #

我有一个混合数据集（分类和数值特征）。这个方法是否适用于此类数据？

回复
- Jason Brownlee 2019年6月27日下午2:17 #
  
  是的，尽管您可能需要先对分类数据进行整数编码或独热编码。
  
  回复
Tristan 2019年7月6日上午2:33 #

为什么在这个数据集中使用准确率来评估模型？它不是一个不平衡的数据集吗？

回复
- Jason Brownlee 2019年7月6日上午8:43 #
  
  它是不平衡的，但并不严重。只要将准确率与基线/朴素结果进行比较，它是合理的。
  
  回复
erik 2019年7月9日下午12:02 #

如何确定用于构建我们层的神经元数量？它取决于特征的数量吗？假设我有 40 个特征……最佳的神经元数量应该是多少？

回复
- Jason Brownlee 2019年7月10日上午7:56 #
  
  这是我在这里回答的一个常见问题
  https://machinelearning.org.cn/faq/single-faq/how-many-layers-and-nodes-do-i-need-in-my-neural-network
  
  回复
Anuj Bhambri 2019年7月23日上午9:24 #

嘿

如何对具有 128 列的 600 万个二进制数据实现神经网络？
我的意思是单位、激活函数、批量大小和周期会是什么？

提前感谢

回复
- Jason Brownlee 2019年7月23日下午2:40 #
  
  从数据集的一个较小样本开始，更多细节请参见此处
  https://machinelearning.org.cn/faq/single-faq/how-to-i-work-with-a-very-large-dataset
  
  回复
Olivier 2019年7月31日下午10:31 #

嗨，Jason，

我读过您很多帖子，都很精彩，恭喜！

我有一个关于 Keras/TF 中二分类使用 binary_crossentropy + sigmoid 概率输出的问题

我反复读到这是获得真实（校准）概率输出的方法。

为了验证这一点，我将校准曲线应用于我的模型，概率结果并不符合我的预期。特别是，我不理解训练数据上不会给出近乎完美的曲线。

用于训练数据校准曲线的伪代码
model.fit(X, Y, epochs=nb_epochs, batch_size=5, verbose=2)
..
predictions = model.predict_classes(X)
…
calibration_curve(Y, predictions, n_bins=100)

您可以在此处找到结果（带有测试集校准曲线）
https://we.tl/t-WwJKqXQFVB

我想知道您对此有什么建议。

提前感谢

回复
- Jason Brownlee 2019年8月1日上午6:51 #
  
  也许这篇教程将有助于校准模型预测的概率
  https://machinelearning.org.cn/calibrated-classification-model-in-scikit-learn/
  
  回复
Hamed 2019年9月4日上午5:01 #

你好 Jason，又一篇很棒的教程，谢谢！不过，我在这里有两个问题

1）如果我的输出是一个 160×160 的二进制图像，其中包含面部地标，该怎么办？我可以使用这个模型，但输出应该是 160×160 = 25600 而不是只有一个神经元吗？

2）论文说他们使用了一个浅层 MLP 与 ReLU。这意味着他们的模型没有任何隐藏层。那么，我只需要将输入面部特征直接连接到输出层来构建地标掩码吗？

非常感谢。

回复
- Jason Brownlee 2019年9月4日上午6:04 #
  
  如果您在预测图像，您可能需要使用不同的模型，例如 U-Net。
  
  我不知道您在引用什么论文，也许可以联系作者？
  
  回复
  - Hamed 2019年9月4日上午8:28 #
    
    感谢您的建议，亲爱的 Jason。我会去了解的。这是论文
    
    “从面部身份特征合成归一化面部”
    
    他们使用 MLP 为中性面部创建面部地标。谢谢！
    
    回复
thomson 2019 年 9 月 28 日晚上 10:56 #

是否采用 LSTM 分类来实现回溯概念？

回复
- Jason Brownlee 2019 年 9 月 29 日上午 6:12 #
  
  抱歉，我不明白，你能详细说明一下吗？
  
  回复
krishna 2019 年 11 月 15 日下午 4:17 #

你好 Jason Brownlee
我对交叉折叠验证的指标计算有一些疑问。
在您的代码中，总准确率是通过以下方式获得的：

results = cross_val_score(estimator, X, encoded_Y, cv=kfold)

print(“基线：%.2f%% (%.2f%%)” % (results.mean()*100, results.std()*100))

我可以使用以下公式计算指标，例如（总准确率、误分类率、灵敏度、精确率和 F1 分数）吗？

from sklearn import metrics
from sklearn.model_selection import cross_val_predict
y_pred = cross_val_predict(estimator, X, encoded_Y, cv=kfold)
totacu=round((metrics.accuracy_score(encoded_Y,y_pred)*100),3)
totMisacu=round((1-metrics.accuracy_score(encoded_Y,y_pred))*100,3)
sensitivityVal=round((metrics.recall_score(encoded_Y,y_pred))*100,3)
precision=round((metrics.precision_score(encoded_Y,y_pred))*100,3);
f1score=round(2*((sensitivityVal*precision)/(sensitivityVal+precision)),2)

回复
- Jason Brownlee 2019 年 11 月 16 日上午 7:19 #
  
  请参阅此教程以获取其他指标
  https://machinelearning.org.cn/how-to-calculate-precision-recall-f1-and-more-for-deep-learning-models/
  
  回复
  - krishna 2019 年 11 月 18 日下午 4:35 #
    
    你好，Jason Brownlee。
    谢谢你的回复。
    在“https://machinelearning.org.cn/how-to-calculate-precision-recall-f1-and-more-for-deep-learning-models/”中，您提供了与训练-测试拆分数据相关的指标。
    
    对于交叉折叠验证
    kfold = StratifiedKFold(n_splits=10, shuffle=True)
    results = cross_val_score(estimator, X, encoded_Y, cv=kfold)
    我们如何计算诸如精确率、灵敏度和 F1 分数之类的指标。
    
    我尝试使用以下语法进行获取
    from sklearn import metrics
    from sklearn.model_selection import cross_val_predict
    y_pred = cross_val_predict(estimator, X, encoded_Y, cv=kfold)
    totacu=round((metrics.accuracy_score(encoded_Y,y_pred)*100),3)
    totMisacu=round((1-metrics.accuracy_score(encoded_Y,y_pred))*100,3)
    sensitivityVal=round((metrics.recall_score(encoded_Y,y_pred))*100,3)
    precision=round((metrics.precision_score(encoded_Y,y_pred))*100,3);
    f1score=round(2*((sensitivityVal*precision)/(sensitivityVal+precision)),2)
    
    这是有效的吗？
    请为交叉折叠验证过程提出正确的计算指标的方法
    
    回复
    - Jason Brownlee 2019 年 11 月 19 日上午 7:38 #
      
      您可以计算每个折叠的预测值的期望指标，然后报告所有折叠的平均值和标准差。
      
      回复
Svetlana 2019 年 12 月 24 日上午 4:42 #

嗨，Jason，

您的教程非常有帮助和信息量，感谢您制作所有教程并提供给我们。非常感谢！！

我有一些具体问题

1. 分层和 10 折 CV 是一样的还是不同的？我知道定义，但我总是想知道它们之间有什么区别。如果它们不同，那么如何对同一示例执行 10 折 CV？

2. 如何在独立/外部测试数据集上评估深度学习训练模型？大多数时候我看到教程将数据随机分为 70% 训练和 30% 测试。

谢谢。

回复
- Jason Brownlee 2019 年 12 月 24 日上午 6:47 #
  
  谢谢。
  
  不同。分层可确保每个折叠的类分布与源数据集相同。
  
  您可以使用训练/测试拆分进行深度学习，也可以使用交叉验证。选择权在您。
  
  我在博客上有两者的示例。
  
  回复
Nancy 2020 年 1 月 2 日上午 3:38 #

你好 Jason，

首先，非常感谢您提供如此出色的教程。如果我喜欢某个人的内容，那就是 Andrew Ng、Corey Schafer 和您的。真的很有帮助和信息量。

我有一个问题。
假设我的问题是一个二元分类问题，并且我已经对参数进行了超参数调整（例如每个层的神经元数量、学习率、dropout 等），那么我在代码中在哪里放入它们？您是否有关于此的教程？

谢谢。

回复
- Jason Brownlee 2020 年 1 月 2 日上午 6:45 #
  
  谢谢！
  
  Dense 对象是层，Dense() 的参数是节点的数量。
  
  听起来您正在询问 Keras API 中神经网络的基础知识，也许可以从这里开始
  https://machinelearning.org.cn/start-here/#deeplearning
  
  回复
Madhur Dheer 2020 年 1 月 4 日晚上 9:50 #

你好先生，

您能告诉我如何使用这个估计模型来评估测试数据集上的输出吗？

回复
- Jason Brownlee 2020 年 1 月 5 日上午 7:04 #
  
  您可以调用
  
  result = model.evaluate(testX)
  
  回复
chris 2020 年 1 月 9 日上午 4:48 #

如何找到被错误分类的数据？

回复
- Jason Brownlee 2020 年 1 月 9 日上午 7:32 #
  
  将预测与您拥有输出的数据集（例如测试集）上的预期输出进行比较，或者与您稍后将获得实际输出的数据集进行比较。
  
  回复
Shashank 2020 年 2 月 20 日下午 6:44 #

encoder = LabelEncoder()
encoder.fit(Y)
encoded_Y = encoder.transform(Y)
# 基线模型
def create_baseline()
# 创建模型
model = Sequential()
model.add(Dense(166, input_dim=166, activation=’sigmoid’))
model.add(Dense(1, activation=’sigmoid’))

# 编译模型
model.compile(loss=’binary_crossentropy’, optimizer=’adam’, metrics=[‘accuracy’])
return model
model.summary()

# 使用标准化数据集评估模型
estimator = KerasClassifier(build_fn=create_baseline, epochs=10, batch_size=5,verbose=0)
kfold = StratifiedKFold(n_splits=10, shuffle=True)
results = cross_val_score(estimator, X, encoded_Y, cv=kfold)
print(results)
print(kfold)
print(estimator)
print(“基线：%.2f%% (%.2f%%)” % (results.mean()*100, results.std()*100))

对于上面的代码，我需要打印 acc 和 loss 图，需要以正确的格式显示 Loss 和 Accuracy 图。（训练和验证均包含）模型的最终性能指标，包括验证准确率、损失、精确率、召回率、F1 分数。

我想知道在这种情况下，我应该使用什么作为 Xtrain、Xtest、Y train、Y_test。

谢谢

回复
- Jason Brownlee 2020 年 2 月 21 日上午 8:20 #
  
  也许这会有帮助。
  https://machinelearning.org.cn/how-to-calculate-precision-recall-f1-and-more-for-deep-learning-models/
  
  还有这个。
  https://machinelearning.org.cn/custom-metrics-deep-learning-keras-python/
  
  回复
Shashank Yadav 2020 年 2 月 21 日上午 3:32 #

您能也帮我处理 tensorboard 吗？

from tensorflow.python.keras.callbacks import TensorBoard
tensorboard = TensorBoard(log_dir=”logs/{}”.format(time()))
我使用了上面的代码，但无法调用 tensorboard 并且无法指定路径？

当我使用 model.save 为 H5 时，我得到 model is not defined。

from keras.models import load_model
model.save_weights(‘model_weights.h5’)
model.save(‘my_model.h5’)
model = load_model(‘my_model.h5’)

回复
- Jason Brownlee 2020 年 2 月 21 日上午 8:28 #
  
  抱歉，我对 tensorboard 不了解。
  
  请参阅此了解如何保存模型
  https://machinelearning.org.cn/save-load-keras-deep-learning-models/
  
  回复
Shashank Yadav 2020 年 2 月 22 日上午 3:37 #

@Jason Brownlee 非常感谢。
很高兴收到您的回复！！🙂

回复
- Jason Brownlee 2020 年 2 月 22 日上午 6:32 #
  
  不客气。
  
  回复
kiri 2020 年 6 月 28 日上午 6:17 #

你好
感谢您的本教程
这个数据的样本量足够训练 cnn 吗？
我该如何将相同的数据用于 cnn？我在您的网站上搜索过但一无所获。

回复
- Jason Brownlee 2020 年 6 月 29 日上午 6:21 #
  
  此数据集不适合 CNN，请参阅此
  https://machinelearning.org.cn/when-to-use-mlp-cnn-and-rnn-neural-networks/
  
  回复
Ferdinand Sonel 2020 年 10 月 24 日上午 6:24 #

你好，在这种情况下，数据集已经排序。列表顶部标记为 R，底部列表标记为 M。我想问一下，如果数据没有像这样排序，会发生什么？

很抱歉我的英语不好

回复
- Jason Brownlee 2020 年 10 月 24 日上午 7:13 #
  
  数据在分割为训练集和测试集之前已经被打乱。
  
  回复
  - Ferdinand Sonel 2020 年 10 月 26 日上午 7:15 #
    
    哦，我明白了
    谢谢你回答我的问题
    
    回复
    - Jason Brownlee 2020 年 10 月 26 日上午 7:34 #
      
      不客气。
      
      回复
Kassaye Akanie 2021 年 5 月 16 日下午 5:49 #

哦！！！！非常感谢，这很重要

回复
- Jason Brownlee 2021 年 5 月 17 日上午 5:37 #
  
  不客气。
  
  回复
Vasilis 2022 年 12 月 10 日上午 1:58 #

你好 Jason，感谢您的精彩教程。不幸的是，它给了我一个错误，我无法继续。你能帮我吗？

“ValueError
所有10次拟合都失败了。
很可能你的模型配置错误。
你可以尝试将error_score='raise'设置为调试错误。

ps 命令
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
现在需要导入为
来自 keras.models import Sequential
from keras.layers import Dense

回复
- James Carmichael 2022 年 12 月 10 日上午 10:51 #
  
  你好 Vasilis… 非常欢迎！以下讨论可能会增加清晰度
  
  https://stackoverflow.com/questions/69005052/how-do-i-fix-fitfailedwarning-estimator-fit-failed-the-score-on-this-train-t
  
  回复
sajjad 2023 年 10 月 20 日晚上 8:27 #

嗨，Jason，
感谢您的精彩教程。

我需要在我的项目中_使用混淆矩阵，如何在代码中添加它？

你能帮我吗？

回复
- James Carmichael 2023 年 10 月 21 日上午 9:19 #
  
  你好 sajjad…以下资源可能对您感兴趣
  
  https://machinelearning.org.cn/confusion-matrix-machine-learning/
  
  回复

导航

使用 Keras 深度学习库的二元分类教程

1. 数据集描述

Python 深度学习需要帮助吗？

2. 基线神经网络模型性能

3. 使用数据准备重新运行基线模型

4. 调整模型中的层和神经元数量

4.1. 评估一个更小的网络

4.2. 评估一个更大的网络

总结

关于此主题的更多信息

198条对使用Keras深度学习库的二元分类教程的回复

留下回复点击此处取消回复。

导航

1. 数据集描述

Python 深度学习需要帮助吗？

2. 基线神经网络模型性能

3. 使用数据准备重新运行基线模型

4. 调整模型中的层和神经元数量

4.1. 评估一个更小的网络

4.2. 评估一个更大的网络

总结

关于此主题的更多信息

198条对使用Keras深度学习库的二元分类教程的回复

留下回复 点击此处取消回复。

留下回复点击此处取消回复。