การใช้งาน Implement Neural Network 2 Layers ในภาษา Delphi Object Pascal แบบง่ายๆ

หากคุณเคยได้ยินเกี่ยวกับ "Neural Network" หรือ "โครงข่ายประสาท" คุณอาจเริ่มสงสัยว่ามันคืออะไรและทำงานอย่างไร? ในบทความนี้ เราจะพูดถึงการ Implement Neural Network 2 layers ใน Delphi Object Pascal แบบง่ายๆ พร้อมทั้งตัวอย่างโค้ด และยกตัวอย่างการใช้งานในโลกจริง

ความเข้าใจเบื้องต้นเกี่ยวกับ Neural Network

โครงข่ายประสาท (Neural Network) เป็นหนึ่งในโมเดลการเรียนรู้เชิงลึก (Deep Learning) ซึ่งได้รับแรงบันดาลใจมาจากวิธีการที่สมองของมนุษย์ทำงาน โดย Neural Network มีการสร้างโครงสร้างที่ประกอบด้วย "นิวรอน" หรือ "เซลล์ประสาท" ซึ่งเชื่อมต่อกันผ่าน "น้ำหนัก" (Weights) และ "ออฟเซต" (Biases) ในการเรียนรู้จากข้อมูลเพื่อให้ได้คำตอบที่ต้องการ

การเตรียมความพร้อม

ในการสร้าง Neural Network เราต้องมีข้อมูล ซึ่งสามารถเป็นข้อมูลที่มีโครงสร้าง เช่น ข้อมูลตัวเลข ข้อมูลภาพ หรืออื่นๆ ก่อนที่จะเริ่ม Implement ตัวอย่างโค้ด Delphi จะใช้ข้อมูลตัวเลขง่ายๆ

การสร้าง Neural Network 2 Layers

ในที่นี้เราจะสร้าง Neural Network ที่มี 2 Layer ได้แก่ 1 Input Layer (ใส่ข้อมูล) และ 1 Output Layer (ส่งออกคำตอบ) โครงข่ายนี้จะมีนิวรอนอยู่ 3 ตัวใน Input Layer และ 2 ตัวใน Output Layer

ตัวอย่างโค้ด

 program SimpleNeuralNetwork;

type
  TNeuralNetwork = class
  private
    FInputLayer: array[0..2] of Double;
    FWeights: array[0..2, 0..1] of Double;
    FOutputLayer: array[0..1] of Double;
    FLearningRate: Double;
    procedure InitializeWeights;
    function Sigmoid(x: Double): Double;
    function SigmoidDerivative(x: Double): Double;
  public
    constructor Create;
    procedure Train(Input: array of Double; Expected: array of Double);
    function Predict(Input: array of Double): array of Double;
  end;

constructor TNeuralNetwork.Create;
begin
  FLearningRate := 0.1;
  InitializeWeights;
end;

procedure TNeuralNetwork.InitializeWeights;
var
  i, j: Integer;
begin
  Randomize;
  for i := 0 to 2 do
    for j := 0 to 1 do
      FWeights[i, j] := Random; // Assign Random Weights
end;

function TNeuralNetwork.Sigmoid(x: Double): Double;
begin
  Result := 1 / (1 + Exp(-x));
end;

function TNeuralNetwork.SigmoidDerivative(x: Double): Double;
begin
  Result := x * (1 - x);
end;

procedure TNeuralNetwork.Train(Input: array of Double; Expected: array of Double);
var
  Output: array[0..1] of Double;
  i, j: Integer;
  Error: Double;
begin
  // Forward propagation
  for i := 0 to 1 do
  begin
    Output[i] := 0;
    for j := 0 to 2 do
      Output[i] := Output[i] + Input[j] * FWeights[j, i];
    Output[i] := Sigmoid(Output[i]);
  end;

  // Back propagation
  for i := 0 to 1 do
  begin
    Error := Expected[i] - Output[i];
    for j := 0 to 2 do
      FWeights[j, i] := FWeights[j, i] + FLearningRate * Error * SigmoidDerivative(Output[i]) * Input[j];
  end;
end;

function TNeuralNetwork.Predict(Input: array of Double): array of Double;
var
  i, j: Integer;
begin
  for i := 0 to 1 do
  begin
    FOutputLayer[i] := 0;
    for j := 0 to 2 do
      FOutputLayer[i] := FOutputLayer[i] + Input[j] * FWeights[j, i];
    FOutputLayer[i] := Sigmoid(FOutputLayer[i]);
  end;
  Result := FOutputLayer; // Return output
end;

// ตัวอย่างการใช้งาน
var
  NN: TNeuralNetwork;
  Input, Expected: array of Double;
  Output: array of Double;
begin
  NN := TNeuralNetwork.Create;

  // Training data
  SetLength(Input, 3);
  SetLength(Expected, 2);

  // Training
  Input[0] := 1.0; Input[1] := 0.0; Input[2] := 1.0; // Input example 1
  Expected[0] := 1.0; Expected[1] := 0.0; // Expected output 1
  NN.Train(Input, Expected);

  Input[0] := 0.0; Input[1] := 1.0; Input[2] := 0.0; // Input example 2
  Expected[0] := 0.0; Expected[1] := 1.0; // Expected output 2
  NN.Train(Input, Expected);

  // Predict
  Output := NN.Predict([1.0, 0.0, 1.0]);
  WriteLn('Output: ', Output[0]:0:2, ' ', Output[1]:0:2); // Display the output
  ReadLn;
end.

การทำงานของโค้ด

3. **Method Sigmoid** และ **SigmoidDerivative** - ฟังก์ชันที่ใช้ในการคำนวณค่าซิกมอยด์สำหรับการส่งสัญญาณผ่านนิวรอนและการคำนวณอนุพันธ์สำหรับการปรับน้ำหนัก

Use Case ในโลกจริง

เรามักจะเห็น Neural Network ถูกนำไปใช้ในหลายสาขา เช่น:

ถ้าคุณสนใจในการเรียนรู้เพิ่มเติมเกี่ยวกับการสร้าง Neural Network หรือการเขียนโปรแกรมเพื่อนำไปใช้งานจริง อย่าลืมศึกษาต่อที่ EPT (Expert-Programming-Tutor) เรามีโปรแกรมการเรียนการสอนที่ครอบคลุมและเหมาะกับทุกระดับ เรียนรู้กับเราเถอะ แล้วคุณจะกลายเป็นโปรแกรมเมอร์ที่เก่งกาจในอนาคต!

สรุป

การสร้าง Neural Network แบบง่ายๆ ผ่าน Delphi Object Pascal ไม่ใช่เรื่องยากและสามารถนำไปใช้ในหลายๆ ด้านของชีวิตประจำวันได้ ในทุกด้านที่เกี่ยวข้องกับการประมวลผลข้อมูล เราหวังว่าตัวอย่างโค้ดและอธิบายให้เห็นภาพในบทความนี้จะเป็นทิศทางในการเริ่มต้นศึกษาการเขียนโปรแกรม Artificial Intelligence และ Machine Learning ได้อย่างดี

มาเรียนรู้และทำความเข้าใจกับเทคโนโลยีที่น่าตื่นเต้นนี้กันเถอะ!

หมายเหตุ: ข้อมูลในบทความนี้อาจจะผิด โปรดตรวจสอบความถูกต้องของบทความอีกครั้งหนึ่ง บทความนี้ไม่สามารถนำไปใช้อ้างอิงใด ๆ ได้ ทาง EPT ไม่ขอยืนยันความถูกต้อง และไม่ขอรับผิดชอบต่อความเสียหายใดที่เกิดจากบทความชุดนี้ทั้งทางทรัพย์สิน ร่างกาย หรือจิตใจของผู้อ่านและผู้เกี่ยวข้อง