从数据到行动：如何利用智能体模型进行自动化决策

import numpy as np
import random

# 定义网格世界环境
class GridWorld:
    def __init__(self, size=(5, 5), goal=(4, 4)):
        self.size = size  # 环境大小
        self.goal = goal  # 目标位置
        self.agent_pos = (0, 0)  # 智能体初始位置

    def reset(self):
        """重置环境，智能体回到起始位置"""
        self.agent_pos = (0, 0)
        return self.agent_pos

    def step(self, action):
        """执行一个动作，并返回新的状态、奖励和是否完成"""
        x, y = self.agent_pos

        if action == 0:  # 上
            x = max(0, x - 1)
        elif action == 1:  # 下
            x = min(self.size[0] - 1, x + 1)
        elif action == 2:  # 左
            y = max(0, y - 1)
        elif action == 3:  # 右
            y = min(self.size[1] - 1, y + 1)

        self.agent_pos = (x, y)

        # 判断是否到达目标
        if self.agent_pos == self.goal:
            return self.agent_pos, 100, True  # 到达目标，奖励100
        else:
            return self.agent_pos, -1, False  # 每步惩罚-1

    def get_state(self):
        return self.agent_pos

    def get_possible_actions(self):
        return [0, 1, 2, 3]  # 上、下、左、右

class QLearningAgent:
    def __init__(self, environment, alpha=0.1, gamma=0.9, epsilon=0.2):
        self.env = environment
        self.alpha = alpha  # 学习率
        self.gamma = gamma  # 折扣因子
        self.epsilon = epsilon  # 探索率
        self.q_table = {}  # Q值表

    def get_q_value(self, state, action):
        """获取Q值"""
        if state not in self.q_table:
            self.q_table[state] = np.zeros(4)  # 初始化Q值为0
        return self.q_table[state][action]

    def update_q_value(self, state, action, reward, next_state):
        """更新Q值"""
        future_q = np.max(self.q_table.get(next_state, np.zeros(4)))
        current_q = self.get_q_value(state, action)
        self.q_table[state][action] = current_q + self.alpha * (reward + self.gamma * future_q - current_q)

    def choose_action(self, state):
        """选择一个动作（ε-贪婪策略）"""
        if random.uniform(0, 1) < self.epsilon:
            return random.choice(self.env.get_possible_actions())  # 随机探索
        else:
            return np.argmax(self.q_table.get(state, np.zeros(4)))  # 利用已有知识

    def train(self, episodes=1000):
        for episode in range(episodes):
            state = self.env.reset()
            done = False
            while not done:
                action = self.choose_action(state)
                next_state, reward, done = self.env.step(action)
                self.update_q_value(state, action, reward, next_state)
                state = next_state

# 创建环境和智能体
env = GridWorld()
agent = QLearningAgent(env)

# 训练智能体
agent.train()

# 打印最终的Q值表
print("训练后的Q值表：")
for state, q_values in agent.q_table.items():
    print(f"状态 {state}: {q_values}")

# 自动驾驶环境简化版示例
class DrivingEnvironment:
    def __init__(self):
        self.state = 'idle'  # 当前状态
        self.traffic_signal = 'green'  # 交通信号
        self.other_vehicles = {'left': 'stop', 'right': 'go'}  # 其他车辆的状态

    def get_state(self):
        return self.state, self.traffic_signal, self.other_vehicles

    def step(self, action):
        """自动驾驶智能体根据动作选择驾驶行为"""
        if action == 'accelerate':
            self.state = 'moving'
        elif action == 'brake':
            self.state = 'stopped'
        return self.state, self.evaluate_action(action)

    def evaluate_action(self, action):
        """根据智能体的动作评估其合理性"""
        if self.state == 'moving' and self.traffic_signal == 'red':
            return -10  # 红灯时加速会被惩罚
        elif self.state == 'stopped' and self.traffic_signal == 'green':
            return 10  # 绿灯时停车加速是奖励
        return 0  # 其他情况下无奖励或惩罚

class FinancialAgent:
    def __init__(self):
        self.balance = 10000  # 初始资金
        self.stock_price = 100  # 初始股价
        self.action_history = []  # 动作历史

    def get_state(self):
        return self.balance, self.stock_price

    def step(self, action):
        """模拟股票交易"""
        if action == 'buy':
            self.balance -= self.stock_price  # 买入股票
        elif action == 'sell':
            self.balance += self.stock_price  # 卖出股票
        self.action_history.append(action)
        reward = self.balance - 10000  # 简化的奖励函数，基于余额的变化
        return self.get_state(), reward

class SupplyChainAgent:
    def __init__(self, initial_stock=100):
        self.stock = initial_stock  # 初始库存
        self.demand = 50  # 需求量
        self.production_rate = 10  # 每单位时间生产量

    def get_state(self):
        return self.stock, self.demand

    def step(self, action):
        """根据生产决策调整库存"""
        if action == 'produce':
            self.stock += self.production_rate
        elif action == 'sell':
            self.stock -= self.demand
        reward = max(0, self.stock - self.demand)  # 库存越高，奖励越大
        return self.get_state(), reward