强化学习 DQN 实战GYM下的CartPole游戏

【ReinforcementLearning】二、强化学习初探——以gym库中的CartPole环境为例 以强化学习的gym官方库中的CartPole环境为例,介绍强化学习中的相关概及智能体与环境分离编程的实现。 阅读详情

代码和解释

安装依赖

!pip uninstall -y parl  # 说明:AIStudio预装的parl版本太老,容易跟其他库产生兼容性冲突,建议先卸载
!pip uninstall -y pandas scikit-learn # 提示:在AIStudio中卸载这两个库再import parl可避免warning提示,不卸载也不影响parl的使用

!pip install gym
!pip install paddlepaddle==1.6.3
!pip install parl==1.3.1

# 说明:安装日志中出现两条红色的关于 paddlehub 和 visualdl 的 ERROR 与parl无关,可以忽略,不影响使用

导入依赖

import parl
from parl import layers
import paddle.fluid as fluid
import copy
import numpy as np
import os
import gym
from parl.utils import logger

设置超参数

LEARN_FREQ = 5 # 训练频率,不需要每一个step都learn,攒一些新增经验后再learn,提高效率
MEMORY_SIZE = 20000    # replay memory的大小,越大越占用内存
MEMORY_WARMUP_SIZE = 200  # replay_memory 里需要预存一些经验数据,再开启训练
BATCH_SIZE = 32   # 每次给agent learn的数据数量,从replay memory随机里sample一批数据出来
LEARNING_RATE = 0.001 # 学习率
GAMMA = 0.99 # reward 的衰减因子,一般取 0.9 到 0.999 不等

搭建Model、Algorithm、Agent架构

Model

class Model(parl.Model):
    def __init__(self, act_dim):
        hid1_size = 128
        hid2_size = 128
        # 3层全连接网络
        self.fc1 = layers.fc(size=hid1_size, act='relu')
        self.fc2 = layers.fc(size=hid2_size, act='relu')
        self.fc3 = layers.fc(size=act_dim, act=None)

    def value(self, obs):
        # 定义网络
        # 输入state,输出所有action对应的Q,[Q(s,a1), Q(s,a2), Q(s,a3)...]
        h1 = self.fc1(obs)
        h2 = self.fc2(h1)
        Q = self.fc3(h2)
        return Q

Algorithm

# from parl.algorithms import DQN # 也可以直接从parl库中导入DQN算法

class DQN(parl.Algorithm):
    def __init__(self, model, act_dim=None, gamma=None, lr=None):
        """ DQN algorithm
        
        Args:
            model (parl.Model): 定义Q函数的前向网络结构
            act_dim (int): action空间的维度,即有几个action
            gamma (float): reward的衰减因子
            lr (float): learning rate 学习率.
        """
        self.model = model
        self.target_model = copy.deepcopy(model)

        assert isinstance(act_dim, int)
        assert isinstance(gamma, float)
        assert isinstance(lr, float)
        self.act_dim = act_dim
        self.gamma = gamma
        self.lr = lr

    def predict(self, obs):
        """ 使用self.model的value网络来获取 [Q(s,a1),Q(s,a2),...]
        """
        return self.model.value(obs)

    def learn(self, obs, action, reward, next_obs, terminal):
        """ 使用DQN算法更新self.model的value网络
        """
        # 从target_model中获取 max Q' 的值,用于计算target_Q
        next_pred_value = self.target_model.value(next_obs)
        best_v = layers.reduce_max(next_pred_value, dim=1)
        best_v.stop_gradient = True  # 阻止梯度传递
        terminal = layers.cast(terminal, dtype='float32')
        target = reward + (1.0 - terminal) * self.gamma * best_v

        pred_value = self.model.value(obs)  # 获取Q预测值
        # 将action转onehot向量,比如:3 => [0,0,0,1,0]
        action_onehot = layers.one_hot(action, self.act_dim)
        action_onehot = layers.cast(action_onehot, dtype='float32')
        # 下面一行是逐元素相乘,拿到action对应的 Q(s,a)
        # 比如:pred_value = [[2.3, 5.7, 1.2, 3.9, 1.4]], action_onehot = [[0,0,0,1,0]]
        #  ==> pred_action_value = [[3.9]]
        pred_action_value = layers.reduce_sum(
            layers.elementwise_mul(action_onehot, pred_value), dim=1)

        # 计算 Q(s,a) 与 target_Q的均方差,得到loss
        cost = layers.square_error_cost(pred_action_value, target)
        cost = layers.reduce_mean(cost)
        optimizer = fluid.optimizer.Adam(learning_rate=self.lr)  # 使用Adam优化器
        optimizer.minimize(cost)
        return cost

    def sync_target(self):
        """ 把 self.model 的模型参数值同步到 self.target_model
        """
        self.model.sync_weights_to(self.target_model)

Agent

class Agent(parl.Agent):
    def __init__(self,
                 algorithm,
                 obs_dim,
                 act_dim,
                 e_greed=0.1,
                 e_greed_decrement=0):
        assert isinstance(obs_dim, int)
        assert isinstance(act_dim, int)
        self.obs_dim = obs_dim
        self.act_dim = act_dim
        super(Agent, self).__init__(algorithm)

        self.global_step = 0
        self.update_target_steps = 200  # 每隔200个training steps再把model的参数复制到target_model中

        self.e_greed = e_greed  # 有一定概率随机选取动作,探索
        self.e_greed_decrement = e_greed_decrement  # 随着训练逐步收敛,探索的程度慢慢降低

    def build_program(self):
        self.pred_program = fluid.Program()
        self.learn_program = fluid.Program()

        with fluid.program_guard(self.pred_program):  # 搭建计算图用于 预测动作,定义输入输出变量
            obs = layers.data(
                name='obs', shape=[self.obs_dim], dtype='float32')
            self.value = self.alg.predict(obs)

        with fluid.program_guard(self.learn_program):  # 搭建计算图用于 更新Q网络,定义输入输出变量
            obs = layers.data(
                name='obs', shape=[self.obs_dim], dtype='float32')
            action = layers.data(name='act', shape=[1], dtype='int32')
            reward = layers.data(name='reward', shape=[], dtype='float32')
            next_obs = layers.data(
                name='next_obs', shape=[self.obs_dim], dtype='float32')
            terminal = layers.data(name='terminal', shape=[], dtype='bool')
            self.cost = self.alg.learn(obs, action, reward, next_obs, terminal)

    def sample(self, obs):
        sample = np.random.rand()  # 产生0~1之间的小数
        if sample < self.e_greed:
            act = np.random.randint(self.act_dim)  # 探索:每个动作都有概率被选择
        else:
            act = self.predict(obs)  # 选择最优动作
        self.e_greed = max(
            0.01, self.e_greed - self.e_greed_decrement)  # 随着训练逐步收敛,探索的程度慢慢降低
        return act

    def predict(self, obs):  # 选择最优动作
        obs = np.expand_dims(obs, axis=0)
        pred_Q = self.fluid_executor.run(
            self.pred_program,
            feed={'obs': obs.astype('float32')},
            fetch_list=[self.value])[0]
        pred_Q = np.squeeze(pred_Q, axis=0)
        act = np.argmax(pred_Q)  # 选择Q最大的下标,即对应的动作
        return act

    def learn(self, obs, act, reward, next_obs, terminal):
        # 每隔200个training steps同步一次model和target_model的参数
        if self.global_step % self.update_target_steps == 0:
            self.alg.sync_target()
        self.global_step += 1

        act = np.expand_dims(act, -1)
        feed = {
            'obs': obs.astype('float32'),
            'act': act.astype('int32'),
            'reward': reward,
            'next_obs': next_obs.astype('float32'),
            'terminal': terminal
        }
        cost = self.fluid_executor.run(
            self.learn_program, feed=feed, fetch_list=[self.cost])[0]  # 训练一次网络
        return cost

ReplayMemory

import random
import collections
import numpy as np


class ReplayMemory(object):
    def __init__(self, max_size):
        self.buffer = collections.deque(maxlen=max_size)

    # 增加一条经验到经验池中
    def append(self, exp):
        self.buffer.append(exp)

    # 从经验池中选取N条经验出来
    def sample(self, batch_size):
        mini_batch = random.sample(self.buffer, batch_size)
        obs_batch, action_batch, reward_batch, next_obs_batch, done_batch = [], [], [], [], []

        for experience in mini_batch:
            s, a, r, s_p, done = experience
            obs_batch.append(s)
            action_batch.append(a)
            reward_batch.append(r)
            next_obs_batch.append(s_p)
            done_batch.append(done)

        return np.array(obs_batch).astype('float32'), \
            np.array(action_batch).astype('float32'), np.array(reward_batch).astype('float32'),\
            np.array(next_obs_batch).astype('float32'), np.array(done_batch).astype('float32')

    def __len__(self):
        return len(self.buffer)

Training && Test

# 训练一个episode
def run_episode(env, agent, rpm):
    total_reward = 0
    obs = env.reset()
    step = 0
    while True:
        step += 1
        action = agent.sample(obs)  # 采样动作,所有动作都有概率被尝试到
        next_obs, reward, done, _ = env.step(action)
        rpm.append((obs, action, reward, next_obs, done))

        # train model
        if (len(rpm) > MEMORY_WARMUP_SIZE) and (step % LEARN_FREQ == 0):
            (batch_obs, batch_action, batch_reward, batch_next_obs,
             batch_done) = rpm.sample(BATCH_SIZE)
            train_loss = agent.learn(batch_obs, batch_action, batch_reward,
                                     batch_next_obs,
                                     batch_done)  # s,a,r,s',done

        total_reward += reward
        obs = next_obs
        if done:
            break
    return total_reward


# 评估 agent, 跑 5 个episode,总reward求平均
def evaluate(env, agent, render=False):
    eval_reward = []
    for i in range(5):
        obs = env.reset()
        episode_reward = 0
        while True:
            action = agent.predict(obs)  # 预测动作,只选最优动作
            obs, reward, done, _ = env.step(action)
            episode_reward += reward
            if render:
                env.render()
            if done:
                break
        eval_reward.append(episode_reward)
    return np.mean(eval_reward)

创建环境和Agent,创建经验池,启动训练,保存模型

env = gym.make('CartPole-v0')  # CartPole-v0: 预期最后一次评估总分 > 180(最大值是200)
action_dim = env.action_space.n  # CartPole-v0: 2
obs_shape = env.observation_space.shape  # CartPole-v0: (4,)

rpm = ReplayMemory(MEMORY_SIZE)  # DQN的经验回放池

# 根据parl框架构建agent
model = Model(act_dim=action_dim)
algorithm = DQN(model, act_dim=action_dim, gamma=GAMMA, lr=LEARNING_RATE)
agent = Agent(
    algorithm,
    obs_dim=obs_shape[0],
    act_dim=action_dim,
    e_greed=0.1,  # 有一定概率随机选取动作,探索
    e_greed_decrement=1e-6)  # 随着训练逐步收敛,探索的程度慢慢降低

# 加载模型
# save_path = './dqn_model.ckpt'
# agent.restore(save_path)

# 先往经验池里存一些数据,避免最开始训练的时候样本丰富度不够
while len(rpm) < MEMORY_WARMUP_SIZE:
    run_episode(env, agent, rpm)

max_episode = 2000

# 开始训练
episode = 0
while episode < max_episode:  # 训练max_episode个回合,test部分不计算入episode数量
    # train part
    for i in range(0, 50):
        total_reward = run_episode(env, agent, rpm)
        episode += 1

    # test part
    eval_reward = evaluate(env, agent, render=False)  # render=True 查看显示效果
    logger.info('episode:{}    e_greed:{}   test_reward:{}'.format(
        episode, agent.e_greed, eval_reward))

# 训练结束,保存模型
save_path = './dqn_model.ckpt'
agent.save(save_path)

运行结果

在这里插入图片描述

【gym环境】基于迭代算法CartPole-v1倒立摆控制测试例程Pycharm代码仿真与实现 其实就一行,调用函数。# 程序从这里开始执行print(get_best_result("hill_climbing")) # 调用爬山算法寻优并输出结果于是我们的小车自己就可以寻找最优解,以达到最大的移动次数。 阅读详情

相关推荐

使用Pytorch实现强化学习——DQN算法

使用pytorch实现强化学习DQN算法

Er_Studying_Bai的博客 2万+

CartPole 强化学习详解1 - DQN

工作中常会接触到强化学习的内容,自己以gym环境中的Cartpole为例动手实现一下,记录点实现细节。 1. gym-CartPole环境准备 环境是用的gym中的CartPole-v1,就是火柴棒倒立摆。gym是openai的开源资源,具体如何安装可参照: 强化学习一、基本原理与gym的使用_wshzd的博客-优快云博客_gym 强化学习 这个环境的具体细节(参考gym源码cartpole.py): action只有向左向右两个选择,离散量 观测值有4个,x, x_dot, thet

Oxalate的博客 1万+

强化学习笔记1——DQN实现CartPole小游戏(代码分析)

state:状态观测值有四个,就是小车的位置,即小车的位置,速度,倾斜角度和角度的变化速度。当位置和角度倾斜超出范围,则环境终止。这里返回一个{ndarray{4,}}的类型,分别代表小车的位置,速度,角度,和角度变化率。action:环境的动作是一维的,能取两个值0和1。取0代表把小车往左移动,取1代表把小车往右边移动。env.step(action)表示执行动作,函数会返回下一个状态st+1,奖励值reward,以及环境终止符done。

qq_48342932的博客 6681

2.4 FrozenLake使用cross-entropy方法

FrozenLake是gym的另一个grid world环境。其环境简单的栅格地图,有四种栅格状态,分别用字母SFHG表示,下面是一个地图的例子: SFFF (S: starting point, safe) FHFH (F: frozen surface, safe) FFFH (H: hole, fall to your doom) HFFG (G: goal, where the frisbee is located) ...

cxw的博客 962

DQN(Deep Q Network)及其代码实现

为什么需要DQN 我们知道,最原始的Q-learning算法在执行过程中始终需要一个Q表进行记录,当维数不高时Q表尚可满足需求,但当遇到指数级别的维数时,Q表的效率就显得十分有限。因此,我们考虑一种值函数近似的方法,实现每次只需事先知晓S或者A,就可以实时得到其对应的Q值。DQN中采用了深度神经网络作为值函数近似的工具,这种方法被证明十分有效。 ​ DQN简介 Q-learning算法很早就有了,但是其与深度学习的结合是在2013年的DeepMind发布的《Playing Atari with Deep R

weixin_45552370的博客 3万+

深度强化学习笔记——DQN原理与实现(pytorch+gym)

概要 1. DQN(Deep Q-Network)基本原理 1.1 1.2 2. DQN的pytorch实现 2.1 所需要的环境配置 2.2 DQN伪代码 2.3

One step, One punch 1万+

关于gym的 CartPole-v1 ,详细的环境代码

最近在学习gym的环境编写,先从CartPole-v1学起,日后早些编写自己的环境。

Youyali_的博客 1万+

强化学习算法 DQN 解决 CartPole 问题,代码逐条详解

本文内容源自百度强化学习 7 日入门课程学习整理 感谢百度 PARL 团队李科浇老师的课程讲解 强化学习算法 DQN 解决 CartPole 问题,移动小车使得车上的摆杆保持直立。 这个游戏环境可以说是强化学习中的 “Hello World” 大部分的算法都可以先利用这个环境来测试下是否可以收敛 环境介绍: 小车在一个导轨上,无摩擦地来回移动,车上有一根杆子,可以绕着小车上的一个点旋转,所以我们要做的是,通过推动小车往左或者往右,来确保杆子不倒 终止条件: 杆子角度大于 +/-12度 车.

AItrust的博客 8146

强化学习算法实战:一个例子搞懂sarsa、dqn、ddqn、qac、a2c及其区别

一个例子搞懂强化学习算法

Rsbstep的博客 1102

强化学习之DQN算法

强化学习之DQN算法实战

m0_64087341的博客 2047

OpenAIGym-Cartpole-Evolution-:这是使用优于传统RL技术的NeuroEvolution算法(与NEAT相似)对OpenAI健身房的卡特尔AI的有效实现。

OpenAIGym-Cartpole-Evolution- 这是使用优于传统RL技术的NeuroEvolution算法(与NEAT相似)对OpenAI健身房的卡特尔AI的有效实现。 这是基于但是,棘手环境太简单了,无法在ES和RL技术之间找到明显的区别。 因此,最大奖励和步骤数已增加到15000。其原因是,经过测试,Evolution策略可能会很幸运,并且仅用2集即可收敛到解决方案。 因此,我增加了游戏时间。 在执行测试时,该算法平均大约需要75集才能收敛到15000的解。 它基于使用遗传算法的感知器权重的演变。 现在以195的分数解决,大约需要1-40集。 只需运行该程序,直到说完成即可。 然后,它会打印“完成”,用于计算操作的权重,最大奖励和所拍摄的剧集数。

在快马平台10分钟搭建DQN游戏AI:零基础玩转强化学习实战

点击部署按钮时,看着自己写的AI在云端跑起来,这成就感绝了!调用Gym库的CartPole-v1环境,状态包含4个参数:杆角度、位置等。这个结合深度学习的强化学习算法,用游戏AI举例最直观——比如教AI玩平衡杆(CartPole),10分钟就能看到训练效果!在快马平台最爽的是训练完直接点【部署】,生成可交互的演示页。传统强化学习处理高维数据(如图像)很吃力,而DQN直接用神经网络拟合Q值函数,Atari游戏里打砖块、太空侵略者都能搞定。设置一个固定大小的记忆池,存储(状态,动作,奖励,下一状态)四元组。

ObsidianRaven13的博客 511

openai-gym-cartpole:演示解决OpenAI健身房手推车杆问题的各种解决方案

OpenAI健身车杆 演示解决OpenAI健身房手推车杆问题的各种解决方案。 用法 $ git clone https://github.com/pyliaorachel/openai-gym-cartpole.git $ cd openai-gym-cartpole $ python3 demos/ < algorithm> / < algorithm> .py # algorithm: random_action, hand_made_policy, q_table, dqn

教你的 Agent 玩游戏

本文将带你从强化学习的基础概念开始,一步步构建一个能够自主学习并玩游戏的AI Agent。我们将使用Python作为主要编程语言,结合OpenAI Gym环境,从最简单的Q-Learning算法开始,逐步深入到深度强化学习。通过完整的代码示例和详细的原理解释,你将掌握游戏AI开发的核心技能。OpenAI Gym是一个用于开发和比较强化学习算法的工具包,它提供了各种各样的游戏环境,从简单的控制任务到复杂的Atari游戏。import gym# 创建CartPole环境# 重置环境,获取初始状态。

操作系统内核探秘的博客 208

86 arduino 电机yl_(八)arduino入门:直流电机控制

一、本节介绍在本实验中,您将学习如何使用驱动芯片L293D和SunFounder Uno板控制小型直流(DC)电机的方向和速度。为了使初学者更容易,我们将让直流电机左右旋转,自动加速和减速。二、材料准备1 *小型直流电机1 * L293D1 * Arduino Uno板1 *面包板1 * USB数据线杜邦线三、原理讲解L293D这是一个非常实用的芯片,可以独立控制两台直流电机。在这个实验中,只有一...

weixin_29163857的博客 3572

Rocky Linux 9.0国内yum源一键替换指南(上海交大镜像站实测)

本文详细介绍了如何将Rocky Linux 9.0的yum源替换为上海交大镜像站,以解决国内用户访问官方源速度慢的问题。通过实测验证,上海交大镜像站提供高速下载和稳定更新,并提供了完整的替换步骤、常见问题解决方案及高级优化配置,帮助用户提升软件包下载效率。

weixin_29304985的博客 364

reinforcement-learning:从零开始的强化学习完整指南

reinforcement-learning是一个由RLCode团队打造的开源项目,提供了从基础到深度强化学习的极简清晰示例,每个算法独立成文件,非常适合新手入门学习强化学习。 ## 为什么选择reinforcement-learning项目? 对于想要学习强化学习的新手来说,面对复杂的理论和代码往往望而却步。而reinforcement-learning项目以其简洁明了的代码实现,让学习者能

gitblog_00711的博客 421

基于Labview2012实现的双通道信号源(课程设计)

双通道信号源,产生8种波形,能进行调制,带信号幅度与频率扫描功能,波形可存储与导入

qq_40617082的博客 1462

(强化学习)DQN实战CartPole游戏

DQN的全称是deep Q network,是将深度神经网络和Q-learing相结合,克服Q-learing在面对状态空间很大时效率变得很低得问题,DQN其实是用一种近似的方式来求Q函数, ...

zhangycode的博客 2562

MATLAB并行开不了的解决办法

在服务器上新安装了MATLAB 2013b,在开并行计算的时候出现了下列问题 经过在网上搜多这个问题,我感觉这个问题应该是安装的时候的验证问题或者激活不成功之类的。注意其中有一句validate the profile ‘local’ in the Cluster Profile Manager.在matlab官网上找到了设置Cluster Manager的教程,如下 parallel>

sinat_36713319的博客 5989

《数学建模与数学实验》第5版 线性规划 习题3.4

1. 某鸡场有1000只鸡,用动物饲料和谷物混合喂养. 2. 某工厂用A1,A2两台机床加工B1,B2,B3三种不同零件. 3. 某工厂利用两种原料甲、乙生产$A_1、A_2、A_3$三种产品. 4. 每班的护士在值班开始时向病房报到,连续工作8个小时. 5. 某工厂生产 A1 、A2 两种型号的产品 6. 有两个煤厂A,B 7. 某工厂制造三种产品,生产这三种产品需要三种资源 8. 已知某工厂计划生产1,2,3三种产品,各产品需要在ABC设备加工。...

hexiaosi_的博客 2万+

强化学习DQN 入门小游戏 最简单的Pytorch代码

本文目的是用最简单的代码,展示DQN玩游戏的效果,不涉及深度学习原理讲解。 毕竟,入门如此艰难,唯一的动力不过是看个效果,装个biu…… 安装OpenAI的游戏库gym pip install gym 看一下运行效果 import gym env = gym.make('CartPole-v1') print('State shape:', env.observation_space.shape) print('Number of actions:', env.action_space.n) for _

不佛的博客 6917

从基础知识到PCB设计,打造全能硬件工程师

成为一名出色的硬件工程师需要在多个领域建立坚实的基础。从硬件基础知识、元器件学习、模拟电子电路到PCB设计,以及数字电子电路与通信,每个方面都是构建全面硬件工程师技能集的重要组成部分。通过深入学习和实践这些领域,你将能够在硬件工程领域中取得更多的成就。

weixin_46969363的博客 2727

强化学习DQN算法实战之CartPole

简介 这篇笔记主要是记录了Deep Q-Learning Network的开发过程。开发环境是:Ubuntu18.04 、tensorflow-gpu 1.13.1 和 OpenAI gym 其中,这篇笔记记录了深度学习的开发环境。安装完成后,在虚拟环境执行pip install gym安装界面环境。 强化学习的一个困难的地方,在于数据收集和环境描述。而 OpenAI的gym给我们提供了一个非常强...

Erick Lv的笔记 4812

【3D无序抓取】--终极技术详解

3D无序抓取技术详解:从感知到执行的全流程技术方案 本文系统梳理了3D无序抓取(Bin Picking)的核心技术栈,涵盖3D感知、抓取规划和机器人执行三大环节。在3D感知层,详细介绍了点云采集与预处理方法(PCL/Open3D)、物体分割(PointNet++)和位姿估计(PVN3D/DenseFusion)等关键技术。抓取规划部分重点解析了抓取生成(GraspNet)、质量评估(Dex-Net)和动态避障(MoveIt!)算法。机器人执行环节则涉及路径规划、力控技术和末端执行器选型。同时提供了完整的工具

weixin_45590420的博客 598

把 ABAP writable CDS view entity 讲透:从只读建模到可写模型的 ABAP CDS 新能力

摘要:SAP引入的writable CDS view entity突破了传统CDS视图只读的限制,允许通过ABAP SQL直接进行数据修改。该特性通过WRITABLE关键字定义,使CDS视图成为与数据库表同等级别的可写对象。其核心价值在于为数据集成、中间层同步等场景提供结构化写入入口,但需注意不应绕过业务规则。最佳实践建议保持底层表结构简单映射,避免复杂变形。这一特性标志着CDS从单纯消费模型向双向数据交互能力的演进,为ABAP开发提供了新的数据边界设计思路。

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 1314
上一篇: LateX beamer 下的报错unknown CJK family \CJKsfdefault is being ignored
下一篇: Leetcode 684. Redundant Connection 并查集 C++
Xurui_Luo
博客等级 码龄10年 46粉丝 288原创
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值