用于多输出回归的深度学习模型

作者 Jason Brownlee 于 2020年8月28日发布在深度学习 170

多输出回归涉及预测两个或多个数值变量。

与为每个样本预测单个值的正常回归不同，多输出回归需要专门的机器学习算法来支持为每次预测输出多个变量。

深度学习神经网络是一个原生支持多输出回归问题的算法示例。可以使用Keras深度学习库轻松定义和评估多输出回归任务的神经网络模型。

在本教程中，您将了解如何为多输出回归开发深度学习模型。

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

多输出回归是一项预测建模任务，涉及两个或多个数值输出变量。
神经网络模型可以配置用于多输出回归任务。
如何评估多输出回归的神经网络并为新数据进行预测。

让我们开始吧。

Deep Learning Models for Multi-Output Regression

用于多输出回归的深度学习模型
照片由 Christian Collins 拍摄，保留部分权利。

教程概述

本教程分为三个部分；它们是：

多输出回归
多输出神经网络
多输出回归神经网络

多输出回归

回归是一项预测建模任务，涉及根据某些输入预测数值输出。

它不同于涉及预测类标签的分类任务。

通常，回归任务涉及预测单个数值。尽管如此，有些任务需要预测多个数值。这些任务被称为多输出回归，简称多输出回归。

在多输出回归中，每个输入样本需要两个或多个输出，并且需要同时输出。假设输出是输入的函数。

我们可以使用scikit-learn库中的make_regression()函数来创建合成的多输出回归数据集。

我们的数据集将有1,000个样本，其中10个输入特征，其中5个与输出相关，5个是冗余的。数据集将为每个样本提供三个数值输出。

下面列出了创建和总结合成多输出回归数据集的完整示例。

# example of a multi-output regression problem
from sklearn.datasets import make_regression
# create dataset
X, y = make_regression(n_samples=1000, n_features=10, n_informative=5, n_targets=3, random_state=2)
# summarize shape
print(X.shape, y.shape)

# 多输出回归问题的示例

from sklearn.datasets import make_regression

# 创建数据集

X, y = make_regression(n_samples=1000, n_features=10, n_informative=5, n_targets=3, random_state=2)

# 总结形状

print(X.shape, y.shape)

运行此示例将创建数据集并总结输入和输出元素的形状。

我们可以看到，正如预期的那样，有1,000个样本，每个样本有10个输入特征和三个输出特征。

(1000, 10) (1000, 3)

1	(1000, 10) (1000, 3)

接下来，让我们看看如何为多输出回归任务开发神经网络模型。

多输出神经网络

许多机器学习算法都支持原生多输出回归。

流行的例子是决策树和决策树的集成。决策树在多输出回归方面的局限性在于，输入和输出之间的关系可能基于训练数据而呈现块状或高度结构化。

神经网络模型也支持多输出回归，并且具有学习连续函数的优点，该函数可以模拟输入和输出变化之间更平滑的关系。

神经网络可以直接支持多输出回归，只需将问题中的目标变量数量指定为输出层中的节点数即可。例如，一个有三个输出变量的任务需要一个输出层节点数为三个的神经网络输出层，每个节点都具有线性（默认）激活函数。

我们可以使用Keras深度学习库来演示这一点。

我们将为上一节定义的多输出回归任务定义一个多层感知器（MLP）模型。

每个样本有10个输入和3个输出，因此，网络需要一个输入层，该输入层通过第一个隐藏层中的“input_dim”参数期望10个输入，并在输出层中有三个节点。

我们将使用流行的ReLU作为隐藏层的激活函数。隐藏层有20个节点，这些节点是在经过一些试错后选择的。我们将使用平均绝对误差（MAE）损失和随机梯度下降的Adam版本来拟合模型。

下面列出了多输出回归任务的网络定义。

...
# define the model
model = Sequential()
model.add(Dense(20, input_dim=10, kernel_initializer='he_uniform', activation='relu'))
model.add(Dense(3))
model.compile(loss='mae', optimizer='adam')

...

# 定义模型

model = Sequential()

model.add(Dense(20, input_dim=10, kernel_initializer='he_uniform', activation='relu'))

model.add(Dense(3))

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

您可能希望为自己的多输出回归任务调整此模型，因此我们可以创建一个函数来定义并返回模型，其中输入变量数量和输出变量数量作为参数提供。

# get the model
def get_model(n_inputs, n_outputs):
	model = Sequential()
	model.add(Dense(20, input_dim=n_inputs, kernel_initializer='he_uniform', activation='relu'))
	model.add(Dense(n_outputs))
	model.compile(loss='mae', optimizer='adam')
	return model

# 获取模型

def get_model(n_inputs, n_outputs):

model = Sequential()

model.add(Dense(20, input_dim=n_inputs, kernel_initializer='he_uniform', activation='relu'))

model.add(Dense(n_outputs))

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

return model

现在我们已经熟悉了如何为多输出回归定义MLP，让我们探讨一下如何评估这个模型。

多输出回归神经网络

如果数据集很小，那么对同一数据集反复评估神经网络模型并报告多次重复的平均性能是一个好习惯。

这是因为学习算法的随机性。

此外，使用k折交叉验证而不是数据集的训练/测试拆分，以获得对新数据进行预测的模型性能的无偏估计，这也是一个好习惯。同样，只有在数据量不大且过程可以在合理的时间内完成的情况下。

考虑到这一点，我们将使用重复的k折交叉验证（10折，3次重复）来评估多输出回归任务的MLP模型。

在每个折叠中，模型都会被定义、拟合和评估。收集得分，并通过报告均值和标准差来总结。

下面的evaluate_model()函数接受数据集，评估模型，并返回评估得分列表，在本例中是MAE得分。

# evaluate a model using repeated k-fold cross-validation
def evaluate_model(X, y):
	results = list()
	n_inputs, n_outputs = X.shape[1], y.shape[1]
	# define evaluation procedure
	cv = RepeatedKFold(n_splits=10, n_repeats=3, random_state=1)
	# enumerate folds
	for train_ix, test_ix in cv.split(X):
		# prepare data
		X_train, X_test = X[train_ix], X[test_ix]
		y_train, y_test = y[train_ix], y[test_ix]
		# define model
		model = get_model(n_inputs, n_outputs)
		# fit model
		model.fit(X_train, y_train, verbose=0, epochs=100)
		# evaluate model on test set
		mae = model.evaluate(X_test, y_test, verbose=0)
		# store result
		print('>%.3f' % mae)
		results.append(mae)
	return results

# 使用重复k折交叉验证评估模型

def evaluate_model(X, y):

results = list()

n_inputs, n_outputs = X.shape[1], y.shape[1]

# 定义评估过程

cv = RepeatedKFold(n_splits=10, n_repeats=3, random_state=1)

# 列举折叠

for train_ix, test_ix in cv.split(X):

# 准备数据

X_train, X_test = X[train_ix], X[test_ix]

y_train, y_test = y[train_ix], y[test_ix]

# 定义模型

model = get_model(n_inputs, n_outputs)

# 拟合模型

model.fit(X_train, y_train, verbose=0, epochs=100)

# 在测试集上评估模型

mae = model.evaluate(X_test, y_test, verbose=0)

# 存储结果

print('>%.3f' % mae)

results.append(mae)

return results

我们可以加载数据集并评估模型，然后报告平均性能。

将这些结合起来，完整的示例列在下面。

# mlp for multi-output regression
from numpy import mean
from numpy import std
from sklearn.datasets import make_regression
from sklearn.model_selection import RepeatedKFold
from keras.models import Sequential
from keras.layers import Dense

# get the dataset
def get_dataset():
	X, y = make_regression(n_samples=1000, n_features=10, n_informative=5, n_targets=3, random_state=2)
	return X, y

# get the model
def get_model(n_inputs, n_outputs):
	model = Sequential()
	model.add(Dense(20, input_dim=n_inputs, kernel_initializer='he_uniform', activation='relu'))
	model.add(Dense(n_outputs))
	model.compile(loss='mae', optimizer='adam')
	return model

# evaluate a model using repeated k-fold cross-validation
def evaluate_model(X, y):
	results = list()
	n_inputs, n_outputs = X.shape[1], y.shape[1]
	# define evaluation procedure
	cv = RepeatedKFold(n_splits=10, n_repeats=3, random_state=1)
	# enumerate folds
	for train_ix, test_ix in cv.split(X):
		# prepare data
		X_train, X_test = X[train_ix], X[test_ix]
		y_train, y_test = y[train_ix], y[test_ix]
		# define model
		model = get_model(n_inputs, n_outputs)
		# fit model
		model.fit(X_train, y_train, verbose=0, epochs=100)
		# evaluate model on test set
		mae = model.evaluate(X_test, y_test, verbose=0)
		# store result
		print('>%.3f' % mae)
		results.append(mae)
	return results

# load dataset
X, y = get_dataset()
# evaluate model
results = evaluate_model(X, y)
# summarize performance
print('MAE: %.3f (%.3f)' % (mean(results), std(results)))

# 用于多输出回归的MLP

from numpy import mean

from numpy import std

from sklearn.datasets import make_regression

from sklearn.model_selection import RepeatedKFold

from keras.models import Sequential

from keras.layers import Dense

# 获取数据集

定义获取_数据集():

X, y = make_regression(n_samples=1000, n_features=10, n_informative=5, n_targets=3, random_state=2)

返回 X, y

# 获取模型

def get_model(n_inputs, n_outputs):

model = Sequential()

model.add(Dense(20, input_dim=n_inputs, kernel_initializer='he_uniform', activation='relu'))

model.add(Dense(n_outputs))

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

return model

# 使用重复k折交叉验证评估模型

def evaluate_model(X, y):

results = list()

n_inputs, n_outputs = X.shape[1], y.shape[1]

# 定义评估过程

cv = RepeatedKFold(n_splits=10, n_repeats=3, random_state=1)

# 列举折叠

for train_ix, test_ix in cv.split(X):

# 准备数据

X_train, X_test = X[train_ix], X[test_ix]

y_train, y_test = y[train_ix], y[test_ix]

# 定义模型

model = get_model(n_inputs, n_outputs)

# 拟合模型

model.fit(X_train, y_train, verbose=0, epochs=100)

# 在测试集上评估模型

mae = model.evaluate(X_test, y_test, verbose=0)

# 存储结果

print('>%.3f' % mae)

results.append(mae)

return results

# 加载数据集

X, y = get_dataset()

# 评估模型

results = evaluate_model(X, y)

# 总结性能

print('MAE: %.3f (%.3f)' % (mean(results), std(results)))

运行此示例会为每次折叠和每次重复报告MAE，以了解评估进度。

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

最后，报告了平均和标准差MAE。在这种情况下，模型显示出大约8.184的MAE。

您可以将此代码作为模板，用于评估您自己的多输出回归任务的MLP模型。模型中的节点数和层数可以根据您数据集的复杂性轻松调整和定制。

...
>8.054
>7.562
>9.026
>8.541
>6.744
MAE: 8.184 (1.032)

...

>8.054

>7.562

>9.026

>8.541

>6.744

MAE: 8.184 (1.032)

一旦选择了模型配置，我们就可以使用它来在所有可用数据上拟合最终模型，并为新数据进行预测。

下面的示例通过首先在整个多输出回归数据集上拟合MLP模型，然后调用保存模型上的predict()函数来为新数据行进行预测来演示这一点。

# use mlp for prediction on multi-output regression
from numpy import asarray
from sklearn.datasets import make_regression
from keras.models import Sequential
from keras.layers import Dense

# get the dataset
def get_dataset():
	X, y = make_regression(n_samples=1000, n_features=10, n_informative=5, n_targets=3, random_state=2)
	return X, y

# get the model
def get_model(n_inputs, n_outputs):
	model = Sequential()
	model.add(Dense(20, input_dim=n_inputs, kernel_initializer='he_uniform', activation='relu'))
	model.add(Dense(n_outputs, kernel_initializer='he_uniform'))
	model.compile(loss='mae', optimizer='adam')
	return model

# load dataset
X, y = get_dataset()
n_inputs, n_outputs = X.shape[1], y.shape[1]
# get model
model = get_model(n_inputs, n_outputs)
# fit the model on all data
model.fit(X, y, verbose=0, epochs=100)
# make a prediction for new data
row = [-0.99859353,2.19284309,-0.42632569,-0.21043258,-1.13655612,-0.55671602,-0.63169045,-0.87625098,-0.99445578,-0.3677487]
newX = asarray([row])
yhat = model.predict(newX)
print('Predicted: %s' % yhat[0])

# 使用MLP进行多输出回归预测

from numpy import asarray

from sklearn.datasets import make_regression

from keras.models import Sequential

from keras.layers import Dense

# 获取数据集

定义获取_数据集():

X, y = make_regression(n_samples=1000, n_features=10, n_informative=5, n_targets=3, random_state=2)

返回 X, y

# 获取模型

def get_model(n_inputs, n_outputs):

model = Sequential()

model.add(Dense(20, input_dim=n_inputs, kernel_initializer='he_uniform', activation='relu'))

model.add(Dense(n_outputs, kernel_initializer='he_uniform'))

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

return model

# 加载数据集

X, y = get_dataset()

n_inputs, n_outputs = X.shape[1], y.shape[1]

# 获取模型

model = get_model(n_inputs, n_outputs)

# 在所有数据上拟合模型

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

# 为新数据进行预测

row = [-0.99859353,2.19284309,-0.42632569,-0.21043258,-1.13655612,-0.55671602,-0.63169045,-0.87625098,-0.99445578,-0.3677487]

newX = asarray([row])

yhat = model.predict(newX)

print('Predicted: %s' % yhat[0])

运行此示例会拟合模型并为新行进行预测。

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

正如预期的那样，预测包含多输出回归任务所需的三个输出变量。

Predicted: [-152.22713 -78.04891 -91.97194]

1	Predicted: [-152.22713 -78.04891 -91.97194]

进一步阅读

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

总结

在本教程中，您了解了如何为多输出回归开发深度学习模型。

具体来说，你学到了：

多输出回归是一项预测建模任务，涉及两个或多个数值输出变量。
神经网络模型可以配置用于多输出回归任务。
如何评估多输出回归的神经网络并为新数据进行预测。

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

关于此主题的更多信息

使用Prophet在Python中进行时间序列预测

深度学习多标签分类

170条对深度学习模型用于多输出回归的回复

Doru 2020年8月28日晚上7:30 #

执行时会生成以下错误

File “C:\ProgramData\Anaconda3\lib\site-packages\keras\backend\tensorflow_backend.py”, line 703, in is_tensor
return isinstance(x, tf_ops._TensorLike) or tf_ops.is_dense_tensor_like(x)

AttributeError: module ‘tensorflow.python.framework.ops’ has no attribute ‘_TensorLike’

如何解决？

回复
- Jason Brownlee 2020年8月29日早上7:59 #
  
  很遗憾听到这个，也许可以确认一下您的Keras和TensorFlow版本是最新的
  https://machinelearning.org.cn/setup-python-environment-machine-learning-deep-learning-anaconda/
  
  这里的提示也可能有帮助
  https://machinelearning.org.cn/faq/single-faq/why-does-the-code-in-the-tutorial-not-work-for-me
  
  回复
Doru 2020年8月28日晚上8:50 #

你好
运行此示例时，我得到以下错误

AttributeError: module ‘tensorflow.python.framework.ops’ has no attribute ‘_TensorLike’

有解决方案吗？

回复
- Jason Brownlee 2020年8月29日早上8:00 #
  
  您正在使用什么版本的Keras和TensorFlow？
  
  您必须使用以下版本或更高版本
  
  tensorflow: 2.3.0 keras: 2.4.3
  
  1
  2
  
  tensorflow: 2.3.0
  keras: 2.4.3
  
  回复
fabou 2020年8月29日早上6:44 #

嗨，Jason，

您能否告诉我为什么在每次交叉验证折叠时都要编译模型？

回复
- Jason Brownlee 2020年8月29日早上8:08 #
  
  每个模型都需要从头开始训练新模型，以便在对样本外实例进行预测时建立模型性能的无偏估计。
  
  如果您是k折交叉验证的新手，可以在这里开始
  https://machinelearning.org.cn/k-fold-cross-validation/
  
  回复
  - fabou 2020年8月30日凌晨1:14 #
    
    我以为模型只需要实例化一次，然后传递给交叉验证循环。我猜我错过了什么……
    
    在下面我从您的一个优秀文章（为缺失值添加二元标志）中摘录的示例中，我理解模型被实例化了，并且此模型实例在每次交叉验证训练折叠上进行评估
    
    [步骤1] model = RandomForest()
    
    [步骤2] cv = RepeatedStratifiedKFold( n_splits = 10 , n_repeats = 3 )
    
    [步骤3] scores = cross_val_score( model , X , y , scoring = ‘accuracy’ , cv = cv , n_jobs = -1 )
    
    这里的每个训练折叠似乎都实例化了一个模型，然后对其进行评估，该模型对应于其测试折叠。
    
    这两种逻辑似乎不同……或者我错过了什么。
    
    回复
    - fabou 2020年8月30日凌晨1:36 #
      
      我测试了将模型传递给评估函数
      
      def evaluate_model( model , X , y )
      
      results = list()
      
      n_inputs = X.shape[ 1 ]
      
      n_outputs = y.shape[ 1 ]
      
      cv = RepeatedKFold( n_splits = 10 , n_repeats = 1 , random_state = 999 )
      
      for train_ix, test_ix in cv.split( X )
      
      X_train, X_test = X[train_ix], X[test_ix]
      
      y_train, y_test = y[train_ix], y[test_ix]
      
      model.fit( X_train , y_train , verbose = 0 , epochs = 100 )
      
      mae = model.evaluate( X_test , y_test , verbose = 0 )
      
      results.append( mae )
      
      print( f’mae : {mae:.3f}’ )
      
      return results
      
      mae持续下降……我不明白为什么…
      
      回复
      - Jason Brownlee 2020年8月30日早上6:42 #
        
        这是无效的，因为您在每次循环中继续训练同一个模型。
        
        模型必须在每次交叉验证循环中重新定义和重新拟合，否则评估会过于乐观。
    - Jason Brownlee 2020年8月30日早上6:41 #
      
      这同样有效。
      
      在这种情况下，模型会在每次交叉验证折叠时新建并拟合。您只是看不到它，因为它发生在函数内部。
      
      回复
      - fabou 2020年8月30日下午4:58 #
        
        好的。我以为模型只创建一次，然后拟合到每个交叉验证折叠。
        
        我做了一些实验。
        
        cv = RepeatedStratifiedKFold( n_splits = 10 , n_repeats = 1 , random_state = 777 )
        
        然后 [ A ]
        
        > scores_A = []
        
        > for train_ix , test_ix in cv.split( X , y )
        
        > X_train , X_test = X[ train_ix , : ] , X[ test_ix , : ]
        
        > y_train , y_test = y[ train_ix ] , y[ test_ix ]
        
        > model = AdaBoostClassifier()
        
        > model.fit( X_train , y_train )
        
        > y_test_pred = model.predict( X_test )
        
        > score = roc_auc_score( y_test , y_test_pred )
        
        > print( f’score : {score}’ )
        
        > scores_A.append( score )
        
        之后 [ B ]
        
        > scores_B = []
        
        > model = AdaBoostClassifier()
        
        > for train_ix , test_ix in cv.split( X , y )
        
        > X_train , X_test = X[ train_ix , : ] , X[ test_ix , : ]
        
        > y_train , y_test = y[ train_ix ] , y[ test_ix ]
        
        > #model = AdaBoostClassifier()
        
        > model.fit( X_train , y_train )
        
        > y_test_pred = model.predict( X_test )
        
        > score = roc_auc_score( y_test , y_test_pred )
        
        > print( f’score : {score}’ )
        
        > scores_B.append( score )
        
        与 [ A ] 和 [ B ] 之间的区别在于，在 [ B ] 中模型只实例化一次，而在 [ A ] 中，模型为每个折叠重新创建。
        
        scores_A 和 _B 相同（即使我更改了 RepeatedStratifiedKFold 的随机状态参数和/或使用的模型：RandomForest……）。
        
        这个实验让我觉得模型应该只创建一次，然后拟合到每个交叉验证折叠。
        
        对我来说，model_A = AdaBoostClassifier() 和 model_B = AdaBoostClassifier() 之间的唯一区别是它们的内存位置，这就是为什么我不明白为什么在 evaluate_model 函数中调用 get_model 函数……
        
        PS
        
        我无法复制分数
        
        > cross_val_score( model , X , y , scoring = ‘roc_auc’ , cv = cv , n_jobs = -1 )
      - Jason Brownlee 2020年8月31日早上6:09 #
        
        交叉验证过程要求每次评估都要重新拟合模型。
        
        在内部，cross_val_score 会克隆模型并在每次迭代时从头开始重新拟合。这在功能上等同于每次迭代重新定义和重新拟合。
Sam 2020年8月29日早上7:42 #

嗨 Jason，

只是出于好奇，为什么您会构建一个多输出模型而不是多个单输出模型？何时会更好/更糟？

回复
- Jason Brownlee 2020年8月29日早上8:11 #
  
  两种都试试，看看哪种最适合您的特定数据集。
  
  回复
  - Vania 2021年6月26日下午2:08 #
    
    Jason您好。如何将这些代码应用于特定数据集？因为您使用的是随机值。
    
    回复
    - Jason Brownlee 2021年6月27日早上4:36 #
      
      这将帮助您加载数据集
      https://machinelearning.org.cn/load-machine-learning-data-python/
      
      回复
Konstantinos 2020年9月4日早上8:54 #

嗨，Jason，

首先，恭喜您的网站以及您详尽的解释和示例。我非常感激！

我有一个问题想问您，因为我已经花了大量时间在网上搜索，但没有成功。我们如何处理目标变量存在部分真实值的情况？（例如，输出向量中包含一些NaN值）

到目前为止，我了解到如果您提供一个包含NaN的y_train，那么损失函数将无法正常工作。如果我们为每个输出变量提供一个损失函数（我认为keras允许通过loss=[‘mse’, ‘mse’, …]实现），那么理论上，我们可以通过过滤掉NaN值来忽略批次中某个输出变量的NaN值（实际上是让y_true和y_pred都等于0）。

问题在于，如果我们创建一个自定义损失函数并尝试在两个向量中将NaN替换为0，那么keras会抛出错误（我认为这与使用非TensorFlow函数过滤NaN有关，因此keras无法计算损失函数的导数）

您能否想到一个优雅的解决方案？或者一个完全不同的方法？（我假设这种方法在优化方面是合理的）

提前感谢您的时间！

回复
- Jason Brownlee 2020年9月4日下午1:36 #
  
  谢谢！
  
  通常使用统计数据或模型替换缺失的输入值。
  
  对于某些模型，您可以为缺失值标记一个特殊值，并允许模型将缺失值视为另一个值。
  
  此外，您还可以为某些模型标记缺失值，并配置它们忽略这些值，例如神经网络中的掩码层。
  
  希望这些能给你一些思路。
  
  回复
  - Konstantinos 2020年9月4日晚上7:21 #
    
    嗨，Jason，
    
    谢谢你的回复。
    
    在这种情况下，输入并非缺失，我也无法真正使用任何统计数据来学习缺失的目标。
    
    关于特殊值，我在 Keras 中没有看到任何相关的内容。您知道这样的符号吗？
    
    另外，我查看了掩码层，但这仍然只针对输入。这不会影响损失函数中的 y_true。
    
    总的来说，这似乎是一个简单的问题，但又没有简单的解决方案……
    也许我需要研究一下人们如何处理多标签分类中的缺失标签。
    
    希望我很快能弄明白！
    
    回复
    - Jason Brownlee 2020 年 9 月 5 日上午 6:45 #
      
      您可以在输出（yhat）中使用零填充，然后在处理输出或评估预测时手动忽略零填充的值。
      
      这在自然语言处理的 seq2seq 问题中非常常见。
      
      回复
  - Ali 2023 年 4 月 15 日上午 9:40 #
    
    嗨 Jason
    
    我的数据集有 4200 个输入值。我需要两个输出（回归）。
    我曾分别尝试过单输出，并在测试集上获得了 0.999 的 R2 分数和预测。
    
    但使用函数式 API，最好只能获得 0.71 的 R2 分数。
    
    我想知道限制是什么？这是怎么发生的？
    
    回复
    - James Carmichael 2023 年 4 月 16 日上午 9:28 #
      
      你好 Ali……你可能正在处理一个回归问题并实现了零预测误差。
      
      或者，你可能正在处理分类问题并实现 100% 的准确率。
      
      这很不寻常，原因有很多，包括：
      
      你不小心在训练集上评估了模型性能。
      你的保留数据集（训练集或验证集）太小或不具代表性。
      你的代码中引入了一个错误，它正在做一些与你预期不同的事情。
      你的预测问题很容易或微不足道，可能不需要机器学习。
      最常见的原因是你的保留数据集太小或不代表更广泛的问题。
      
      可以通过以下方法解决：
      
      使用 k 折交叉验证来估计模型性能，而不是训练/测试拆分。
      收集更多数据。
      使用不同的数据拆分进行训练和测试，例如 50/50。
      
      回复
robgonz 2020 年 9 月 5 日上午 9:03 #

这是一个很棒的用于回归的神经网络模型。我尝试使用均方对数误差作为损失，以便更好地解释结果。

现在，当你评估或使用评估时，如果设置了所需的重复次数，会有区别吗？还是只重复调用具有 2 或 3 次重复的评估函数？

只是对这个算法感到好奇，因为我以前从未尝试过重复 K 折交叉验证。

感谢分享 J。

回复
- Jason Brownlee 2020 年 9 月 6 日上午 6:01 #
  
  也许你可以将损失保持为 mse，并将平方对数误差作为指标？
  
  对于随机模型来说，重复 K 折交叉验证是一种很好的做法，前提是拟合成本不是太高。3 次重复是保守的，10 次或 30 次更好。
  
  更多信息在这里
  https://machinelearning.org.cn/repeated-k-fold-cross-validation-with-python/
  
  回复
Pratyay Mukherjee 2020 年 9 月 6 日下午 3:10 #

您能否解释一下 Keras 损失函数中的平均绝对误差是如何在多输出向量上计算的？它是向量中对应值的平均值，然后对输出的维度和样本进行平均吗？

回复
- Jason Brownlee 2020 年 9 月 7 日上午 8:25 #
  
  我相信它是跨变量和样本的平均误差。
  
  回复
zeinab 2020 年 9 月 14 日晚上 10:35 #

你好
我有一个问题。
我的数据不依赖于时间
不是图像和视频
哪个深度学习模型更适合预测我的数据？
感谢您的指导。

回复
- Jason Brownlee 2020 年 9 月 15 日上午 5:24 #
  
  一个 MLP。
  
  另外，这将有所帮助。
  https://machinelearning.org.cn/when-to-use-mlp-cnn-and-rnn-neural-networks/
  
  回复
j.sanjay 2020 年 9 月 29 日上午 11:30 #

嗨，Jason，
你能做我的老师吗？

回复
- Jason Brownlee 2020 年 9 月 29 日下午 12:52 #
  
  我很乐意回答有关机器学习的问题。
  
  回复
Noodle 2020 年 10 月 7 日晚上 11:16 #

你好，谢谢你的教程。

如果目标仅仅是预测，那么拟合多输出神经网络而不是多个单输出神经网络有什么好处？在这种情况下有什么收益？是否有您推荐的论文或参考资料？

回复
- Jason Brownlee 2020 年 10 月 8 日上午 8:31 #
  
  这个问题将需要一个或多个输出。您必须使用实现项目目标的模型。
  
  回复
Davide 2020 年 10 月 9 日上午 4:44 #

你好，谢谢这篇文章！

我没有理解，一旦您完成了交叉验证步骤，您将如何选择一个配置而不是其他配置以对新数据进行预测。我的意思是，一旦所有循环完成，下一步该怎么做？

回复
- Jason Brownlee 2020 年 10 月 9 日上午 6:49 #
  
  看这里
  https://machinelearning.org.cn/make-predictions-scikit-learn/
  
  回复
  - Davide Mori 2020 年 10 月 9 日晚上 8:05 #
    
    好的，我想我明白了。
    根据您在这篇文章中的内容，我使用 k 折交叉验证来评估模型，并根据分数来相应地更改模型中的层及其参数。然后，我让我的网络在所有已用于验证的数据上进行学习，最后进行预测。
    总而言之，验证只是用来衡量我构建的模型性能，对吗？
    
    回复
    - Jason Brownlee 2020 年 10 月 10 日上午 7:05 #
      
      训练集用于拟合模型。
      测试集用于评估模型。
      验证集可用于调整模型或在正确的时间停止模型训练。
      
      更多信息在这里
      https://machinelearning.org.cn/difference-test-validation-datasets/
      
      回复
Urs 2020 年 10 月 10 日凌晨 12:42 #

对此感到好奇：使用“model.compile(loss=’mae’, optimizer=’adam’)”，我基本上是在指示 Keras 一起最小化两个输出值的组合损失。这平均了来自两个单独目标值的两个误差，这可能导致目标 1 出现大的正误差，而被目标 2 的大的负误差所抵消。

我想为了避免这种情况，我需要创建 2 个单独的子模型来单独优化每个损失——可能使用函数式 API？

回复
- Jason Brownlee 2020 年 10 月 10 日上午 7:07 #
  
  是的。
  
  另一种方法是使用两个输出和两个损失（所谓的“多输出模型”）的模型。
  https://machinelearning.org.cn/keras-functional-api-deep-learning/
  
  回复
Julm 2020 年 10 月 14 日凌晨 2:00 #

你好，我真的很欣赏你的内容！

我刚开始学习深度学习模型，并且有一个项目。

我想做的是，给定某些输入值（例如：10 个特征），我想预测一条曲线。我的意思是，我想获得一条二维曲线（其中 Y 轴是力，X 轴是时间）。“多输出回归”能解决这个问题吗？我将预测时间步长（t0=5，t1=16，t2=26……）。

在这种情况下我还可以使用哪些解决方案？

先谢谢了

回复
- Jason Brownlee 2020 年 10 月 14 日上午 6:22 #
  
  如果你想要一条曲线，那么也许可以直接进行曲线拟合。
  https://docs.scipy.org.cn/doc/scipy/reference/generated/scipy.optimize.curve_fit.html
  
  回复
pratyush 2020 年 10 月 22 日上午 4:41 #

我在我的数据集上测试了这一点，发现如果使用 iloc，它就能正常工作。例如：

X_train, X_test = X.iloc[train_ix], X.iloc[test_ix]
y_train, y_test = y.iloc[train_ix], y.iloc[test_ix]

回复
- Jason Brownlee 2020 年 10 月 22 日上午 6:51 #
  
  干得好！
  
  回复
Igor 2020 年 11 月 6 日下午 12:09 #

我能用它来预测 t+1、t+2 等吗？

回复
- Jason Brownlee 2020 年 11 月 6 日下午 1:15 #
  
  是的。
  
  回复
Luz N 2020 年 11 月 7 日下午 1:11 #

你好 Jason，对于多输出二元分类，这会怎么样？
例如，预测 t+1 是 0 还是 1，t+2 是 0 还是 1，t+3 是 0 还是 1。
1. 输出层：model.add(Dense(n_outputs, activation=’sigmoid’))？
2. 损失函数：‘binary_crossentropy’？

提前感谢。
很棒的教程！！！

回复
- Jason Brownlee 2020 年 11 月 8 日上午 6:37 #
  
  是的，我相信是这样。试试看。
  
  回复
Yuchen 2020 年 11 月 20 日上午 8:45 #

你好 Jason，首先，感谢你的精彩内容！我也在使用 MLP 进行多输出回归，但我发现当我测试模型时，输出总是与输入无关（训练阶段也发生过这种情况）。我已经标准化了输入数据，输入和输出的维度分别是 450 和 120，我还使用了 tanh 激活函数将输出限制在 [-1,1] 范围内。你对此有什么建议吗？先谢谢了：)

回复
- Jason Brownlee 2020 年 11 月 20 日下午 1:04 #
  
  这可能表明您的模型需要针对您的数据集进行进一步调整。
  
  这里的建议会有所帮助
  https://machinelearning.org.cn/start-here/#better
  
  回复
Chiedozie 2020 年 11 月 24 日凌晨 3:23 #

嘿 Jason，我真的很喜欢你在这里的作品。我正在处理一个数据集_1，其中这个数据集_1 的输出类别还有其他特征数据集，比如数据集_2，模型也可以从中学习。我面临的挑战是数据集_1 和数据集_2 完全不同，所以无法在某些共同特征上合并它们。
我想知道是否有办法训练一个模型，该模型能够先在数据集_1 上学习，然后依次在数据集_2 上学习？

我正在考虑使用降维技术将数据集_2 的特征减少为单个值，然后将这个单值作为数据集_1 的输出在多输出模型中使用。你觉得这是一个好方法吗？

回复
- Jason Brownlee 2020 年 11 月 24 日上午 6:21 #
  
  谢谢！
  
  尝试一下，并与其他方法进行比较。
  
  也许可以尝试集成它们的预测？
  
  回复
Goutam 2020 年 12 月 1 日下午 5:55 #

非常感谢这篇精彩的文章。我喜欢你的作品。我实际上需要关于多输出回归问题的建议。在这个问题中，输出是百分比。所有输出的总和必须为 1。
例如，我需要预测 3 个输出 A、B、C。每个输出的值都在 0 到 1 之间。例如：
A = 0.6, B = 0.3, C = 0.1 或 A = 1.0, B = 0.0, C = 0.0
所以，A+B+C 等于 1。我该如何处理这个问题？
提前感谢。

回复
- Jason Brownlee 2020 年 12 月 2 日上午 7:38 #
  
  谢谢！
  
  使用 softmax 激活。
  https://machinelearning.org.cn/softmax-activation-function-with-python/
  
  回复
Dinani 2020 年 12 月 12 日晚上 8:10 #

嗨
我很欣赏你的帖子。我有一个问题，如何确定隐藏层的数量及其密集层？它们与输入/输出的形状之间有什么关系吗？

回复
- Jason Brownlee 2020 年 12 月 13 日上午 6:00 #
  
  谢谢。
  
  好问题，我在这里回答
  https://machinelearning.org.cn/faq/single-faq/how-many-layers-and-nodes-do-i-need-in-my-neural-network
  
  回复
Joshua 2020 年 12 月 19 日上午 9:55 #

嗨，Jason，

绝对喜欢阅读这些简洁的教程。在使用网格搜索的多输出回归模型中有哪些可用指标？在编译模型时，除了[“Accuracy”]之外的任何其他指标都会导致错误。在这种情况下，准确性是 MAE 还是 R^2 值？

回复
- Jason Brownlee 2020 年 12 月 19 日下午 1:27 #
  
  谢谢。
  
  您可以使用相同的旧回归指标来表示总体误差或每个输出变量的误差。
  
  准确性不适用于回归，您可以使用 MSE、RMSE 或 MAE 作为常用误差指标。
  
  回复
Maha 2020 年 12 月 30 日上午 6:20 #

嗨
如果我想构建深度模型，输出将是 20 个元素的向量，每个元素将取两个可能值中的一个……我可以使用什么样的系统？有谁能帮助我解决这个问题？

回复
- Jason Brownlee 2020 年 12 月 30 日上午 6:46 #
  
  我建议测试一系列不同的模型，以发现最适合您数据集的模型。
  
  也许可以从一个简单的 MLP 开始。
  
  回复
  - Maha 2020 年 12 月 30 日上午 7:15 #
    
    谢谢回复。
    是否有 MLP 示例可以参考？
    
    回复
    - Jason Brownlee 2020 年 12 月 30 日上午 7:49 #
      
      是的，上面的教程正是关于这个的，即用于多输出回归的 MLP（多层感知机）。
      
      回复
Katherine 2021 年 1 月 5 日上午 6:10 #

你好，首先谢谢你的教程！在过去的几个月里，这个网站对我帮助很大，因为我开始将机器学习纳入我的研究。对于这个帖子，我的主要问题是为什么你选择 he_uniform 作为输出层的核初始化器。我知道它最适合 relu 激活，但我找不到任何说明它也应该用于线性激活的内容。也许你在这里有一个好的来源/原因？说实话，我找不到太多关于线性激活的最佳内置初始化器，所以我真的很好奇你的想法。

回复
- Jason Brownlee 2021 年 1 月 5 日上午 6:30 #
  
  不客气！
  
  它可能不应该用于线性激活。但可能不会造成太大影响。
  
  回复
  - Ramesh 2023 年 3 月 26 日上午 9:06 #
    
    你好，如何在我使用多个文本输入特征训练模型后获得多个文本输出？
    
    回复
    - James Carmichael 2023 年 3 月 26 日上午 10:23 #
      
      你好 Ramesh……你可能会发现以下资源很有趣。
      
      https://blog.paperspace.com/combining-multiple-features-outputs-keras/
      
      回复
Maha 2021 年 1 月 14 日上午 8:33 #

嗨
是否有基于将数据集划分为训练集和测试集的多输出回归的示例？

回复
- Jason Brownlee 2021 年 1 月 14 日上午 8:46 #
  
  这与单输出回归相同。
  https://machinelearning.org.cn/train-test-split-for-evaluating-machine-learning-algorithms/
  
  除非您有时间序列数据，否则这将有所帮助。
  https://machinelearning.org.cn/time-series-forecasting-supervised-learning/
  
  回复
Maha 2021 年 1 月 15 日上午 6:18 #

你好，
您提到如果数据集很小，可以使用 k 折进行评估……那么数据集很大的情况呢？例如，不是 1000，而是 5000 或 10000？

回复
- Jason Brownlee 2021 年 1 月 15 日上午 8:44 #
  
  这些仍然是小数据集，并且进行了 k 折交叉验证。
  
  不过，对于非常大的数据（数百万/数十亿样本）或样本量小但稳定/平稳的数据，您可以使用训练/测试分割。
  
  回复
  - Maha 2021 年 1 月 16 日上午 10:45 #
    
    好的……非常感谢 Jason。
    
    回复
Ladu Tandel 2021 年 1 月 20 日晚上 8:29 #

嗨，

我可以知道如何导入我的 Excel 数据而不是上面代码中自动生成的 x y 数据吗？

我想预测多个输出，上面的概念是一个很好的起点，但由于我刚开始学习编码，所以想得到关于如何导入我的 Excel 数据（包含多个 x 和多个 y）的帮助。

谢谢你
非常感谢您的帮助。

回复
- Jason Brownlee 2021 年 1 月 21 日上午 6:48 #
  
  将您的 Excel 文件保存为 CSV，然后将 CSV 加载为 numpy 数组。
  https://machinelearning.org.cn/load-machine-learning-data-python/
  
  回复
Sada Hussain 2021 年 1 月 27 日上午 5:21 #

用什么深度学习模型来预测作物产量、湿度、温度、pH 值和降雨量？

回复
Sean Murphy 2021 年 2 月 26 日上午 9:53 #

你好，只是好奇，如果它使用 Keras 的顺序 API，这个神经网络如何使用多个输入和输出？我在线上看到的所有信息都说需要函数式 API 才能处理多个输入和输出？谢谢！

回复
- Jason Brownlee 2021 年 2 月 26 日下午 1:27 #
  
  是的，如果您想使用单独的输入模型或输出模型，则需要函数式 API。
  
  要拥有向量输入或向量输出，可以直接使用顺序模型。
  
  回复
  - Sean Murphy 2021 年 2 月 27 日凌晨 3:34 #
    
    感谢您的回复，我非常感激。如果您不介意的话，能否解释一下使用“单独的输入模型”和仅使用“向量输入或向量输出”之间的区别？例如，我的数据有 5 个数值输入和 9 个数值输出。输入代表运算放大器的性能特性（例如增益和转换速率），输出是给出这些性能特性的晶体管的宽度。这些是向量输入和输出还是单独的模型？如果这是个愚蠢的问题，请原谅，这一切对我来说都很新。再次感谢您的帮助和这篇精彩的文章。
    
    回复
    - Jason Brownlee 2021 年 2 月 27 日上午 6:09 #
      
      单独的输入模型将是多个不相干的向量作为模型的输入，例如。
      
      您可以在此处查看带有单独输入模型的模型。
      https://machinelearning.org.cn/keras-functional-api-deep-learning/
      
      是的，您描述的是一个接受向量输入并预测向量输出的单个模型。如果您愿意，也可以将其建模为一个独立的“模型”来输出每个向量元素——如果这些元素不相关/无关，这可能是合理的。
      
      回复
Peter 2021 年 3 月 10 日上午 4:47 #

嗨，Jason，

我有一个关于多输出回归神经网络中激活函数的问题。我注意到您为输出选择了默认的线性函数，为隐藏层选择了 ReLU。

在我的案例中，我的输出可能是非常小的数字，而且预测值经常是负值，这在物理上没有意义。我该如何将输出限制为仅正值？回归模型是否需要线性输出，还是可以更改输出传递函数为 tansig、logsig 等？

谢谢！

回复
- Jason Brownlee 2021 年 3 月 10 日上午 6:26 #
  
  也许您可以使用 sigmoid 激活，然后将输出缩放到所需的范围。
  
  回复
Syed Khurram Mahmud 2021 年 3 月 17 日下午 6:42 #

你好！工作不错。
请在这里帮我。

yhat = model.predict(newX)

模型未定义。我认为其他部分工作正常。

为什么会出现这个错误？

回复
- Jason Brownlee 2021 年 3 月 18 日上午 5:17 #
  
  也许您遗漏了示例中的某些代码行，这会有所帮助。
  https://machinelearning.org.cn/faq/single-faq/why-does-the-code-in-the-tutorial-not-work-for-me
  
  回复
ali 2021 年 3 月 23 日下午 1:43 #

嗨，Jason，

太棒了！！非常感谢您的精彩教程。但是，我能否知道如何为开发可解释模型（例如多输出回归的排列特征重要性）开发解释器？

谢谢你

回复
- Jason Brownlee 2021 年 3 月 24 日上午 5:48 #
  
  抱歉，我无法帮助您进行模型解释——我没有这方面的主题教程。
  
  回复
Sepideh 2021 年 4 月 21 日上午 8:20 #

嗨，Jason，

您能否帮助我开发多输出分类神经网络？

谢谢

回复
- Jason Brownlee 2021 年 4 月 22 日上午 5:35 #
  
  请看这个例子
  https://machinelearning.org.cn/multi-class-classification-tutorial-keras-deep-learning-library/
  
  回复
Ayan Mitra 2021 年 4 月 29 日下午 6:37 #

嗨，Jason，
感谢这篇教程，它在我一个实际项目中帮助了我。
我有一个相关问题，请。
我有一组图像矩阵数据（例如，红色、绿色、蓝色、白色等），输出颜色由三个输入（x、y、z）（数值）决定。因此，数据看起来像这样（所有都是数值，没有分类）：

输入
X1,Y1,Z1 –> 蓝色矩阵（展平的 1D 数组）
X2,Y2,Z2 –> 红色矩阵
‘
‘
Xn,Yn,Zn –> 白色矩阵

现在我想构建一个 NN 回归模型，就像你在这里展示的那样，如果 [X,Y,Z] 是输入，它会预测整个颜色矩阵（或展平的 1D 数组）。

现在，我理解这个输出层将具有 shape = shape(1D 颜色矩阵)（类似于你示例中的 2）。我也明白输出层的 shape 远大于输入层的大小。

你能给我一些评论吗？这是否可行（技术上我不认为有什么不行）？你建议哪种算法是理想的。

谢谢

回复
- Jason Brownlee 2021 年 4 月 30 日上午 6:03 #
  
  也许模型可以预测一个类标签，然后你可以编写代码来创建矩阵——如果每个类标签都相同。
  
  回复
Ayoub AIT IDIR 2021 年 5 月 17 日上午 12:08 #

你好，

首先，感谢你给出如此精彩的解释，这非常有帮助。
我的问题是，我们是否可以使用 RNN 或 LSTM 来预测多个输出变量，因为我一直在搜索并发现 LSTM 可能是最佳选择，但没有找到任何实现可以开始。

谢谢你。

回复
- Jason Brownlee 2021 年 5 月 17 日上午 5:39 #
  
  不客气。
  
  是的，请看这个
  https://machinelearning.org.cn/faq/single-faq/how-do-you-use-lstms-for-multi-step-time-series-forecasting
  
  回复
Maha 2021 年 5 月 25 日上午 11:13 #

你好
我想知道 MAE 如何用于多输出回归的数值计算，如果你能给出数学方程以便于理解，那就太好了？
提前感谢

回复
- Jason Brownlee 2021 年 5 月 26 日上午 5:45 #
  
  平均绝对差值的平均值，更多信息请参见
  https://scikit-learn.cn/stable/modules/model_evaluation.html#mean-absolute-error
  
  回复
Samaneh Manavi 2021 年 5 月 26 日晚上 9:46 #

亲爱的 Jason,
感谢这个很好的教程。
我有一个复杂的多输出回归任务，其中输入元素和输出元素不是独立的。我已经通过试错设计了一个具有多层一维卷积的网络。我想知道您是否能为多输出回归问题推荐一个知名的网络架构。
我想，优化一个知名模型的超参数比从头开始设计它更有意义。

在此先感谢，
Samaneh

回复
- Jason Brownlee 2021 年 5 月 27 日上午 5:38 #
  
  我们无法知道哪种架构对数据集有效或效果最好，我建议测试一系列模型和模型配置，以发现最适合您特定数据集的方法。
  
  回复
sepideh 2021 年 6 月 17 日上午 3:48 #

你好，
我运行了这段代码：我有两个特征（输入）和 13 个输出，但我遇到了这个错误：
—————————————————————————
TypeError Traceback (most recent call last)
in
16 mae = model.evaluate(x_test, y_test, verbose=0)
17 # 存储结果
—> 18 print(‘>%.3f’ % mae)
19 results.append(mae)
20 return results

TypeError: must be real number, not list

######################################
def evaluate_model(x, y)
results = list()
n_inputs, n_outputs = x.shape[1], y.shape[1]
# 定义评估过程
cv = RepeatedKFold(n_splits=10, n_repeats=3, random_state=1)
# 枚举折
for train_ix, test_ix in cv.split(x)
# 准备数据
x_train, x_test = x[train_ix], x[test_ix]
y_train, y_test = y[train_ix], y[test_ix]
# 定义模型
model = build_regression(n_inputs, n_outputs)
# 拟合模型
model.fit(x_train, y_train, verbose=0, epochs=100)
# 在测试集上评估模型
mae = model.evaluate(x_test, y_test, verbose=0)
# 存储结果
print(‘>%.3f’ % mae)
results.append(mae)
return results

回复
- Jason Brownlee 2021 年 6 月 17 日上午 6:19 #
  
  很抱歉听到这个消息，这些提示可能会有所帮助
  https://machinelearning.org.cn/faq/single-faq/why-does-the-code-in-the-tutorial-not-work-for-me
  
  回复
Jean-Rassaire 2021 年 6 月 23 日上午 1:09 #

嗨，Jason Brownlee，
感谢您这个具有教学意义的模型。
我想知道如何将此代码保存在文件中。您有保存代码吗？

回复
- Jason Brownlee 2021 年 6 月 23 日上午 5:39 #
  
  不客气。
  
  这将帮助您保存代码。
  https://machinelearning.org.cn/faq/single-faq/how-do-i-copy-code-from-a-tutorial
  
  回复
Jean-Rassaire 2021 年 6 月 23 日晚上 10:30 #

谢谢 Jason Brownlee，但是对不起，那是一个愚蠢的问题。

回复
- Jason Brownlee 2021 年 6 月 24 日上午 6:02 #
  
  不客气。
  
  回复
Gireesh B 2021 年 7 月 15 日下午 4:38 #

嗨 Jason，我只想训练一个模型，它有一组数字输入和一组数字输出，而不知道它们（输入和输出）之间的关系。

回复
- Jason Brownlee 2021 年 7 月 16 日上午 5:21 #
  
  是的，这就是回归问题的定义。
  
  回复
Amn 2021 年 9 月 15 日上午 3:06 #

嗨，首先，非常感谢您的教程！我的问题是：我以学生 ID 作为样本，并希望预测未来的 3 个成绩来评估他们的表现，但问题是学生 ID 是重复的，因为他们有很多家庭作业和测验等等。我该如何单独预测每个学生的成绩？然后我想将这些预测的成绩保存在一个带有唯一学生 ID 的新文件中，以确定学生的表现。注意：学生 ID 的重复会因学生而异。有什么建议吗？预先感谢！

回复
- Adrian Tam 2021 年 9 月 15 日晚上 11:53 #
  
  学生 ID 是名义数据。不应将其输入模型。我建议您为每个学生 ID 创建一个向量，其中包含家庭作业和测验的成绩，并预测最终成绩。此向量中不应包含学生 ID。
  
  回复
wb 2021 年 9 月 15 日晚上 9:34 #

嗨，我买了一些您的书，它们都很棒。顺便问一下，对于多输出回归，每个输出是否有不同的权重和偏差？还是所有输出共享相同的 w 和 b？在这种情况下，多输出回归的性能如何与单独的单输出回归相比？

回复
- Adrian Tam 2021 年 9 月 16 日上午 12:53 #
  
  很可能是不同的，因为模型中没有任何东西可以强制它们相同（但如果您坚持，您可以构建一个这样的模型）。对于性能比较，我怀疑是否可能，因为这听起来像是在比较苹果和橘子。
  
  回复
Amn 2021 年 9 月 21 日上午 2:08 #

嗨，分类和回归之间有共享的度量吗？我想比较回归 NN 和分类 NN 的性能？

回复
- Adrian Tam 2021 年 9 月 21 日上午 9:32 #
  
  您在比较苹果和橘子。请注意，回归是关于预测具有实际意义的连续值。然而，分类是关于预测名义值，其中输出中的数字只是名称。这种巨大的差异导致一个度量在错误的问题上可能没有意义。
  
  回复
Paul 2021 年 11 月 10 日上午 2:21 #

首先，祝贺您的网站以及您详细的解释和示例。我真的很喜欢！

多输出回归涉及预测两个或多个数值变量。
在最后（# 使用重复的 k 折交叉验证评估模型）的加载数据集部分，出现了这个错误：

ValueError: 要解包的值太多 (预期为2)

您能告诉我可能是什么原因吗？

不胜感激。

回复
- Adrian Tam 2021 年 11 月 14 日下午 1:17 #
  
  我无法确切知道是什么，但这是触发此错误的方法：
  
  X, y = a, b, c
  
  1
  
  X, y = a, b, c
  
  在 Python 中，您可以使用如上所示的元组表示法在一行中进行多个赋值。但是，如果赋值两侧的元素数量不匹配，您就会收到“值过多，无法解包”的错误。
  
  回复
Ashiq 2022 年 1 月 26 日晚上 9:01 #

我们是否也可以为 RNN 和 CNN 开发多输出回归模型？如果可以，您是否有任何教程？

回复
Alice Mani 2022 年 2 月 7 日上午 1:58 #

嗨 Jason，感谢您有用的解释。我有一个我认为是多输出回归的问题。我想用 MLP 重构图像。我有 12000 个数据并创建了一个全连接层 NN。我的损失（MSE）在训练和验证时很低，但预测效果很差。当我归一化我的输入数据时，性能有所改善，但预测效果仍然不好，而且也不在地面真实值的尺度上。您能给我一些建议吗？

回复
- James Carmichael 2022 年 2 月 7 日下午 12:12 #
  
  嗨 Alice……有可能过拟合训练数据。
  
  这意味着模型正在学习训练数据集中特定的随机变化，代价是模型对新数据的泛化能力较差。
  
  这可以通过模型在训练数据集上进行预测的技能提高，而在测试数据集上进行预测的技能下降来观察。
  
  减少训练数据集过拟合可能性的一种良好通用方法是使用 k 折交叉验证来估计模型在新数据上进行预测的技能。
  
  除了使用 k 折交叉验证之外，第二种良好的通用方法是拥有一个留出测试集，该测试集仅在项目结束时使用一次，以帮助在最终模型之间进行选择。
  
  回复
  - Alice Mani 2022 年 2 月 8 日上午 1:09 #
    
    谢谢回复，但不幸的是，在训练数据上的预测也不好。
    
    回复
Alice Mani 2022 年 2 月 8 日上午 1:07 #

谢谢回复，但在训练数据集上的预测也不好。

回复
Ashiq 2022 年 2 月 25 日下午 5:11 #

我们如何为 RNN 和 CNN 开发多输出回归模型？如果可以，您是否有任何教程？

回复
Shan 2022 年 3 月 13 日晚上 7:24 #

如何添加另一个隐藏层？

回复
Shan 2022 年 3 月 13 日晚上 7:25 #

如何添加另外两个隐藏层？

回复
- James Carmichael 2022 年 3 月 14 日下午 11:58 #
  
  嗨 Shan……以下资源解释了如何在多层感知机模型中添加其他层
  
  https://machinelearning.org.cn/build-multi-layer-perceptron-neural-network-models-keras/
  
  回复
David 2022 年 3 月 16 日上午 1:28 #

你好！

很棒的教程！快速提问，目前我们对所有 3 个预测值都得到一个 MAE 值。我如何获得 3 个 MAE 值，每个预测值一个？

提前感谢！

回复
- James Carmichael 2022 年 3 月 16 日上午 10:44 #
  
  嗨 David……您可以在“追加”它之前将每个 MAE 捕获到一个变量中。
  
  mae = model.evaluate(X_test, y_test, verbose=0) # 存储结果
  print(‘>%.3f’ % mae)
  
  回复
Marianna 2022 年 4 月 5 日上午 10:47 #

你好。我想问你以下问题。

如果我们有一个具有 2 个目标的回归问题，我们在计算 L1Loss（或 Keras 中的 MAE）之前是否应该展平向量？

回复
- James Carmichael 2022 年 4 月 6 日上午 8:47 #
  
  嗨 Marianna……您可能会发现以下内容有益：
  
  https://moviecultists.com/why-flattening-is-used
  
  回复
  - Marianna 2022 年 4 月 8 日晚上 11:00 #
    
    谢谢您的回答。
    我发现它很有益，但在我的 2 个目标预测中，我想知道例如预测 p1 是与预测 p2 配对的，在 y.shape [1,2] 中。所以，我认为展平不是解决办法。
    
    另外一个我想问您的问题是，对于这个特定的例子，并考虑到归一化的目标 p1、p2 服从不同的分布（正态分布、幂律分布），在训练模型后，我发现 p1 的预测很好，但 p2 的预测却不好。似乎这些不同的目标具有不同的损失，而 p2 的损失更大。
    
    我应该采取哪些后续行动来改进 p2 目标（损失较大）的预测？
    
    感谢您的时间和考虑。
    
    回复
Putra 2022 年 4 月 6 日下午 12:22 #

嗨。我想问个问题。

我想用 3 个输入因子来预测某个变量，这 3 个因子会影响该变量，如何从 3 个因子创建输入数据？

回复
Indra 2022 年 4 月 23 日晚上 6:55 #

嗨，Jason，

我想问一个关于多输出模型的问题，我构建了一个多输出模型，在训练后，当我比较单个和多个输出模型时，多输出模型产生的损失非常大。我该怎么做才能让多输出模型具有更低的损失？是否可以分别运行多输出的优化器和损失？因为看起来损失的下降速度比单个输出慢。

回复
- James Carmichael 2022 年 4 月 24 日上午 3:19 #
  
  嗨 Indra，
  
  以下内容可能有助于阐明。
  
  https://machinelearning.org.cn/feature-selection-to-improve-accuracy-and-decrease-training-time/
  
  https://machinelearning.org.cn/classification-accuracy-is-not-enough-more-performance-measures-you-can-use/
  
  回复
KayD 2022 年 4 月 28 日上午 6:45 #

嗨，Jason，

很棒的文章，感谢您对该过程的详细解释。

我正在为 4 个目标变量构建一个多输出回归模型，使用表格数据作为输入。您推荐哪种类型的神经网络模型来处理此类问题？

此外，除了神经网络，您还推荐哪些其他模型用于此类场景？我想使用 XGB，但根据我的理解，它不支持多目标回归模型。

再次感谢！

您的评论正在等待审核。

回复
- James Carmichael 2022 年 5 月 2 日上午 9:31 #
  
  你好 KayD……以下内容可能对您感兴趣。
  
  https://machinelearning.org.cn/deep-learning-models-for-multi-output-regression/
  
  https://machinelearning.org.cn/multi-output-regression-models-with-python/
  
  回复
Shirsendu Mitra 2022 年 5 月 10 日晚上 11:01 #

嗨，Jason博士，

是否有可能开发一个机器学习模型，其中有多个输出（例如 10 到 20 个），并且这些输出是相互依赖的？我的意思是，对于一组特定的输入，会期望一种输出组合。

我有一个训练数据集，其中输入是图像，每个图像对应一个特定的输出向量。现在，如果我尝试使用这 1000 张图像作为训练集来预测相似和未知图像的输出向量。

您能否指导我如何处理此类问题？

回复
- James Carmichael 2022 年 5 月 13 日上午 1:23 #
  
  嗨 Shirsendu……以下内容可能对您感兴趣。
  
  https://machinelearning.org.cn/multi-output-regression-models-with-python/
  
  回复
Elias Siskos 2022 年 5 月 20 日上午 4:10 #

你好，我正在尝试开发一个预测手写字母的神经网络。我已经创建了我的数据集，现在我想拟合一个模型。
我的观点是我必须使用多输出回归，但不是使用数值。相反，我必须在输出层使用 sigmoid 激活函数。我说得对吗？
我该怎么做？你能帮帮我吗？

附言：我必须祝贺您迄今为止所做的出色工作。您可能是我看过的最好的网站（我看过太多了）。

回复
- James Carmichael 2022 年 5 月 20 日晚上 11:04 #
  
  嗨 Elias……您可能想考虑用于此任务的 CNN。
  
  使用卷积神经网络和 Python Keras 进行手写数字识别
  
  回复
Adrian 2022 年 8 月 9 日晚上 6:23 #

你好，
我尝试为 k 折交叉验证绘制两个学习曲线。它们旨在表示测试数据和验证数据。不幸的是，我没有成功实现 def evaluate_model(X, y)。有解决方案吗？
提前感谢您！

回复
- James Carmichael 2022 年 8 月 10 日上午 5:38 #
  
  嗨 Adrian……请说明您遇到的具体问题，以便我们更好地帮助您。
  
  回复
Oscar 2022 年 8 月 30 日上午 6:21 #

嗨 Jason 博士，

我正在尝试开发一个多输出回归模型（4 个输入，4 个输出）。到目前为止，我已经成功使用了神经网络算法（4-5-5-4 架构）；它是前馈的。我使用的是我从物理实验中收集的时间序列数据作为输入和由此产生的输出。

我现在正试图覆盖我的足迹，并将结果与使用其他可能适用的机器学习算法开发的模型进行比较。

您对可以探索的算法有什么建议吗？

我看到您在这篇文章中提到了“决策树和决策树的集成”（随机森林？）。还有其他的吗？

此致，

OLB

回复
- James Carmichael 2022 年 8 月 30 日上午 6:34 #
  
  嗨 Oscar……您可能想研究一下序列到序列预测模型。
  
  https://machinelearning.org.cn/develop-encoder-decoder-model-sequence-sequence-prediction-keras/
  
  回复
Cuong 2022 年 9 月 17 日下午 12:36 #

嗨 Jason 博士，

感谢您提供的有用课程。

当我运行您的代码时，出现了错误：“IndentationError: expected an indented block”，如下所示：

def evaluate_model(X, y)
results = list()
n_inputs, n_outputs = X.shape[1], y.shape[1]

def evaluate_model(X, y)
Input In [31]
def evaluate_model(X, y)
^
IndentationError: 期望一个缩进块

请告诉我原因和如何修复。

谢谢你。

回复
WDDouble 2022 年 10 月 5 日下午 1:48 #

嗨，我有一个训练数据集，其训练数据是一条曲线（x 轴是频率），上面有 50,000 个点，对于每条曲线，我有超过 100 个相应的参数/标签。我想训练一个模型，以便为每条曲线回归这些数百个参数。

我想到的第一件事是使用 mlp……您有什么建议吗？

谢谢你

回复
- James Carmichael 2022 年 10 月 6 日上午 7:12 #
  
  嗨 WDDouble……MLP 将是您描述的回归的一个很好的起点。以下资源可能有助于阐明何时使用各种模型类型。
  
  https://machinelearning.org.cn/when-to-use-mlp-cnn-and-rnn-neural-networks/
  
  回复
Aref 2022 年 10 月 26 日上午 4:53 #

亲爱的 Jason,

感谢分享如此有用的信息，并有清晰的描述。它对我帮助很大。

我有一个重要的项目相关问题。我必须为每 10 个输入值定义 10 个权重，以便每个输入特征都有指定的权重，并且损失函数应该通过考虑这些特征的权重来最小化成本。这意味着权重最高的特征在最小化误差方面具有更高的优先级。

让我更详细地描述一下。

假设我们为 10 个输入特征定义了 1 到 5 的权重范围。

输入特征权重
1 5
2 3
3 4
4 4
5 3
6 1
7 5
8 2
9 1
10 2

如何为每个元素设置自定义加权损失函数？

回复
- James Carmichael 2022 年 10 月 26 日上午 7:06 #
  
  嗨 Aref……以下资源可能对您感兴趣：
  
  https://stackoverflow.com/questions/62059060/how-to-set-custom-weights-in-layers
  
  回复
Aref 2022 年 10 月 26 日上午 5:25 #

亲爱的 Jason,

如果您在此处提供定义自定义加权损失函数的代码，我将不胜感激。

回复
- James Carmichael 2022 年 10 月 26 日上午 7:04 #
  
  感谢您的推荐 Aref！
  
  回复
Aref 2022 年 10 月 26 日上午 8:24 #

伙计们，

我不明白为什么我的问题在几分钟后就消失了？！这太令人恼火了。

回复
- Aref 2022 年 10 月 26 日上午 8:26 #
  
  抱歉，我找不到我的问题，但我现在找到了。它有点奇怪。
  
  回复
Nasim 2022 年 12 月 5 日下午 1:03 #

您好。我想知道如何为训练数据集定义多输出回归的均方误差。对于单输出回归，均方误差为 1/2m(sum(y_p-y)^2)，求和是遍历训练数据集。现在，对于多输出回归，情况如何？

回复
- James Carmichael 2022 年 12 月 6 日上午 10:03 #
  
  嗨 Nasim……以下资源可能对您感兴趣：
  
  https://stackoverflow.com/questions/66707594/rmse-for-multidimensional-data
  
  回复
Med 2023 年 2 月 5 日上午 4:25 #

嗨，Jason，

您能告诉我，建模后，如何找到输入变量的值来优化（最小化一个，最大化另一个等）多个输出变量吗？

祝好，
Med

回复
- James Carmichael 2023 年 2 月 5 日下午 1:21 #
  
  嗨 Med……以下资源可能对您感兴趣：
  
  https://machinelearning.org.cn/tour-of-optimization-algorithms/
  
  回复
JJ Dela Cruz 2023 年 2 月 11 日晚上 8:47 #

你好！我目前正在处理一个包含 2 个因变量的数据集，但这两个因变量也相互依赖。在这种情况下，算法仍然有效吗？谢谢！

回复
- James Carmichael 2023 年 2 月 12 日上午 9:32 #
  
  嗨 JJ Dela Cruz……我建议您在您的场景中尝试该模型。请让我们知道您的发现。
  
  回复
Lally 2023 年 4 月 29 日上午 2:47 #

你好！你能帮我为 ResNet 34 构建多输出模型吗？

回复
- James Carmichael 2023 年 4 月 29 日上午 10:57 #
  
  嗨 Lally……以下是利用迁移学习的一个很好的起点。
  
  https://machinelearning.org.cn/transfer-learning-for-deep-learning/
  
  回复
Gamuchirai Ndawana 2023 年 6 月 25 日上午 6:31 #

嗨 Jason，您知道您有让信息更容易获取的天赋吗？您知道您在充满问题的世界中是祝福、灵感和指导的源泉吗？

我祝您长寿，您免费提供的信息的价值是难以置信的 ❤️

回复
- James Carmichael 2023 年 6 月 25 日上午 9:07 #
  
  感谢您的支持和善意的话！我们随时准备回答有关机器学习的任何问题！我们祝您在机器学习之旅中一切顺利！
  
  回复
Carlos 2023 年 7 月 26 日下午 2:30 #

嗨。这是一个优秀的机器学习网站。恭喜。在函数“def evaluate_model(X, y):”中，我尝试通过在 Return 行添加这些数组来获取训练和测试数据集，但这会产生错误。我还打印了它们在 for 循环中，并观察到它们在每次迭代时都会更改。您能否详细说明一下？您能否在例程末尾添加一些图表，或者指导我们如何检索信息进行比较？即训练 vs 计算，测试 vs 计算，mse 等。谢谢。

回复
- James Carmichael 2023 年 7 月 27 日上午 9:21 #
  
  嗨 Carlos……请说明您遇到的具体错误，以便我们更好地帮助您。
  
  回复
  - Carlos 2023 年 7 月 30 日下午 4:38 #
    
    嗨 James。谢谢你的回复。在上面代码的第 42 行“return results”的“def evaluate_model(X, y)”函数中，我修改为“return results, X_train, y_train, X_test, y_test”。
    
    回复
Carlos 2023 年 7 月 30 日下午 4:37 #

嗨 James。谢谢你的回复。在上面代码的第 42 行“return results”的“def evaluate_model(X, y)”函数中，我修改为“return results, X_train, y_train, X_test, y_test”。

回复
Srivatsa Datta 2023 年 10 月 21 日上午 1:49 #

嗨 James，

我非常感谢这个精彩的网站。特别是作为一名教育者，你们网站提供详细解释您所提供选项“原因”的细节，这对我来说最具吸引力。
此外，正如本教程中所述，您还指出，有时我们需要使用“试错法”来达到“相当正确”的规范。
我一直在评估各种网站，为我的学生提供额外的参考资料，以补充我的课堂笔记。我很高兴地说，我已经找到了我要推荐给学生的网站。我发现，在学习您创作的这些精彩示例时，我也可以更新自己的知识和理解。
感谢您为无数机器学习和深度学习学生提供了一个真正精彩的学习网站。看到您花时间回答这里各种用户的提问，我也觉得非常有价值。
我来自一个发展中国家，我的学生买不起您所著的书籍。不过，我打算通过购买来支持您的事业。此外，作为一个狂热的R语言用户，看到您也有一个专门的R语言版块，这让我备受鼓舞和激动。

诚挚地，

Vatsa

回复
- James Carmichael 2023年10月21日上午9:22 #
  
  您好 Srivatsa…我们非常感谢您的支持和反馈！以下位置提供了电子书的完整列表，其中包含每本电子书内容的详细描述。如果您在查阅我们的教程和电子书时有任何疑问，请随时告知我们！
  
  https://machinelearning.org.cn/products/
  
  回复
Srivatsa Datta 2023年10月25日上午2:06 #

非常感谢您的链接，Jason。我会仔细研究一下目录。

回复
Javad 2023年11月21日上午8:14 #

你好，

感谢您的精彩文章。

我有一个分类输出和四个连续数值输出。您能告诉我如何处理这个分类目标吗？我应该使用独热编码或其他方法将其转换为数值输出，然后使用多输出回归，最后将分类输出的数值四舍五入吗？
这样有意义吗？或者有其他方法来训练我的数据集吗？

回复
- James Carmichael 2023年11月21日上午10:35 #
  
  您好 Javad… 不客气！以下资源可能会让您感兴趣。
  
  https://stackoverflow.com/questions/61202580/correct-way-of-one-hot-encoding-class-labels-for-multi-class-problem
  
  回复
Jim 2023年12月8日上午4:31 #

第29行有一个for循环，但其下没有任何缩进。什么东西应该被缩进？

回复
- James Carmichael 2023年12月8日上午11:11 #
  
  您好 Jim… 您是手动输入的还是复制粘贴的代码？另外，您使用的是什么环境（Anaconda、Google Colab？）
  
  回复
  - Jim 2023年12月12日上午5:39 #
    
    嘿，詹姆斯，
    
    当我复制粘贴而不是手动输入时，它就修复了。
    
    回复
    - James Carmichael 2023年12月12日上午11:14 #
      
      感谢 Jim 的更新！继续加油！
      
      回复
Jim 2023年12月12日上午5:17 #

您如何为您的答案设置下限？我想要设置一个下限为0。

回复
- James Carmichael 2023年12月12日上午11:19 #
  
  您好 Jim… 以下讨论可能会让您感兴趣
  
  https://stats.stackexchange.com/questions/485865/how-to-bound-a-regressor-function
  
  回复
Jim 2023年12月13日上午8:13 #

嘿，詹姆斯，

如何将输出导出到数据框？具体来说，我正在尝试创建一个包含输出数据的 CSV 文件。

非常感谢您的帮助
Jim

回复

导航

用于多输出回归的深度学习模型

教程概述

多输出回归

多输出神经网络

多输出回归神经网络

进一步阅读

总结

关于此主题的更多信息

170条对深度学习模型用于多输出回归的回复

撰写回复点击此处取消回复。

导航

教程概述

多输出回归

多输出神经网络

多输出回归神经网络

进一步阅读

总结

关于此主题的更多信息

170条对深度学习模型用于多输出回归的回复

撰写回复 点击此处取消回复。

撰写回复点击此处取消回复。