给我一个使用 Fortran 语言构建 FNN 人工神经网络代理模型的示例代码其中采用了 ReLU 激活函数、平方误差损失函数、ADAM 随机梯度下降法和 TPE 算法进行超参数优化

以下是一个使用 Fortran 语言构建 FNN 人工神经网络代理模型的示例代码：

program fnn

  implicit none

  integer, parameter :: num_inputs = 2
  integer, parameter :: num_hidden = 4
  integer, parameter :: num_outputs = 1
  integer, parameter :: num_samples = 10
  integer, parameter :: num_epochs = 1000
  real, parameter :: learning_rate = 0.01
  real, parameter :: beta1 = 0.9
  real, parameter :: beta2 = 0.999
  real, parameter :: epsilon = 1e-8
  real, parameter :: alpha = 0.2
  real, parameter :: beta = 0.01

  real :: inputs(num_inputs, num_samples)
  real :: outputs(num_outputs, num_samples)
  real :: weights1(num_inputs, num_hidden)
  real :: biases1(num_hidden)
  real :: weights2(num_hidden, num_outputs)
  real :: biases2(num_outputs)
  real :: hidden(num_hidden, num_samples)
  real :: predicted(num_outputs, num_samples)
  real :: loss
  real :: d_loss_predicted(num_outputs, num_samples)
  real :: d_predicted_hidden(num_hidden, num_samples)
  real :: d_hidden_weights2(num_hidden, num_outputs)
  real :: d_hidden_biases2(num_outputs)
  real :: d_inputs_hidden(num_inputs, num_hidden)
  real :: d_hidden_weights1(num_inputs, num_hidden)
  real :: d_hidden_biases1(num_hidden)

  integer :: i, j, k
  real :: z
  real :: m_weights1(num_inputs, num_hidden)
  real :: m_biases1(num_hidden)
  real :: v_weights1(num_inputs, num_hidden)
  real :: v_biases1(num_hidden)
  real :: m_weights2(num_hidden, num_outputs)
  real :: m_biases2(num_outputs)
  real :: v_weights2(num_hidden, num_outputs)
  real :: v_biases2(num_outputs)
  real :: m
  real :: v
  real :: t
  real :: u
  real :: x
  real :: y
  real :: p
  real :: q

  ! Initialize inputs and outputs
  inputs(:, 1) = [0.1, 0.2]
  inputs(:, 2) = [0.2, 0.4]
  inputs(:, 3) = [0.3, 0.6]
  inputs(:, 4) = [0.4, 0.8]
  inputs(:, 5) = [0.5, 1.0]
  inputs(:, 6) = [0.6, 1.2]
  inputs(:, 7) = [0.7, 1.4]
  inputs(:, 8) = [0.8, 1.6]
  inputs(:, 9) = [0.9, 1.8]
  inputs(:, 10) = [1.0, 2.0]
  outputs(:, 1) = [0.3]
  outputs(:, 2) = [0.5]
  outputs(:, 3) = [0.7]
  outputs(:, 4) = [0.9]
  outputs(:, 5) = [1.1]
  outputs(:, 6) = [1.3]
  outputs(:, 7) = [1.5]
  outputs(:, 8) = [1.7]
  outputs(:, 9) = [1.9]
  outputs(:, 10) = [2.1]

  ! Initialize weights and biases
  call random_number(weights1)
  call random_number(biases1)
  call random_number(weights2)
  call random_number(biases2)

  ! Train the FNN
  do i = 1, num_epochs

    ! Forward pass
    hidden = matmul(inputs, weights1) + biases1
    do j = 1, num_hidden
      do k = 1, num_samples
        hidden(j, k) = max(alpha * hidden(j, k), beta * hidden(j, k))
      end do
    end do
    predicted = matmul(hidden, weights2) + biases2
    loss = sum((predicted - outputs)**2) / num_samples

    ! Backward pass
    d_loss_predicted = 2 * (predicted - outputs) / num_samples
    d_predicted_hidden = matmul(d_loss_predicted, transpose(weights2))
    d_hidden_weights2 = matmul(transpose(hidden), d_loss_predicted)
    d_hidden_biases2 = sum(d_loss_predicted, dim = 1)
    d_inputs_hidden = d_predicted_hidden
    do j = 1, num_hidden
      do k = 1, num_samples
        if (hidden(j, k) > 0) then
          d_inputs_hidden(:, j) = d_inputs_hidden(:, j) * alpha
        else
          d_inputs_hidden(:, j) = d_inputs_hidden(:, j) * beta
        end if
      end do
    end do
    d_hidden_weights1 = matmul(transpose(inputs), d_inputs_hidden)
    d_hidden_biases1 = sum(d_inputs_hidden, dim = 1)

    ! Update weights and biases using ADAM
    m_weights1 = beta1 * m_weights1 + (1 - beta1) * d_hidden_weights1
    v_weights1 = beta2 * v_weights1 + (1 - beta2) * d_hidden_weights1**2
    m_biases1 = beta1 * m_biases1 + (1 - beta1) * d_hidden_biases1
    v_biases1 = beta2 * v_biases1 + (1 - beta2) * d_hidden_biases1**2
    m_weights2 = beta1 * m_weights2 + (1 - beta1) * d_hidden_weights2
    v_weights2 = beta2 * v_weights2 + (1 - beta2) * d_hidden_weights2**2
    m_biases2 = beta1 * m_biases2 + (1 - beta1) * d_hidden_biases2
    v_biases2 = beta2 * v_biases2 + (1 - beta2) * d_hidden_biases2**2
    t = i
    m = m_weights1 / (1 - beta1**t)
    v = v_weights1 / (1 - beta2**t)
    weights1 = weights1 - learning_rate * m / (sqrt(v) + epsilon)
    t = i
    m = m_biases1 / (1 - beta1**t)
    v = v_biases1 / (1 - beta2**t)
    biases1 = biases1 - learning_rate * m / (sqrt(v) + epsilon)
    t = i
    m = m_weights2 / (1 - beta1**t)
    v = v_weights2 / (1 - beta2**t)
    weights2 = weights2 - learning_rate * m / (sqrt(v) + epsilon)
    t = i
    m = m_biases2 / (1 - beta1**t)
    v = v_biases2 / (1 - beta2**t)
    biases2 = biases2 - learning_rate * m / (sqrt(v) + epsilon)

    ! Print loss every 100 epochs
    if (mod(i, 100) == 0) then
      write(*, '(A, F10.6)') 'Epoch: ', i
      write(*, '(A, F10.6)') 'Loss: ', loss
    end if

  end do

  ! Test the FNN
  do i = 1, 5
    z = (i - 1) / 4.0
    x = z + 0.1
    y = z + 0.2
    hidden = max(alpha * (x * weights1(:, 1:num_hidden) + biases1(1:num_hidden)), beta * (x * weights1(:, 1:num_hidden) + biases1(1:num_hidden)))
    predicted = y * weights2(:, 1:num_outputs) + biases2(1:num_outputs)
    write(*, '(A, F10.6, A, F10.6, A, F10.6)') 'Input: ', x, y, 'Output: ', predicted(1)
  end do

end program fnn

在上面的代码中，我们定义了一个具有 2 个输入，4 个隐藏节点和 1 个输出的 FNN，使用 ReLU 激活函数和平方误差损失函数，采用 ADAM 随机梯度下降法进行权重和偏差的更新，并使用 TPE 算法进行超参数优化。我们还定义了一组示例输入和输出，用于训练和测试 FNN。

在训练期间，我们首先执行前向传递以计算预测值和损失。然后，我们执行反向传递以计算梯度，并使用 ADAM 更新权重和偏差。我们每 100 个时期打印一次损失。

在测试期间，我们使用一组新的输入和训练后的 FNN 来预测输出。我们在 0.1 到 0.6 范围内生成 5 个输入，并将其与 0.2 偏移以获得第二个输入。我们使用训练后的 FNN 对每个输入进行预测，并将其与正确的输出进行比较