强化学习QLearning小例子以及注释代码

最新推荐文章于 2022-07-18 12:17:37 发布
最新推荐文章于 2022-07-18 12:17:37 发布
阅读量596 收藏 4
点赞数 2
分类专栏： 强化学习 文章标签： python 机器学习 强化学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41626059/article/details/114395085
版权

运行过程就是下面这样：
在这里插入图片描述
下面是代码：

# -*- coding: utf-8 -*-
"""
Created on Fri Mar  5 08:48:06 2021

@author: DELL
"""

import cv2 as cv
import numpy as np
import pandas as pd
import random as rd

nums_states = 8
nums_action = 4
gammma = 0.9 #衰减因子
epslion = 0.4 # 随机选择动作因子
epochs = 50

lr = 0.1

def Make_Q_table(nums_states,nums_action):
    '''
    Parameters
    ----------
    nums_states : int
        状态的数量，总共有九个状态，其中一个为终止状态.
    nums_action : int
        上下左右四个动作可以选择噢，还要根据当前所处的状态进行有条件的选择，比如靠近左边墙的时候，不可以选择向左移动.

    Returns
    -------
    q_table : DataFrame
        存储所有的q值.

    '''
    
    columns = ['up','down','left','right']
    index = range(1,9)
    q_table = pd.DataFrame(np.zeros(shape = (nums_states,nums_action)),index=index,columns=columns)
    
    return q_table

def Environment(s,step_nums):
    '''
    Parameters
    ----------
    s : int
        描述当前所处的状态.

    Returns
    -------
    使用cv绘图.

    '''
    id_map = {1:(1,1),
              2:(2,1),
              3:(3,1),
              4:(1,2),
              5:(2,2),
              6:(3,2),
              7:(1,3),
              8:(2,3)
        }
    if s == 'end':
        # 当s是end的时候，表示agent已经寻得了宝藏
        img = np.ones(shape=(600,600))
        img[400:600,400:600]=0.1
        for i in range(4):
            cv.line(img,(0,200*i),(600,200*i),(0,0,0),1)
            cv.line(img,(200*i,0),(200*i,600),(0,0,0),1)
        cv.putText(img,'getting treasure and taking %d steps'%step_nums,(100,300),cv.FONT_HERSHEY_SIMPLEX, 0.7,(0,0,0), 1, cv.LINE_AA)
        cv.imshow('treasure',img)
        cv.waitKey(2000)
        cv.destroyAllWindows()
            
    else:
        size = id_map[s]
        img = np.ones(shape=(600,600))
        img[(size[1]-1)*200:size[1]*200,(size[0]-1)*200:size[0]*200]=0.5
        img[400:600,400:600]=0
        for i in range(4):
            cv.line(img,(0,200*i),(600,200*i),(0,0,0),1)
            cv.line(img,(200*i,0),(200*i,600),(0,0,0),1)
        cv.imshow('treasure',img)
        cv.waitKey(100)

    
def choose_action(s,q_table):
    '''
    根据当前的状态选择agent需要执行的动作
    感觉这个选择动作稍微麻烦一些些，一个个来判断吧

    Parameters
    ----------
    s : int
        位置id.

    Returns
    -------
    动作名字（up,down,left,right）.
    奖励
    和下一个状态

    '''
    q_value_sa_dict = q_table.iloc[s-1,].to_dict()
    if s==1:#当该条件成立时，表示agent所处的位置是（1，1），agent不能向上走，也不能向左走,我们只能在向下和向右里面选择动作啦
        
        #只能在‘down’和‘right’之间选择动作
        actions = ['down','right']
        part_dict = {}
        for a in actions:
            part_dict[a]=q_value_sa_dict[a]
            
        is_rand = np.random.rand()
        if is_rand<epslion or all(x==0 for x in q_value_sa_dict.values()):#agent随机选择动作
            n = rd.randint(0,1)
            if n == 0:
                s_ = 4
                r = 0
                return actions[0], s_, r
            else:
                s_ = 2
                r = 0
                return actions[1], s_, r
        else:
            
            action = max(part_dict,key=part_dict.get)
            if action == 'down':
                s_ = 4
                r = 0
                return 'down', s_, r
            else:
                s_ = 2
                r = 0
                return 'right', s_, r
            
    elif s == 2: #可以采取的动作有down,left,right
        
        actions = ['down', 'left', 'right']
        part_dict = {}
        for a in actions:
            part_dict[a]=q_value_sa_dict[a]
        
        is_rand = np.random.rand()
        if is_rand<epslion or all(x==0 for x in q_value_sa_dict.values()):#agent随机选择动作
            n = rd.randint(0,2)
            if n == 0:
                s_ = 5
                r = 0
                return actions[0], s_, r
            elif n == 1:
                s_ = 1
                r = 0
                return actions[1], s_, r
            elif n == 2:
                s_ = 3
                r = 0
                return actions[2], s_, r
        else:
            
            action = max(part_dict,key=part_dict.get)
            
            if action == 'down':
                s_ = 5
                r = 0
                return 'down', s_, r
            elif action == 'left':
                s_ = 1
                r = 0
                return 'left', s_, r
            elif action == 'right':
                s_ = 3
                r = 0
                return 'right', s_, r
    elif s == 3: #只能在down和left之间选择动作
        actions = ['down','left']
        part_dict = {}
        for a in actions:
            part_dict[a]=q_value_sa_dict[a]
            
        is_rand = np.random.rand()
        if is_rand<epslion or all(x==0 for x in q_value_sa_dict.values()):#agent随机选择动作
            n = rd.randint(0,1)
            if n == 0:
                s_ = 6
                r = 0
                return actions[0], s_, r
            else:
                s_ = 2
                r = 0
                return actions[1], s_, r
        else:
            
            action = max(part_dict,key=part_dict.get)
            if action == 'down':
                s_ = 6
                r = 0
                return 'down', s_, r
            else:
                s_ = 2
                r = 0
                return 'left', s_, r
    elif s == 4: #可以采取的动作只有up,down,right
        actions = ['up', 'down', 'right']
        part_dict = {}
        for a in actions:
            part_dict[a]=q_value_sa_dict[a]
        
        is_rand = np.random.rand()
        if is_rand<epslion or all(x==0 for x in q_value_sa_dict.values()):#agent随机选择动作
            n = rd.randint(0,2)
            if n == 0:
                s_ = 1
                r = 0
                return actions[0], s_, r
            elif n == 1:
                s_ = 7
                r = 0
                return actions[1], s_, r
            elif n == 2:
                s_ = 5
                r = 0
                return actions[2], s_, r
        else:
            
            action = max(part_dict,key=part_dict.get)
            
            if action == 'up':
                s_ = 1
                r = 0
                return 'up', s_, r
            elif action == 'down':
                s_ = 7
                r = 0
                return 'down', s_, r
            elif action == 'right':
                s_ = 5
                r = 0
                return 'right', s_, r
    elif s == 5:#可以采取的动作是全部四种上下左右
        actions = ['up', 'down', 'left', 'right']
        part_dict = {}
        for a in actions:
            part_dict[a]=q_value_sa_dict[a]
        
        is_rand = np.random.rand()
        if is_rand<epslion or all(x==0 for x in q_value_sa_dict.values()):#agent随机选择动作
            n = rd.randint(0,3)
            if n == 0:
                s_ = 2
                r = 0
                return actions[0], s_, r
            elif n == 1:
                s_ = 8
                r = 0
                return actions[1], s_, r
            elif n == 2:
                s_ = 4
                r = 0
                return actions[2], s_, r
            elif n == 3:
                s_ = 6
                r = 0
                return actions[3], s_, r
                
        else:
            
            action = max(part_dict,key=part_dict.get)
            
            if action == 'up':
                s_ = 2
                r = 0
                return 'up', s_, r
            elif action == 'down':
                s_ = 8
                r = 0
                return 'down', s_, r
            elif action == 'right':
                s_ = 6
                r = 0
                return 'right', s_, r
            elif action == 'left':
                s_ = 4
                r = 0
                return 'left', s_, r
            
    elif s == 6:#可以选择的动作有up,down, left
        actions = ['up', 'down', 'left']
        part_dict = {}
        for a in actions:
            part_dict[a]=q_value_sa_dict[a]
        
        is_rand = np.random.rand()
        if is_rand<epslion or all(x==0 for x in q_value_sa_dict.values()):#agent随机选择动作
            n = rd.randint(0,2)
            if n == 0:
                s_ = 3
                r = 0
                return actions[0], s_, r
            elif n == 1:
                s_ = 'end'
                r = 1
                return actions[1], s_, r
            elif n == 2:
                s_ = 5
                r = 0
                return actions[2], s_, r
        else:
            
            action = max(part_dict,key=part_dict.get)
            
            if action == 'up':
                s_ = 3
                r = 0
                return 'up', s_, r
            elif action == 'down':
                s_ = 'end'
                r = 1
                return 'down', s_, r
            elif action == 'left':
                s_ = 5
                r = 0
                return 'left', s_, r
    elif s == 7:
        
        actions = ['up','right']
        part_dict = {}
        for a in actions:
            part_dict[a]=q_value_sa_dict[a]
            
        is_rand = np.random.rand()
        if is_rand<epslion or all(x==0 for x in q_value_sa_dict.values()):#agent随机选择动作
            n = rd.randint(0,1)
            if n == 0:
                s_ = 4
                r = 0
                return actions[0], s_, r
            else:
                s_ = 8
                r = 0
                return actions[1], s_, r
        else:
            
            action = max(part_dict,key=part_dict.get)
            if action == 'up':
                s_ = 4
                r = 0
                return 'up', s_, r
            else:
                s_ = 8
                r = 0
                return 'right', s_, r
    elif s == 8:
        actions = ['up', 'left', 'right']
        part_dict = {}
        for a in actions:
            part_dict[a]=q_value_sa_dict[a]
        
        is_rand = np.random.rand()
        if is_rand<epslion or all(x==0 for x in q_value_sa_dict.values()):#agent随机选择动作
            n = rd.randint(0,2)
            if n == 0:
                s_ = 5
                r = 0
                return actions[0], s_, r
            elif n == 1:
                s_ = 7
                r = 0
                return actions[1], s_, r
            elif n == 2:
                s_ = 'end'
                r = 1
                return actions[2], s_, r
        else:
            
            action = max(part_dict,key=part_dict.get)
            
            if action == 'up':
                s_ = 5
                r = 0
                return 'up', s_, r
            elif action == 'left':
                s_ = 7
                r = 0
                return 'left', s_, r
            elif action == 'right':
                s_ = 'end'
                r = 1
                return 'right', s_, r
        
        
def learn():
    # 开始学习，并且按照公式更新q表
    #先初始化一个q表
    q_table = Make_Q_table(nums_states,nums_action)
    
    
    for e in range(epochs):
        
        #初始化一个状态 s = 1
        s = 1
        #声明一个变量统计每一个episode行进了多少步
        step_nums = 0
        Environment(s,step_nums)
        flags = True
        
        while flags:
            
            a, s_, r = choose_action(s,q_table)
            
            if s_ == 'end':
                q_table.loc[s,a] = (1-lr) * q_table.loc[s,a] + lr*r
                flags = False
            else:
                q_table.loc[s,a] = (1-lr) * q_table.loc[s,a] + lr * (r + max(q_table.iloc[s_-1,]))
            
            step_nums+=1       
            s = s_           
            Environment(s,step_nums) 
    return q_table
         
                
if __name__ == '__main__':
    q_table = learn()
六七～
关注
专栏目录
Python QLearning算法详解及源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
08-07 157
QLearning算法的核心思想是根据当前状态和动作的奖励更新Q值。QLearning算法的核心思想是根据当前状态和动作的奖励更新Q值。QLearning算法的核心思想是根据当前状态和动作的奖励更新Q值。QLearning算法的核心思想是根据当前状态和动作的奖励更新Q值。QLearning算法的核心思想是根据当前状态和动作的奖励更新Q值。QLearning算法的核心思想是根据当前状态和动作的奖励更新Q值。QLearning算法的核心思想是根据当前状态和动作的奖励更新Q值。
白话强化学习（理论+代码）
`or 1 or 不正经の泡泡
12-02 2350
昨天无意中翻了翻以前的博文，发现关于强化学习部分的理论部分说的不是很清晰，属于那种懂得都懂，不懂的很难懂的那种。所以的话刚好趁期末有点空复习，那么把这个简要补充一下吧。从最基础的地方重新开始讲起吧，那么本文的话也是会将看起来比较复杂的概念进行简化，但是本文当中还是会有的，但是你可以选择性忽略，或者自行加一个补充。。那么本文目标啥呢强化学习的概念强加学习的特征理解马尔科夫决策bellman方程是啥Q-learnDQN。
rl:强化学习代码示例
03-22
rl 强化学习代码示例
强化学习 -- Q-Learning小实例手写入门代码
qq_34533266的博客
02-18 886
前言 本文针对下面这篇文章进行代码复现，文章写的很棒，但是算法最关键的更新步骤貌似有问题，本人使用原版公式。 http://www.cnblogs.com/coshaho/p/7475988.html 正文 使用矩阵模拟了环境以及奖励，可以先尝试读懂原文章。本文是针对文章做的复现，我的学习经历告诉我，要啃很多遍概念才可以将知识转化为实践。所以对该文章以及本文示例代码有困惑请务必多看教学视频理解概念。 本人也只是刚刚入门强化学习，对一些概念理解感觉较为困难，故有不足之处一定要评论私聊告知我。 import
强化学习入门及其实现代码
09-07
资料介绍了强化学习的基本概念概念、与其他机器学习方法的比较、基本原理和简单代码实例
Q-learning
guan18883287586的博客
04-26 935
学习增强学习有段时间了，也接触了Ｑ－learning了。但对此理解不是很透彻，知道看到头条文章对一篇ｐｏｓｔ翻译文才对此有了较深的理解，特此copy，望见谅。目录：故事案例Ｑ-table简介Q-learning 算法：学习动作值函数（action value function）Q-learning 算法流程Q-learning 算法的伪代码故事案例：骑士和公主假设你是一名骑士，并且你需要拯救上面的...
莫烦大大的增强学习的代码实例
08-06
莫烦大大的增强学习的代码实例````
强化学习 Q-learning 练手项目 二维世界寻找出口
qq_41314151的博客
08-23 2368
强化学习 Q-learning 练手项目 二维世界寻找出口 之前看到一个强化学习有意思的小项目，在一维世界里寻找宝藏的一个小项目。具体可点击： 莫烦Python-强化学习小例子 对于莫先生的讲解我有一些自己的理解，注释在了以下代码中，以防遗忘。我根据自己的理解和想法将这个一维的世界扩展成了二维的，把这个项目扩展成了一个在二维的平面世界中寻找出口的一个小项目，当然核心算法仍然是Q-learning，...
深度强化学习DQN算法实现小车平衡杆(CartPole)问题
最新发布
02-07
DQN（Deep Q-Network）算法是一种基于深度神经网络的强化学习算法，旨在解决Q-learning算法在高维状态空间中面临的问题。 本代码借鉴学习《深度强化学习专栏 —— 2.手撕DQN算法实现CartPole控制》，对每一行代码...
莫烦强化学习笔记整理（二）Q-learning
lxs3213196的博客
11-02 1337
莫烦强化学习笔记整理
深度强化学习笔记(二)——Q-learning学习与二维寻路demo实现
InkBamboo920的博客
08-07 2322
深度强化学习笔记(二)——Q-learning学习与二维寻路demo实现 文章目录深度强化学习笔记(二)——Q-learning学习与二维寻路demo实现前言理论什么是Q-Learning算法学习率折扣因子初始条件例子代码基础版走迷宫示意图升级版走迷宫示意图完整代码 前言 这几天稍微闲下来，把原来漏的坑给补上，并做了一个Q-Learning的demo，因为Q-leraning的demo,目前我看到比较多的都是莫烦大佬讲的那个一纬寻路的demo，我觉得看起来没有那么有代表性，于是在此基础上，自己修改做了一个二
强化学习实例（直接运行，直观，方法可替换，初学者代码友好）
08-19
强化学习模仿写的一段自动打乒乓球可视化的实例，直接运行val.py可观察到可视化结果，另外附上训练好的.pth文件，方便看到每一步运行过程，运行时直接替换对应的pth文件即可。
Q-learning代码
01-11
这是Q-learning算法的一个计算Q值表格的小代码，可以看出Q-table是如何更新的。
Q-Learning代码
10-19
Q-Learning代码，给出使用Q-Learning 的代码。
强化学习经典案列
02-02
1-grid-world,2-cartpole,3-atari 强化学习入门案例。
强化学习经典案例冰面滑行python代码带注释
12-14
冰面滑行问题是python拓展库Gym里内置的一个环境任务，本资源为强化学习经典案例冰面滑行代码，带注释，简单易懂，通过有模型的策略迭代解出最优状态价值函数和最优策略，值得一学
简单例子入门q learning附代码
qq_35027690的博客
11-19 1829
参考于：Step-By-Step Tutorial 极简Qlearning教程 假设有这样的大房间， 有门表示相互连通，将房间表示为点，连通关系表示为线，则上图可以建模为： 假设有个机器人处在任意某一个房间，它的最终目标是走到房间5。为了表示能走到房间5，我们在能直接到达房间5的边权重设为100，其他不能到达的边设为0，不存在的边设为-1（比如0和2之间不在直达路径）。则该问题就抽象为： 在...
Q-Learning的简单例子
duduhonghong的博客
03-22 869
这个例子是训练一个让小人从起点到达终点的智能体，从整个过程用控制台打印的方式展示，o代表小人，T代表终点，-代表可走的地方，小人到达T时游戏结束，获得奖励，示例如下： o----T， 小人向右走之后结果是 -o---T ， 再向右走之后结果是 --o--T ， 向左走之后结果是 -o---T ， 以此类推 先上代码 import numpy as np import pandas as pd import time # 设置随机数池，确保每次运行程序随机数都一样以便观察 np.random.see
强化学习代码实战
Allen_人工智能与大数据
07-18 4261
本文就介绍了机器学习中强化学习的经典模型DQN网络,代码实战。
MATLAB实现Q-learning强化学习算法训练指南
资源摘要信息:"Q-learning是一种无需模型的强化学习算法，主要用于解决马尔可夫决策过程中的决策问题。其核心思想是通过不断尝试和错误来学习一个动作-价值函数，该函数可以为给定状态下采取某个动作的期望收益提供...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值