文章详情

登录

短信预约-IT技能 免费直播动态提醒

选择考试省份

  • 北京
  • 上海
  • 天津
  • 重庆
  • 河北
  • 山东
  • 辽宁
  • 黑龙江
  • 吉林
  • 甘肃
  • 青海
  • 河南
  • 江苏
  • 湖北
  • 湖南
  • 江西
  • 浙江
  • 广东
  • 云南
  • 福建
  • 海南
  • 山西
  • 四川
  • 陕西
  • 贵州
  • 安徽
  • 广西
  • 内蒙
  • 西藏
  • 新疆
  • 宁夏
  • 兵团

请输入下面的图形验证码

提交验证

短信预约提醒成功

深度学习神经网络的预测间隔

2024-12-03 08:12

关注

预测间隔为回归问题的预测提供了不确定性度量。

例如，95%的预测间隔表示100次中的95次，真实值将落在该范围的下限值和上限值之间。这不同于可能表示不确定性区间中心的简单点预测。没有用于计算深度学习神经网络关于回归预测建模问题的预测间隔的标准技术。但是，可以使用一组模型来估计快速且肮脏的预测间隔，这些模型又提供了点预测的分布，可以从中计算间隔。

在本教程中，您将发现如何计算深度学习神经网络的预测间隔。完成本教程后，您将知道：

教程概述

本教程分为三个部分：他们是：

预测间隔

通常，用于回归问题的预测模型(即预测数值)进行点预测。这意味着他们可以预测单个值，但不能提供任何有关该预测的不确定性的指示。根据定义，预测是估计值或近似值，并且包含一些不确定性。不确定性来自模型本身的误差和输入数据中的噪声。该模型是输入变量和输出变量之间关系的近似值。预测间隔是对预测不确定性的量化。它为结果变量的估计提供了概率上限和下限。

预测间隔是在预测数量的回归模型中进行预测或预测时最常使用的时间间隔。预测间隔围绕模型所做的预测，并希望覆盖真实结果的范围。有关一般的预测间隔的更多信息，请参见教程：

《机器学习的预测间隔》：

https://machinelearningmastery.com/prediction-intervals-for-machine-learning/

既然我们熟悉了预测间隔，那么我们可以考虑如何计算神经网络的间隔。首先定义一个回归问题和一个神经网络模型来解决这个问题。

回归神经网络

在本节中，我们将定义回归预测建模问题和神经网络模型来解决该问题。首先，让我们介绍一个标准回归数据集。我们将使用住房数据集。住房数据集是一个标准的机器学习数据集，包括506行数据，其中包含13个数字输入变量和一个数字目标变量。

使用具有三个重复的重复分层10倍交叉验证的测试工具，一个朴素的模型可以实现约6.6的平均绝对误差(MAE)。在大约1.9的相同测试工具上，性能最高的模型可以实现MAE。这为该数据集提供了预期性能的界限。该数据集包括根据美国波士顿市房屋郊区的详细信息来预测房价。

房屋数据集(housing.csv)：

https://raw.githubusercontent.com/jbrownlee/Datasets/master/housing.csv

房屋描述(房屋名称)：

https://raw.githubusercontent.com/jbrownlee/Datasets/master/housing.names

无需下载数据集;作为我们工作示例的一部分，我们将自动下载它。

下面的示例将数据集下载并加载为Pandas DataFrame，并概述了数据集的形状和数据的前五行。

  1. # load and summarize the housing dataset 
  2. from pandas import read_csv 
  3. from matplotlib import pyplot 
  4. # load dataset 
  5. url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/housing.csv' 
  6. dataframe = read_csv(url, header=None) 
  7. # summarize shape 
  8. print(dataframe.shape) 
  9. # summarize first few lines 
  10. print(dataframe.head()) 

运行示例将确认506行数据和13个输入变量以及一个数字目标变量(总共14个)。我们还可以看到所有输入变量都是数字。

  1. (506, 14) 
  2.         0     1     2   3      4      5   ...  8      9     10      11    12    13 
  3. 0  0.00632  18.0  2.31   0  0.538  6.575  ...   1  296.0  15.3  396.90  4.98  24.0 
  4. 1  0.02731   0.0  7.07   0  0.469  6.421  ...   2  242.0  17.8  396.90  9.14  21.6 
  5. 2  0.02729   0.0  7.07   0  0.469  7.185  ...   2  242.0  17.8  392.83  4.03  34.7 
  6. 3  0.03237   0.0  2.18   0  0.458  6.998  ...   3  222.0  18.7  394.63  2.94  33.4 
  7. 4  0.06905   0.0  2.18   0  0.458  7.147  ...   3  222.0  18.7  396.90  5.33  36.2 
  8.   
  9. [5 rows x 14 columns] 

接下来，我们可以准备用于建模的数据集。首先，可以将数据集拆分为输入和输出列，然后可以将行拆分为训练和测试数据集。在这种情况下，我们将使用约67%的行来训练模型，而其余33%的行用于估计模型的性能。

  1. # split into input and output values 
  2. X, y = values[:,:-1], values[:,-1] 
  3. # split into train and test sets 
  4. X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.67) 

您可以在本教程中了解有关训练测试拆分的更多信息：训练测试拆分以评估机器学习算法然后，我们将所有输入列(变量)缩放到0-1范围，称为数据归一化，这在使用神经网络模型时是一个好习惯。

  1. # scale input data 
  2. scaler = MinMaxScaler() 
  3. scaler.fit(X_train) 
  4. X_train = scaler.transform(X_train) 
  5. X_test = scaler.transform(X_test) 

您可以在本教程中了解有关使用MinMaxScaler标准化输入数据的更多信息：《如何在Python中使用StandardScaler和MinMaxScaler转换 》:

https://machinelearningmastery.com/standardscaler-and-minmaxscaler-transforms-in-python/

下面列出了准备用于建模的数据的完整示例。

  1. # load and prepare the dataset for modeling 
  2. from pandas import read_csv 
  3. from sklearn.model_selection import train_test_split 
  4. from sklearn.preprocessing import MinMaxScaler 
  5. # load dataset 
  6. url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/housing.csv' 
  7. dataframe = read_csv(url, header=None) 
  8. values = dataframe.values 
  9. # split into input and output values 
  10. X, y = values[:,:-1], values[:,-1] 
  11. # split into train and test sets 
  12. X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.67) 
  13. # scale input data 
  14. scaler = MinMaxScaler() 
  15. scaler.fit(X_train) 
  16. X_train = scaler.transform(X_train) 
  17. X_test = scaler.transform(X_test) 
  18. # summarize 
  19. print(X_train.shape, X_test.shape, y_train.shape, y_test.shape) 

运行示例像以前一样加载数据集，然后将列拆分为输入和输出元素，将行拆分为训练集和测试集，最后将所有输入变量缩放到[0,1]范围。列印了训练图和测试集的形状，显示我们有339行用于训练模型，有167行用于评估模型。

  1. (339, 13) (167, 13) (339,) (167,) 

接下来，我们可以在数据集中定义，训练和评估多层感知器(MLP)模型。我们将定义一个简单的模型，该模型具有两个隐藏层和一个预测数值的输出层。我们将使用ReLU激活功能和“ he”权重初始化，这是一个好习惯。经过一些反复试验后，选择了每个隐藏层中的节点数。

  1. # define neural network model 
  2. features = X_train.shape[1] 
  3. model = Sequential() 
  4. model.add(Dense(20, kernel_initializer='he_normal', activation='relu', input_dim=features)) 
  5. model.add(Dense(5, kernel_initializer='he_normal', activation='relu')) 
  6. model.add(Dense(1)) 

我们将使用具有接近默认学习速率和动量值的高效亚当版随机梯度下降法，并使用均方误差(MSE)损失函数(回归预测建模问题的标准)拟合模型。

  1. # compile the model and specify loss and optimizer 
  2. opt = Adam(learning_rate=0.01, beta_1=0.85, beta_2=0.999) 
  3. model.compile(optimizer=opt, loss='mse') 

您可以在本教程中了解有关Adam优化算法的更多信息：

《从头开始编写代码Adam梯度下降优化》

https://machinelearningmastery.com/adam-optimization-from-scratch/

然后，该模型将适合300个纪元，批处理大小为16个样本。经过一番尝试和错误后，才选择此配置。

  1. # fit the model on the training dataset 
  2. model.fit(X_train, y_train, verbose=2, epochs=300, batch_size=16) 

您可以在本教程中了解有关批次和纪元的更多信息：

《神经网络中批次与时期之间的差异》

https://machinelearningmastery.com/difference-between-a-batch-and-an-epoch/

最后，该模型可用于在测试数据集上进行预测，我们可以通过将预测值与测试集中的预期值进行比较来评估预测，并计算平均绝对误差(MAE)，这是模型性能的一种有用度量。

  1. # make predictions on the test set 
  2. yhat = model.predict(X_test, verbose=0) 
  3. # calculate the average error in the predictions 
  4. mae = mean_absolute_error(y_test, yhat) 
  5. print('MAE: %.3f' % mae) 

完整实例如下：

  1. # train and evaluate a multilayer perceptron neural network on the housing regression dataset 
  2. from pandas import read_csv 
  3. from sklearn.model_selection import train_test_split 
  4. from sklearn.metrics import mean_absolute_error 
  5. from sklearn.preprocessing import MinMaxScaler 
  6. from tensorflow.keras.models import Sequential 
  7. from tensorflow.keras.layers import Dense 
  8. from tensorflow.keras.optimizers import Adam 
  9. # load dataset 
  10. url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/housing.csv' 
  11. dataframe = read_csv(url, header=None) 
  12. values = dataframe.values 
  13. # split into input and output values 
  14. X, y = values[:, :-1], values[:,-1] 
  15. # split into train and test sets 
  16. X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.67, random_state=1) 
  17. # scale input data 
  18. scaler = MinMaxScaler() 
  19. scaler.fit(X_train) 
  20. X_train = scaler.transform(X_train) 
  21. X_test = scaler.transform(X_test) 
  22. # define neural network model 
  23. features = X_train.shape[1] 
  24. model = Sequential() 
  25. model.add(Dense(20, kernel_initializer='he_normal', activation='relu', input_dim=features)) 
  26. model.add(Dense(5, kernel_initializer='he_normal', activation='relu')) 
  27. model.add(Dense(1)) 
  28. # compile the model and specify loss and optimizer 
  29. opt = Adam(learning_rate=0.01, beta_1=0.85, beta_2=0.999) 
  30. model.compile(optimizer=opt, loss='mse') 
  31. # fit the model on the training dataset 
  32. model.fit(X_train, y_train, verbose=2, epochs=300, batch_size=16) 
  33. # make predictions on the test set 
  34. yhat = model.predict(X_test, verbose=0) 
  35. # calculate the average error in the predictions 
  36. mae = mean_absolute_error(y_test, yhat) 
  37. print('MAE: %.3f' % mae) 

运行示例将加载并准备数据集，在训练数据集上定义MLP模型并将其拟合，并在测试集上评估其性能。

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

在这种情况下，我们可以看到该模型实现的平均绝对误差约为2.3，这比朴素的模型要好，并且接近于最佳模型。

毫无疑问，通过进一步调整模型，我们可以达到接近最佳的性能，但这对于我们研究预测间隔已经足够了。

  1. Epoch 296/300 
  2. 22/22 - 0s - loss: 7.1741 
  3. Epoch 297/300 
  4. 22/22 - 0s - loss: 6.8044 
  5. Epoch 298/300 
  6. 22/22 - 0s - loss: 6.8623 
  7. Epoch 299/300 
  8. 22/22 - 0s - loss: 7.7010 
  9. Epoch 300/300 
  10. 22/22 - 0s - loss: 6.5374 
  11. MAE: 2.300 

接下来，让我们看看如何使用住房数据集上的MLP模型计算预测间隔。

神经网络预测间隔

在本节中，我们将使用上一节中开发的回归问题和模型来开发预测间隔。

与像线性回归这样的线性方法(预测间隔计算很简单)相比，像神经网络这样的非线性回归算法的预测间隔计算具有挑战性。没有标准技术。有许多方法可以为神经网络模型计算有效的预测间隔。我建议“更多阅读”部分列出的一些论文以了解更多信息。

在本教程中，我们将使用一种非常简单的方法，该方法具有很大的扩展空间。我将其称为“快速且肮脏的”，因为它快速且易于计算，但有一定的局限性。它涉及拟合多个最终模型(例如10到30)。来自集合成员的点预测的分布然后用于计算点预测和预测间隔。

例如，可以将点预测作为来自集合成员的点预测的平均值，并且可以将95%的预测间隔作为与该平均值的1.96标准偏差。这是一个简单的高斯预测间隔，尽管可以使用替代方法，例如点预测的最小值和最大值。或者，可以使用自举方法在不同的自举样本上训练每个合奏成员，并且可以将点预测的第2.5个百分点和第97.5个百分点用作预测间隔。

有关bootstrap方法的更多信息，请参见教程：

《Bootstrap方法的简要介绍》

https://machinelearningmastery.com/a-gentle-introduction-to-the-bootstrap-method/

这些扩展保留为练习;我们将坚持简单的高斯预测区间。

假设在上一部分中定义的训练数据集是整个数据集，并且我们正在对该整个数据集训练一个或多个最终模型。然后，我们可以在测试集上使用预测间隔进行预测，并评估该间隔在将来的有效性。

我们可以通过将上一节中开发的元素划分为功能来简化代码。首先，让我们定义一个函数，以加载和准备由URL定义的回归数据集。

  1. # load and prepare the dataset 
  2. def load_dataset(url): 
  3.  dataframe = read_csv(url, header=None) 
  4.  values = dataframe.values 
  5.  # split into input and output values 
  6.  X, y = values[:, :-1], values[:,-1] 
  7.  # split into train and test sets 
  8.  X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.67, random_state=1) 
  9.  # scale input data 
  10.  scaler = MinMaxScaler() 
  11.  scaler.fit(X_train) 
  12.  X_train = scaler.transform(X_train) 
  13.  X_test = scaler.transform(X_test) 
  14.  return X_train, X_test, y_train, y_test 

接下来，我们可以定义一个函数，该函数将在给定训练数据集的情况下定义和训练MLP模型，然后返回适合进行预测的拟合模型。

  1. # define and fit the model 
  2. def fit_model(X_train, y_train): 
  3.  # define neural network model 
  4.  features = X_train.shape[1] 
  5.  model = Sequential() 
  6.  model.add(Dense(20, kernel_initializer='he_normal', activation='relu', input_dim=features)) 
  7.  model.add(Dense(5, kernel_initializer='he_normal', activation='relu')) 
  8.  model.add(Dense(1)) 
  9.  # compile the model and specify loss and optimizer 
  10.  opt = Adam(learning_rate=0.01, beta_1=0.85, beta_2=0.999) 
  11.  model.compile(optimizer=opt, loss='mse') 
  12.  # fit the model on the training dataset 
  13.  model.fit(X_train, y_train, verbose=0, epochs=300, batch_size=16) 
  14.  return model 

我们需要多个模型来进行点预测，这些模型将定义点预测的分布，从中可以估计间隔。

因此，我们需要在训练数据集上拟合多个模型。每个模型必须不同，以便做出不同的预测。在训练MLP模型具有随机性，随机初始权重以及使用随机梯度下降优化算法的情况下，可以实现这一点。模型越多，点预测将更好地估计模型的功能。我建议至少使用10种型号，而超过30种型号可能不会带来太多好处。下面的函数适合模型的整体，并将其存储在返回的列表中。出于兴趣，还对测试集评估了每个拟合模型，并在拟合每个模型后报告了该测试集。我们希望每个模型在保持测试集上的估计性能会略有不同，并且报告的分数将有助于我们确认这一期望。

  1. # fit an ensemble of models 
  2. def fit_ensemble(n_members, X_train, X_test, y_train, y_test): 
  3.  ensemble = list() 
  4.  for i in range(n_members): 
  5.   # define and fit the model on the training set 
  6.   model = fit_model(X_train, y_train) 
  7.   # evaluate model on the test set 
  8.   yhat = model.predict(X_test, verbose=0) 
  9.   mae = mean_absolute_error(y_test, yhat) 
  10.   print('>%d, MAE: %.3f' % (i+1, mae)) 
  11.   # store the model 
  12.   ensemble.append(model) 
  13.  return ensemble 

最后，我们可以使用训练有素的模型集合进行点预测，可以将其总结为一个预测区间。

下面的功能实现了这一点。首先，每个模型对输入数据进行点预测，然后计算95%的预测间隔，并返回该间隔的下限值，平均值和上限值。

该函数被设计为将单行作为输入，但是可以很容易地适应于多行。

  1. # make predictions with the ensemble and calculate a prediction interval 
  2. def predict_with_pi(ensemble, X): 
  3.  # make predictions 
  4.  yhat = [model.predict(X, verbose=0) for model in ensemble] 
  5.  yhat = asarray(yhat) 
  6.  # calculate 95% gaussian prediction interval 
  7.  interval = 1.96 * yhat.std() 
  8.  lower, upper = yhat.mean() - interval, yhat.mean() + interval 
  9.  return lower, yhat.mean(), upper 

最后，我们可以调用这些函数。首先，加载并准备数据集，然后定义并拟合集合。

  1. # load dataset 
  2. url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/housing.csv' 
  3. X_train, X_test, y_train, y_test = load_dataset(url) 
  4. # fit ensemble 
  5. n_members = 30 
  6. ensemble = fit_ensemble(n_members, X_train, X_test, y_train, y_test) 

然后，我们可以使用测试集中的一行数据，并以预测间隔进行预测，然后报告结果。

我们还报告了预期的期望值，该期望值将在预测间隔内涵盖(可能接近95%的时间;这并不完全准确，而是粗略的近似值)。

  1. # make predictions with prediction interval 
  2. newX = asarray([X_test[0, :]]) 
  3. lower, mean, upper = predict_with_pi(ensemble, newX) 
  4. print('Point prediction: %.3f' % mean) 
  5. print('95%% prediction interval: [%.3f, %.3f]' % (lower, upper)) 
  6. print('True value: %.3f' % y_test[0]) 

综上所述，下面列出了使用多层感知器神经网络以预测间隔进行预测的完整示例。

  1. # prediction interval for mlps on the housing regression dataset 
  2. from numpy import asarray 
  3. from pandas import read_csv 
  4. from sklearn.model_selection import train_test_split 
  5. from sklearn.metrics import mean_absolute_error 
  6. from sklearn.preprocessing import MinMaxScaler 
  7. from tensorflow.keras.models import Sequential 
  8. from tensorflow.keras.layers import Dense 
  9. from tensorflow.keras.optimizers import Adam 
  10.   
  11. # load and prepare the dataset 
  12. def load_dataset(url): 
  13.  dataframe = read_csv(url, header=None) 
  14.  values = dataframe.values 
  15.  # split into input and output values 
  16.  X, y = values[:, :-1], values[:,-1] 
  17.  # split into train and test sets 
  18.  X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.67, random_state=1) 
  19.  # scale input data 
  20.  scaler = MinMaxScaler() 
  21.  scaler.fit(X_train) 
  22.  X_train = scaler.transform(X_train) 
  23.  X_test = scaler.transform(X_test) 
  24.  return X_train, X_test, y_train, y_test 
  25.   
  26. # define and fit the model 
  27. def fit_model(X_train, y_train): 
  28.  # define neural network model 
  29.  features = X_train.shape[1] 
  30.  model = Sequential() 
  31.  model.add(Dense(20, kernel_initializer='he_normal', activation='relu', input_dim=features)) 
  32.  model.add(Dense(5, kernel_initializer='he_normal', activation='relu')) 
  33.  model.add(Dense(1)) 
  34.  # compile the model and specify loss and optimizer 
  35.  opt = Adam(learning_rate=0.01, beta_1=0.85, beta_2=0.999) 
  36.  model.compile(optimizer=opt, loss='mse') 
  37.  # fit the model on the training dataset 
  38.  model.fit(X_train, y_train, verbose=0, epochs=300, batch_size=16) 
  39.  return model 
  40.   
  41. # fit an ensemble of models 
  42. def fit_ensemble(n_members, X_train, X_test, y_train, y_test): 
  43.  ensemble = list() 
  44.  for i in range(n_members): 
  45.   # define and fit the model on the training set 
  46.   model = fit_model(X_train, y_train) 
  47.   # evaluate model on the test set 
  48.   yhat = model.predict(X_test, verbose=0) 
  49.   mae = mean_absolute_error(y_test, yhat) 
  50.   print('>%d, MAE: %.3f' % (i+1, mae)) 
  51.   # store the model 
  52.   ensemble.append(model) 
  53.  return ensemble 
  54.   
  55. # make predictions with the ensemble and calculate a prediction interval 
  56. def predict_with_pi(ensemble, X): 
  57.  # make predictions 
  58.  yhat = [model.predict(X, verbose=0) for model in ensemble] 
  59.  yhat = asarray(yhat) 
  60.  # calculate 95% gaussian prediction interval 
  61.  interval = 1.96 * yhat.std() 
  62.  lower, upper = yhat.mean() - interval, yhat.mean() + interval 
  63.  return lower, yhat.mean(), upper 
  64.   
  65. # load dataset 
  66. url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/housing.csv' 
  67. X_train, X_test, y_train, y_test = load_dataset(url) 
  68. # fit ensemble 
  69. n_members = 30 
  70. ensemble = fit_ensemble(n_members, X_train, X_test, y_train, y_test) 
  71. # make predictions with prediction interval 
  72. newX = asarray([X_test[0, :]]) 
  73. lower, mean, upper = predict_with_pi(ensemble, newX) 
  74. print('Point prediction: %.3f' % mean) 
  75. print('95%% prediction interval: [%.3f, %.3f]' % (lower, upper)) 
  76. print('True value: %.3f' % y_test[0]) 

运行示例依次适合每个集合成员，并在保留测试集上报告其估计性能;最后，做出并预测一个具有预测间隔的预测。

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

在这种情况下，我们可以看到每个模型的性能略有不同，这证实了我们对模型确实有所不同的期望。

最后，我们可以看到该合奏以95%的预测间隔[26.287，34.822]进行了约30.5的点预测。我们还可以看到，真实值为28.2，并且间隔确实捕获了该值，这非常好。

  1. >1, MAE: 2.259 
  2. >2, MAE: 2.144 
  3. >3, MAE: 2.732 
  4. >4, MAE: 2.628 
  5. >5, MAE: 2.483 
  6. >6, MAE: 2.551 
  7. >7, MAE: 2.505 
  8. >8, MAE: 2.299 
  9. >9, MAE: 2.706 
  10. >10, MAE: 2.145 
  11. >11, MAE: 2.765 
  12. >12, MAE: 3.244 
  13. >13, MAE: 2.385 
  14. >14, MAE: 2.592 
  15. >15, MAE: 2.418 
  16. >16, MAE: 2.493 
  17. >17, MAE: 2.367 
  18. >18, MAE: 2.569 
  19. >19, MAE: 2.664 
  20. >20, MAE: 2.233 
  21. >21, MAE: 2.228 
  22. >22, MAE: 2.646 
  23. >23, MAE: 2.641 
  24. >24, MAE: 2.492 
  25. >25, MAE: 2.558 
  26. >26, MAE: 2.416 
  27. >27, MAE: 2.328 
  28. >28, MAE: 2.383 
  29. >29, MAE: 2.215 
  30. >30, MAE: 2.408 
  31. Point prediction: 30.555 
  32. 95% prediction interval: [26.287, 34.822] 
  33. True value: 28.200 

True value: 28.200

 

来源： Python中文社区内容投诉

免责声明：

① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的，并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据，供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。

② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

软考中级精品资料免费领

  • 历年真题答案解析
  • 备考技巧名师总结
  • 高频考点精准押题

  • 2024年上半年信息系统项目管理师第二批次真题及答案解析（完整版）

    难度     813人已做
    查看

  • 【考后总结】2024年5月26日信息系统项目管理师第2批次考情分析

    难度     354人已做
    查看

  • 【考后总结】2024年5月25日信息系统项目管理师第1批次考情分析

    难度     318人已做
    查看

  • 2024年上半年软考高项第一、二批次真题考点汇总（完整版）

    难度     435人已做
    查看

  • 2024年上半年系统架构设计师考试综合知识真题

    难度     224人已做
    查看

相关文章

发现更多好内容

猜你喜欢

AI推送时光机

深度学习神经网络的预测间隔

后端开发深度学习预测2024-12-03

机器学习、深度学习、神经网络之间的区别

后端开发机器学习深度学习2024-11-30

Python Pytorch深度学习之神经网络

后端开发2024-04-02

Python深度学习神经网络残差块

后端开发2024-04-02

Python深度学习pytorch神经网络块的网络之VGG

后端开发2024-04-02

Python深度学习pytorch卷积神经网络LeNet

后端开发2024-04-02

机器学习、深度学习和神经网络之间的区别和联系

机器学习、深度学习和神经网络之间的区别和联系
后端开发2024-04-02

Python深度学习神经网络基本原理

后端开发2024-04-02

深度学习实验3 - 卷积神经网络

后端开发2023-09-02

Python深度学习TensorFlow神经网络基础概括

后端开发2024-04-02

Python深度学习之实现卷积神经网络

后端开发2024-04-02

Pytorch 使用Google Colab训练神经网络深度学习

后端开发2024-04-02

Python深度学习pytorch神经网络汇聚层理解

后端开发2024-04-02

Pytorch深度学习经典卷积神经网络resnet模块训练

后端开发2024-04-02

Python深度学习pytorch神经网络Dropout应用详解解

后端开发2024-04-02

Python深度学习pytorch神经网络填充和步幅的理解

后端开发2024-04-02

Python深度学习理解pytorch神经网络批量归一化

后端开发2024-04-02

深度学习神经网络之图像分类应用实战

后端开发深度学习神经网络2024-11-30

深度学习—卷积神经网络（CNN）全笔记，附代码

后端开发2023-10-23

python深度学习TensorFlow神经网络模型的保存和读取

后端开发2024-04-02
位置：首页-资讯-后端开发
咦！没有更多了？去看看其它编程学习网 内容吧
首页课程
资料下载问答资讯