传统观点认为，尖端人工智能依赖于大量数据，一个国家（或企业）能够获取的数据量是其人工智能进展的关键指标。当前很多人工智能系统确实使用了大量数据，然而，并非所有人工智能系统都需要海量数据作为支撑，小数据也拥有巨大人工智能潜力。在没有大型预标记数据集的情况下，可以利用这些方法训练人工智能系统。 1. 迁移学习（Transfer learning）是一种机器学习方法，可以在数据丰富的环境中学习执行任务，而后将所学知识“迁移”到可用数据少的任务中。这一方法对于解决关联问题标记数据丰富但所研究问题数据不足的情况有很大价值。 2. 数据标记（Data labeling）方法，即从有限的标记数据和大量无标记数据开始，使用一系列方法来理解可用的未标记数据。例如自动生成标记（自动标记）或识别标记重要数据点（主动学习）。 3. 人工数据生成（Artificial data generation）方法，旨在通过创建新数据点或其他相关技术，最大限度地从少量数据中提取更多信息。该方法可以通过对现有数据的小幅更改（如图像分类数据集中裁剪或旋转图像）或其他更复杂的方法，推断可用数据的基础结构并从中进行推测。 4. 贝叶斯方法（Bayesian methods）是机器学习和统计学的一种大类方法，有两个共同特点。首先，该方法明确地将问题先验信息纳入其解决问题的方法中，而其他方法则更倾向于对研究问题做出最少的假设。贝叶斯方法会在数据进一步改进之前合并这些“先验”信息，因此更适合某些数据较为缺乏，但可以采取实用数学形式写出问题相关信息的环境。其次，贝叶斯方法侧重于对其预测的不确定性进行良好校准后的估计。该方法可以更容易地识别数据点，从而极大减少不确定性，在可用数据有限的情况下能发挥很大作用。 5. 强化学习（Reinforcement learning）是一个关于机器学习方法的广义术语，在强化学习中，计算机系统通过反复试验来学习如何与环境进行交互。强化学习通常用于训练游戏系统、机器人和自动驾驶汽车。

在使用ModelArts完成AI全流程开发时，端到端过程中，提供免费规格，让您免费体验ModelArts的全流程开发。单击此处进入ModelArts管理控制台，参考如下操作指导体验免费规格的使用。使用场景在AI全流程开发过程中，分为如下几个步骤：数据管理：ModelArts数据管理功能目前免费开放，但是由于数据需存储在OBS中，存储的数据按OBS规则进行计费。算法开发或预置算法：ModelArts官方发布在AI Gallery的算法，均可免费使用。如果您自己在本地开发算法，则不涉及费用。模型训练：在创建训练作业时，可选择免费规格，完成模型训练。导入模型：ModelArts提供的模型导入及管理功能，不收费。部署上线：将导入的模型部署为在线服务时，可选择免费规格（CPU或GPU）的资源，将模型部署为服务。针对之前的ModelArts，如果您想端到端体验AI全流程开发，在“模型训练”和“部署上线”时，都需要付费体验。当前ModelArts提供免费规格后，整个AI开发过程，可端到端免费体验。注意：由于免费规格仅针对ModelArts服务，在使用过程中，需使用OBS存储数据或模型时，会根据OBS计费规则进行计费。免费规格声明（模型训练）免费规格用于使用体验，训练作业会在1小时后自动停止，因此建议设置最大训练时长为1小时。限时免费的规格，性能有限，如果您的数据量较大，或者训练时长会超过1小时，建议选择收费的计算规格用于模型训练。免费规格的资源是有限的，当使用人数较多时，会出现长时间的排队。如果希望获得更佳的体验，请选择付费规格。训练作业功能，仅提供了GPU类型的免费规格。同一个帐号只能在1个训练作业中使用免费规格。等训练作业结束后，其他训练作业可重新使用免费规格。“训练管理”中，只有“创建训练作业”功能支持使用免费规格，“可视化作业”暂时无法使用免费规格进行体验。仅在“华北-北京四”区域提供了免费规格，请注意您使用的区域。免费规格声明（部署上线）免费规格用于使用体验，部署的服务会在1小时后自动停止。如果您还需要使用免费规格继续运行，可重新启动服务，可再运行1小时，1小时后仍然会自动停止。72小时内没有再次启动，会释放资源，请注意文件备份。免费规格的资源是有限的，当使用人数较多时，会出现长时间的排队。如果希望获得更佳的体验，请选择付费规格。使用“部署上线”功能时，可用的免费规格有2种，1个免费CPU规格，1个免费GPU规格。但是两种规格不能同时在一个服务中使用。同一个帐号下，任意一种免费规格只能在1个服务中使用免费规格。如果一个部署上线已使用了一种免费规格，不管是运行中还是停止状态，其他部署上线任务都无法再使用这个免费规格。只有部署为“在线服务”时，支持使用免费规格。“批量服务”和“边缘服务”暂时无法使用免费规格进行体验。使用免费规格的服务，可以通过修改操作，将资源规格修改为收费的规格，也可以修改为另一种免费规格。但是已经在使用收费规格的服务，无法修改为免费规格。仅在“华北-北京四”区域提供了免费规格，请注意您使用的区域。免费体验AI全流程开发如下免费使用的教程，以使用预置算法创建训练作业为例，其他类型的训练作业，操作步骤类似，不再赘述。在开始使用如下端到端流程前，请参考准备工作，完成帐号注册、全局配置等操作。本文重点指导用户如何免费使用，如需自动学习详细操作步骤，可参见快速入门。登录ModelArts管理控制台。参考创建数据集（旧版），创建一个“图像分类”类型的数据集。同时，将需要进行标注的数据，上传至对应的OBS中。您可以使用花卉数据集样例完成体验。参考图像分类，将上传的数据全部完成标注。参考发布数据集，将标注好的数据集发布为可用版本。参考使用已有算法训练模型，上传一个可应用于图像分类的算法，如“ResNet_v1_50”算法，创建训练作业。在“规格”右侧的下拉框中，选择带有“限时免费”标识的规格，用于免费体验。然后单击“下一步”，根据界面提示完成训练作业的创建。选用免费规格时，其对应的计算节点个数，仅支持使用1个节点，无法修改。图2 选择限时免费的规格等待训练作业运行结束，当训练作业的状态变为“运行成功”时，表示模型训练完成。参考从训练中选择元模型，将训练后得到的模型导入ModelArts进行管理。参考部署为在线服务，将导入的模型部署为在线服务。在“计算节点规格”中，选择带有“免费规格”标识的规格，部署在线服务。图3 选择免费规格部署为在线服务在服务管理列表中，使用免费规格创建的服务，名称右侧带“免费”标识，等待服务部署完成，当状态变为“运行中”时，表示服务已部署完成。您可以单击服务名称进入服务详情页面，在“调用指南”查看服务的URL接口，或者进入“预测”页签，上传一张图片，进行预测识别。使用免费规格的服务，将在1个小时后自动停止，如果您还需要使用此服务，可在“在线服务”页面，单击“启动”，系统将使用之前选择的免费规格启动服务。图4 使用免费规格运行的服务

>摘要：六一儿童节，快来训练一款自己的游戏 AI，用代码让马里奥从大反派酷霸王的魔掌里救回桃花公主。 本文分享自华为云社区《[儿童节，和 AI 一起通关 “超级马里奥兄弟”](https://bbs.huaweicloud.com/blogs/357378?utm_source=csdn&utm_medium=bbs-ex&utm_campaign=other&utm_content=content)》，作者：华为云社区精选。 在蘑菇王国，流传着这样一个故事： 某天，操纵着强力魔法的大乌龟酷霸王一族侵略了蘑菇们居住的和平王国。蘑菇一族都被酷霸王变成了岩石、砖块等形状，蘑菇王国即将灭亡。 只有蘑菇王国的桃花公主，才能解开魔法，让蘑菇们苏醒。 然而，她却被大魔王酷霸王所捉住。 为了打倒乌龟一族、救出桃花公主、给蘑菇王国带回和平，水管工马里奥决定站出来，向酷霸王发起挑战。 是的，这就是童年游戏《超级马里奥》的故事。 你是不是仍旧对马里奥这个游戏记忆犹新，是不是仍旧对过关焦头烂额，**六一儿童节，快来训练一款自己的游戏 AI，用代码让马里奥从大反派酷霸王的魔掌里救回桃花公主。** # 当 AI 玩起超级马里奥 基于华为云一站式AI开发平台ModelArts，利用强化学习中的 PPO 算法来玩超级马里奥，对于绝大部分关卡，训练出来的 AI 智能体都可以在 1500 个 episode 内学会过关。 ModelArts 是面向开发者的一站式 AI 平台，支持海量数据预处理及交互式智能标注、大规模分布式训练、自动化模型生成，及端 - 边 - 云模型按需部署能力，可以让 AI 应用开发到商用部署缩短为分钟级别。 就算不懂代码，也可以按照教程案例，通过简单的调参，一步步实现游戏 AI 开发，成为超级马里奥闯关王者。 话不多说，先来看看实际的效果：  超级马里奥游戏 AI 的整体开发流程为：**创建马里奥环境 -> 构建 PPO 算法 -> 训练 -> 推理 -> 可视化效果，目前可以在AI Gallery上免费体验。** AI Gallery 是在 ModelArts 的基础上构建的开发者生态社区， 支持算法、模型、数据集、Notebook 案例和技术文章的共享。 下面，童年回忆杀走起。 # PPO 算法科普 因为这个游戏 AI 是基于 PPO 算法来训练的，所以先简单科普一下强化学习算法。PPO 算法有两种主要形式：PPO-Penalty 和 PPO-Clip (PPO2)。在这里，我们讨论 PPO-Clip（OpenAI 使用的主要形式）。 PPO 的主要特点如下： - PPO 属于 on-policy 算法 - PPO 同时适用于离散和连续的动作空间 - 损失函数 PPO-Clip 算法最精髓的地方就是加入了一项比例用以描绘新老策略的差异，通过超参数 ϵ 限制策略的更新步长：  - 更新策略：  - 探索策略 PPO 采用随机探索策略。 - 优势函数 表示在状态 s 下采取动作 a，相较于其他动作有多少优势，如果 > 0, 则当前动作比平均动作好，反之，则差  算法主要流程大致如下：  看起来有点复杂，不用担心，**即便你不懂这些算法，有了华为云 ModelArts，可以跟着下面的步骤轻松实现超级马里奥游戏 AI 的强化学习。** # 开发步骤 本案例运行环境为 Pytorch-1.0.0，且需使用 GPU 运行，开始之前一定要选择对应的硬件规格。在 ModelArts Jupyter 中，只要点击代码前面的箭头，就能自动运行。  ## 1. 程序初始化 ### 第 1 步：安装基础依赖 ``` !pip install -U pip !pip install gym==0.19.0 !pip install tqdm==4.48.0 !pip install nes-py==8.1.0 !pip install gym-super-mario-bros==7.3.2 ``` ### 第 2 步：导入相关的库 ``` import os import shutil import subprocess as sp from collections import deque import numpy as np import torch import torch.nn as nn import torch.nn.functional as F import torch.multiprocessing as _mp from torch.distributions import Categorical import torch.multiprocessing as mp from nes_py.wrappers import JoypadSpace import gym_super_mario_bros from gym.spaces import Box from gym import Wrapper from gym_super_mario_bros.actions import SIMPLE_MOVEMENT, COMPLEX_MOVEMENT, RIGHT_ONLY import cv2 import matplotlib.pyplot as plt from IPython import display import moxing as mox ``` ## 2. 训练参数初始化 此处划重点，该部分参数可以自己调整，以训练出更好的效果。 ``` opt={ "world": 1, # 可选大关：1,2,3,4,5,6,7,8 "stage": 1, # 可选小关：1,2,3,4 "action_type": "simple", # 动作类别："simple"，"right_only", "complex" 'lr': 1e-4, # 建议学习率：1e-3，1e-4, 1e-5，7e-5 'gamma': 0.9, # 奖励折扣 'tau': 1.0, # GAE参数 'beta': 0.01, # 熵系数 'epsilon': 0.2, # PPO的Clip系数 'batch_size': 16, # 经验回放的batch_size 'max_episode':10, # 最大训练局数 'num_epochs': 10, # 每条经验回放次数 "num_local_steps": 512, # 每局的最大步数 "num_processes": 8, # 训练进程数，一般等于训练机核心数 "save_interval": 5, # 每{}局保存一次模型 "log_path": "./log", # 日志保存路径 "saved_path": "./model", # 训练模型保存路径 "pretrain_model": True, # 是否加载预训练模型，目前只提供1-1关卡的预训练模型，其他需要从零开始训练 "episode":5 } ``` 如果你想选择其他关卡时，记得调整参数 world 和 stage ，这里默认的是第一关。 ## 3. 创建环境 **结束标志：** - 胜利：mario 到达本关终点 - 失败：mario 受到敌人的伤害、坠入悬崖或者时间用完 **奖励函数：** - 得分：收集金币、踩扁敌人、结束时夺旗 - 扣分：受到敌人伤害、掉落悬崖、结束时未夺旗 ``` #创建环境 def create_train_env(world, stage, actions, output_path=None): # 创建基础环境 env = gym_super_mario_bros.make("SuperMarioBros-{}-{}-v0".format(world, stage)) env = JoypadSpace(env, actions) # 对环境自定义 env = CustomReward(env, world, stage, monitor=None) env = CustomSkipFrame(env) return env # 对原始环境进行修改，以获得更好的训练效果 class CustomReward(Wrapper): def __init__(self, env=None, world=None, stage=None, monitor=None): super(CustomReward, self).__init__(env) self.observation_space = Box(low=0, high=255, shape=(1, 84, 84)) self.curr_score = 0 self.current_x = 40 self.world = world self.stage = stage if monitor: self.monitor = monitor else: self.monitor = None def step(self, action): state, reward, done, info = self.env.step(action) if self.monitor: self.monitor.record(state) state = process_frame(state) reward += (info["score"] - self.curr_score) / 40. self.curr_score = info["score"] if done: if info["flag_get"]: reward += 50 else: reward -= 50 if self.world == 7 and self.stage == 4: if (506 = info["x_pos"] = 832 and info["y_pos"] > 127) or ( 832 info["x_pos"] = 1064 and info["y_pos"] 80) or ( 1113 info["x_pos"] = 1464 and info["y_pos"] 191) or ( 1579 info["x_pos"] = 1943 and info["y_pos"] 191) or ( 1946 info["x_pos"] = 1964 and info["y_pos"] >= 191) or ( 1984 info["x_pos"] = 2060 and (info["y_pos"] >= 191 or info["y_pos"] 127)) or ( 2114 info["x_pos"] 2440 and info["y_pos"] 191) or info["x_pos"] self.current_x - 500: reward -= 50 done = True if self.world == 4 and self.stage == 4: if (info["x_pos"] = 1500 and info["y_pos"] 127) or ( 1588 = info["x_pos"] 2380 and info["y_pos"] >= 127): reward = -50 done = True self.current_x = info["x_pos"] return state, reward / 10., done, info def reset(self): self.curr_score = 0 self.current_x = 40 return process_frame(self.env.reset()) class MultipleEnvironments: def __init__(self, world, stage, action_type, num_envs, output_path=None): self.agent_conns, self.env_conns = zip(*[mp.Pipe() for _ in range(num_envs)]) if action_type == "right_only": actions = RIGHT_ONLY elif action_type == "simple": actions = SIMPLE_MOVEMENT else: actions = COMPLEX_MOVEMENT self.envs = [create_train_env(world, stage, actions, output_path=output_path) for _ in range(num_envs)] self.num_states = self.envs[0].observation_space.shape[0] self.num_actions = len(actions) for index in range(num_envs): process = mp.Process(target=self.run, args=(index,)) process.start() self.env_conns[index].close() def run(self, index): self.agent_conns[index].close() while True: request, action = self.env_conns[index].recv() if request == "step": self.env_conns[index].send(self.envs[index].step(action.item())) elif request == "reset": self.env_conns[index].send(self.envs[index].reset()) else: raise NotImplementedError def process_frame(frame): if frame is not None: frame = cv2.cvtColor(frame, cv2.COLOR_RGB2GRAY) frame = cv2.resize(frame, (84, 84))[None, :, :] / 255. return frame else: return np.zeros((1, 84, 84)) class CustomSkipFrame(Wrapper): def __init__(self, env, skip=4): super(CustomSkipFrame, self).__init__(env) self.observation_space = Box(low=0, high=255, shape=(skip, 84, 84)) self.skip = skip self.states = np.zeros((skip, 84, 84), dtype=np.float32) def step(self, action): total_reward = 0 last_states = [] for i in range(self.skip): state, reward, done, info = self.env.step(action) total_reward += reward if i >= self.skip / 2: last_states.append(state) if done: self.reset() return self.states[None, :, :, :].astype(np.float32), total_reward, done, info max_state = np.max(np.concatenate(last_states, 0), 0) self.states[:-1] = self.states[1:] self.states[-1] = max_state return self.states[None, :, :, :].astype(np.float32), total_reward, done, info def reset(self): state = self.env.reset() self.states = np.concatenate([state for _ in range(self.skip)], 0) return self.states[None, :, :, :].astype(np.float32) ``` ## 4. 定义神经网络 神经网络结构包含四层卷积网络和一层全连接网络，提取的特征输入 critic 层和 actor 层，分别输出 value 值和动作概率分布。 ``` class Net(nn.Module): def __init__(self, num_inputs, num_actions): super(Net, self).__init__() self.conv1 = nn.Conv2d(num_inputs, 32, 3, stride=2, padding=1) self.conv2 = nn.Conv2d(32, 32, 3, stride=2, padding=1) self.conv3 = nn.Conv2d(32, 32, 3, stride=2, padding=1) self.conv4 = nn.Conv2d(32, 32, 3, stride=2, padding=1) self.linear = nn.Linear(32 * 6 * 6, 512) self.critic_linear = nn.Linear(512, 1) self.actor_linear = nn.Linear(512, num_actions) self._initialize_weights() def _initialize_weights(self): for module in self.modules(): if isinstance(module, nn.Conv2d) or isinstance(module, nn.Linear): nn.init.orthogonal_(module.weight, nn.init.calculate_gain('relu')) nn.init.constant_(module.bias, 0) def forward(self, x): x = F.relu(self.conv1(x)) x = F.relu(self.conv2(x)) x = F.relu(self.conv3(x)) x = F.relu(self.conv4(x)) x = self.linear(x.view(x.size(0), -1)) return self.actor_linear(x), self.critic_linear(x) ``` ## 5. 定义 PPO 算法 ``` def evaluation(opt, global_model, num_states, num_actions,curr_episode): print('start evalution !') torch.manual_seed(123) if opt['action_type'] == "right": actions = RIGHT_ONLY elif opt['action_type'] == "simple": actions = SIMPLE_MOVEMENT else: actions = COMPLEX_MOVEMENT env = create_train_env(opt['world'], opt['stage'], actions) local_model = Net(num_states, num_actions) if torch.cuda.is_available(): local_model.cuda() local_model.eval() state = torch.from_numpy(env.reset()) if torch.cuda.is_available(): state = state.cuda() plt.figure(figsize=(10,10)) img = plt.imshow(env.render(mode='rgb_array')) done=False local_model.load_state_dict(global_model.state_dict()) #加载网络参数\ while not done: if torch.cuda.is_available(): state = state.cuda() logits, value = local_model(state) policy = F.softmax(logits, dim=1) action = torch.argmax(policy).item() state, reward, done, info = env.step(action) state = torch.from_numpy(state) img.set_data(env.render(mode='rgb_array')) # just update the data display.display(plt.gcf()) display.clear_output(wait=True) if info["flag_get"]: print("flag getted in episode:{}!".format(curr_episode)) torch.save(local_model.state_dict(), "{}/ppo_super_mario_bros_{}_{}_{}".format(opt['saved_path'], opt['world'], opt['stage'],curr_episode)) opt.update({'episode':curr_episode}) env.close() return True return False def train(opt): #判断cuda是否可用 if torch.cuda.is_available(): torch.cuda.manual_seed(123) else: torch.manual_seed(123) if os.path.isdir(opt['log_path']): shutil.rmtree(opt['log_path']) os.makedirs(opt['log_path']) if not os.path.isdir(opt['saved_path']): os.makedirs(opt['saved_path']) mp = _mp.get_context("spawn") #创建环境 envs = MultipleEnvironments(opt['world'], opt['stage'], opt['action_type'], opt['num_processes']) #创建模型 model = Net(envs.num_states, envs.num_actions) if opt['pretrain_model']: print('加载预训练模型') if not os.path.exists("ppo_super_mario_bros_1_1_0"): mox.file.copy_parallel( "obs://modelarts-labs-bj4/course/modelarts/zjc_team/reinforcement_learning/ppo_mario/ppo_super_mario_bros_1_1_0", "ppo_super_mario_bros_1_1_0") if torch.cuda.is_available(): model.load_state_dict(torch.load("ppo_super_mario_bros_1_1_0")) model.cuda() else: model.load_state_dict(torch.load("ppo_super_mario_bros_1_1_0",torch.device('cpu'))) else: model.cuda() model.share_memory() optimizer = torch.optim.Adam(model.parameters(), lr=opt['lr']) #环境重置 [agent_conn.send(("reset", None)) for agent_conn in envs.agent_conns] #接收当前状态 curr_states = [agent_conn.recv() for agent_conn in envs.agent_conns] curr_states = torch.from_numpy(np.concatenate(curr_states, 0)) if torch.cuda.is_available(): curr_states = curr_states.cuda() curr_episode = 0 #在最大局数内训练 while curr_episode0 and curr_episode > 0: torch.save(model.state_dict(), "{}/ppo_super_mario_bros_{}_{}_{}".format(opt['saved_path'], opt['world'], opt['stage'], curr_episode)) curr_episode += 1 old_log_policies = [] actions = [] values = [] states = [] rewards = [] dones = [] #一局内最大步数 for _ in range(opt['num_local_steps']): states.append(curr_states) logits, value = model(curr_states) values.append(value.squeeze()) policy = F.softmax(logits, dim=1) old_m = Categorical(policy) action = old_m.sample() actions.append(action) old_log_policy = old_m.log_prob(action) old_log_policies.append(old_log_policy) #执行action if torch.cuda.is_available(): [agent_conn.send(("step", act)) for agent_conn, act in zip(envs.agent_conns, action.cpu())] else: [agent_conn.send(("step", act)) for agent_conn, act in zip(envs.agent_conns, action)] state, reward, done, info = zip(*[agent_conn.recv() for agent_conn in envs.agent_conns]) state = torch.from_numpy(np.concatenate(state, 0)) if torch.cuda.is_available(): state = state.cuda() reward = torch.cuda.FloatTensor(reward) done = torch.cuda.FloatTensor(done) else: reward = torch.FloatTensor(reward) done = torch.FloatTensor(done) rewards.append(reward) dones.append(done) curr_states = state _, next_value, = model(curr_states) next_value = next_value.squeeze() old_log_policies = torch.cat(old_log_policies).detach() actions = torch.cat(actions) values = torch.cat(values).detach() states = torch.cat(states) gae = 0 R = [] #gae计算 for value, reward, done in list(zip(values, rewards, dones))[::-1]: gae = gae * opt['gamma'] * opt['tau'] gae = gae + reward + opt['gamma'] * next_value.detach() * (1 - done) - value.detach() next_value = value R.append(gae + value) R = R[::-1] R = torch.cat(R).detach() advantages = R - values #策略更新 for i in range(opt['num_epochs']): indice = torch.randperm(opt['num_local_steps'] * opt['num_processes']) for j in range(opt['batch_size']): batch_indices = indice[ int(j * (opt['num_local_steps'] * opt['num_processes'] / opt['batch_size'])): int((j + 1) * ( opt['num_local_steps'] * opt['num_processes'] / opt['batch_size']))] logits, value = model(states[batch_indices]) new_policy = F.softmax(logits, dim=1) new_m = Categorical(new_policy) new_log_policy = new_m.log_prob(actions[batch_indices]) ratio = torch.exp(new_log_policy - old_log_policies[batch_indices]) actor_loss = -torch.mean(torch.min(ratio * advantages[batch_indices], torch.clamp(ratio, 1.0 - opt['epsilon'], 1.0 + opt['epsilon']) * advantages[ batch_indices])) critic_loss = F.smooth_l1_loss(R[batch_indices], value.squeeze()) entropy_loss = torch.mean(new_m.entropy()) #损失函数包含三个部分：actor损失，critic损失，和动作entropy损失 total_loss = actor_loss + critic_loss - opt['beta'] * entropy_loss optimizer.zero_grad() total_loss.backward() torch.nn.utils.clip_grad_norm_(model.parameters(), 0.5) optimizer.step() print("Episode: {}. Total loss: {}".format(curr_episode, total_loss)) finish=False for i in range(opt["num_processes"]): if info[i]["flag_get"]: finish=evaluation(opt, model,envs.num_states, envs.num_actions,curr_episode) if finish: break if finish: break ``` ## 6. 训练模型 训练 10 Episode，耗时约 5 分钟 ``` train(opt) ``` ## 7. 使用模型推理游戏 定义推理函数 ``` def infer(opt): if torch.cuda.is_available(): torch.cuda.manual_seed(123) else: torch.manual_seed(123) if opt['action_type'] == "right": actions = RIGHT_ONLY elif opt['action_type'] == "simple": actions = SIMPLE_MOVEMENT else: actions = COMPLEX_MOVEMENT env = create_train_env(opt['world'], opt['stage'], actions) model = Net(env.observation_space.shape[0], len(actions)) if torch.cuda.is_available(): model.load_state_dict(torch.load("{}/ppo_super_mario_bros_{}_{}_{}".format(opt['saved_path'],opt['world'], opt['stage'],opt['episode']))) model.cuda() else: model.load_state_dict(torch.load("{}/ppo_super_mario_bros_{}_{}_{}".format(opt['saved_path'], opt['world'], opt['stage'],opt['episode']), map_location=torch.device('cpu'))) model.eval() state = torch.from_numpy(env.reset()) plt.figure(figsize=(10,10)) img = plt.imshow(env.render(mode='rgb_array')) while True: if torch.cuda.is_available(): state = state.cuda() logits, value = model(state) policy = F.softmax(logits, dim=1) action = torch.argmax(policy).item() state, reward, done, info = env.step(action) state = torch.from_numpy(state) img.set_data(env.render(mode='rgb_array')) # just update the data display.display(plt.gcf()) display.clear_output(wait=True) if info["flag_get"]: print("World {} stage {} completed".format(opt['world'], opt['stage'])) break if done and info["flag_get"] is False: print('Game Failed') break infer(opt) World 1 stage 1 completed ```  # 最后 六一儿童节，快来华为云 AI Gallery 上体验 AI 闯关超级马里奥，无需考虑计算资源，环境的搭建，在 ModelArts 里跟着运行代码，[点击链接](https://developer.huaweicloud.com/develop/aigallery/usecase/detail?id=3390253c-a00f-4c2a-92b6-08384ec31693)在ModelArts里运行简单几行代码，手把手带你5分钟速成游戏王。

以下文章来源于Smarter ，作者ChenJoyaAbstract  （1）在作者的计算方式下，PASCAL VOC (test2007) 的上界可以达到 91.6%，COCO (val2017) 可以达到 78.2%， OpenImages V4 (val) 可以达到 58.9%，它们的上界离现在所能达到的最佳的性能仍有很大的差距；（2）发现分类错误（混淆/漏检）比定位错误和重复检测错误更加重要；（3）分析了一些数据增强的措施对检测器的影响。分析   1. 实验细节（1）平台：主流检测框架 mmdetection，detectron2 ;（2）模型：R-CNN 系列（FasterRCNN, MaskRCNN, GridRCNN, LibraRCNN, CascadeRCNN, MaskScoringRCNN, GAFasterRCNN, HTC），one-stage/anchor-free系列 （RetinaNet，SSD, FCOS, CenterNet [objects as points]）;（3）数据集：PASCAL VOC (训练 07+12, 测试 07test), MS COCO (训练 train2017, 测试 val2017), OpenImages V4 (as Kaggle Competition), Fashion dataset (作者自个的)；（4）评价标准：COCO-style AP；2. 如何估计性能上界（1）假定性能上界是由 best object classifier 能达到的，即认为定位问题已经解决；（2）探究实验，利用大网络 ResNet152 对目标进行分类，能得到多少的准确率（top-1 accuracy），发现将 object 单独分离出来效果是最好的；（3）准备基于 recognition accuracy 来估计 AP 上界。设计一种生成 candidate box 的机制，用于生成不同 IoU 的 bounding-boxes 来计算 AP，并且基于这些 bounding-boxes 重新训练 ResNet-152 分类器；（4）对于每一个 bounding-box 分配 ResNet-152 的 top-1 score 所对应的 label；3. 各数据集的上界（1） PASCAL VOC（2）COCO（3）OpenImages V4（4）AP 与识别 accuracy 的关联不同类别识别精度与对应 AP 的关联4. Error Diagnosis（1）定义四种错误类型：（2）对于每种错误，人为地消除后观察其提升，没有了分类方面的错误后，性能提升最明显：5. Invariance Analysis做各种数据处理，观察性能变化。总的来说，FCOS，RetinaNet 属于最优秀的那一档。结论   （1）现在检测器的性能还没有离上界还有一定差距（但似乎在 IoU@0.5 时已经十分接近上界了）；（2）检测器的瓶颈在目标识别（recognition）上；（3）检测器缺乏鲁棒性；（4）并没有发现明显的证据说明 context 对于分类目标是有效的。

本文转载自机器之心。在本节中，我们将简要概述一些主要的技术，用于正则化和优化深度神经网络 (DNN)。7.1 DropoutSrivastava 等人 (2014) 提出 Dropout，以防止神经网络过拟合。Dropout 是一种神经网络模型平均正则化方法，通过增加噪声到其隐藏单元。在训练过程中，它会从神经网络中随机抽取出单元和连接。Dropout 可以用于像 RBM (Srivastava et al.，2014) 这样的图形模型中，也可以用于任何类型的神经网络。最近提出的一个关于 Dropout 的改进是 Fraternal Dropout，用于循环神经网络 (RNN)。7.2 MaxoutGoodfellow 等人 (2013) 提出 Maxout，一种新的激活函数，用于 Dropout。Maxout 的输出是一组输入的最大值，有利于 Dropout 的模型平均。7.3 ZoneoutKrueger 等人 (2016) 提出了循环神经网络 (RNN) 的正则化方法 Zoneout。Zoneout 在训练中随机使用噪音，类似于 Dropout，但保留了隐藏的单元而不是丢弃。7.4 深度残差学习He 等人 (2015) 提出了深度残差学习框架，该框架被称为低训练误差的 ResNet。7.5 批归一化Ioffe 和 Szegedy(2015) 提出了批归一化，通过减少内部协变量移位来加速深度神经网络训练的方法。Ioffe(2017) 提出批重归一化，扩展了以前的方法。7.6 DistillationHinton 等人 (2015) 提出了将知识从高度正则化模型的集合 (即神经网络) 转化为压缩小模型的方法。7.7 层归一化Ba 等人 (2016) 提出了层归一化，特别是针对 RNN 的深度神经网络加速训练，解决了批归一化的局限性。

本文转载自机器之心。1. 引言 「深度学习」（DL）一词最初在 1986 被引入机器学习（ML），后来在 2000 年时被用于人工神经网络（ANN）。深度学习方法由多个层组成，以学习具有多个抽象层次的数据特征。DL 方法允许计算机通过相对简单的概念来学习复杂的概念。对于人工神经网络（ANN），深度学习（DL）（也称为分层学习（Hierarchical Learning））是指在多个计算阶段中精确地分配信用，以转换网络中的聚合激活。为了学习复杂的功能，深度架构被用于多个抽象层次，即非线性操作；例如 ANNs，具有许多隐藏层。用准确的话总结就是，深度学习是机器学习的一个子领域，它使用了多层次的非线性信息处理和抽象，用于有监督或无监督的特征学习、表示、分类和模式识别。深度学习即表征学习是机器学习的一个分支或子领域，大多数人认为近代深度学习方法是从 2006 开始发展起来的。本文是关于最新的深度学习技术的综述，主要推荐给即将涉足该领域的研究者。本文包括 DL 的基本思想、主要方法、最新进展以及应用。综述论文是非常有益的，特别是对某一特定领域的新研究人员。一个研究领域如果在不久的将来及相关应用领域中有很大的价值，那通常很难被实时跟踪到最新进展。现在，科学研究是一个很有吸引力的职业，因为知识和教育比以往任何时候都更容易分享和获得。对于一种技术研究的趋势来说，唯一正常的假设是它会在各个方面有很多的改进。几年前对某个领域的概述，现在可能已经过时了。考虑到近年来深度学习的普及和推广，我们简要概述了深度学习和神经网络（NN），以及它的主要进展和几年来的重大突破。我们希望这篇文章将帮助许多新手研究者在这一领域全面了解最近的深度学习的研究和技术，并引导他们以正确的方式开始。同时，我们希望通过这项工作，向这个时代的顶级 DL 和 ANN 研究者们致敬：Geoffrey Hinton（Hinton）、Juergen Schmidhuber（Schmidhuber）、Yann LeCun（LeCun）、Yoshua Bengio（Bengio）和许多其他研究学者，他们的研究构建了现代人工智能（AI）。跟进他们的工作，以追踪当前最佳的 DL 和 ML 研究进展对我们来说也至关重要。在本论文中，我们首先简述过去的研究论文，对深度学习的模型和方法进行研究。然后，我们将开始描述这一领域的最新进展。我们将讨论深度学习（DL）方法、深度架构（即深度神经网络（DNN））和深度生成模型（DGM），其次是重要的正则化和优化方法。此外，用两个简短的部分对于开源的 DL 框架和重要的 DL 应用进行总结。我们将在最后两个章节（即讨论和结论）中讨论深入学习的现状和未来。

文章来源于AI算法修炼营 ，作者周威Encode 前面提到过Encode的过程是将ground-truth bounding box信息映射为类似网络输出的格式。这样可以加速求解损失函数的计算。我们知道在CornerNet中将检测框的左上角点和右下角点映射到heatmap上的过程，并不是简单的一一对应关系的（也就是将原图中的某关键点映射到heatmap中的某一关键点中），而是将原图中的某关键点（在CenterNet中为检测框的中点）映射到heatmap中的某一高斯核区域内。如下图4所示，为每个检测框中心点的高斯核区域显示。又或者借用https://zhuanlan.zhihu.com/p/66048276中的图，为某一中心点在heatmap的映射可视化。可以直观地感受其呈现二维高斯分布。那么根据获得的heatmap，我们可以将ground-truth bbox的偏移信息和宽高信息按照该映射关系，等同地映射到前面提到的Offset特征图和Height&Width特征图中，实现整个encode的过程 4.损失函数的设置 实现了encode过程后，设定损失函数就变得非常简单了。4.1 focal loss原论文中令为网络输出的heatmap，为ground_truth信息，即heatmap的标签/监督信息。类似CornerNet使用focal loss进行损失函数设定，实现过程如下这里的和为focal loss的超参数，N是图片中关键点的个数。4.2 offset loss为了弥补由于stride的原因造成的偏移误差，论文中设定了一个关于偏移的损失函数，使得训练后的网络能够有效计算offset值，从而修正检测框的位置。不妨这里引用一下论文中的offset loss公式。这里的p是检测框中心点（原图中）的真实坐标，p/R是理论上该中心点映射到特征图的准确位置区域（很可能是浮点型）。但是我们知道在特征图中，所有的点的位置都是整型的（即不存在某一个点的位置为（1.1，2.9）的），所以实际上，原图中坐标为p的点映射到特征图后的位置应该是是p向下取整的结果，所以这里就造成了误差了，那么这个误差就是公式中的是网络的offset输出特征图。那么这个指的是关键点实际落入的区域。说明该offset loss只关注在关键点区域的offset输出。

文章来源于AI算法修炼营 ，作者周威.检测框获取Decode 前面我们已经知道了CenterNet网络有三个输出，分别为（1） HeatMap，大小为（W/4,H/4,80），输出不同类别（80个类别）物体中心点的位置（2） Offset，大小为（W/4,H/4,2），对HeatMap的输出进行精炼，提高定位准确度（3） Height&Width,大小为（W/4,H/4,2），预测以关键点为中心的检测框的宽高那么如何将这些输出转为直观的检测框信息呢？在目标检测领域，通常将这一过程称为decode，就是根据网络的输出获取直观的检测框信息。那么encode就是将检测框信息（通常为ground-truth bounding box的坐标、宽高信息）转化为形为网络输出的信息，便于网络损失函数的求解。代码中实现decode这一过程的代码如下def _ctdet_decode(hm, reg, wh, k=100, output_stride=4): """将网络的输出转换为标准的检测框信息""" hm = K.sigmoid(hm) hm = _nms(hm) hm_shape = K.shape(hm) reg_shape = K.shape(reg) wh_shape = K.shape(wh) # cat为通道数 batch, width, cat = hm_shape[0], hm_shape[2], hm_shape[3] # 对输出的特征图进行铺平 hm_flat = K.reshape(hm, (batch, -1)) reg_flat = K.reshape(reg, (reg_shape[0], -1, reg_shape[-1])) wh_flat = K.reshape(wh, (wh_shape[0], -1, wh_shape[-1])) def _process_sample(args): _hm, _reg, _wh = args _scores, _inds = tf.math.top_k(_hm, k=k, sorted=True) # 寻找前k个heatmap的值 _classes = K.cast(_inds % cat, 'float32') #获取索引对应的类别 _inds = K.cast(_inds / cat, 'int32') #在某一类别中的位置（最大长度为 width*width），一维的 # 一维位置转二维坐标 _xs = K.cast(_inds % width, 'float32') #二维坐标中的横坐标 _ys = K.cast(K.cast(_inds / width, 'int32'), 'float32') #二维坐标的纵坐标 _wh = K.gather(_wh, _inds) #根据索引获得宽高数据 _reg = K.gather(_reg, _inds) #根据坐标获得offset _xs = _xs + _reg[..., 0] _ys = _ys + _reg[..., 1] _x1 = _xs - _wh[..., 0] / 2 _y1 = _ys - _wh[..., 1] / 2 _x2 = _xs + _wh[..., 0] / 2 _y2 = _ys + _wh[..., 1] / 2 # rescale to image coordinates _x1 = output_stride * _x1 _y1 = output_stride * _y1 _x2 = output_stride * _x2 _y2 = output_stride * _y2 _detection = K.stack([_x1, _y1, _x2, _y2, _scores, _classes], -1) return _detection detections = K.map_fn(_process_sample, [hm_flat, reg_flat, wh_flat], dtype=K.floatx()) return detections主要通过非极大值抑制（NMS）后在heatmap上寻找topk个最大值，即可能为物体中心的索引。然后根据这topk个中心点，寻找其对应的类别、宽高和offset信息。这里的NMS并不像Anchor-free中的NMS（即利用检测框的IOU为距离基准求解极大值，抑制非极大值）。而CenterNet的NMS，是寻找某点与其周围的八个点之间最大值，作为其NMS的极大值。那么该操作可以使用最简单的3x3的MaxPooling实现。实现代码如下：def _nms(heat, kernel=3): hmax = K.pool2d(heat, (kernel, kernel), padding='same', pool_mode='max') keep = K.cast(K.equal(hmax, heat), K.floatx()) return heat * keep貌似该keras代码中，并没有实现训练CenterNet的过程。所以我们没办法结合代码进行训练过程的解析，包括（1）损失函数设定（2）将ground-truth bounding box信息映射为类似网络输出的格式，被称为encode。那么下面直接结合论文进行损失函数与encode的解析。

随机森林指的是利用多棵树对样本进行训练并预测的一种分类器。该分类器最早由Leo Breiman和Adele Cutler提出，并被注册成了商标。在机器学习中，随机森林是一个包含多个决策树的分类器， 并且其输出的类别是由个别树输出的类别的众数而定。 Leo Breiman和Adele Cutler发展出推论出随机森林的算法。 而 "Random Forests" 是他们的商标。 这个术语是1995年由贝尔实验室的Tin Kam Ho所提出的随机决策森林（random decision forests）而来的。这个方法则是结合 Breimans 的 "Bootstrap aggregating" 想法和 Ho 的"random subspace method"以建造决策树的集合。随机森林的优缺点优点：1.可以用来解决分类和回归问题：随机森林可以同时处理分类和数值特征2.抗过拟合能力：通过平均决策树，降低过拟合的风险性3.只有在半数以上的基分类器出现差错时才会做出错误的预测：随机森林非常稳定，即使数据集中出现了一个新的数据点，整个算法也不会受到过多影响，它只会影响到一颗决策树，很难对所有决策树产生影响缺点：1.据观测，如果一些分类/回归问题的训练数据中存在噪音，随机森林中的数据集会出现过拟合的现象2.比决策树算法更复杂，计算成本更高3.由于其本身的复杂性，它们比其他类似的算法需要更多的时间来训练非常推荐这个学习视频https://education.huaweicloud.com/courses/course-v1:HuaweiX+CBUCNXE086+Self-paced/courseware/45c5a9b65ee348719ddc4f4c3801ad0f/b67e40f52a7447f79364a2de6f2b9398/相关概念1.分裂：在决策树的训练过程中，需要一次次的将训练数据集分裂成两个子数据集，这个过程就叫做分裂。2.特征：在分类问题中，输入到分类器中的数据叫做特征。以上面的股票涨跌预测问题为例，特征就是前一天的交易量和收盘价。3.待选特征：在决策树的构建过程中，需要按照一定的次序从全部的特征中选取特征。待选特征就是在步骤之前还没有被选择的特征的集合。例如，全部的特征是 ABCDE，第一步的时候，待选特征就是ABCDE，第一步选择了C，那么第二步的时候，待选特征就是ABDE。4.分裂特征：接待选特征的定义，每一次选取的特征就是分裂特征，例如，在上面的例子中，第一步的分裂特征就是C。因为选出的这些特征将数据集分成了一个个不相交的部分，所以叫它们分裂特征。

TensorFlow训练网络有两种方式，一种是基于tensor(array)，另外一种是迭代器两种方式区别是：第一种是要加载全部数据形成一个tensor，然后调用model.fit()然后指定参数batch_size进行将所有数据进行分批训练第二种是自己先将数据分批形成一个迭代器，然后遍历这个迭代器，分别训练每个批次的数据方式一：通过迭代器1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283IMAGE_SIZE = 1000 # step1:加载数据集(train_images, train_labels), (val_images, val_labels) = tf.keras.datasets.mnist.load_data() # step2:将图像归一化train_images, val_images = train_images / 255.0, val_images / 255.0 # step3:设置训练集大小train_images = train_images[:IMAGE_SIZE]val_images = val_images[:IMAGE_SIZE]train_labels = train_labels[:IMAGE_SIZE]val_labels = val_labels[:IMAGE_SIZE] # step4:将图像的维度变为(IMAGE_SIZE,28,28,1)train_images = tf.expand_dims(train_images, axis=3)val_images = tf.expand_dims(val_images, axis=3) # step5:将图像的尺寸变为(32,32)train_images = tf.image.resize(train_images, [32, 32])val_images = tf.image.resize(val_images, [32, 32]) # step6:将数据变为迭代器train_loader = tf.data.Dataset.from_tensor_slices((train_images, train_labels)).batch(32)val_loader = tf.data.Dataset.from_tensor_slices((val_images, val_labels)).batch(IMAGE_SIZE) # step5:导入模型model = LeNet5() # 让模型知道输入数据的形式model.build(input_shape=(1, 32, 32, 1)) # 结局Output Shape为 multiplemodel.call(Input(shape=(32, 32, 1))) # step6:编译模型model.compile(optimizer='adam',              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),              metrics=['accuracy']) # 权重保存路径checkpoint_path = "./weight/cp.ckpt" # 回调函数，用户保存权重save_callback = tf.keras.callbacks.ModelCheckpoint(filepath=checkpoint_path,                                                   save_best_only=True,                                                   save_weights_only=True,                                                   monitor='val_loss',                                                   verbose=0) EPOCHS = 11 for epoch in range(1, EPOCHS):    # 每个批次训练集误差    train_epoch_loss_avg = tf.keras.metrics.Mean()    # 每个批次训练集精度    train_epoch_accuracy = tf.keras.metrics.SparseCategoricalAccuracy()    # 每个批次验证集误差    val_epoch_loss_avg = tf.keras.metrics.Mean()    # 每个批次验证集精度    val_epoch_accuracy = tf.keras.metrics.SparseCategoricalAccuracy()     for x, y in train_loader:        history = model.fit(x,                            y,                            validation_data=val_loader,                            callbacks=[save_callback],                            verbose=0)         # 更新误差，保留上次        train_epoch_loss_avg.update_state(history.history['loss'][0])        # 更新精度，保留上次        train_epoch_accuracy.update_state(y, model(x, training=True))         val_epoch_loss_avg.update_state(history.history['val_loss'][0])        val_epoch_accuracy.update_state(next(iter(val_loader))[1], model(next(iter(val_loader))[0], training=True))     # 使用.result()计算每个批次的误差和精度结果    print("Epoch {:d}: trainLoss: {:.3f}, trainAccuracy: {:.3%} valLoss: {:.3f}, valAccuracy: {:.3%}".format(epoch,                                                                                                             train_epoch_loss_avg.result(),                                                                                                             train_epoch_accuracy.result(),                                                                                                             val_epoch_loss_avg.result(),                                                                                                             val_epoch_accuracy.result()))方式二：适用model.fit()进行分批训练123456789101112131415161718192021222324252627282930313233343536373839404142434445464748import model_sequential (train_images, train_labels), (test_images, test_labels) = tf.keras.datasets.mnist.load_data() # step2:将图像归一化train_images, test_images = train_images / 255.0, test_images / 255.0 # step3:将图像的维度变为(60000,28,28,1)train_images = tf.expand_dims(train_images, axis=3)test_images = tf.expand_dims(test_images, axis=3) # step4:将图像尺寸改为(60000,32,32,1)train_images = tf.image.resize(train_images, [32, 32])test_images = tf.image.resize(test_images, [32, 32]) # step5:导入模型# history = LeNet5()history = model_sequential.LeNet() # 让模型知道输入数据的形式history.build(input_shape=(1, 32, 32, 1))# history(tf.zeros([1, 32, 32, 1])) # 结局Output Shape为 multiplehistory.call(Input(shape=(32, 32, 1)))history.summary() # step6:编译模型history.compile(optimizer='adam',                loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),                metrics=['accuracy']) # 权重保存路径checkpoint_path = "./weight/cp.ckpt" # 回调函数，用户保存权重save_callback = tf.keras.callbacks.ModelCheckpoint(filepath=checkpoint_path,                                                   save_best_only=True,                                                   save_weights_only=True,                                                   monitor='val_loss',                                                   verbose=1)# step7:训练模型history = history.fit(train_images,                      train_labels,                      epochs=10,                      batch_size=32,                      validation_data=(test_images, test_labels),                      callbacks=[save_callback])

在ModelArts中创建训练作业，并完成模型训练，在得到满意的模型后，可以将训练后得到的模型导入至模型管理，方便统一管理，同时支持将模型快速部署上线为服务。背景信息如果使用ModelArts训练作业生成的模型，请确保训练作业已运行成功，且模型已存储至对应OBS目录下。针对使用订阅算法的训练作业，无需推理代码和配置文件，其生成的模型可直接导入ModelArts。针对使用常用框架或自定义镜像创建的训练作业，需根据模型包规范介绍，将推理代码和配置文件上传至模型的存储目录中。确保您使用的OBS目录与ModelArts在同一区域。创建AI应用操作步骤登录ModelArts管理控制台，在左侧导航栏中选择“AI应用管理 > AI应用”，进入AI应用列表页面。单击左上角的“创建”，进入“创建AI应用”页面。在“创建AI应用”页面，填写相关参数。写元模型来源及其相关参数。当“元模型来源”选择“从训练中选择”时，其相关的参数配置如下确认信息填写无误，单击“立即创建”，完成AI应用的创建。在AI应用列表中，您可以查看刚创建的AI应用及其对应的版本。当AI应用状态变更为“正常”时，表示AI应用导入成功。在此页面，您还可以创建新版本、快速部署服务、发布AI应用等操作。后续操作部署服务：在“AI应用列表”中，单击AI应用名称左侧的小三角，打开此AI应用下的所有版本。在对应版本所在行，单击“操作”列的“部署”，在下拉框中选择部署类型，可以将AI应用部署上线为创建AI应用时所选择的部署类型。

目前来看，大部分的AI应用都是通过监督学习，利用一组已标注的训练数据，对分类器的参数进行调整，使其达到所要求的性能。但在现实生活中，监督学习不足以被称为“智能”。对照人类的学习过程，许多都是建立在与事物的交互中，通过人类自身的体会、领悟，得到对事物的理解，并将之应用于未来的生活中。而机器的局限就在于缺乏这些“常识”。卷积神经网络之父、Facebook AI研究院院长YannLeCun曾通过一个“黑森林蛋糕”的比喻来形容他所理解的监督学习、非监督学习与强化学习间的关系：如果将机器学习视作一个黑森林蛋糕，那（纯粹的）强化学习是蛋糕上不可或缺的樱桃，需要的样本量只有几个Bits；监督学习是蛋糕外层的糖衣，需要10到10000个的样本量；无监督学习则是蛋糕的主体，需要数百万Bits的样本量，具备强大的预测能力。但他也强调，樱桃是必须出现的配料，意味着强化学习与无监督学习是相辅相成、缺一不可的。 无监督学习领域近期的研究重点在于“**生成对抗网络**”(GANs)，其实现方式是让生成器（Generator)和判别器(Discriminator)这两个网络互相博弈，生成器随机从训练集中选取真实数据和干扰噪音，产生新的训练样本，判别器通过与真实数据进行对比，判断数据的真实性。 在这个过程中，生成器与判别器交互学习、自动优化预测能力，从而创造最佳的预测模型。自2014由lan Goodfellow提出后，GANs席卷各大顶级会议，被Yann LeCun评价为是“20年来机器学习领域最酷的想法”。 而强化学习，则更接近于**自然界生物学习过程的本源**：如果把自己想象成环境（Environment)中的一个代理(Agent)，面你需要不断探索以发现新的可能性(Exploration)，一方面又要现有条件下做到极致(Exploitation)。正确的决定或早或晚一定会为你带来奖励（Positive Reward)，反之则会带来惩罚(Negative Reward)，直到最终彻底掌握问题的答案（Optimal Policy)。强化学习的一个重要研究方向在于建立一个有效的、与真实世界存在交互的仿真模拟环境，不断训练，模拟采取各种动作、接受各种反馈，以此对模型进行训练。

获取您的EI红宝书：https://www.huaweicloud.com/ei/                     AI测试是对基于AI的应用系统的测试；与任何系统一样，基于AI的系统具有功能性和非功能性需求。AI应用测试的主要流程包括场景分析，特征因子分析，数据构建，评测指标，自动化方案等AI应用测试AI测试任务分层AI应用测试框架关键角色AI开发工程师负责设计、开发实现、数据验收、自测、调优等工作数据工程师负责数据采集、数据清洗、数据整合、数据标注、数据质量检测等工作测试工程师负责测试数据采集、测试场景分析、测试方案、测试用例、测试策略、测试自动化、测试验收和评估等工作测试流程和活动① 结合需求描述，梳理典型应用场景，场景使用主体、特点等，将场景细化② 基于场景分析，分析影响Al模型识别率的特征因子，建立特征因子库。不同的AI场景对特征因子要求和复杂度不一样，比如CV应用场景的特征因子有拍摄因素（曝光、角度等）、环境因素（阴晴雨雪、背景等）、属性因素（人物年龄、肤色等）③ 基于应用场景、特征因子等进行数据集构建,包括不限于:数据类别、不同因子比例、环境因素、特定要求等④ 不同业务场景，关注不同的指标，评价的结果也不同，所以需要根据需求场景和侧重点，确定指标和相关定义。比如：有些业务求全，所以召回率优先；有些业务求准,所以准确率优先；有的业务因类别不均衡，要看单个类别的准确率；还有的业务内存非常敏感，所以对模型大小优先。⑤ 自动化批量测试及评测指标统计https://mp.weixin.qq.com/s?__biz=Mzg5Mjc4NjE1Nw==&mid=2247484542&idx=1&sn=4e6a77a15df21988fe72d41e133e8bdf&chksm=c03980fcf74e09eae416f1a5085ecba06804d9e17210e9a32f2706ebe201fbb8ceab4a6d13e8&token=70826191&lang=zh_CN#rd                                            云与数据- HCCDA-AI合集：https://mp.weixin.qq.com/mp/appmsgalbum?__biz=Mzg5Mjc4NjE1Nw==&action=getalbum&album_id=2398219468813811715&scene=173&from_msgid=2247483927&from_itemidx=1&count=3&nolastread=1#wechat_redirect**

2022年5月11日晚,由华为云HCDE与EI开发者支持团队、福建DTSE团队联合举办的“华为云HCDE上云之路人工智能行业解决方案闭门会”于线上举行。本次会议，华为云EI开发者生态总监林旅强、华为云EI高级工程师杜奇、华为云EI生态经理陈桢、上海麦图信息科技有限公司CTO李鑫与来自多个行业中导入人工智能的各企业CEO、CTO、技术总监等三十多位专家伙伴齐聚线上，就此展开了一场华为云高端技术圈层的精彩思想碰撞和技术落地方案交流。华为云EI高级工程师 零一华为云EI高级工程师零一老师进行了主题为“后疫情时代下，如何加速AI行业开发和落地，实现智能化转型？”的分享。疫情加速人工智能的落地，根据相关统计，疫情期间，具有以下两类特征的企业在疫情期间展现出显著优势：1）能够基于传统 IT 软件，提供叠加人工智能技术拓展其功能边界的企业。2）应用场景清晰，为行业直接提供垂直解决方案的人工智能技术企业。AI产业未来趋势将从局部应用到千行百业，预计2025年，企业对AI的采用率86%。AI助力行业升级的三大主要场景包括：海量重复场景（Repetitive, high-volume work）、专家经验场景（Expert experience）、多域协同场景（Multi-domain collaboration），通过AI技术能使的这些场景实现效率提升、专业传承、突破极限。AI落地短期是为了替代重复劳动解放生产力，长期是为了突破智力极限发现新知识。在落地过程中会面临三大挑战：1）数据敏感，难以适应长尾分布；2）模型敏感，通常需求巨大算力；3)缺乏知识, 算法可解释性较差。这也导致了AI落地的可复制性弱，开发成本居高不下。华为云高效开发平台ModelArts，通过超强预训练大模型、高效数据扩增和生成、模型按需抽取、自动优化和部署等能力，使得AI在落地过程中实现数据高效、模型高效、知识高效。华为云EI生态经理Dino华为云EI生态经理Dino，基于零一老师老师对人工智能行业的分析与洞察，进行了主题为“华为云ModelArts 轻松助力企业降本增效”的产品分享。华为云构筑AI生态圈，助力千行百业智能升级。华为云ModelArts是面向开发者的一站式AI开发平台，为机器学习与深度学习提供海量数据预处理及交互式智能标注、大规模分布式 训练、自动化模型生成，及端-边-云模型按需部署能力，帮助用户快速创建和部署模型，管理全周期AI工作流ModelArts也是千行百业实现智能升级的AI使能平台。基于华为云的先进算法和快速训练能力，ModelArts提供大量预置行业 工作流和模型，降低开发应用难度，将大部分定制场景自动化，提升企业AI应用的落地效率。在异构分布式资源调度引擎的加持下， 算力得到极致利用，通过AI社区 AI Gallery 承载的天筹(OptVerse)求解器、知识计算、科学计算、盘古大模型和来自生态伙伴的丰富行业组件/工具，企业可轻松实现极简、高效的智能系统开发。华为云与客户和伙伴一起探索AI在千行百业的实践，为构筑AI开发者生态，提供丰富的AI基础服务及行业化解决方案。与梦饷集团一起基于ModelArts搭建推荐平台，开拓电商新价值，店主人数突破200万，月GMV突破10亿元。HEXA IoT开发人员基于华为云ModelArts开发辣椒识别模型，统一辣椒分拣标准，有效减少了人工筛选带来的判断误差，使得整体分拣效率提升50%。华为云为AI开发者伙伴提供技术、商业孵化、营销等全流程生态支持，与伙伴共创AI应用生态，助力伙伴商业成功。上海麦图科技有限公司CTO 李鑫上海麦图科技有限公司CTO李鑫，分享了以“AI助力民航，坚守安全底线，优化流程保障”为题的行业AI应用经验。分享中讲述了如何利用视频目标识别技术在民航领域实现机坪放冲突与流程保障节点采集的工作，给出了一种利用华为云EI的ModelArts线上训练+线下离线部署的解决方案，支持Atlas等多种硬件架构执行AI应用。该方案充分利用了ModelArts在数据管理、数据协同标注、模型订阅训练与转换等多种功能，实现高效率低成本的行业AI应用，为到场的各位提供了华为云EI在生产项目的一线经验。活动的最后，进行了线上圆桌交流环节，多位华为云专家与来自人工智能行业的工程师、公司CEO、CTO等三十多位伙伴围绕“疫情下的危与机，AI行业技术管理者如何发现机遇、迎接挑战、输出解法？”主题进行了探讨。多位伙伴分别提出了对AI行业、场景解决方案以及华为云相关的产品的问题，华为云专家们针对问题与伙伴们展开了激烈的探讨，将本场活动气氛推向了高潮。与此同时，华为云HCDE上云之路人工智能行业解决方案闭门顺利落下了帷幕。华为云致力于搭建技术交流平台、机遇共创的通道，全面助力每一位开发者、每一位合作伙伴，期待下期活动再次相会。如想了解参加更多华为云HCDE相关活动或有AI合作需求请联系小助手（微信号：hwyzj123）