Bỏ qua nội dung
RLMatrix Documentation

Ví dụ Cartpole

Bạn đã sẵn sàng để xem học tăng cường trong hành động? Trong hướng dẫn này, chúng ta sẽ thử thách với bài toán cân bằng cổ điển, nơi bạn sẽ theo dõi AI của mình học cách giữ cho một thanh đứng thẳng trên một chiếc xe di chuyển.

Thử thách cartpole kết hợp sự đơn giản với phản hồi trực quan, làm cho nó trở thành lý tưởng cho học tăng cường. Bạn đẩy xe sang trái hoặc phải, và vật lý sẽ quyết định liệu thanh gắn trên đó có giữ được thăng bằng hay sẽ đổ. Mỗi bước thời gian, tác tử (agent) của bạn đưa ra quyết định, và bạn có sự hài lòng khi xem thuật toán của mình dần dần thành thạo nhiệm vụ.

Thiết lập dự án của bạn

Chúng ta sẽ sử dụng SciSharp/Gym.NET để cung cấp môi trường vật lý mô phỏng.

Bạn có thể làm theo hoặc tải dự án hoàn chỉnh nếu bạn thích.

Hãy cài đặt các gói cần thiết:

Cài đặt các gói cần thiết
dotnet add package RLMatrix
dotnet add package RLMatrix.Toolkit
dotnet add package Gym.NET
dotnet add package Gym.NET.Environments
dotnet add package Gym.NET.Rendering.WinForm

Xây dựng môi trường

Đây là cách triển khai môi trường cartpole của chúng ta:

CartPoleEnvironment.cs
using System;
using System.Threading.Tasks;
using Gym.Environments.Envs.Classic;
using Gym.Rendering.WinForm;
using RLMatrix.Toolkit;
using NumSharp;


namespace MyEnv
{
    [RLMatrixEnvironment]
    public partial class CartPoleEnvironment
    {
        private CartPoleEnv myEnv;
        private float[] myState;
        private int stepCounter;
        private const int MaxSteps = 100000;
        private bool isDone;


        public CartPoleEnvironment()
        {
            InitialiseAsync();
        }


        private void InitialiseAsync()
        {
            myEnv = new CartPoleEnv(WinFormEnvViewer.Factory);
            ResetEnvironment();
        }


        [RLMatrixObservation]
        public float GetCartPosition() => myState[0];


        [RLMatrixObservation]
        public float GetCartVelocity() => myState[1];


        [RLMatrixObservation]
        public float GetPoleAngle() => myState[2];


        [RLMatrixObservation]
        public float GetPoleAngularVelocity() => myState[3];


        [RLMatrixActionDiscrete(2)]
        public void ApplyForce(int action)
        {
            if (isDone)
                ResetEnvironment();


            var (observation, reward, done, _) = myEnv.Step(action);
            myEnv.Render();
            myState = ToFloatArray(observation);
            isDone = done;
            stepCounter++;


            if (stepCounter > MaxSteps)
                isDone = true;
        }


        private float[] ToFloatArray(NDArray npArray)
        {
            double[] doubleArray = npArray.ToArray<double>();
            return Array.ConvertAll(doubleArray, item => (float)item);
        }


        [RLMatrixReward]
        public float CalculateReward()
        {
            return isDone ? 0 : 1;
        }


        [RLMatrixDone]
        public bool IsEpisodeFinished()
        {
            return isDone;
        }


        [RLMatrixReset]
        public void ResetEnvironment()
        {
            myEnv.Reset();
            myState = new float[4] { 0, 0, 0, 0 };
            isDone = false;
            stepCounter = 0;
        }
    }
}

Thiết lập huấn luyện

Bây giờ đến mã huấn luyện sẽ dạy tác tử của chúng ta cách cân bằng:

Program.cs
using RLMatrix.Agents.Common;
using RLMatrix;
using MyEnv;


Console.WriteLine("Starting cart-pole training...\n");


// Cấu hình tham số học
var learningSetup = new PPOAgentOptions(
    batchSize: 8,
    ppoEpochs: 8,
    memorySize: 1000,
    gamma: 0.99f,
    width: 128,
    entropyCoefficient: 0.01f,
    lr: 1E-02f
);


// Tạo môi trường và gắn vào tác tử
var environment = new CartPoleEnvironment().RLInit(maxStepsSoft: 1200, maxStepsHard: 1200);
var env = new List<IEnvironmentAsync<float[]>> {
    environment,
    //new CartPoleEnvironment().RLInit() //bỏ chú thích để huấn luyện với nhiều môi trường
};


// Khởi tạo tác tử
var agent = new LocalDiscreteRolloutAgent<float[]>(learningSetup, env);


// Huấn luyện đến khi hội tụ
for (int i = 0; i < 100000; i++)
{
    await agent.Step();
}


Console.WriteLine("\nTraining complete!");
Console.ReadLine();

Phần thưởng đơn giản +1 cho mỗi bước thời gian mạnh mẽ một cách đáng ngạc nhiên. Các thuật toán học tăng cường sâu tự nhiên tối ưu hóa cho trò chơi dài, hiểu rằng những điều chỉnh tinh tế, chủ động dẫn đến thời gian cân bằng lâu hơn và phần thưởng tích lũy cao hơn.

PPO trong RLMatrix: Điều gì khác biệt

Trong khi DQN (từ các hướng dẫn trước đây của chúng ta) có thể hiệu quả hơn về mẫu cho các tác vụ đơn giản, PPO thường mang lại quá trình huấn luyện ổn định hơn mà không đòi hỏi điều chỉnh siêu tham số rộng rãi. Điều này làm cho nó đặc biệt phù hợp cho các vấn đề kiểm soát đầy thách thức.

Kỹ thuật tiết kiệm bộ nhớ bạn cần biết

Hãy nhìn vào dòng này trong mã huấn luyện của chúng ta:

var environment = new CartPoleEnvironment().RLInit(maxStepsSoft: 1200, maxStepsHard: 1200);

Cấu hình tham số tưởng chừng như vô hại này chứa chìa khóa để huấn luyện với các tập rất dài mà không làm quá tải bộ nhớ GPU của bạn. Hãy để tôi giải thích:

Điều gì xảy ra khi chúng ta sửa đổi các giá trị này?

var environment = new CartPoleEnvironment().RLInit(maxStepsSoft: 200, maxStepsHard: 1200);

Bây giờ điều kỳ diệu xảy ra:

  1. Chúng ta chỉ tích lũy phần thưởng và tính toán gradient cho 200 bước đầu tiên
  2. Mô phỏng tiếp tục chạy tự nhiên lên đến 1200 bước hoặc cho đến khi thất bại
  3. Sử dụng bộ nhớ GPU của bạn giảm đáng kể

Khi bạn chạy cấu hình này, hãy kiểm tra biểu đồ phần thưởng – bạn sẽ nhận thấy không có phần thưởng nào vượt quá 200 (giới hạn mềm của chúng ta), mặc dù vật lý cartpole vẫn tiếp tục sau điểm đó. Mở trình quản lý tác vụ và xem việc tiết kiệm bộ nhớ theo thời gian thực.

Kỹ thuật này trở nên không thể thiếu đối với các môi trường phức tạp, nơi các tập có thể chạy vô thời hạn. Thay vì gặp sự cố với lỗi hết bộ nhớ, bạn kiểm soát chính xác mức độ nỗ lực tính toán để đầu tư trong khi vẫn duy trì động lực môi trường tự nhiên.

Xem quá trình học trong hành động

Khi bạn chạy quá trình huấn luyện này, một cửa sổ sẽ hiện lên hiển thị môi trường cartpole. Ban đầu, thanh sẽ đổ nhanh chóng – tác tử của bạn không biết nó đang làm gì. Nhưng trong vòng vài phút, bạn sẽ chứng kiến một sự chuyển đổi đáng kinh ngạc:

  1. Ban đầu, tác tử thực hiện các chuyển động ngẫu nhiên không có chiến lược
  2. Sau đó, nó bắt đầu phản ứng khi thanh đã đang rơi (quá muộn!)
  3. Nó dần dần học cách thực hiện các di chuyển điều chỉnh sớm hơn và sớm hơn
  4. Cuối cùng, nó thực hiện các điều chỉnh tinh tế, chủ động, giữ cho thanh cân bằng hoàn hảo

Sự tiến triển có thể nhìn thấy này là điều làm cho cartpole trở thành một ví dụ học tập thú vị. Bạn không chỉ thấy các con số cải thiện trong biểu đồ – bạn đang xem AI của mình phát triển một kỹ năng trước mắt bạn.

Kiểm tra sự hiểu biết của bạn

Hiểu về học tăng cường với Cartpole

Các bước tiếp theo

Trong hướng dẫn này, bạn đã:

  • Thiết lập mô phỏng vật lý thời gian thực cho học tăng cường
  • Triển khai một tác tử hoàn chỉnh để làm chủ vấn đề kiểm soát cổ điển
  • Học cách quản lý bộ nhớ hiệu quả với kỹ thuật kết thúc mềm/cứng
  • Hiểu cách triển khai PPO của RLMatrix khác với các triển khai tiêu chuẩn

Tiếp theo, chúng ta sẽ triển khai cùng môi trường mà không sử dụng bộ công cụ, cung cấp cho bạn cái nhìn sâu sắc về những gì đang xảy ra đằng sau những thuộc tính gọn gàng mà chúng ta đã sử dụng.

Cartpole không có Toolkit Xem những gì xảy ra bên dưới nắp capô bằng cách triển khai cartpole mà không có lớp trừu tượng toolkit.