【机器学习】dense的用法以及如何用Numpy构建一个简单神经网络

引言

在TensorFlow和Keras中，Dense 层是全连接（fully connected）层的标准实现，其中每个输入都与每个输出有连接

一、dense的用法

1.1 步骤

1.1.1 导入必要的库

通常，你需要从 tensorflow.keras 中导入 models 和 layers。

from tensorflow.keras import models, layers

1.1.2 创建模型

使用 models.Sequential() 创建一个顺序模型。

model = models.Sequential()

1.1.3 添加 Dense 层

使用 model.add() 方法添加 Dense 层到模型中。

model.add(layers.Dense(units, activation='activation_function'))

其中：

• units 是层的输出维度，即该层中的神经元数量。
• activation 是激活函数，例如 ‘relu’、‘sigmoid’、‘softmax’ 等。

1.1.4 编译模型

选择损失函数、优化器，并定义评估指标。

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

1.1.5 训练模型

使用训练数据对模型进行训练。

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

1.2 代码示例

以下是一个使用 Dense 层构建简单全连接神经网络的示例

from tensorflow.keras import models, layers
# 创建模型
model = models.Sequential()
# 添加输入层，假设输入数据有 64 个特征
model.add(layers.Dense(64, input_shape=(64,), activation='relu'))
# 添加一个隐藏层，有 128 个神经元，并使用 ReLU 激活函数
model.add(layers.Dense(128, activation='relu'))
# 添加输出层，假设是二分类问题，因此有一个神经元和 'sigmoid' 激活函数
model.add(layers.Dense(1, activation='sigmoid'))
# 编译模型
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
# 假设 x_train 和 y_train 是训练数据和标签
# 训练模型
# model.fit(x_train, y_train, epochs=10, batch_size=32)

1.3 代码解释

• 在这个例子中，我们创建了一个三层的全连接神经网络：一个输入层，一个隐藏层和一个输出层
• 使用ReLU激活函数在输入层和隐藏层，并在输出层使用sigmoid函数，因为这是一个二分类问题
• 编译模型时，我们选择了 adam 优化器和 binary_crossentropy 损失函数，这是二分类问题的常见选择

1.4 总结

在实际应用中，需要用实际的训练数据替换 x_train 和 y_train，并设置合适的 epochs 和 batch_size 参数来训练模型

二、用Numpy构建一个简单神经网络

2.1 导入第三方库

import numpy as np
import matplotlib.pyplot as plt
plt.style.use('./deeplearning.mplstyle')
import tensorflow as tf
from lab_utils_common import dlc, sigmoid
from lab_coffee_utils import load_coffee_data, plt_roast, plt_prob, plt_layer, plt_network, plt_output_unit
import logging
logging.getLogger("tensorflow").setLevel(logging.ERROR)
tf.autograph.set_verbosity(0)

2.2 数据集

X,Y = load_coffee_data();
print(X.shape, Y.shape)

让我们在下面绘制咖啡烘焙数据。这两个功能是以摄氏度为单位的温度和以分钟为单位的持续时间。在家烘焙咖啡建议持续时间最好保持在 12 到 15 分钟之间，而温度应在 175 到 260 摄氏度之间。当然，随着温度的升高，持续时间应该会缩短。

plt_roast(X,Y)

输出结果：

2.3 归一化数据

如果数据被归一化，那么将权重拟合到数据（反向传播）将更快地进行。这与您在课程 1 中使用的过程相同，其中数据中的每个要素都被归一化为具有相似的范围。以下过程使用 Keras 归一化层。它包含以下步骤：

• 创建一个“归一化层”。请注意，如此处应用的，这不是模型中的层
• “适应”数据。这将学习数据集的均值和方差，并在内部保存值
• 对数据进行规范化，将归一化应用于利用学习模型的任何未来数据非常重要

print(f"Temperature Max, Min pre normalization: {np.max(X[:,0]):0.2f}, {np.min(X[:,0]):0.2f}")
print(f"Duration    Max, Min pre normalization: {np.max(X[:,1]):0.2f}, {np.min(X[:,1]):0.2f}")
norm_l = tf.keras.layers.Normalization(axis=-1)
norm_l.adapt(X)  # learns mean, variance
Xn = norm_l(X)
print(f"Temperature Max, Min post normalization: {np.max(Xn[:,0]):0.2f}, {np.min(Xn[:,0]):0.2f}")
print(f"Duration    Max, Min post normalization: {np.max(Xn[:,1]):0.2f}, {np.min(Xn[:,1]):0.2f}")

输出结果：

2.4 Numpy模型

让我们来构建讲座中描述的“咖啡烘焙网络”。有两层具有 sigmoid 激活
可以使用 NumPy 构建自己的密集层。然后，这可以用来构建多层神经网络

在第一个可选实验中，在 NumPy 和 Tensorflow 中构建了一个神经元，并注意到它们的相似性。一层仅包含多个神经元/单元。可以利用 for 循环访问层中的每个单元j，并执行该单位的权重W的点积，并将该单位的偏差相加 （b[j]） 形成 z。然后可以将激活函数 g（z） 应用于该结果。让我们在下面尝试构建一个“密集层”子程序

def my_dense(a_in, W, b, g):
    """
    Computes dense layer
    Args:
      a_in (ndarray (n, )) : Data, 1 example 
      W    (ndarray (n,j)) : Weight matrix, n features per unit, j units
      b    (ndarray (j, )) : bias vector, j units  
      g    activation function (e.g. sigmoid, relu..)
    Returns
      a_out (ndarray (j,))  : j units|
    """
    units = W.shape[1]
    a_out = np.zeros(units)
    for j in range(units):               
        w = W[:,j]                                    
        z = np.dot(w, a_in) + b[j]         
        a_out[j] = g(z)               
    return(a_out)
)

以下单元利用上述 my_dense 子程序构建一个两层神经网络

def my_sequential(x, W1, b1, W2, b2):
    a1 = my_dense(x,  W1, b1, sigmoid)
    a2 = my_dense(a1, W2, b2, sigmoid)
    return(a2)

我们可以在 Tensorflow 中复制来自前一个实验室的经过训练的权重和偏差

W1_tmp = np.array( [[-8.93,  0.29, 12.9 ], [-0.1,  -7.32, 10.81]] )
b1_tmp = np.array( [-9.82, -9.28,  0.96] )
W2_tmp = np.array( [[-31.18], [-27.59], [-32.56]] )
b2_tmp = np.array( [15.41] )

2.5 预测

一旦有了经过训练的模型，就可以使用它来做出预测。回想一下，我们模型的输出是一个概率。在这种情况下，良好烤肉的概率。要做出决定，必须将概率应用于阈值。在本例中，我们将使用 0.5

• 让我们从编写一个类似于 Tensorflow 的 model.predict（） 的例程开始。这将采用一个矩阵 𝑋，行中有所有 𝑚个示例，并通过运行模型进行预测。

def my_predict(X, W1, b1, W2, b2):
    m = X.shape[0]
    p = np.zeros((m,1))
    for i in range(m):
        p[i,0] = my_sequential(X[i], W1, b1, W2, b2)
    return(p)

我们可以在两个示例中尝试此例程：

X_tst = np.array([
    [200,13.9],  # postive example
    [200,17]])   # negative example
X_tstn = norm_l(X_tst)  # remember to normalize
predictions = my_predict(X_tstn, W1_tmp, b1_tmp, W2_tmp, b2_tmp)

为了将概率转换为决策，我们应用了一个阈值：

yhat = np.zeros_like(predictions)
for i in range(len(predictions)):
    if predictions[i] >= 0.5:
        yhat[i] = 1
    else:
        yhat[i] = 0
print(f"decisions = \n{yhat}")
This can be accomplished more succinctly:

输出结果：

这可以更简洁地完成：

yhat = (predictions >= 0.5).astype(int)
print(f"decisions = \n{yhat}")

输出结果：

2.6 网络功能

此图显示了整个网络的操作，与上一个实验的 Tensorflow 结果相同
左图是最后一层的原始输出，由蓝色阴影表示。这叠加在由 X 和 O 表示的训练数据上
右图是决策阈值之后网络的输出。这里的 X 和 O 对应于网络做出的决策

netf= lambda x : my_predict(norm_l(x),W1_tmp, b1_tmp, W2_tmp, b2_tmp)
plt_network(X,Y,netf)

输出结果：

2.7 总结

在NumPy中构建了一个小型神经网络，揭示了构成神经网络中一层的相当简单和熟悉的函数