1
import gymnasium as gym
2
import numpy as np
3

4
# 初始化环境
5
env = gym.make("CartPole-v1")
6
state, _ = env.reset()
7
total_reward = 0
8

9
# 智能体与环境交互
10
for _ in range(100):
11
    action = env.action_space.sample()  # 随机动作
12
    next_state, reward, done, truncated, info = env.step(action)
13
    total_reward += float(reward)
14
    state = next_state
15
    if done or truncated:
16
        break
17

18
print(f"总奖励：{total_reward}")
19
env.close()

1
# 导入需要使用的库,其中numpy是支持数组和矩阵运算的科学计算库,而matplotlib是绘图库
2
import numpy as np
3
import matplotlib.pyplot as plt
4

5

6
class BernoulliBandit:
7
    """ 伯努利多臂老虎机,输入K表示拉杆个数 """
8
    def __init__(self, K:int):
9
        self.probs = np.random.uniform(size=K)  # 随机生成K个0～1的数,作为拉动每根拉杆的获奖概率
10
        # 概率
11
        self.best_idx = np.argmax(self.probs)  # 获奖概率最大的拉杆
12
        self.best_prob = self.probs[self.best_idx]   # 最大的获奖概率
13
        self.K = K
14

15
    def step(self, k):
16
        # 当玩家选择了k号拉杆后,根据拉动该老虎机的k号拉杆获得奖励的概率返回1（获奖）或0（未
17
        # 获奖）
18
        if np.random.rand() < self.probs[k]:
19
            return 1
20
        else:
21
            return 0
22

23

24
np.random.seed(1)  # 设定随机种子,使实验具有可重复性
25
K = 10
26
bandit_10_arm = BernoulliBandit(K)
27
print("随机生成了一个%d臂伯努利老虎机" % K)
28
print("获奖概率最大的拉杆为%d号,其获奖概率为%.4f" %
29
      (bandit_10_arm.best_idx, bandit_10_arm.best_prob))

1
class Solver:
2
    """ 多臂老虎机算法基本框架 """
3
    def __init__(self, bandit): #bandit：BernoulliBandit 的实例
4
        self.bandit = bandit
5
        self.counts = np.zeros(self.bandit.K)  # 每根拉杆的尝试次数
6
        self.regret = 0.  # 当前步的累积懊悔
7
        self.actions = []  # 维护一个列表,记录每一步的动作
8
        self.regrets = []  # 维护一个列表,记录每一步的累积懊悔
9

10
    def update_regret(self, k):
11
        # 计算累积懊悔并保存,k为本次动作选择的拉杆的编号
12
        self.regret += self.bandit.best_prob - self.bandit.probs[k]
13
        self.regrets.append(self.regret)
14

15
    def run_one_step(self):
16
        # 返回当前动作选择哪一根拉杆,由每个具体的策略实现
17
        raise NotImplementedError
18

19
    def run(self, num_steps):
20
        # 运行一定次数,num_steps为总运行次数
21
        for _ in range(num_steps):
22
            k = self.run_one_step()
23
            self.counts[k] += 1
24
            self.actions.append(k)
25
            self.update_regret(k)

1
class EpsilonGreedy(Solver):
2
    """ epsilon贪婪算法,继承Solver类 """
3
    def __init__(self, bandit, epsilon=0.01, init_prob=1.0):
4
        super(EpsilonGreedy, self).__init__(bandit)
5
        self.epsilon = epsilon
6
        #初始化拉动所有拉杆的期望奖励估值
7
        self.estimates = np.array([init_prob] * self.bandit.K)
8

9
    def run_one_step(self):
10
        if np.random.random() < self.epsilon:
11
            k = np.random.randint(0, self.bandit.K)  # 随机选择一根拉杆 随机抽取[0,K]的一个整数
12
        else:
13
            k = np.argmax(self.estimates)  # 选择期望奖励估值最大的拉杆
14
        r = self.bandit.step(k)  # 得到本次动作的奖励
15
        '''
16
        Q_old:self.estimates[k]
17
        N:self.counts[k] + 1(本次算进去后的第 N 次）
18
        r:这次奖励 r
19
        Q_new=Q_old+1/N(r-Q_old)
20
        '''
21
        self.estimates[k] += 1. / (self.counts[k] + 1) * (r - self.estimates[k])
22
        return k

1
def plot_results(solvers, solver_names):
2
    """生成累积懊悔随时间变化的图像。输入solvers是一个列表,列表中的每个元素是一种特定的策略。
3
    而solver_names也是一个列表,存储每个策略的名称"""
4
    for idx, solver in enumerate(solvers):
5
        time_list = range(len(solver.regrets))
6
        plt.plot(time_list, solver.regrets, label=solver_names[idx])
7
    plt.xlabel('Time steps')
8
    plt.ylabel('Cumulative regrets')
9
    plt.title('%d-armed bandit' % solvers[0].bandit.K)
10
    plt.legend()
11
    plt.show()
12

13
np.random.seed(1)
14
epsilon_greedy_solver = EpsilonGreedy(bandit_10_arm, epsilon=0.01)
15
epsilon_greedy_solver.run(5000)
16
print('epsilon-贪婪算法的累积懊悔为：', epsilon_greedy_solver.regret)
17
plot_results([epsilon_greedy_solver], ["EpsilonGreedy"])

1
np.random.seed(0)
2
epsilons = [1e-4, 0.01, 0.1, 0.25, 0.5]
3
epsilon_greedy_solver_list = [
4
    EpsilonGreedy(bandit_10_arm, epsilon=e) for e in epsilons
5
]
6
epsilon_greedy_solver_names = ["epsilon={}".format(e) for e in epsilons]
7
for solver in epsilon_greedy_solver_list:
8
    solver.run(5000)
9

10
plot_results(epsilon_greedy_solver_list, epsilon_greedy_solver_names)