введение
Семантика элементов интерфейса всегда была проблемой, от которой страдает D2C и индустрия ИИ, а семантика — это ключевое звено искусственного интеллекта в продуктах генерации кода (таких как D2C), которое играет жизненно важную роль в гуманизированном дизайне. В настоящее время большинство распространенных семантических технологий в мире являются производными от самого чистого поля, например, TxtCNN, Attention, Bert и т. д. Хотя эти методы работают хорошо, они все же имеют определенные ограничения при применении к продуктам D2C, поскольку видения D2C Он должен стать сквозной системой, и его трудно семантически определить из чистых полей.Например, поле «200¥» трудно связать с соответствующей семантикой, что может означать исходную цену , активная цена и т. д. Следовательно, чтобы решить семантическую задачу элементов интерфейса, D2C необходимо решить как минимум две задачи: 1. Чтобы иметь возможность генерировать семантику элементов, соответствующую текущему интерфейсу, 2. Уменьшить пользовательские ограничения и не требовать от пользователей ввод дополнительной вспомогательной информации.
В последние годы обучение с подкреплением отлично зарекомендовало себя во многих областях, таких как AlphaGo, робототехника, автономное вождение, игры и т. д. Отличная производительность привлекла внимание многих ученых. В данной работе для семантической проблемы элементов интерфейса вводится глубокое обучение с подкреплением (DRL, Deep Reinforcement Learning) на основе игрового мышления, предлагается семантическое решение, основанное на глубоком обучении с подкреплением, и обучающая среда обучения с подкреплением для семантических задач. , и 2 различных типа алгоритмов глубокого обучения с подкреплением (1. Алгоритм обучения с подкреплением на основе функции ценности DQN 2. Алгоритм DPPO на основе комбинированной функции ценности и градиента политики DPPO) Проведены сравнительные эксперименты, и экспериментальные результаты демонстрируют эффективность метода в данной работе и превосходство семантической схемы на основе алгоритма DPPO.
В этой статье семантическая проблема элементов интерфейса рассматривается как проблема принятия решения в этой ситуации, начиная непосредственно с изображения интерфейса и используя изображение интерфейса в качестве входных данных на основе глубокого обучения с подкреплением, которое изучается посредством непрерывного «пробного опыта». и ошибка». Оптимальная политика (т.е. оптимальная семантика). Конкретная работа этой статьи заключается в следующем: 1. Чтобы лучше описать принцип работы этой статьи, ключевые технологии алгоритма DQN и алгоритма DPPO представлены в деталях 2. Создана интересная обучающая среда для обучения семантической модели. на основе обучения с подкреплением, 3. Проанализируйте результаты эксперимента.
Подробные математические основы методов глубокого обучения с подкреплением вы можете прочитать в моем общем документе: [Обзор методов глубокого обучения с подкреплением] (Колонка Calling.com/afraid/283438275…
Обзор методов, использованных в этой статье
Алгоритм глубокого обучения с подкреплением на основе функции ценности DQN
В этой статье алгоритм глубокого обучения с подкреплением, основанный на функции ценности, используется в качестве одной из конкретных технологий реализации для распознавания семантического поля.Алгоритм глубокого обучения с подкреплением, основанный на функции ценности, использует CNN для аппроксимации функции ценности действия традиционного обучения с подкреплением. репрезентативным алгоритмом является алгоритм DQN, алгоритм DQN. Фрейм выглядит следующим образом:Как видно из приведенного выше рисунка, одной из особенностей алгоритма глубокого обучения с подкреплением DQN, основанного на функции ценности, является использование глубокой сверточной нейронной сети для аппроксимации функции ценности действия. Среди них состояния S и S' являются многомерными данными, пул опыта используется для хранения опыта успеха или неудачи в тренировочном процессе.
В DQN есть две нейронные сети с одинаковой структурой, называемые соответственно целевой сетью и оценочной сетью. выходное значение в целевой сетипредставляет показатель затухания, когда действие a выбирается в состоянии S, то есть:
В формуле r и S 'являются оценкой и соответствующим следующим состоянием, когда действие a выполняется в состоянии S соответственно;
- коэффициент затухания; a' - максимальное значение, которое может быть получено в состоянии S' в таблице векторов значений Q выхода сети оценки
ценное действие,
— весовой параметр целевой сети.
Оцените выходное значение сетипредставляет ценность выполнения действия a в состоянии S, то есть:
В формуле
Весовые параметры для оценки сети.
Процесс обучения DQN делится на три этапа:
(1) Начальная стадия. В это время пул опыта D не заполнен и случайным образом выбирает поведение для получения кортежей опыта в каждый момент времени t., а затем сохраните кортеж опыта каждого шага в пуле опыта
. Этот этап в основном используется для накопления опыта, в это время ни одна из двух сетей DQN не обучена;
(2) Стадия разведки. На этом этапе- Жадная стратегия (
Постепенно уменьшать от 1 до 0) для получения действия а, пока сеть принимает решения, она также может с определенной вероятностью исследовать другие возможные оптимальные варианты поведения, избегая проблемы попадания в локально оптимальное решение. На этом этапе кортежи опыта в пуле опыта постоянно обновляются и используются в качестве входных данных оценочной сети и целевой сети, мы получаем
и
. Затем разница между ними используется в качестве функции потерь, а весовые параметры оценочной сети обновляются алгоритмом градиентного спуска. Для сходимости обучения метод обновления весовых параметров целевой сети заключается в следующем: копирование весовых параметров оценочной сети в параметры целевой сети через фиксированное количество итераций;
(3) Стадия использования. этот этапдо 0, то есть все выбранные действия исходят из выходных данных оценочной сети. Метод обновления оценочной сети и целевой сети такой же, как и на этапе исследования.
Алгоритм глубокого обучения с подкреплением на основе функции ценности DQN проводит обучение сети в соответствии с тремя вышеуказанными этапами.Когда обучение сети сходится, сеть оценки приближается к оптимальной функции ценности действия для достижения цели оптимального обучения политике.
DPPO (Distribution Proximal Policy Optimization) алгоритм оптимизации распределенной политики ближнего конца
Я попытался применить алгоритм DQN к задаче связывания полей и обнаружил, что алгоритму DQN трудно поддерживать совместное обучение нескольких изображений, поэтому я обратился к поиску эффективного алгоритма более высокого порядка. что PPO в настоящее время является очень популярным алгоритмом обучения с подкреплением. OpenAI использует PPO в качестве текущего алгоритма по умолчанию. Вполне возможно, что PPO может быть не самым сильным в настоящее время, но это может быть наиболее применимый алгоритм в настоящее время. Кроме того, PPO легче справляться со сложными средами, поэтому мы хотим внедрить PPO в семантические задачи. И DPPO - это распределенная версия PPO, например, 8 рабочих, каждый работник имеет независимый опыт. Поскольку корреляции между опытом можно избежать, а обучение происходит быстрее, DPPO значительно лучше, чем PPO.
Алгоритм PPO
Во-первых, вводится алгоритм PPO. Алгоритм PPO основан на архитектуре Актер-Критик (AC). Это алгоритм AC, который может адаптироваться к скорости обучения. Он резюмирует PPO в одном предложении: Решение проблемы, которую представляет собой градиент политики. нелегко определить скорость обучения (или размер шага). Потому что, если размер шага слишком велик, выученная Политика всегда будет перемещаться и не будет сходиться, а если размер шага слишком мал, мы будем ждать до отчаяния, чтобы завершить обучение. PPO использует соотношение новой политики и старой политики, чтобы ограничить диапазон обновления новой политики, делая градиент политики менее чувствительным к несколько большему размеру шага.
Алгоритм ППО следующий:В общем, PPO представляет собой набор структур Актер-Критик, Актер хочет максимизировать J_PPO, а Критик хочет минимизировать L_BL. Потеря Critic легко сказать, это уменьшить ошибку временной разницы (TD). Актер должен изменить новую Политику на основе преимущества (ошибка TD) по сравнению со старой Политикой.Когда преимущество велико, диапазон модификации велик, что повышает вероятность появления новой Политики. И добавляется KL Penalty (штрафной пункт, поиск расхождения KL для тех, кто не понимает) для контроля скорости обучения.Короче говоря, если новая Политика слишком отличается от старой Политики, то расхождение KL будет больше , и нам не нужна новая Политика. Она намного хуже старой Политики. Если ее слишком много, это эквивалентно использованию большой скорости обучения, что нехорошо и трудно сходиться.
Алгоритм DPPO
Google DeepMind предложил параллельный алгоритм PPO, аналогичный A3C, а именно DPPO.По сравнению с PPO различия сводятся к следующему:
- Обрезанная суррогатная цель с OpenAI
- Используйте несколько потоков (воркеров) для параллельного сбора данных в разных средах.
- работники совместно используют глобальный PPO
- Рабочие не будут вычислять градиенты PPO сами по себе и не будут передавать градиенты в глобальную сеть, как A3C.
- работники только передают данные, собранные ими самими, в Global PPO
- Глобальный PPO обновляет определенный пакет данных от нескольких рабочих процессов (воркеры перестают собирать данные при обновлении).
- После обновления воркеры собирают данные с последней Политикой
процесс эксперимента
Создание среды обучения с подкреплением
Важные факторы обучения с подкреплением: агент, среда, функция вознаграждения и наказания, дизайн обратной связи, пошаговый дизайн. Идея этой статьи заключается в следующем: рассматривать задачу распознавания семантического поля как игровой процесс, в котором модель алгоритма постоянно обновляет параметры модели в соответствии с обратной связью от окружающей среды и изучает правило, как максимизировать вознаграждение. и функция наказания. В частности, изображение модуля выбирается непосредственно в качестве среды, а кадр элемента в модуле используется в качестве агента.При обучении алгоритма агент (кадр элемента) будет перемещаться сверху вниз и слева направо. ,так же как и хождение по лабиринту.Необходимо принять решение и выбрать Действие(это Действие и есть то смысловое поле,которое мы хотим).Только при правильном выборе Действия,агент может "уйти" вниз.Когда агент" идет" все элементы, значит Алгоритмические модели учатся побеждать. Структура окружения следующая:
Обучение с подкреплением — это обучение без учителя, не требующее ручной разметки, но задача распознавания семантического поля искусственно размечена, чтобы облегчить создание функций поощрения и наказания (при наличии CSS-кода для этого изображения модуля разметка не требуется) , набор данных можно сначала использовать для маркировки LabelImg, каждый элемент имеет соответствующее семантическое поле, а метод маркировки показан на следующем рисунке (первое изображение — изображение модуля, второе — информация маркировки элементов в модуль, а третье — семантическое поле информации):
обучение модели
Для обучения модели необходимо импортировать приведенный выше код среды.В качестве примера алгоритма DQN коды обучения и тестирования модели выглядят следующим образом:
# coding:utf-8
import os
import random
import numpy as np
# import tensorflow as tf
import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()
from collections import deque
import matplotlib
matplotlib.use('TkAgg')
import matplotlib.pyplot as plt
from keras.models import Sequential
from keras.layers import Convolution2D, Flatten, Dense,Conv2D
from gan_env_semantic import semantic_env
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
from matplotlib.figure import Figure
import tkinter as tk
import time
os.environ['CUDA_VISIBLE_DEVICES']='0'
ENV_NAME = 'semantic_env'#'Breakout-v0' # Environment name
#FRAME_WIDTH = 714 # Resized frame width
#FRAME_HEIGHT = 534 # Resized frame height
NUM_EPISODES = 2000000 # Number of episodes the agent plays
STATE_LENGTH = 1 # Number of most recent frames to produce the input to the network
GAMMA = 0.9 # Discount factor
EXPLORATION_STEPS = 10000 # Number of steps over which the initial value of epsilon is linearly annealed to its final value
INITIAL_EPSILON = 1.0 # Initial value of epsilon in epsilon-greedy
FINAL_EPSILON = 0.01 # Final value of epsilon in epsilon-greedy
INITIAL_REPLAY_SIZE = 4000 #4000 Number of steps to populate the replay memory before training starts
NUM_REPLAY_MEMORY = 10000 #10000 Number of replay memory the agent uses for training
BATCH_SIZE = 64 #128 Mini batch size
TARGET_UPDATE_INTERVAL = 1000 # The frequency with which the target network is updated
TRAIN_INTERVAL = 4 # The agent selects 4 actions between successive updates
LEARNING_RATE = 0.00025 # Learning rate used by RMSProp
MOMENTUM = 0.95 # Momentum used by RMSProp
MIN_GRAD = 0.01 # Constant added to the squared gradient in the denominator of the RMSProp update
SAVE_INTERVAL = 10000 #10000 The frequency with which the network is saved
NO_OP_STEPS = 30 # Maximum number of "do nothing" actions to be performed by the agent at the start of an episode
LOAD_NETWORK = True
TRAIN = False
SAVE_NETWORK_PATH = 'saved_networks/' + ENV_NAME
SAVE_SUMMARY_PATH = 'summary/' + ENV_NAME
NUM_EPISODES_AT_TEST = 300 # Number of episodes the agent plays at test time
class Agent():
def __init__(self, num_actions, FRAME_WIDTH, FRAME_HEIGHT):
self.num_actions = num_actions
self.epsilon = INITIAL_EPSILON
self.epsilon_step = (INITIAL_EPSILON - FINAL_EPSILON) / EXPLORATION_STEPS
self.t = 0
self.FRAME_WIDTH, self.FRAME_HEIGHT = FRAME_WIDTH, FRAME_HEIGHT
# Parameters used for summary
self.total_reward = 0
self.total_q_max = 0
self.total_loss = 0
self.duration = 0
self.episode = 0
# Create replay memory
self.replay_memory = deque()
# Create q network
self.s, self.q_values, q_network = self.build_network()
q_network_weights = q_network.trainable_weights
# Create target network
self.st, self.target_q_values, target_network = self.build_network()
target_network_weights = target_network.trainable_weights
# Define target network update operation
self.update_target_network = [target_network_weights[i].assign(q_network_weights[i]) for i in range(len(target_network_weights))]
# Define loss and gradient update operation
self.a, self.y, self.loss, self.grads_update = self.build_training_op(q_network_weights)
self.sess = tf.InteractiveSession()
self.saver = tf.train.Saver(q_network_weights)
self.summary_placeholders, self.update_ops, self.summary_op = self.setup_summary()
self.summary_writer = tf.summary.FileWriter(SAVE_SUMMARY_PATH, self.sess.graph)
if not os.path.exists(SAVE_NETWORK_PATH):
os.makedirs(SAVE_NETWORK_PATH)
self.sess.run(tf.global_variables_initializer())
# Load network
if LOAD_NETWORK:
self.load_network()
# Initialize target network
self.sess.run(self.update_target_network)
def build_network(self):
model = Sequential()
#model.add(Convolution2D(32, (8, 8), subsample=(4, 4), activation='relu', input_shape=(FRAME_WIDTH, FRAME_HEIGHT,STATE_LENGTH)))
#model.add(Convolution2D(64, (4, 4), subsample=(2, 2), activation='relu'))
#model.add(Convolution2D(64, (3, 3), subsample=(1, 1), activation='relu'))
model.add(Conv2D(32, (8, 8), strides=(4, 4), activation='relu',input_shape=(self.FRAME_WIDTH, self.FRAME_HEIGHT,1)))
model.add(Conv2D(64, (4, 4), strides=(2, 2), activation='relu'))
model.add(Conv2D(64, (3, 3), strides=(1, 1), activation='relu'))
model.add(Flatten())
model.add(Dense(512, activation='relu'))
model.add(Dense(self.num_actions))
s = tf.placeholder(tf.float32, [None,self.FRAME_WIDTH, self.FRAME_HEIGHT,1])
q_values = model(s)
return s, q_values, model
def build_training_op(self, q_network_weights):
a = tf.placeholder(tf.int64, [None])
y = tf.placeholder(tf.float32, [None])
# Convert action to one hot vector
a_one_hot = tf.one_hot(a, self.num_actions, 1.0, 0.0)
q_value = tf.reduce_sum(tf.multiply(self.q_values, a_one_hot), reduction_indices=1)
# Clip the error, the loss is quadratic when the error is in (-1, 1), and linear outside of that region
error = tf.abs(y - q_value)
quadratic_part = tf.clip_by_value(error, 0.0, 1.0)
linear_part = error - quadratic_part
loss = tf.reduce_mean(0.5 * tf.square(quadratic_part) + linear_part)
optimizer = tf.train.RMSPropOptimizer(LEARNING_RATE, momentum=MOMENTUM, epsilon=MIN_GRAD)
grads_update = optimizer.minimize(loss, var_list=q_network_weights)
return a, y, loss, grads_update
def get_initial_state(self, observation):
processed_observation = np.reshape(observation,(self.FRAME_WIDTH,self.FRAME_HEIGHT,1))
state = processed_observation
return state
def get_action(self, state):
if self.epsilon >= random.random() or self.t < INITIAL_REPLAY_SIZE:
action = random.randrange(self.num_actions)
else:
action = np.argmax(self.q_values.eval(feed_dict={self.s: [np.float32(state)]}))
# Anneal epsilon linearly over time
if self.epsilon > FINAL_EPSILON and self.t >= INITIAL_REPLAY_SIZE:
self.epsilon -= self.epsilon_step
#print("epsilon:{},t:{}".format(self.epsilon,self.t))
return action
def run(self, state, action, reward, terminal, observation):
#next_state = np.append(state[1:, :, :,:], observation, axis=0)
next_state = observation
# Clip all positive rewards at 1 and all negative rewards at -1, leaving 0 rewards unchanged
reward = np.clip(reward, -1, 1)
# Store transition in replay memory
self.replay_memory.append((state, action, reward, next_state, terminal))
if len(self.replay_memory) > NUM_REPLAY_MEMORY:
self.replay_memory.popleft()
if self.t >= INITIAL_REPLAY_SIZE:
# Train network
if self.t % TRAIN_INTERVAL == 0:
self.train_network()
# Update target network
if self.t % TARGET_UPDATE_INTERVAL == 0:
self.sess.run(self.update_target_network)
# Save network
if self.t % SAVE_INTERVAL == 0:
save_path = self.saver.save(self.sess, SAVE_NETWORK_PATH + '/' + ENV_NAME, global_step=self.t)
print('Successfully saved: ' + save_path)
self.total_reward += reward
self.total_q_max += np.max(self.q_values.eval(feed_dict={self.s: [np.float32(state)]}))
self.duration += 1
if terminal or self.duration % 100 == 0:
# Write summary
if self.t >= INITIAL_REPLAY_SIZE:
stats = [self.total_reward, self.total_q_max / float(self.duration),
self.duration, self.total_loss / (float(self.duration) / float(TRAIN_INTERVAL))]
for i in range(len(stats)):
self.sess.run(self.update_ops[i], feed_dict={
self.summary_placeholders[i]: float(stats[i])
})
summary_str = self.sess.run(self.summary_op)
self.summary_writer.add_summary(summary_str, self.episode + 1)
if terminal:
# Debug
if self.t < INITIAL_REPLAY_SIZE:
mode = 'random'
elif INITIAL_REPLAY_SIZE <= self.t < INITIAL_REPLAY_SIZE + EXPLORATION_STEPS:
mode = 'explore'
else:
mode = 'exploit'
print('EPISODE: {0:6d} / TIMESTEP: {1:8d} / DURATION: {2:5d} / EPSILON: {3:.5f} / TOTAL_REWARD: {4:3.0f} / AVG_MAX_Q: {5:2.4f} / AVG_LOSS: {6:.5f} / MODE: {7}'.format(
self.episode + 1, self.t, self.duration, self.epsilon,
self.total_reward, self.total_q_max / float(self.duration),
self.total_loss / (float(self.duration) / float(TRAIN_INTERVAL)), mode))
self.total_reward = 0
self.total_q_max = 0
self.total_loss = 0
self.duration = 0
self.episode += 1
self.t += 1
return next_state
def train_network(self):
state_batch = []
action_batch = []
reward_batch = []
next_state_batch = []
terminal_batch = []
y_batch = []
# Sample random minibatch of transition from replay memory
minibatch = random.sample(self.replay_memory, BATCH_SIZE)
for data in minibatch:
state_batch.append(data[0])
action_batch.append(data[1])
reward_batch.append(data[2])
next_state_batch.append(data[3])
terminal_batch.append(data[4])
# Convert True to 1, False to 0
terminal_batch = np.array(terminal_batch) + 0
next_action_batch = np.argmax(self.q_values.eval(feed_dict={self.s: next_state_batch}), axis=1)
target_q_values_batch = self.target_q_values.eval(feed_dict={self.st: next_state_batch})
for i in range(len(minibatch)):
y_batch.append(reward_batch[i] + (1 - terminal_batch[i]) * GAMMA * target_q_values_batch[i][next_action_batch[i]])
loss, _ = self.sess.run([self.loss, self.grads_update], feed_dict={
self.s: np.float32(np.array(state_batch)),
self.a: action_batch,
self.y: y_batch
})
self.total_loss += loss
def setup_summary(self):
episode_total_reward = tf.Variable(0.)
tf.summary.scalar(ENV_NAME + '/Total Reward/Episode', episode_total_reward)
episode_avg_max_q = tf.Variable(0.)
tf.summary.scalar(ENV_NAME + '/Average Max Q/Episode', episode_avg_max_q)
episode_duration = tf.Variable(0.)
tf.summary.scalar(ENV_NAME + '/Duration/Episode', episode_duration)
episode_avg_loss = tf.Variable(0.)
tf.summary.scalar(ENV_NAME + '/Average Loss/Episode', episode_avg_loss)
summary_vars = [episode_total_reward, episode_avg_max_q, episode_duration, episode_avg_loss]
summary_placeholders = [tf.placeholder(tf.float32) for _ in range(len(summary_vars))]
update_ops = [summary_vars[i].assign(summary_placeholders[i]) for i in range(len(summary_vars))]
summary_op = tf.summary.merge_all()
return summary_placeholders, update_ops, summary_op
def load_network(self):
checkpoint = tf.train.get_checkpoint_state(SAVE_NETWORK_PATH)
if checkpoint and checkpoint.model_checkpoint_path:
self.saver.restore(self.sess, checkpoint.model_checkpoint_path)
print('Successfully loaded: ' + checkpoint.model_checkpoint_path)
else:
print('Training new network...')
def get_action_at_test(self, state):
"""
if random.random() <= 0.05:
action = random.randrange(self.num_actions)
else:
action = np.argmax(self.q_values.eval(feed_dict={self.s: [np.float32(state)]}))
"""
action = np.argmax(self.q_values.eval(feed_dict={self.s: [np.float32(state)]}))
self.t += 1
return action
def main():
root = tk.Tk()
root.title("matplotlib in TK")
f = Figure(figsize=(6, 6), dpi=100)
canvas = FigureCanvasTkAgg(f, master=root)
canvas.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=1)
env = semantic_env()
# FRAME_WIDTH, FRAME_HEIGHT= env.img_width,env.img_height
agent = Agent(num_actions=env.len_actions, FRAME_WIDTH = env.img_width, FRAME_HEIGHT = env.img_height)
if TRAIN: # Train mode
for _ in range(NUM_EPISODES):
terminal = False
observation, curr_rec_class = env.env_reset()
state = agent.get_initial_state(observation)
while not terminal:
f.clf()
a = f.add_subplot(111)
a.imshow(observation[:, :], interpolation='nearest', aspect='auto', cmap='gray')
a.axis('off')
canvas.draw()
root.update()
action = agent.get_action(state)
observation,reward, terminal, curr_rec_class = env.step(action,curr_rec_class)
print(action,env.action_space[action],reward,terminal)
if env.current_rec_num == 0:
print("hahahhahahhaaha I am Winner!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
processed_observation = np.reshape(observation, (env.img_width, env.img_height, 1))
state = agent.run(state, action, reward, terminal, processed_observation)
else: # Test mode
for _ in range(NUM_EPISODES_AT_TEST):
terminal = False
observation, curr_rec_class = env.env_reset()
state = agent.get_initial_state(observation)
while not terminal:
f.clf()
a = f.add_subplot(111)
a.imshow(observation[:, :], interpolation='nearest', aspect='auto', cmap='gray')
a.axis('off')
canvas.draw()
root.update()
action = agent.get_action_at_test(state)
observation,reward, terminal, curr_rec_class = env.step(action,curr_rec_class)
print('This semantic word is -> ' + env.action_space[action]+'\n')
if env.current_rec_num == 0:
pass
state = np.reshape(observation, (env.img_width, env.img_height, 1))
if __name__ == '__main__':
main()
Оценка модели и представление результатов
Оценка модели
Метод оценки модели обучения с подкреплением отличается от проблемы классификации и обнаружения.Нет такого показателя измерения, как точность.Его показатель измерения заключается в том, что счет растет, а не падает, то есть игра не будет повторяться. Экспериментальный результат этой статьи действительно заключается в том, что оценка растет, и повторения нет. Общий балл изменяется следующим образом:
Отображение эффекта модели
Результаты обучения алгоритма DQN показаны следующим образом:
Результаты обучения алгоритма DPPO показаны ниже.Можно видеть, что этот алгоритм может поддерживать обучение с несколькими изображениями.
анализ эксперимента
В настоящее время, хотя модель может успешно выполнять семантические задачи, модель все еще имеет много точек оптимизации и недостатков:
- Так как в качестве обучающего набора данных алгоритм использует пиксельные изображения, обученная модель чувствительна к стилю элемента и имеет хороший эффект распознавания, но эффект от простого текста без стиля будет несколько уступать классификации в модели классификации текста.
- Алгоритм имеет широкий спектр сценариев применения и представляет собой модель обучения, которую можно применять ко многим другим задачам.