24/8/15算法笔记 时序差分算法sarsa

最新推荐文章于 2024-10-14 17:16:49 发布
最新推荐文章于 2024-10-14 17:16:49 发布
阅读量440 收藏 2
点赞数 17
文章标签： 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yyyy2711/article/details/141231294
版权

  1. 在线学习：TD学习是一种在线学习算法，它可以在与环境交互的过程中逐步更新预测。

  2. 引导探索：TD学习算法使用之前的估计来引导对状态或状态-动作对的价值评估，这有助于在探索过程中减少不确定性。

  3. 时间差分更新：

    • TD更新公式通常写作：V(St)←V(St)+α[Rt+1+γV(St+1)−V(St)]V(St​)←V(St​)+α[Rt+1​+γV(St+1​)−V(St​)]
    • 其中，VV 是状态价值函数，StSt​ 和 St+1St+1​ 分别是当前和下一个状态，Rt+1Rt+1​ 是在 St+1St+1​ 处获得的即时奖励，αα 是学习率，γγ 是折扣因子。

  4. TD(0)：TD(0)是TD学习的一个特殊情况，它使用当前状态的估计值作为下一个状态的估计值，更新公式简化为：V(St)←V(St)+α[Rt+1−V(St)]V(St​)←V(St​)+α[Rt+1​−V(St​)]

  5. SARSA：状态-动作-奖励-状态-动作（State-Action-Reward-State-Action, SARSA）算法是TD学习的一种变体，它用于学习一个策略，同时更新状态-动作对的价值函数 QQ。

  6. Q-Learning：Q-Learning是另一种TD学习变体，它使用一个偏置策略来探索所有可能的动作，并更新状态-动作对的价值函数 QQ，目标是学习最优价值函数。

  7. 收敛性：在某些条件下，TD学习算法能够收敛到最优价值函数或最优策略。

  8. 应用：TD学习方法广泛应用于各种强化学习问题，包括游戏、机器人导航和控制等领域。

  9. 实现：TD学习可以很容易地实现，并与神经网络等函数逼近方法结合使用。

#获取一个格子的状态
def get_state(row,col):
    if row!=3:
        return 'ground'
    if row==3 and col==0:
        return 'ground'
    if row==3 and col==11:
        return 'terminal'
    return 'trap'
get_state(0,0)

def move(row,col,action):
    if get_state(row,col) in['trap','terminal']:
        return row,col,0
    if action ==0:
        row-=1
    if action==1:
        row+=1
    if action==2:
        col-=1
    if action==3:
        col+=1
    row = max(0,row)
    row = min(3,row)
    col = max(0,col)
    col = min(11,col)
    
    reward=-1
    if get_state(row,col) =='trap':
        reward-=100
    return row,col,reward
#初始化Q矩阵，用于评估每个动作的价值
import numpy as np
#初始化在每个格子里采取每个动作的分数，初始化都是0，因为没有任何的知识
Q = np.zeros([4,12,4])

Q.shape

(4, 12, 4)
#动作函数
import random
#根据状态选择一个动作
def get_action(row,col):
    #有小概率选择随机动作
    if random.random()<0.1:
        return random.choice(range(4))
    #否则选择分数最高的动作
    return Q[row,col].argmax()
get_action(0,0)
#算法核心
#更新分数，每次取决于当前的格子，当前的动作，下个格子，下个格子的动作
def get_update(row,col,action,reward,next_row,next_col,next_action):
    #计算target
    target = 0.9*Q[next_row,next_col,next_action]#用q矩阵来衡量
    target+=reward
    
    #计算value
    value = Q[row,col,action]
    
    #根据时序差分算法，当前state,action的分数 = 下一个state,action的分数*gamma+reward
    #此处是求两者的差，越接近0越好
    update = target-value
    
    #这个0.1相当于lr
    update*=0.1
    
    #更新当前状态和动作的分数
    return update
#在0，0向右走，得到-1，到达0，1，再次执行向右走
get_update(0,0,3,-1,0,1,3)

#训练，sarsa算法是在线学习算法
def train():
    for epoch in range(1500):
        #初始化当前位置
        row = random.choice(range(4))
        col = 0
        
        #初始化第一个动作
        action = get_action(row,col)
        
        #计算反馈的和，这个数字应该越大越好
        reward_sum=0   #衡量这个游戏玩的有多好
        
        #循环直到到达终点或者陷阱
        while get_state(row,col)not in ['terminal','trap']:
            
            #执行动作
            next_row,next_col,reward = move(row,col,action)
            reward_sum+=reward
            
            #求新位置的动作
            next_action = get_action(next_row,next_col)
            
            #更新分数
            update = get_update(row,col,actoin,reward,next_row,next_col,next_action)
            
            Q[row,col,action]+=update
            #更新当前位置
            row = next_row
            col = next_col
            action = next_action
        
        if epoch%150==0:
            print(epoch,reward_sum)
def show(row,col,action):
    graph=[
     '','0','0','0','0','0','0','0','0','0','0','0','0','0',
     '0','0','0','0','0','0','0','0','0','0','0','0','0','0',
     '0','0','0','0','0','0','0','0','0','2','2','2','2','2',   
     '2','2','2','2','2','1'
    ]
    action = {0:'上',1:'下',2:'左',3:'右'}[action]
    
    graph[row*12+col] = action
    
    graph=' '.join(graph)
    
    for i in range(0,4*12,12):
        print(graph[i:i+12])
        
show(1,1,0)
#测试函数
from IPython import display
import time

def test():
    #起点
    row = random.choice(range(4))
    col = 0
    
    #最多玩N步
    for _ in range(200):
        
        #获取当前状态，如果状态时终点或者陷阱
        if get_state(row,col)in ['trap','terminal']:
            break
        #选择最优动作
        action = Q[row,col].argmax()
        
        #打印这个动作
        display.clear_output(wait = True)
        time.sleep(0.1)
        show(row,col,action)
        
        #执行动作
        row,col,reward = move(row,col,action)
        
test()
for row in range(4):
    line=''
    for col in range(12):
        action = Q[row,col].argmax()
        action = {0:'上',1:'下',2:'左',3:'右'}[action]
        line+=action
    print(line)

Qlearning算法，sarsa算法的改进

#qlearning算法，在sarsa算法的改进
#算法核心
#更新分数，每次取决于当前的格子，当前的动作，下个格子，下个格子的动作
def get_update(row,col,action,reward,next_row,next_col,next_action):
    #计算target
    target = 0.9*Q[next_row,next_col,next_action].max()#改进#用q矩阵来衡量
    target+=reward
    
    #计算value
    value = Q[row,col,action]
    
    #根据时序差分算法，当前state,action的分数 = 下一个state,action的分数*gamma+reward
    #此处是求两者的差，越接近0越好
    update = target-value
    
    #这个0.1相当于lr
    update*=0.1
    
    #更新当前状态和动作的分数
    return update
#在0，0向右走，得到-1，到达0，1，再次执行向右走
get_update(0,0,3,-1,0,1,3)

N步sarsa算法

玩N步更新第一步参数

#获取一个格子的状态
def get_state(row,col):
    if row!=3:
        return 'ground'
    if row==3 and col==0:
        return 'ground'
    if row==3 and col==11:
        return 'terminal'
    return 'trap'
get_state(0,0)
#动作函数
import random
#根据状态选择一个动作
def get_action(row,col):
    #有小概率选择随机动作
    if random.random()<0.1:
        return random.choice(range(4))
    #否则选择分数最高的动作
    return Q[row,col].argmax()
get_action(0,0)
def move(row,col,action):
    if get_state(row,col) in['trap','terminal']:
        return row,col,0
    if action ==0:
        row-=1
    if action==1:
        row+=1
    if action==2:
        col-=1
    if action==3:
        col+=1
    row = max(0,row)
    row = min(3,row)
    col = max(0,col)
    col = min(11,col)
    
    reward=-1
    if get_state(row,col) =='trap':
        reward-=100
    return row,col,reward
#初始化q矩阵和3个list
import numpy as np

#初始化在每一个格子里采取每个动作的分数初始化都是0，因为没有任何的知识
Q = np.zeros([4,12,4])

#初始化3个list,用来存储状态动作，反馈的历史数据，因为后面要回溯这些数据
state_list = []
action_list=[]
reward_list=[]

Q.shape
#获取更新量的函数
#target时累加的
#获取5个时间步分别的分数
def get_update_list(next_row,next_col,next_action):
    #初始化的target是最后一个state和最后一个action的分数
    target = Q[next_row,next_col,next_action]
    
    #计算每一步的target
    #每一步的target等于下一步的target*0.9,再加上基本的reward
    #时间从后往前回溯，越以前的target会累加的信息越多
    #[4,3,2,1,0]
    target_list = []
    for i in range(5):
        row,col = state_list[i]
        action = action_list[i]
        value_list.append(Q[row,col,action])
        
    #计算每一步的更新量
    update_list = []
    for i in range(5):
        #根据时序差分算法，当前state,action的分数 = 下一个state,action的分数*gamma+reward
        #此处是求两者的差，越接近0越好
        update = target_list[i]-value_list[i]
        
        #这个0.1指lr学习率
        update*=0.1
        
        update_list.append(update)
        
    return update_list
#训练函数
def train():
    for epoch in range(1500):
        #初始化当前位置
        row =random.choice(range(4))
        col = 0
        #初始化第一个动作
        action = get_action(row,col)
        
        #计算反馈的和，这个数字一个越来越小
        reward_sum = 0
        
        #初始化3个列表
        state_list.clear()
        action_list.clear()
        reward_list.clear()
        
        #循环直到到达终点或陷阱
        while get_state(row,col)not in ['termianl','trap']:
            
            #执行动作
            next_row,next_col,reward = move(row,col,action)
            reward_sum+=reward
            
            #求新位置的动作
            next_action = get_action(next_row,next_col)
            
            #记录历史数据
            state_list.append([row,col])
            action_list.append([action])
            reward_list.append(reward)
            
            #积累到5步以后再开始更新参数
            if len(state_list)==5:
                #计算分数
                update_list = get_update_list(next_row,next_col,next_action)
                
                #只更新第一步的分数
                row,col = state_list[0]
                action = action_list[0]
                update = update_list[0]
                
                Q[row,col,action]+=update
                
                #移除第一步，这样再下一次循环时保持列表时5个元素
                state_list.pop(0)
                action_list.pop(0)
                reward_list.pop(0)
            #更新当前位置
            row = next_row
            col = next_col
            action = next_action
        #走到终点以后，更新剩下步数的update
        for i in range(len(state_list)):
            row,col = state_list[i]
            action = action_list[i]
            update =update_list[i]
            Q[row,col,action]+=update
            
        if epoch%100 ==0:
            print(epoch,reward_sum)

DynaQ算法

#获取一个格子的状态
def get_state(row,col):
    if row!=3:
        return 'ground'
    if row==3 and col==0:
        return 'ground'
    if row==3 and col==11:
        return 'terminal'
    return 'trap'
get_state(0,0)

def move(row,col,action):
    if get_state(row,col) in['trap','terminal']:
        return row,col,0
    if action ==0:
        row-=1
    if action==1:
        row+=1
    if action==2:
        col-=1
    if action==3:
        col+=1
    row = max(0,row)
    row = min(3,row)
    col = max(0,col)
    col = min(11,col)
    
    reward=-1
    if get_state(row,col) =='trap':
        reward-=100
    return row,col,reward
#动作函数
import random
#根据状态选择一个动作
def get_action(row,col):
    #有小概率选择随机动作
    if random.random()<0.1:
        return random.choice(range(4))
    #否则选择分数最高的动作
    return Q[row,col].argmax()
get_action(0,0)
#初始化Q矩阵和历史数据字典
import numpy as np

#初始化再每一个格子里采取每个动作的分数，初始化都是0，因为没有任何的知识
Q = np.zeros([4,12,4])

#保存历史数据，键是(row,col,action),值是(next_row,next_col,reward)
history = dict() #字典

Q.shape,history
((4, 12, 4), {})
#计算更新量函数，和qlearning函数一样
#更新分数，每次取决于当前的格子，当前的动作，下个格子，下个格子的动作
def get_update(row,col,action,reward,next_row,next_col,next_action):
    #计算target
    target = 0.9*Q[next_row,next_col,next_action]#用q矩阵来衡量
    target+=reward
    
    #计算value
    value = Q[row,col,action]
    
    #根据时序差分算法，当前state,action的分数 = 下一个state,action的分数*gamma+reward
    #此处是求两者的差，越接近0越好
    update = target-value
    
    #这个0.1相当于lr
    update*=0.1
    
    #更新当前状态和动作的分数
    return update
#在0，0向右走，得到-1，到达0，1，再次执行向右走
get_update(0,0,3,-1,0,1,3)

#离线学习函数
import random
def q_planning():
    #Qplanning循环，相当于是在反刍历史数据，随机取N个历史数据再进行离线学习
    for _ in range(20):
        #随机选择曾经遇到过的状态动作对
        row,col,action = random.choice(list(history.keys()))
        
        #再获取下一个状态和反馈
        next_row,next_col,reward = history[(row,col,action)]
        
        #计算分数
        update = get_update(row,col,action,reward,next_row,next_col)
        
        #更新分数
        Q[row,col,action]+=update
        
#训练，sarsa算法是在线学习算法
def train():
    for epoch in range(1500):
        #初始化当前位置
        row = random.choice(range(4))
        col = 0
        
        #初始化第一个动作
        action = get_action(row,col)
        
        #计算反馈的和，这个数字应该越大越好
        reward_sum=0   #衡量这个游戏玩的有多好
        
        #循环知道到达终点或者陷阱
        while get_state(row,col)not in ['terminal','trap']:
            
            #执行动作
            next_row,next_col,reward = move(row,col,action)
            reward_sum+=reward
            
            #求新位置的动作
            next_action = get_action(next_row,next_col)
            
            #更新分数
            update = get_update(row,col,actoin,reward,next_row,next_col,next_action)
            
            #将数据添加到模型中
            history [(row,col,action)] = next_row,next_col,reward
            
            #反刍历史数据，进行离线学习
            q_planning()

            #更新当前位置
            row = next_row
            col = next_col
            action = next_action
        
        if epoch%150==0:
            print(epoch,reward_sum)

青椒大仙KI11
关注
时序差分方法：Q-learning、SARSA和SARSA-Lambda【附带三个算法的代码实现】
一起加油~
07-11 648
本文详细介绍了强化学习中的时序差分方法，主要涉及Q-Learning算法、SARSA算法和多步SARSA算法。附带了这三个算法的代码实现，其中，SARSA算法和多步SARSA算法是基于CartPole-v0环境的，Q-Learning算法是基于Pendulum0v0环境的。......
强化学习系列--时序差分学习方法（SARSA算法）
qq_36892712的博客
08-25 1020
SARSA（State-Action-Reward-State-Action）是一种强化学习算法，用于解决马尔可夫决策过程（MDP）中的问题。SARSA算法属于基于值的强化学习算法，用于学习最优策略。在SARSA算法中，智能体通过与环境进行交互来学习。它基于当前状态、选择的动作、获得的奖励、下一个状态和下一个动作来更新价值函数（或者动作值函数），并根据更新后的价值函数选择下一个动作。
强化学习笔记(3)-时序差分更新算法
09-06 793
时序差分更新算法和回合更新算法一样都是利用经验数据进行学习，其区别在于时序差分更新不必等到回合结束，可以用现有的价值估计值来更新。因此时序差分更新既可用于回合制任务，也可用于连续性任务。 同策时序差分更新 从给定策略的情况下动作价值函数的定义出发，我们可以得到： 单步时序差分只需要采样一步，用来估计回报样本的值，这里表示有偏回报样本，与回合更新中由奖励计算得到的无偏回报样本相区别。 基于以上分析，我们可以定义单步时序差分目标为： 这里的U的上标(q)表示是对动作价值定义的，下标t:t+1表
强化学习时序差分算法之多步Sarsa算法——以悬崖漫步环境为例
佚名
07-31 1053
通过实验我们可以发现5步Sarsa算法的收敛性比单步Sarsa算法更快，此时多步Sarsa算法得到的策略会在最远离悬崖的一边行走，以保证最大的安全性。蒙特卡洛算法是无偏的，但是它的每一步的状态转移具有不确定性，同时每一步状态采取的动作所得到的不一样的奖励最终会累计起来，从而极大影响最终的状态估计，因而其方差较大。时序差分算法只采用了一步状态转移以及使用了一步奖励，因而具有非常小的方差；蒙特卡洛方法利用当前状态之后每一步奖励而不使用任何价值估计，时序差分算法则只利用当前状态的奖励以及对下一状态的价值估计。
时序差分算法：Sarsa&Qlearning
ggjkd的博客
03-12 552
一、 时序差分法 通过学习后继状态s’的值函数来逼近当前状态值函数，实现对不完整轨迹的学习（因为仅估计后继状态s’）。 V(st)=V(st)+α(Rt+1+γV(st+1)−V(st)) V\left(s_{t}\right)=V\left(s_{t}\right)+\alpha\left(R_{t+1}+\gamma V\left(s_{t+1}\right)-V\left(s_{t}\right)\right) V(st​)=V(st​)+α(Rt+1​+γV(st+1​)−V(st​)) 和MC相似
强化学习时序差分算法之Sarsa算法——以悬崖漫步环境为例
佚名
07-31 854
2.本悬崖漫步环境中无需提供奖励函数以及状态转移函数，而需提供一个与智能体进行交互的step()函数，该函数输入为智能体当前状态下的动作，输出为当前状态下的奖励以及智能体的下一状态，代码如下所示。3.实现Sarsa算法，维护一个Q_table()表格，本表格主要存储当前策略下所有状态动作对的价值，即所有状态下各个动作的动作价值函数，Sarsa算法与环境进行交互，采用。我们可以发现随着训练的进行，Sarsa算法获得的回报越来越高，在进行500条序列的学习后，可以获得-20左右的回报，此时非常接近最优策略了。
第5章 时序差分算法
qq_45481856的博客
08-15 760
我们在第四章介绍的动态规划算法要求是的，即要求与智能体交互的环境是完全已知的（例如迷宫或者给定规则的网格世界）。在这个条件下，智能体不需要和环境真正交互来采样数据，直接使用动态规划方法就可以解除最优价值或策略。这就好比对于有监督学习任务，如果直接显式给出了数据的分布公式，那么也可以通过在期望层面上直接最小化模型的泛化误差来更新参数，并不需要采样任何数据点。但是这在大部分场景下是无法实现的，机器学习的主要方法都是在数据分布未知的情况下针对具体的数据对模型做出更新的。
强化学习入门笔记3——时序差分算法，Sarsa 算法，Q-learning
bigludou的博客
04-18 272
需要强调的是， Q-learning的更新并非必须使用当前贪婪策略arg max aQ( s, a)采样得到的数据， 因为给定任意 (s ,a , r,s′ )都可以直接根据更新公式来更新 Q ， 为了探索， 我们通常使用一个 -贪婪策略来与环境交互。Sarsa 必须使用当前 -贪婪策略采样得到的数据， 因为它的更新中用到的Q(s′,a′)中的 a′ 是当前策略在s′ 下的动作。具体来说， 时序差分算法用当前获得的奖励加上下一个状态的价值估计来作为在当前状态会获得的回报， 即。现在开始无模型的学习。
时序差分 （Q-learning && SARSA）
一起加油~
05-23 2281
时序差分方法 时序差分方法是强化学习理论中最核心的内容，是强化学习领域最重要的成果，没有之一。与动态规划的方法和蒙特卡罗的方法比，时序差分的方法主要的不同点在值函数估计上面。 动态规划方法计算值函数是通过下式： V(St)←Eπ[Rt+1+γV(St+1)]=∑aπ(a∣St)∑s′,rp(s′,r∣St,a)[r+γV(s′)]V\left(S_{t}\right) \leftarrow E_{\pi}\left[R_{t+1}+\gamma V\left(S_{t+1}\right)\right]=\s
时序差分方法求解强化学习任务——基于同轨策略的时序差分控制(SARSA算法)
静静的学习就好
07-07 621
上一节介绍了时序差分方法的策略评估过程以及相比于蒙特卡洛方法，时序差分方法的优势。本节将介绍时序差分方法中具有代表性的方法：基于同轨策略的时序差分控制——SARSA算法。
25、n步时序差分预测1
08-03
通过n步时序差分算法，我们可以逐步逼近真实状态价值函数。 在Python中实现n步时序差分预测通常涉及以下步骤： - 初始化状态空间、起始状态、折扣因子、终端状态和真实价值函数。 - 定义一个函数来执行n步时序差分...
（5-2）时序差分学习和SARSA算法：SARSA算法
码农三叔
02-16 1373
SARSA（State-Action-Reward-State-Action）是一种强化学习算法，用于解决马尔可夫决策过程（MDP）中的控制问题，即学习一个最优策略来最大化累积奖励。
强化学习之Grid World的时序差分算法解析【MiniWorld】SYSU_2023SpringRL
zik的博客
04-21 389
Assignment1/td.py 提供了一个示例模板，模板内容可根据需求使用和修改，但需要保证其是一个可运行的程序，运行结果需打印出最终收敛的 V 表 v ，以及使用 env.update_r(v) 后将 V 表的值同步至环境端后的渲染图形，输出格式不限制。为了更好地展现最终的策略，我们有一个打印策略的函数，用于打印当前策略在每个状态下智能体会采取的动作。可以看到从起始位置开始到目标位置的路径大致是对的，这里的结果和一些超参数十分相关，例如迭代的次数num_episodes，和。里面介绍了，不再赘述。
【笔记】Day2.3.1DTO对象
2301_81538937的博客
10-11 471
当前端传来的数据中包含后端数据库没有的字段时，DTO 可以对这些数据进行转换和映射，以确保后端可以正常接收并处理这些数据。就传到（经过）DTO DTO对前端数据进行转换，使得后端数据库得以正常接收前端传回的数据。当前端传回的数据中含有后端数据库没有的字段时。DTO是一个联系前端数据和后端数据库的桥梁。一个默认前提：前端传回数据到数据库。存着后端数据库中没有的实体字段。
Go Wails 学习笔记：创建第一个项目
最新发布
程序媛平平无奇的一天
10-14 1042
Wails 通过结合前端技术和 Go 后端，提供了一个高效的方式来开发跨平台的桌面应用。其简单的项目初始化和清晰的结构使得开发者能够快速上手。通过 Wails，可以充分利用 Web 开发技能，同时获得原生桌面应用的优势。
【JasperReports笔记06】JasperReports报表开发之Jasper Studio开发工具中添加自定义字体
✅ Java 开发工程师，从事 Web 应用程序的研发，擅长 Spring、SpringBoot 等技术。 ✅ 热爱编程，业余时间学习新知识，通过 CSDN 记录学习心得和笔记内容。
10-11 144
在使用Jasper Studio工具制作报表模板的时候，我们一定会使用到字体文件，常见的字体有：微软雅黑和宋体，但是如果你想添加其他的字体，那么必须要下载字体，然后将其添加到Jasper Studio工具里面，这样才可以在开发开发工具里面使用对应的字体。我们可以在一些字体网站找自己喜欢的字体，然后下载到本地电脑里面，后续就可以开始配置字体路径啦。字体下载_免费字体下载_商用字体设计定制--字魂网字体天下-提供各类字体的免费下载和在线预览服务免费字体下载_免费商用字体_免费字体网_自由字体官网。
PostgreSQL学习笔记十：锁机制详解
软件行业技术文化交流。
10-11 1304
它通过不同级别的锁来控制对数据对象的并发访问，主要包括表级锁、行级锁、页级锁、咨询锁（Advisory Locks）以及死锁（Deadlocks）。咨询锁可以用于实现更细粒度的锁控制，例如，在不同的事务之间同步对特定资源的访问。咨询锁可以是会话级别的或事务级别的，允许用户在不同的进程或事务之间进行协调。：设计事务时，应尽量减少锁的持有时间，并避免长时间运行的事务，因为这会增加死锁的风险。这些锁可以是行级的、事务级的，或者是咨询锁（advisory locks），它们用于控制对表或行的并发访问。
stm32单片机个人学习笔记9（TIM输入捕获）
2302_80867398的博客
10-13 269
从模式选择Reset模式可以实现自动清零计数器CNT。
苍穹外卖学习笔记(二十一)
₍˄·͈༝·͈˄*₎◞ ̑̑的博客
10-13 358
取消订单与再来一单
Sarsa算法解析：现时策略时序差分控制在强化学习中的应用
"这篇文档是关于强化学习(RL)的教程，主要讲解了现时策略时序差分控制，特别是Sarsa算法及其扩展Sarsa(λ)，并结合Keras训练曲线和混淆矩阵对CNN层输出进行可视化。文档内容包括马尔科夫决策过程、动态规划、蒙特...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值