提交

Author: lihong

人工智能导论/农夫过河/2105050132_李虹.py

@@ -0,0 +1,82 @@
+
+name = ["农夫", "狼", "羊", "菜"]
+scheme_count = 0
+
+# 完成过河
+def is_done(status):
+    return status[0] and status[1] and status[2] and status[3]
+
+# 生成下一个过河的所有情况
+def create_all_next_status(status):
+    next_status_list = []
+
+    for i in range(0, 4):
+        if status[0] != status[i]: # 和农夫不同一侧
+            continue
+
+        next_status = [status[0],status[1],status[2],status[3]]
+        # 农夫和其中一个过河，i 为 0 时候，农夫自己过河。
+        next_status[0] = not next_status[0]
+        next_status[i] = next_status[0] # 和农夫一起过河
+
+        if is_valid_status(next_status):
+            next_status_list.append(next_status)
+
+    return next_status_list
+
+# 判断是否合法的局面
+def is_valid_status(status):
+    if status[1] == status[2]:
+        if status[0] != status[1]:
+            # 狼和羊同侧，没有农夫在场
+            return False
+
+    if status[2] == status[3]:
+        if status[0] != status[2]:
+            # 羊和菜同侧，没有农夫在场
+            return False
+
+    return True
+
+def search(history_status):
+    global scheme_count
+    current_status = history_status[len(history_status) - 1]
+
+    next_status_list = create_all_next_status(current_status)
+    for next_status in next_status_list:
+        if next_status in history_status:
+            # 出现重复的情况
+            continue
+
+        history_status.append(next_status)
+
+        if is_done(next_status):
+            scheme_count += 1
+            print("方案 " + str(scheme_count) + ":")
+            print_history_status(history_status)
+        else:
+            search(history_status)
+
+        history_status.pop()
+
+def readable_status(status, is_across):
+    result = ""
+    for i in range(0,4):
+        if status[i] == is_across:
+            if len(result) != 0:
+                result += ","
+            result += name[i]
+
+    return "[" + result + "]"
+
+#打印结果
+def print_history_status(history_status):
+    for status in history_status:
+        print(readable_status(status, False) + "≈≈≈≈≈≈≈≈≈≈" + readable_status(status, True))
+
+if __name__ == "__main__":
+    # 初始状态
+    status = [False, False, False, False]
+    # 情况队列
+    history_status = [status]
+    search(history_status)

人工智能导论/基于Q-learning寻宝游戏/.idea/.gitignore

@@ -0,0 +1,227 @@
+import pandas as pd
+import numpy as np
+import time
+import tkinter as tk
+
+UNIT = 40  # 像素
+ENV_H = 8  # 格子高度
+ENV_W = 8  # 格子宽度
+
+
+class env(tk.Tk, object):
+    def __init__(self):
+        super(env, self).__init__()
+        self.action_space = ['u', 'd', 'l', 'r']  #上下左右四个动作
+        self.n_actions = len(self.action_space)
+        self.title('寻宝游戏')
+        self.geometry('{0}x{1}'.format(ENV_H * UNIT, ENV_H * UNIT))  #设置窗口的大小
+        self._build_ENV()
+
+    def _build_ENV(self):
+        # 创建游戏画布
+        self.canvas = tk.Canvas(self, bg='white',
+                                height=ENV_H * UNIT,
+                                width=ENV_W * UNIT)
+
+        # 绘制网格
+        for c in range(0, ENV_W * UNIT, UNIT):
+            x0, y0, x1, y1 = c, 0, c, ENV_H * UNIT
+            self.canvas.create_line(x0, y0, x1, y1)
+        for r in range(0, ENV_H * UNIT, UNIT):
+            x0, y0, x1, y1 = 0, r, ENV_W * UNIT, r
+            self.canvas.create_line(x0, y0, x1, y1)
+
+        # create origin
+        origin = np.array([20, 20])
+
+        # 创建陷阱
+        hell1_center = origin + np.array([UNIT * 2, UNIT])
+        self.hell1 = self.canvas.create_rectangle(
+            hell1_center[0] - 15, hell1_center[1] - 15,
+            hell1_center[0] + 15, hell1_center[1] + 15,
+            fill='black')
+        # 创建陷阱
+        hell2_center = origin + np.array([UNIT, UNIT * 2])
+        self.hell2 = self.canvas.create_rectangle(
+            hell2_center[0] - 15, hell2_center[1] - 15,
+            hell2_center[0] + 15, hell2_center[1] + 15,
+            fill='black')
+
+        # 创建陷阱
+        hell3_center = origin + np.array([UNIT * 2, UNIT * 6])
+        self.hell3 = self.canvas.create_rectangle(
+            hell3_center[0] - 15, hell3_center[1] - 15,
+            hell3_center[0] + 15, hell3_center[1] + 15,
+            fill='black')
+
+        # 创建陷阱
+        hell4_center = origin + np.array([UNIT * 6, UNIT * 2])
+        self.hell4 = self.canvas.create_rectangle(
+            hell4_center[0] - 15, hell4_center[1] - 15,
+            hell4_center[0] + 15, hell4_center[1] + 15,
+            fill='black')
+
+        # 创建陷阱
+        hell5_center = origin + np.array([UNIT * 4, UNIT * 4])
+        self.hell5 = self.canvas.create_rectangle(
+            hell5_center[0] - 15, hell5_center[1] - 15,
+            hell5_center[0] + 15, hell5_center[1] + 15,
+            fill='black')
+
+        # 创建陷阱
+        hell6_center = origin + np.array([UNIT * 4, UNIT * 1])
+        self.hell6 = self.canvas.create_rectangle(
+            hell6_center[0] - 15, hell6_center[1] - 15,
+            hell6_center[0] + 15, hell6_center[1] + 15,
+            fill='black')
+
+        # 创建陷阱
+        hell7_center = origin + np.array([UNIT * 1, UNIT * 3])
+        self.hell7 = self.canvas.create_rectangle(
+            hell7_center[0] - 15, hell7_center[1] - 15,
+            hell7_center[0] + 15, hell7_center[1] + 15,
+            fill='black')
+
+        # 创建陷阱
+        hell8_center = origin + np.array([UNIT * 2, UNIT * 4])
+        self.hell8 = self.canvas.create_rectangle(
+            hell8_center[0] - 15, hell8_center[1] - 15,
+            hell8_center[0] + 15, hell8_center[1] + 15,
+            fill='black')
+
+        # 创建陷阱
+        hell9_center = origin + np.array([UNIT * 3, UNIT * 2])
+        self.hell9 = self.canvas.create_rectangle(
+            hell9_center[0] - 15, hell9_center[1] - 15,
+            hell9_center[0] + 15, hell9_center[1] + 15,
+            fill='black')
+
+        # 创建宝藏
+        oval_center = origin + UNIT * 3
+        self.oval = self.canvas.create_oval(
+            oval_center[0] - 15, oval_center[1] - 15,
+            oval_center[0] + 15, oval_center[1] + 15,
+            fill='yellow')
+
+        # 创建寻宝人
+        self.rect = self.canvas.create_rectangle(
+            origin[0] - 15, origin[1] - 15,
+            origin[0] + 15, origin[1] + 15,
+            fill='red')
+
+        # 显示画布
+        self.canvas.pack()
+
+    def reset(self):
+        self.update()
+        time.sleep(0.5)
+        self.canvas.delete(self.rect)
+        origin = np.array([20, 20])
+        self.rect = self.canvas.create_rectangle(
+            origin[0] - 15, origin[1] - 15,
+            origin[0] + 15, origin[1] + 15,
+            fill='red')
+        # 返回观察结果
+        return self.canvas.coords(self.rect)
+
+    def step(self, action):
+        s = self.canvas.coords(self.rect) #获取当前寻宝人位置
+        base_action = np.array([0, 0])
+        if action == 0:  # 上
+            if s[1] > UNIT:
+                base_action[1] -= UNIT
+        elif action == 1:  # 下
+            if s[1] < (ENV_H - 1) * UNIT:
+                base_action[1] += UNIT
+        elif action == 2:  # 右
+            if s[0] < (ENV_W - 1) * UNIT:
+                base_action[0] += UNIT
+        elif action == 3:  # 左
+            if s[0] > UNIT:
+                base_action[0] -= UNIT
+
+        self.canvas.move(self.rect, base_action[0], base_action[1])  # 移动寻宝人
+
+        s_ = self.canvas.coords(self.rect)  # 获取新位置
+
+        # 奖励函数
+        if s_ == self.canvas.coords(self.oval):
+            reward = 1
+            done = True
+            s_ = 'terminal'
+        elif s_ in [self.canvas.coords(self.hell1), self.canvas.coords(self.hell2), self.canvas.coords(self.hell3),
+                    self.canvas.coords(self.hell4), self.canvas.coords(self.hell5), self.canvas.coords(self.hell6),
+                    self.canvas.coords(self.hell7),
+                    self.canvas.coords(self.hell8), self.canvas.coords(self.hell9)]:
+            reward = -1
+            done = True
+            s_ = 'terminal'
+        else:
+            reward = 0
+            done = False
+
+        return s_, reward, done
+
+    def render(self):
+        time.sleep(0.1)
+        self.update() #强制画布重绘
+
+
+class QLearningTable:
+    def __init__(self, actions, learning_rate=0.01, reward_decay=0.9, e_greedy=0.9):
+        self.actions = actions
+        self.lr = learning_rate
+        self.gamma = reward_decay
+        self.epsilon = e_greedy
+        self.q_table = pd.DataFrame(columns=self.actions, dtype=np.float64) #存储每个状态-动作对的 Q 值的数据帧
+
+    def choose_action(self, observation):
+        self.check_state_exist(observation)
+        if np.random.uniform() < self.epsilon:
+            #根据Q表选择最大的Q值对应的动作
+            state_action = self.q_table.loc[observation, :]
+            action = np.random.choice(state_action[state_action == np.max(state_action)].index)
+        else:
+            #随机选择一个动作
+            action = np.random.choice(self.actions)
+        return action
+
+    def learn(self, s, a, r, s_):
+        self.check_state_exist(s_)
+        q_predict = self.q_table.loc[s, a]
+        if s_ != 'terminal':
+            #结合当前奖励和未来预期的奖励
+            q_target = r + self.gamma * self.q_table.loc[s_, :].max()
+        else:
+            q_target = r
+        self.q_table.loc[s, a] += self.lr * (q_target - q_predict)
+
+
+    def check_state_exist(self, state): #检查状态 state 是否存在于 Q 表中
+        if state not in self.q_table.index:
+            self.q_table = self.q_table._append(
+                pd.Series([0] * len(self.actions), index=self.q_table.columns, name=state))
+
+
+def update():
+    for episode in range(150):
+        observation = env.reset()
+        print(episode)
+        while True:
+            env.render()
+            action = RL.choose_action(str(observation))
+            observation_, reward, done = env.step(action)
+            RL.learn(str(observation), action, reward, str(observation_))
+            observation = observation_
+            if done:
+                break
+    print('game over')
+    env.destroy()
+
+
+if __name__ == '__main__':
+    env = env()
+    RL = QLearningTable(actions=list(range(env.n_actions)))
+
+    env.after(100, update)
+    env.mainloop()

人工智能导论/基于Q-learning寻宝游戏/.idea/.name

@@ -0,0 +1,316 @@
+import numpy as np
+import copy
+import matplotlib.pyplot as plt
+import random
+
+#准备好距离矩阵
+city_num = 5
+city_dist_mat = np.zeros([city_num, city_num])
+city_dist_mat[0][1] = city_dist_mat[1][0] = 11
+city_dist_mat[0][2] = city_dist_mat[2][0] = 22
+city_dist_mat[0][3] = city_dist_mat[3][0] = 33
+city_dist_mat[0][4] = city_dist_mat[4][0] = 44
+city_dist_mat[1][2] = city_dist_mat[2][1] = 55
+city_dist_mat[1][3] = city_dist_mat[3][1] = 66
+city_dist_mat[1][4] = city_dist_mat[4][1] = 77
+city_dist_mat[2][3] = city_dist_mat[3][2] = 88
+city_dist_mat[2][4] = city_dist_mat[4][2] = 99
+city_dist_mat[3][4] = city_dist_mat[4][3] = 100
+
+
+# 定义全局变量，用于记录个体数量和距离列表
+num_person_idx = 0  # 个体索引
+num_person = 0      # 个体数量
+dis_list = []       # 距离列表
+
+class Individual:
+    def __init__(self, genes=None):
+        global num_person
+        global dis_list
+        global num_person_idx
+        num_person_idx += 1
+        # 每训练20次增加一个个体数量
+        if num_person_idx % 20 == 0:
+            num_person += 1
+        
+        self.genes = genes
+        
+        # 初始化基因
+        if self.genes == None:
+            genes = [0] * 5  # 城市数量
+            temp = [0] * 4
+            temp = [i for i in range(1, city_num)]  # 城市编号
+            random.shuffle(temp)  # 打乱城市顺序
+            genes[1:] = temp
+            genes[0] = 0
+            self.genes = genes
+            self.fitness = self.evaluate_fitness()  # 计算适应度
+        else:
+            self.fitness = float(self.evaluate_fitness())
+    
+    # 计算个体的适应度
+    def evaluate_fitness(self):
+        dis = 0
+        # 计算路径长度
+        for i in range(city_num - 1):
+            dis += city_dist_mat[self.genes[i]][self.genes[i+1]]
+            if i == city_num - 2:
+                dis += city_dist_mat[self.genes[i + 1]][0]  # 回到起点
+        # 每20个个体记录一次距离
+        if num_person_idx % 20 == 0:
+            dis_list.append(dis)
+        # 适应度为距离的倒数
+        return 1 / dis
+
+# 复制列表函数
+def copy_list(old):
+    new = []
+    for element in old:
+        new.append(element)
+    return new
+
+# 按适应度排序函数
+def sort_win_num(group):
+    for i in range(len(group)):
+        for j in range(len(group) - i - 1):
+            if group[j].fitness < group[j+1].fitness:
+                temp = group[j]
+                group[j] = group[j+1]
+                group[j+1] = temp
+    return group
+#定义Ga类 
+#3~5，交叉、变异、更新种群，全部在Ga类中实现
+class Ga:
+    #input_为城市间的距离矩阵
+    def __init__(self, input_):
+        #声明全局变量
+        global city_dist_mat
+        city_dist_mat = input_
+        #当代的最佳个体
+        self.best = Individual(None)
+        #种群
+        self.individual_list = []
+        #每一代的最佳个体
+        self.result_list = []
+        #每一代个体对应的最佳适应度
+        self.fitness_list = []
+   
+    
+    # 交叉操作，采用交叉变异方法
+    def cross(self):
+        new_gen = []  # 用于存放新一代的个体
+        num_cross = 3  # 交叉时选择的城市数量
+
+        # 对每两个相邻的个体进行交叉
+        for i in range(0, len(self.individual_list) - 1, 2):
+            parent_gen1 = copy_list(self.individual_list[i].genes)  # 父代1的基因
+            parent_gen2 = copy_list(self.individual_list[i+1].genes)  # 父代2的基因
+            index1_1 = 0
+            index1_2 = 0
+            index2_1 = 0
+            index2_2 = 0
+            index_list = [0] * 3  # 存放交叉的起始索引的列表
+
+            # 随机选择交叉的起始索引
+            for i in range(city_num - 3):  # 这里应该是range(city_num - num_cross)，即0，1
+                index_list[i] = i + 1
+            index1_1 = random.choice(index_list)
+            index1_2 = index1_1 + 2
+            index2_1 = random.choice(index_list)
+            index2_2 = index2_1 + 2
+
+            # 获取交叉段的城市列表
+            choice_list1 = parent_gen1[index1_1:index1_2 + 1]
+            choice_list2 = parent_gen2[index2_1:index2_2 + 1]
+
+            # 初始化两个子代的基因列表
+            son_gen1 = [0] * city_num
+            son_gen2 = [0] * city_num
+
+            # 将交叉段复制到子代中
+            son_gen1[index1_1: index1_2 + 1] = choice_list1
+            son_gen2[index2_1: index2_2 + 1] = choice_list2
+
+            temp1 = choice_list1  # 临时保存交叉段的城市列表
+            temp2 = choice_list2
+
+            # 处理未被交叉的城市
+            if index1_1 == 0:
+                pass
+            else:
+                for i in range(index1_1):
+                    for j in range(city_num):
+                        if parent_gen2[j] not in choice_list1:
+                            son_gen1[i] = parent_gen2[j]
+                            choice_list1.append(parent_gen2[j])
+                            break
+
+            choice_list1 = temp1
+
+            if index1_2 == city_num - 1:
+                pass
+            else:
+                for i in range(index1_2 + 1, city_num):
+                    for j in range(city_num):
+                        if parent_gen2[j] not in choice_list1:
+                            son_gen1[i] = parent_gen2[j]
+                            choice_list1.append(parent_gen2[j])
+                            break
+
+            # 处理子代2中未被交叉的城市，同理
+            if index2_1 == 0:
+                pass
+            else:
+                for i in range(index2_1):
+                    for j in range(city_num):
+                        if parent_gen1[j] not in choice_list2:
+                            son_gen2[i] = parent_gen1[j]
+                            choice_list2.append(parent_gen1[j])
+                            break
+
+            choice_list2 = temp2
+
+            if index2_2 == city_num - 1:
+                pass
+            else:
+                for i in range(index2_2 + 1, city_num):
+                    for j in range(city_num):
+                        if parent_gen1[j] not in choice_list2:
+                            son_gen2[i] = parent_gen1[j]
+                            choice_list2.append(parent_gen1[j])
+                            break
+
+            # 将新生成的子代加入新一代的列表中
+            new_gen.append(Individual(son_gen1))
+            new_gen.append(Individual(son_gen2))
+
+        return new_gen
+    #变异
+    def mutate(self, new_gen):
+        mutate_p = 0.02  # 变异概率，待调参数
+        index_list = [0] * (city_num - 1)  # 初始化索引列表
+        index_1 = 1  # 变异位置索引1
+        index_2 = 1  # 变异位置索引2
+        
+        # 初始化索引列表，表示基因中除了起点之外的位置
+        for i in range(city_num - 1):
+            index_list[i] = i + 1
+        
+        # 对于新生成的个体群中的每个个体
+        for individual in new_gen:
+            # 根据变异概率决定是否进行变异
+            if random.random() < mutate_p:
+                # 随机选择两个不同的位置进行交换
+                index_1 = random.choice(index_list)
+                index_2 = random.choice(index_list)
+                while index_1 == index_2:  # 确保选择的两个位置不相同
+                    index_2 = random.choice(index_list)
+                
+                # 交换选定位置上的基因值
+                temp = individual.genes[index_1]
+                individual.genes[index_1] = individual.genes[index_2]
+                individual.genes[index_2] = temp
+        
+        # 变异结束，将新生成的个体与老一代进行合并
+        self.individual_list += new_gen
+    #选择
+    def select(self):
+        #在此选用轮盘赌算法
+        #考虑到5的阶乘是120，所以可供选择的个体基数应该适当大一些，
+        #在此每次从种群中选择6个，进行轮盘赌，初始化60个个体，同时适当调高变异的概率
+        select_num = 6
+        select_list = []
+        for i in range(select_num):
+            
+            gambler = random.choice(self.individual_list)
+            gambler = Individual(gambler.genes)
+            select_list.append(gambler)
+        #求出这些fitness之和
+        sum = 0
+        for i in range(select_num):
+            sum += select_list[i].fitness
+        sum_m = [0]*select_num
+        #实现概率累加
+        for i in range(select_num):
+            for j in range(i+1):
+                sum_m[i] += select_list[j].fitness
+            sum_m[i] /= sum
+        new_select_list = []
+        p_num = 0#随机数
+        for i in range(select_num):
+            p_num = random.uniform(0,1)
+            if p_num>0 and p_num < sum_m[0]:
+                new_select_list.append(select_list[0])
+            elif p_num>= sum_m[0] and p_num < sum_m[1]:
+                new_select_list.append(select_list[1])
+            elif p_num >= sum_m[1] and p_num < sum_m[2]:
+                new_select_list.append(select_list[2])
+            elif p_num >= sum_m[2] and p_num < sum_m[3]:
+                new_select_list.append(select_list[3])
+            elif p_num >= sum_m[3] and p_num < sum_m[4]:
+                new_select_list.append(select_list[4])
+            elif p_num >= sum_m[4] and p_num < sum_m[5]:
+                new_select_list.append(select_list[5])
+            else:
+                pass
+        #将新生成的一代替代父代种群
+        self.individual_list = new_select_list
+    #更新种群
+    def next_gen(self):
+        #交叉
+        new_gene = self.cross()
+        #变异
+        self.mutate(new_gene)
+        #选择
+        self.select()
+        #获得这一代的最佳个体
+        for individual in self.individual_list:
+            if individual.fitness > self.best.fitness:
+                self.best = individual
+                
+                
+    def train(self):
+        #随机出初代种群#
+        individual_num = 60
+        self.individual_list = [Individual() for _ in range(individual_num)]
+        #迭代
+        gen_num = 100
+        for i in range(gen_num):
+            #从当代种群中交叉、变异、选择出适应度最佳的个体，获得子代产生新的种群
+            self.next_gen()
+            #连接首位
+            result = copy.deepcopy(self.best.genes)
+            result.append(result[0])
+            self.result_list.append(result)
+            self.fitness_list.append(self.best.fitness)
+        print(self.result_list[-1])
+        print('距离总和是：', 1/self.fitness_list[-1])
+        
+        
+    def draw(self):
+        # 创建x轴坐标，即迭代次数
+        x_list = [i for i in range(num_person)]
+        # 获取每一代最佳路径的长度列表作为y轴坐标
+        y_list = dis_list
+        # 设置图表大小
+        plt.rcParams['figure.figsize'] = (60, 45)
+        # 绘制折线图
+        plt.plot(x_list, y_list, color='g')
+        # 设置x轴标签
+        plt.xlabel('Cycles', size=50)
+        # 设置y轴标签
+        plt.ylabel('Route', size=50)
+        # 设置x轴刻度
+        x = np.arange(0, 80, 5)
+        plt.xticks(x)
+        y = np.arange(0, 1000, 20)
+        plt.yticks(y)
+        # 设置图表标题
+        plt.title('Trends in distance changes', size=50)
+        # 设置刻度标签大小
+        plt.tick_params(labelsize=30)
+        plt.show()
+
+route = Ga(city_dist_mat)  # 初始化遗传算法对象
+route.train()  # 训练遗传算法获取最优路径
+route.draw()  # 绘制路径长度变化趋势图