Trong các hệ thống đa tác tử (Multi-Agent Systems - MAS), việc đạt được sự đồng thuận giữa các cá thể có mục tiêu riêng biệt là một thách thức lớn. Thay vì sử dụng một bộ điều khiển trung tâm, lý thuyết trò chơi phân tán cho phép mỗi tác tử tự điều chỉnh chiến lược dựa trên tương tác cục bộ với các láng giềng, từ đó dẫn dắt toàn bộ hệ thống đến một trạng thái cân bằng ổn định. Để minh họa, chúng ta sẽ mô phỏng một kịch bản gồm 5 tác tử được kết nối theo cấu trúc vòng tròn. Mỗi tác tử khởi đầu với một giá trị chiến lược ngẫu nhiên.

import numpy as np

# Khởi tạo trạng thái ban đầu của 5 tác tử
state_vector = np.array([2.5, 7.2, 4.8, 1.5, 8.6])
# Định nghĩa cấu trúc mạng (danh sách láng giềng của từng node)
topology = [[4, 1], [0, 2], [1, 3], [2, 4], [3, 0]]

print("Trạng thái chiến lược ban đầu:", state_vector)

Điểm mấu chốt của trò chơi phân tán nằm ở quy tắc cập nhật. Mỗi tác tử phải cân bằng giữa hai yếu tố: xu hướng hội tụ theo số đông (consensus) và sự bảo thủ hoặc cạnh tranh cá nhân (conflict). Chúng ta điều phối sự cân bằng này thông qua một tham số trọng số. Dưới đây là hàm tính toán bước nhảy chiến lược:

def calculate_next_step(current, neighbors_data, gamma=0.25):
    # Tính giá trị trung bình của các tác tử láng giềng
    local_mean = np.mean(neighbors_data)
    
    # Thành phần hội tụ: thu hẹp khoảng cách với láng giềng
    cohesion = (1 - gamma) * (local_mean - current)
    
    # Thành phần điều chỉnh (game factor): tạo ra sự dao động thử nghiệm
    adjustment = gamma * (local_mean - current)
    
    return current + cohesion + adjustment

Trong công thức trên, tham số `gamma` đóng vai trò quyết định. Nếu `gamma` bằng 0, hệ thống trở thành một thuật toán đồng thuận thuần túy. Khi `gamma` tăng lên, các tác tử sẽ có những phản ứng mang tính "toan tính" hơn đối với sự thay đổi của đối phương, tạo ra các tương tác phức tạp hơn trước khi đạt tới điểm cân bằng. Tiếp theo, chúng ta thực hiện mô phỏng quá trình lặp để quan sát sự hội tụ của hệ thống:

import matplotlib.pyplot as plt

history_log = [state_vector.copy()]
iterations = 25

for i in range(iterations):
    next_states = np.zeros_like(state_vector)
    for idx in range(len(state_vector)):
        neighbor_values = state_vector[topology[idx]]
        next_states[idx] = calculate_next_step(state_vector[idx], neighbor_values, gamma=0.35)
    
    state_vector = next_states
    history_log.append(state_vector.copy())

# Trực quan hóa quá trình hội tụ
plt.figure(figsize=(10, 5))
data_points = np.array(history_log)
for agent_idx in range(data_points.shape[1]):
    plt.plot(data_points[:, agent_idx], label=f'Agent {agent_idx}', marker='s', markersize=3)

plt.title('Quá trình hội tụ của trò chơi phân tán')
plt.xlabel('Số lần lặp (Iterations)')
plt.ylabel('Giá trị chiến lược')
plt.legend()
plt.grid(alpha=0.3)
plt.show()

Trong thực tế, việc truyền thông giữa các tác tử không phải lúc nào cũng hoàn hảo. Độ trễ mạng hoặc mất gói tin có thể làm gián đoạn quá trình cập nhật. Để mô phỏng tính không xác định này, chúng ta có thể áp dụng cơ chế cập nhật bất đồng bộ:

def stochastic_update(current, neighbors_data, gamma=0.35, failure_rate=0.15):
    # Mô phỏng trường hợp tác tử không nhận được dữ liệu do lỗi truyền tin
    if np.random.rand() < failure_rate:
        return current
    return calculate_next_step(current, neighbors_data, gamma)

Sự xuất hiện của các yếu tố ngẫu nhiên đôi khi giúp hệ thống thoát khỏi các điểm tối ưu cục bộ, mặc dù nó có thể kéo dài thời gian cần thiết để đạt được sự đồng thuận cuối cùng. Khi triển khai các hệ thống này, cần lưu ý rằng nếu tham số điều chỉnh (gamma) quá lớn, hệ thống có thể rơi vào trạng thái phân kỳ hoặc dao động vĩnh viễn. Việc kiểm soát biên độ tương tác là chìa khóa để đảm bảo tính ổn định của toàn bộ mạng lưới tác tử trong các bài toán thực tế như điều khiển lưới điện thông minh hoặc điều phối bầy đàn robot.