โจทย์ทั้งหมด
ปานกลาง 0 ข้อที่แก้แล้ว อัตราผ่าน 0%

การส่งผ่านไปข้างหน้าในโครงข่ายสองชั้น

ส่งอินพุตผ่านเลเยอร์ซ่อนที่ใช้ ReLU และเลเยอร์เอาต์พุตที่ใช้ sigmoid

สิ่งที่คุณจะได้เรียนรู้

  • ต่อชั้นซ่อนเข้ากับชั้นเอาต์พุต
  • ส่งเอาต์พุตของชั้นหนึ่งไปยังชั้นถัดไป
  • รันการทำนายของโครงข่ายทั้งหมด

โจทย์

โครงข่ายประสาทเทียมขนาดเล็กมี เลเยอร์ซ่อน และ เลเยอร์เอาต์พุต ข้อมูลไหลผ่านทั้งสองตามลำดับ:

  1. เลเยอร์ซ่อน: h_j = ReLU(inputs · hidden_weights[j] + hidden_biases[j]) โดย ReLU(z) = max(0, z)
  2. เลเยอร์เอาต์พุต: y_k = sigmoid(h · output_weights[k] + output_biases[k]) โดย sigmoid(z) = 1 / (1 + e^(-z))

จงเขียน forward_pass(inputs, hidden_weights, hidden_biases, output_weights, output_biases)

อินพุต

inputs: ค่าอินพุต n ค่า

hidden_weights, hidden_biases: เลเยอร์ซ่อน หนึ่งแถวและไบแอสหนึ่งค่าต่อนิวรอนซ่อนหนึ่งตัว

output_weights, output_biases: เลเยอร์เอาต์พุต หนึ่งแถวและไบแอสหนึ่งค่าต่อเอาต์พุตหนึ่งตัว แต่ละแถวมีน้ำหนักหนึ่งค่าต่อนิวรอนซ่อนหนึ่งตัว

เอาต์พุต

คืนค่าลิสต์เอาต์พุต y ของโครงข่าย

เงื่อนไข

1 ≤ จำนวนอินพุต นิวรอนซ่อน และเอาต์พุต ≤ 50

-10 ≤ แต่ละค่า ≤ 10

ตัวอย่าง

ตัวอย่างที่ 1
อินพุต:
inputs = [1.0, 0.5]
hidden_biases = [0.0, 0.5]
output_biases = [0.0]
hidden_weights = [
    [1.0, -2.0],
    [0.5, 1.0]
]
output_weights = [
    [1.0, -1.0]
]

ผลลัพธ์ที่คาดหวัง:
expected = [0.182426]
อินพุต:
std::vector<double> inputs = {1.0, 0.5};
std::vector<double> hidden_biases = {0.0, 0.5};
std::vector<double> output_biases = {0.0};
std::vector<std::vector<double>> hidden_weights = {
    {1.0, -2.0},
    {0.5, 1.0}
};
std::vector<std::vector<double>> output_weights = {
    {1.0, -1.0}
};

ผลลัพธ์ที่คาดหวัง:
std::vector<double> expected = {0.182426};
อินพุต:
double[] inputs = new double[] {1.0, 0.5};
double[] hidden_biases = new double[] {0.0, 0.5};
double[] output_biases = new double[] {0.0};
double[][] hidden_weights = new double[][] {
    new double[] {1.0, -2.0},
    new double[] {0.5, 1.0}
};
double[][] output_weights = new double[][] {
    new double[] {1.0, -1.0}
};

ผลลัพธ์ที่คาดหวัง:
double[] expected = new double[] {0.182426};

คำอธิบาย

เลเยอร์ซ่อน: ReLU(1×1 + 0.5×(-2) + 0) = ReLU(0) = 0 และ ReLU(1×0.5 + 0.5×1 + 0.5) = 1.5 เอาต์พุต: sigmoid(0×1 + 1.5×(-1) + 0) = sigmoid(-1.5) ≈ 0.182426

ตัวอย่างที่ 2
อินพุต:
inputs = [2.0]
hidden_biases = [0.0, 0.0]
output_biases = [-1.0, 0.0]
hidden_weights = [
    [1.0],
    [-1.0]
]
output_weights = [
    [0.5, 0.5],
    [-0.5, 2.0]
]

ผลลัพธ์ที่คาดหวัง:
expected = [0.5, 0.268941]
อินพุต:
std::vector<double> inputs = {2.0};
std::vector<double> hidden_biases = {0.0, 0.0};
std::vector<double> output_biases = {-1.0, 0.0};
std::vector<std::vector<double>> hidden_weights = {
    {1.0},
    {-1.0}
};
std::vector<std::vector<double>> output_weights = {
    {0.5, 0.5},
    {-0.5, 2.0}
};

ผลลัพธ์ที่คาดหวัง:
std::vector<double> expected = {0.5, 0.268941};
อินพุต:
double[] inputs = new double[] {2.0};
double[] hidden_biases = new double[] {0.0, 0.0};
double[] output_biases = new double[] {-1.0, 0.0};
double[][] hidden_weights = new double[][] {
    new double[] {1.0},
    new double[] {-1.0}
};
double[][] output_weights = new double[][] {
    new double[] {0.5, 0.5},
    new double[] {-0.5, 2.0}
};

ผลลัพธ์ที่คาดหวัง:
double[] expected = new double[] {0.5, 0.268941};

คำอธิบาย

เลเยอร์ซ่อน: ReLU(2) = 2 และ ReLU(-2) = 0 เอาต์พุต 1: sigmoid(2×0.5 + 0 - 1) = sigmoid(0) = 0.5 เอาต์พุต 2: sigmoid(2×(-0.5) + 0) = sigmoid(-1) ≈ 0.268941

แหล่งอ้างอิง

โจทย์นี้ปรับให้เหมาะกับ CodeUtility กรุณาทำตามคำชี้แจงและข้อจำกัดด้านบน

เรียนรู้จากคนอื่น

แนวทางจากชุมชน

ยังไม่มีวิธีทำที่เผยแพร่ ลองแก้โจทย์นี้เพื่อแชร์วิธีแรก