Tất cả thử thách
Trung bình 0 đã giải Tỷ lệ chấp nhận 0%

Dense Layer Forward Pass

Compute the outputs of a fully connected layer of neurons with a choice of activation.

Bạn sẽ học được gì

  • Compute a full layer of neurons at once
  • Apply a chosen activation to each output
  • Organize weights as one row per neuron

Đề bài

Xem bản dịch

A dense layer is a group of neurons that all receive the same inputs. Neuron j has its own weights weights[j] and bias biases[j]:

z_j = inputs · weights[j] + biases[j]

Then the layer's activation is applied to each z_j:

  • "linear": output z_j unchanged
  • "relu": max(0, z_j)
  • "sigmoid": 1 / (1 + e^(-z_j))

Implement dense_forward(inputs, weights, biases, activation).

Input

inputs: The n input values.

weights: One row per neuron; each row has n weights.

biases: One bias per neuron.

activation: "linear", "relu" or "sigmoid".

Output

Return the list of outputs, one per neuron, in order.

Ràng buộc

1 ≤ n ≤ 100, 1 ≤ number of neurons ≤ 100

-10 ≤ each value ≤ 10

Ví dụ

Ví dụ 1
Đầu vào:
biases = [0.0, -1.0]
inputs = [1.0, 2.0]
weights = [
    [0.5, -1.0],
    [1.5, 0.5]
]
activation = "relu"

Kết quả mong đợi:
expected = [0.0, 1.5]
Đầu vào:
std::vector<double> biases = {0.0, -1.0};
std::vector<double> inputs = {1.0, 2.0};
std::vector<std::vector<double>> weights = {
    {0.5, -1.0},
    {1.5, 0.5}
};
std::string activation = "relu";

Kết quả mong đợi:
std::vector<double> expected = {0.0, 1.5};
Đầu vào:
double[] biases = new double[] {0.0, -1.0};
double[] inputs = new double[] {1.0, 2.0};
double[][] weights = new double[][] {
    new double[] {0.5, -1.0},
    new double[] {1.5, 0.5}
};
string activation = "relu";

Kết quả mong đợi:
double[] expected = new double[] {0.0, 1.5};

Giải thích

Neuron 1: 1×0.5 + 2×(-1) + 0 = -1.5, and ReLU gives 0. Neuron 2: 1×1.5 + 2×0.5 - 1 = 1.5, which ReLU keeps. Result: [0, 1.5].

Ví dụ 2
Đầu vào:
biases = [1.0, 0.0, -1.5]
inputs = [3.0]
weights = [
    [2.0],
    [-1.0],
    [0.5]
]
activation = "linear"

Kết quả mong đợi:
expected = [7.0, -3.0, 0.0]
Đầu vào:
std::vector<double> biases = {1.0, 0.0, -1.5};
std::vector<double> inputs = {3.0};
std::vector<std::vector<double>> weights = {
    {2.0},
    {-1.0},
    {0.5}
};
std::string activation = "linear";

Kết quả mong đợi:
std::vector<double> expected = {7.0, -3.0, 0.0};
Đầu vào:
double[] biases = new double[] {1.0, 0.0, -1.5};
double[] inputs = new double[] {3.0};
double[][] weights = new double[][] {
    new double[] {2.0},
    new double[] {-1.0},
    new double[] {0.5}
};
string activation = "linear";

Kết quả mong đợi:
double[] expected = new double[] {7.0, -3.0, 0.0};

Giải thích

With a linear activation the outputs are just 3×2 + 1 = 7, 3×(-1) + 0 = -3 and 3×0.5 - 1.5 = 0.

Hướng tiếp cận

Hãy tự thử trước, sau đó mở từng gợi ý một.

Gợi ý 1

Treat each neuron separately: each one has its own weight row and bias.

Gợi ý 2

Compute every neuron's dot product with the input vector, add its bias, then apply the chosen activation.

Gợi ý 3

Make sure the activation choice is applied after the linear step, and preserve neuron order in the output.

Độ phức tạp mong đợi

O(mn) time, O(m) extra space

Tham khảo

Thử thách này đã được điều chỉnh cho CodeUtility. Hãy làm theo đề bài và các ràng buộc ở trên.

Học hỏi từ người khác

Giải pháp cộng đồng

Chưa có giải pháp nào được chia sẻ. Hãy giải thử thách này để đăng giải pháp đầu tiên.