Quay lại danh sách thử thách
Trung bình 0 đã giải Tỷ lệ chấp nhận 0%

Lan truyền xuôi qua một lớp dense

Tính đầu ra của một lớp nơ-ron kết nối đầy đủ với hàm kích hoạt tùy chọn.

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

  • Tính cả một lớp nơ-ron cùng lúc
  • Áp dụng hàm kích hoạt đã chọn cho mỗi đầu ra
  • Tổ chức trọng số thành một hàng cho mỗi nơ-ron

Đề bài

Xem bản gốc (English)

Lớp dense là một nhóm nơ-ron cùng nhận chung các đầu vào. Nơ-ron j có trọng số riêng weights[j] và bias riêng biases[j]:

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

Sau đó hàm kích hoạt của lớp được áp dụng cho từng z_j:

  • "linear": giữ nguyên z_j
  • "relu": max(0, z_j)
  • "sigmoid": 1 / (1 + e^(-z_j))

Hãy cài đặt dense_forward(inputs, weights, biases, activation).

Đầu vào

inputs: n giá trị đầu vào.

weights: Mỗi nơ-ron một hàng; mỗi hàng có n trọng số.

biases: Mỗi nơ-ron một bias.

activation: "linear", "relu" hoặc "sigmoid".

Đầu ra

Trả về danh sách đầu ra, mỗi nơ-ron một giá trị, theo thứ tự.

Ràng buộc

1 ≤ n ≤ 100, 1 ≤ số nơ-ron ≤ 100

-10 ≤ mỗi giá trị ≤ 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

Nơ-ron 1: 1×0.5 + 2×(-1) + 0 = -1.5, ReLU cho ra 0. Nơ-ron 2: 1×1.5 + 2×0.5 - 1 = 1.5, ReLU giữ nguyên. Kết quả: [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

Với hàm kích hoạt tuyến tính, đầu ra chỉ là 3×2 + 1 = 7, 3×(-1) + 0 = -3 và 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

Xử lý từng neuron riêng: mỗi neuron có một hàng weight và một bias riêng.

Gợi ý 2

Tính dot product của từng neuron với vector input, cộng bias rồi áp dụng activation đã chọn.

Gợi ý 3

Đảm bảo activation được áp dụng sau bước tuyến tính, và giữ đúng thứ tự neuron trong output.

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

thời gian O(mn), bộ nhớ phụ O(m)

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.