+Training and validation Curves +
+# Reproduce DQN, DoubleDQN, DuelingDQN model with fluid version of PaddlePaddle
-# Reproduce DQN model
- + DQN in:
++ DQN in:
[Human-level Control Through Deep Reinforcement Learning](http://www.nature.com/nature/journal/v518/n7540/full/nature14236.html)
++ DoubleDQN in:
+[Deep Reinforcement Learning with Double Q-Learning](https://www.aaai.org/ocs/index.php/AAAI/AAAI16/paper/viewPaper/12389)
++ DuelingDQN in:
+[Dueling Network Architectures for Deep Reinforcement Learning](http://proceedings.mlr.press/v48/wangf16.html)
-# Mountain-CAR benchmark & performance
-[MountainCar-v0](https://gym.openai.com/envs/MountainCar-v0/)
+# Atari benchmark & performance
+## [Atari games introduction](https://gym.openai.com/envs/#atari)
-A car is on a one-dimensional track, positioned between two "mountains". The goal is to drive up the mountain on the right; however, the car's engine is not strong enough to scale the mountain in a single pass. Therefore, the only way to succeed is to drive back and forth to build up momentum.
++ Pong game result
+
+# How to use
++ Dependencies:
+ + python2.7
+ + gym
+ + tqdm
+ + paddlepaddle-gpu==0.12.0
++ Start Training:
+ ```
+ # To train a model for Pong game with gpu (use DQN model as default)
+ python train.py --rom ./rom_files/pong.bin --use_cuda
-
+ # To train a model for Pong with DoubleDQN
+ python train.py --rom ./rom_files/pong.bin --use_cuda --alg DoubleDQN
+ # To train a model for Pong with DuelingDQN
+ python train.py --rom ./rom_files/pong.bin --use_cuda --alg DuelingDQN
+ ```
+To train more games, can install more rom files from [here](https://github.com/openai/atari-py/tree/master/atari_py/atari_roms)
-# How to use
-+ Dependencies:
- + python2.7
- + gym
- + tqdm
- + paddle-fluid
-+ Start Training:
- ```
- # use mountain-car enviroment as default
- python DQN.py
++ Start Testing:
+ ```
+ # Play the game with saved model and calculate the average rewards
+ python play.py --rom ./rom_files/pong.bin --use_cuda --model_path ./saved_model/DQN-pong/stepXXXXX
- # use other enviorment
- python DQN.py --env CartPole-v0
- ```
+ # Play the game with visualization
+ python play.py --rom ./rom_files/pong.bin --use_cuda --model_path ./saved_model/DQN-pong/stepXXXXX --viz 0.01
+ ```
diff --git a/fluid/DeepQNetwork/agent.py b/fluid/DeepQNetwork/agent.py
deleted file mode 100644
index 928ce86e573ed1f042d1b8a85d5443405ea109e1..0000000000000000000000000000000000000000
--- a/fluid/DeepQNetwork/agent.py
+++ /dev/null
@@ -1,148 +0,0 @@
-#-*- coding: utf-8 -*-
-#File: agent.py
-
-import paddle.fluid as fluid
-from paddle.fluid.param_attr import ParamAttr
-import numpy as np
-from tqdm import tqdm
-import math
-
-UPDATE_TARGET_STEPS = 200
-
-
-class Model(object):
- def __init__(self, state_dim, action_dim, gamma):
- self.global_step = 0
- self.state_dim = state_dim
- self.action_dim = action_dim
- self.gamma = gamma
- self.exploration = 1.0
-
- self._build_net()
-
- def _get_inputs(self):
- return [fluid.layers.data(\
- name='state', shape=[self.state_dim], dtype='float32'),
- fluid.layers.data(\
- name='action', shape=[1], dtype='int32'),
- fluid.layers.data(\
- name='reward', shape=[], dtype='float32'),
- fluid.layers.data(\
- name='next_s', shape=[self.state_dim], dtype='float32'),
- fluid.layers.data(\
- name='isOver', shape=[], dtype='bool')]
-
- def _build_net(self):
- state, action, reward, next_s, isOver = self._get_inputs()
- self.pred_value = self.get_DQN_prediction(state)
- self.predict_program = fluid.default_main_program().clone()
-
- action_onehot = fluid.layers.one_hot(action, self.action_dim)
- action_onehot = fluid.layers.cast(action_onehot, dtype='float32')
-
- pred_action_value = fluid.layers.reduce_sum(\
- fluid.layers.elementwise_mul(action_onehot, self.pred_value), dim=1)
-
- targetQ_predict_value = self.get_DQN_prediction(next_s, target=True)
- best_v = fluid.layers.reduce_max(targetQ_predict_value, dim=1)
- best_v.stop_gradient = True
-
- target = reward + (1.0 - fluid.layers.cast(\
- isOver, dtype='float32')) * self.gamma * best_v
- cost = fluid.layers.square_error_cost(\
- input=pred_action_value, label=target)
- cost = fluid.layers.reduce_mean(cost)
-
- self._sync_program = self._build_sync_target_network()
-
- optimizer = fluid.optimizer.Adam(1e-3)
- optimizer.minimize(cost)
-
- # define program
- self.train_program = fluid.default_main_program()
-
- # fluid exe
- place = fluid.CUDAPlace(0)
- self.exe = fluid.Executor(place)
- self.exe.run(fluid.default_startup_program())
-
- def get_DQN_prediction(self, state, target=False):
- variable_field = 'target' if target else 'policy'
- # layer fc1
- param_attr = ParamAttr(name='{}_fc1'.format(variable_field))
- bias_attr = ParamAttr(name='{}_fc1_b'.format(variable_field))
- fc1 = fluid.layers.fc(input=state,
- size=256,
- act='relu',
- param_attr=param_attr,
- bias_attr=bias_attr)
-
- param_attr = ParamAttr(name='{}_fc2'.format(variable_field))
- bias_attr = ParamAttr(name='{}_fc2_b'.format(variable_field))
- fc2 = fluid.layers.fc(input=fc1,
- size=128,
- act='tanh',
- param_attr=param_attr,
- bias_attr=bias_attr)
-
- param_attr = ParamAttr(name='{}_fc3'.format(variable_field))
- bias_attr = ParamAttr(name='{}_fc3_b'.format(variable_field))
- value = fluid.layers.fc(input=fc2,
- size=self.action_dim,
- param_attr=param_attr,
- bias_attr=bias_attr)
-
- return value
-
- def _build_sync_target_network(self):
- vars = fluid.default_main_program().list_vars()
- policy_vars = []
- target_vars = []
- for var in vars:
- if 'GRAD' in var.name: continue
- if 'policy' in var.name:
- policy_vars.append(var)
- elif 'target' in var.name:
- target_vars.append(var)
-
- policy_vars.sort(key=lambda x: x.name.split('policy_')[1])
- target_vars.sort(key=lambda x: x.name.split('target_')[1])
-
- sync_program = fluid.default_main_program().clone()
- with fluid.program_guard(sync_program):
- sync_ops = []
- for i, var in enumerate(policy_vars):
- sync_op = fluid.layers.assign(policy_vars[i], target_vars[i])
- sync_ops.append(sync_op)
- sync_program = sync_program.prune(sync_ops)
- return sync_program
-
- def act(self, state, train_or_test):
- sample = np.random.random()
- if train_or_test == 'train' and sample < self.exploration:
- act = np.random.randint(self.action_dim)
- else:
- state = np.expand_dims(state, axis=0)
- pred_Q = self.exe.run(self.predict_program,
- feed={'state': state.astype('float32')},
- fetch_list=[self.pred_value])[0]
- pred_Q = np.squeeze(pred_Q, axis=0)
- act = np.argmax(pred_Q)
- self.exploration = max(0.1, self.exploration - 1e-6)
- return act
-
- def train(self, state, action, reward, next_state, isOver):
- if self.global_step % UPDATE_TARGET_STEPS == 0:
- self.sync_target_network()
- self.global_step += 1
-
- action = np.expand_dims(action, -1)
- self.exe.run(self.train_program, \
- feed={'state': state, \
- 'action': action, \
- 'reward': reward, \
- 'next_s': next_state, \
- 'isOver': isOver})
-
- def sync_target_network(self):
- self.exe.run(self._sync_program)
diff --git a/fluid/DeepQNetwork/assets/dqn.png b/fluid/DeepQNetwork/assets/dqn.png
new file mode 100644
index 0000000000000000000000000000000000000000..f8f8d12f9887cdab62f09b52597ec187a4c8107c
Binary files /dev/null and b/fluid/DeepQNetwork/assets/dqn.png differ
diff --git a/fluid/DeepQNetwork/atari.py b/fluid/DeepQNetwork/atari.py
new file mode 100644
index 0000000000000000000000000000000000000000..5006de4d4e6b57110ca7301395e170666d24e8b4
--- /dev/null
+++ b/fluid/DeepQNetwork/atari.py
@@ -0,0 +1,160 @@
+# -*- coding: utf-8 -*-
+
+import numpy as np
+import os
+import cv2
+import threading
+
+import gym
+from gym import spaces
+from gym.envs.atari.atari_env import ACTION_MEANING
+
+from ale_python_interface import ALEInterface
+
+__all__ = ['AtariPlayer']
+
+ROM_URL = "https://github.com/openai/atari-py/tree/master/atari_py/atari_roms"
+_ALE_LOCK = threading.Lock()
+"""
+The following AtariPlayer are copied or modified from tensorpack/tensorpack:
+ https://github.com/tensorpack/tensorpack/blob/master/examples/DeepQNetwork/atari.py
+"""
+
+
+class AtariPlayer(gym.Env):
+ """
+ A wrapper for ALE emulator, with configurations to mimic DeepMind DQN settings.
+ Info:
+ score: the accumulated reward in the current game
+ gameOver: True when the current game is Over
+ """
+
+ def __init__(self,
+ rom_file,
+ viz=0,
+ frame_skip=4,
+ nullop_start=30,
+ live_lost_as_eoe=True,
+ max_num_frames=0):
+ """
+ Args:
+ rom_file: path to the rom
+ frame_skip: skip every k frames and repeat the action
+ viz: visualization to be done.
+ Set to 0 to disable.
+ Set to a positive number to be the delay between frames to show.
+ Set to a string to be a directory to store frames.
+ nullop_start: start with random number of null ops.
+ live_losts_as_eoe: consider lost of lives as end of episode. Useful for training.
+ max_num_frames: maximum number of frames per episode.
+ """
+ super(AtariPlayer, self).__init__()
+ assert os.path.isfile(rom_file), \
+ "rom {} not found. Please download at {}".format(rom_file, ROM_URL)
+
+ try:
+ ALEInterface.setLoggerMode(ALEInterface.Logger.Error)
+ except AttributeError:
+ print "You're not using latest ALE"
+
+ # avoid simulator bugs: https://github.com/mgbellemare/Arcade-Learning-Environment/issues/86
+ with _ALE_LOCK:
+ self.ale = ALEInterface()
+ self.ale.setInt(b"random_seed", np.random.randint(0, 30000))
+ self.ale.setInt(b"max_num_frames_per_episode", max_num_frames)
+ self.ale.setBool(b"showinfo", False)
+
+ self.ale.setInt(b"frame_skip", 1)
+ self.ale.setBool(b'color_averaging', False)
+ # manual.pdf suggests otherwise.
+ self.ale.setFloat(b'repeat_action_probability', 0.0)
+
+ # viz setup
+ if isinstance(viz, str):
+ assert os.path.isdir(viz), viz
+ self.ale.setString(b'record_screen_dir', viz)
+ viz = 0
+ if isinstance(viz, int):
+ viz = float(viz)
+ self.viz = viz
+ if self.viz and isinstance(self.viz, float):
+ self.windowname = os.path.basename(rom_file)
+ cv2.startWindowThread()
+ cv2.namedWindow(self.windowname)
+
+ self.ale.loadROM(rom_file.encode('utf-8'))
+ self.width, self.height = self.ale.getScreenDims()
+ self.actions = self.ale.getMinimalActionSet()
+
+ self.live_lost_as_eoe = live_lost_as_eoe
+ self.frame_skip = frame_skip
+ self.nullop_start = nullop_start
+
+ self.action_space = spaces.Discrete(len(self.actions))
+ self.observation_space = spaces.Box(low=0,
+ high=255,
+ shape=(self.height, self.width),
+ dtype=np.uint8)
+ self._restart_episode()
+
+ def get_action_meanings(self):
+ return [ACTION_MEANING[i] for i in self.actions]
+
+ def _grab_raw_image(self):
+ """
+ :returns: the current 3-channel image
+ """
+ m = self.ale.getScreenRGB()
+ return m.reshape((self.height, self.width, 3))
+
+ def _current_state(self):
+ """
+ returns: a gray-scale (h, w) uint8 image
+ """
+ ret = self._grab_raw_image()
+ # avoid missing frame issue: max-pooled over the last screen
+ ret = np.maximum(ret, self.last_raw_screen)
+ if self.viz:
+ if isinstance(self.viz, float):
+ cv2.imshow(self.windowname, ret)
+ cv2.waitKey(int(self.viz * 1000))
+ ret = ret.astype('float32')
+ # 0.299,0.587.0.114. same as rgb2y in torch/image
+ ret = cv2.cvtColor(ret, cv2.COLOR_RGB2GRAY)
+ return ret.astype('uint8') # to save some memory
+
+ def _restart_episode(self):
+ with _ALE_LOCK:
+ self.ale.reset_game()
+
+ # random null-ops start
+ n = np.random.randint(self.nullop_start)
+ self.last_raw_screen = self._grab_raw_image()
+ for k in range(n):
+ if k == n - 1:
+ self.last_raw_screen = self._grab_raw_image()
+ self.ale.act(0)
+
+ def reset(self):
+ if self.ale.game_over():
+ self._restart_episode()
+ return self._current_state()
+
+ def step(self, act):
+ oldlives = self.ale.lives()
+ r = 0
+ for k in range(self.frame_skip):
+ if k == self.frame_skip - 1:
+ self.last_raw_screen = self._grab_raw_image()
+ r += self.ale.act(self.actions[act])
+ newlives = self.ale.lives()
+ if self.ale.game_over() or \
+ (self.live_lost_as_eoe and newlives < oldlives):
+ break
+
+ isOver = self.ale.game_over()
+ if self.live_lost_as_eoe:
+ isOver = isOver or newlives < oldlives
+
+ info = {'ale.lives': newlives}
+ return self._current_state(), r, isOver, info
diff --git a/fluid/DeepQNetwork/atari_wrapper.py b/fluid/DeepQNetwork/atari_wrapper.py
new file mode 100644
index 0000000000000000000000000000000000000000..81ec7e0ba0ee191f70591c16bfff560a62d3d395
--- /dev/null
+++ b/fluid/DeepQNetwork/atari_wrapper.py
@@ -0,0 +1,106 @@
+# -*- coding: utf-8 -*-
+
+import numpy as np
+from collections import deque
+
+import gym
+from gym import spaces
+
+_v0, _v1 = gym.__version__.split('.')[:2]
+assert int(_v0) > 0 or int(_v1) >= 10, gym.__version__
+"""
+The following wrappers are copied or modified from openai/baselines:
+https://github.com/openai/baselines/blob/master/baselines/common/atari_wrappers.py
+"""
+
+
+class MapState(gym.ObservationWrapper):
+ def __init__(self, env, map_func):
+ gym.ObservationWrapper.__init__(self, env)
+ self._func = map_func
+
+ def observation(self, obs):
+ return self._func(obs)
+
+
+class FrameStack(gym.Wrapper):
+ def __init__(self, env, k):
+ """Buffer observations and stack across channels (last axis)."""
+ gym.Wrapper.__init__(self, env)
+ self.k = k
+ self.frames = deque([], maxlen=k)
+ shp = env.observation_space.shape
+ chan = 1 if len(shp) == 2 else shp[2]
+ self.observation_space = spaces.Box(low=0,
+ high=255,
+ shape=(shp[0], shp[1], chan * k),
+ dtype=np.uint8)
+
+ def reset(self):
+ """Clear buffer and re-fill by duplicating the first observation."""
+ ob = self.env.reset()
+ for _ in range(self.k - 1):
+ self.frames.append(np.zeros_like(ob))
+ self.frames.append(ob)
+ return self.observation()
+
+ def step(self, action):
+ ob, reward, done, info = self.env.step(action)
+ self.frames.append(ob)
+ return self.observation(), reward, done, info
+
+ def observation(self):
+ assert len(self.frames) == self.k
+ return np.stack(self.frames, axis=0)
+
+
+class _FireResetEnv(gym.Wrapper):
+ def __init__(self, env):
+ """Take action on reset for environments that are fixed until firing."""
+ gym.Wrapper.__init__(self, env)
+ assert env.unwrapped.get_action_meanings()[1] == 'FIRE'
+ assert len(env.unwrapped.get_action_meanings()) >= 3
+
+ def reset(self):
+ self.env.reset()
+ obs, _, done, _ = self.env.step(1)
+ if done:
+ self.env.reset()
+ obs, _, done, _ = self.env.step(2)
+ if done:
+ self.env.reset()
+ return obs
+
+ def step(self, action):
+ return self.env.step(action)
+
+
+def FireResetEnv(env):
+ if isinstance(env, gym.Wrapper):
+ baseenv = env.unwrapped
+ else:
+ baseenv = env
+ if 'FIRE' in baseenv.get_action_meanings():
+ return _FireResetEnv(env)
+ return env
+
+
+class LimitLength(gym.Wrapper):
+ def __init__(self, env, k):
+ gym.Wrapper.__init__(self, env)
+ self.k = k
+
+ def reset(self):
+ # This assumes that reset() will really reset the env.
+ # If the underlying env tries to be smart about reset
+ # (e.g. end-of-life), the assumption doesn't hold.
+ ob = self.env.reset()
+ self.cnt = 0
+ return ob
+
+ def step(self, action):
+ ob, r, done, info = self.env.step(action)
+ self.cnt += 1
+ if self.cnt == self.k:
+ done = True
+ return ob, r, done, info
diff --git a/fluid/DeepQNetwork/curve.png b/fluid/DeepQNetwork/curve.png
deleted file mode 100644
index a283413797c96350f399ea0236750525d2dba1f3..0000000000000000000000000000000000000000
Binary files a/fluid/DeepQNetwork/curve.png and /dev/null differ
diff --git a/fluid/DeepQNetwork/expreplay.py b/fluid/DeepQNetwork/expreplay.py
index 06599226418ffa7ec04905e5f538d272ef986bf0..5f27ca7286b5db7ac963bc25236be416fad50eb0 100644
--- a/fluid/DeepQNetwork/expreplay.py
+++ b/fluid/DeepQNetwork/expreplay.py
@@ -1,50 +1,98 @@
-#-*- coding: utf-8 -*-
-#File: expreplay.py
+# -*- coding: utf-8 -*-
-from collections import namedtuple
import numpy as np
+import copy
+from collections import deque, namedtuple
Experience = namedtuple('Experience', ['state', 'action', 'reward', 'isOver'])
class ReplayMemory(object):
- def __init__(self, max_size, state_shape):
+ def __init__(self, max_size, state_shape, context_len):
self.max_size = int(max_size)
self.state_shape = state_shape
+ self.context_len = int(context_len)
- self.state = np.zeros((self.max_size, ) + state_shape, dtype='float32')
+ self.state = np.zeros((self.max_size, ) + state_shape, dtype='uint8')
self.action = np.zeros((self.max_size, ), dtype='int32')
self.reward = np.zeros((self.max_size, ), dtype='float32')
self.isOver = np.zeros((self.max_size, ), dtype='bool')
self._curr_size = 0
self._curr_pos = 0
+ self._context = deque(maxlen=context_len - 1)
def append(self, exp):
+ """append a new experience into replay memory
+ """
if self._curr_size < self.max_size:
self._assign(self._curr_pos, exp)
self._curr_size += 1
else:
self._assign(self._curr_pos, exp)
self._curr_pos = (self._curr_pos + 1) % self.max_size
+ if exp.isOver:
+ self._context.clear()
+ else:
+ self._context.append(exp)
+
+ def recent_state(self):
+ """ maintain recent state for training"""
+ lst = list(self._context)
+ states = [np.zeros(self.state_shape, dtype='uint8')] * \
+ (self._context.maxlen - len(lst))
+ states.extend([k.state for k in lst])
+ return states
+
+ def sample(self, idx):
+ """ return state, action, reward, isOver,
+ note that some frames in state may be generated from last episode,
+ they should be removed from state
+ """
+ state = np.zeros(
+ (self.context_len + 1, ) + self.state_shape, dtype=np.uint8)
+ state_idx = np.arange(idx, idx + self.context_len + 1) % self._curr_size
+
+ # confirm that no frame was generated from last episode
+ has_last_episode = False
+ for k in range(self.context_len - 2, -1, -1):
+ to_check_idx = state_idx[k]
+ if self.isOver[to_check_idx]:
+ has_last_episode = True
+ state_idx = state_idx[k + 1:]
+ state[k + 1:] = self.state[state_idx]
+ break
+
+ if not has_last_episode:
+ state = self.state[state_idx]
+
+ real_idx = (idx + self.context_len - 1) % self._curr_size
+ action = self.action[real_idx]
+ reward = self.reward[real_idx]
+ isOver = self.isOver[real_idx]
+ return state, reward, action, isOver
+
+ def __len__(self):
+ return self._curr_size
def _assign(self, pos, exp):
self.state[pos] = exp.state
- self.action[pos] = exp.action
self.reward[pos] = exp.reward
+ self.action[pos] = exp.action
self.isOver[pos] = exp.isOver
- def __len__(self):
- return self._curr_size
-
- def sample(self, batch_idx):
- # index mapping to avoid sampling lastest state
+ def sample_batch(self, batch_size):
+ """sample a batch from replay memory for training
+ """
+ batch_idx = np.random.randint(
+ self._curr_size - self.context_len - 1, size=batch_size)
batch_idx = (self._curr_pos + batch_idx) % self._curr_size
- next_idx = (batch_idx + 1) % self._curr_size
-
- state = self.state[batch_idx]
- reward = self.reward[batch_idx]
- action = self.action[batch_idx]
- next_state = self.state[next_idx]
- isOver = self.isOver[batch_idx]
- return (state, action, reward, next_state, isOver)
+ batch_exp = [self.sample(i) for i in batch_idx]
+ return self._process_batch(batch_exp)
+
+ def _process_batch(self, batch_exp):
+ state = np.asarray([e[0] for e in batch_exp], dtype='uint8')
+ reward = np.asarray([e[1] for e in batch_exp], dtype='float32')
+ action = np.asarray([e[2] for e in batch_exp], dtype='int8')
+ isOver = np.asarray([e[3] for e in batch_exp], dtype='bool')
+ return [state, action, reward, isOver]
diff --git a/fluid/DeepQNetwork/mountain_car.gif b/fluid/DeepQNetwork/mountain_car.gif
deleted file mode 100644
index 5665d67d2cddbfb9c30dc588a085748e056bb16a..0000000000000000000000000000000000000000
Binary files a/fluid/DeepQNetwork/mountain_car.gif and /dev/null differ
diff --git a/fluid/DeepQNetwork/play.py b/fluid/DeepQNetwork/play.py
new file mode 100644
index 0000000000000000000000000000000000000000..2920391f105aeca1e99c347174464688edb47dae
--- /dev/null
+++ b/fluid/DeepQNetwork/play.py
@@ -0,0 +1,65 @@
+#-*- coding: utf-8 -*-
+
+import argparse
+import os
+import numpy as np
+import paddle.fluid as fluid
+
+from train import get_player
+from tqdm import tqdm
+
+
+def predict_action(exe, state, predict_program, feed_names, fetch_targets,
+ action_dim):
+ if np.random.randint(100) == 0:
+ act = np.random.randint(action_dim)
+ else:
+ state = np.expand_dims(state, axis=0)
+ pred_Q = exe.run(predict_program,
+ feed={feed_names[0]: state.astype('float32')},
+ fetch_list=fetch_targets)[0]
+ pred_Q = np.squeeze(pred_Q, axis=0)
+ act = np.argmax(pred_Q)
+ return act
+
+
+if __name__ == '__main__':
+ parser = argparse.ArgumentParser()
+ parser.add_argument(
+ '--use_cuda', action='store_true', help='if set, use cuda')
+ parser.add_argument('--rom', type=str, required=True, help='atari rom')
+ parser.add_argument(
+ '--model_path', type=str, required=True, help='dirname to load model')
+ parser.add_argument(
+ '--viz',
+ type=float,
+ default=0,
+ help='''viz: visualization setting:
+ Set to 0 to disable;
+ Set to a positive number to be the delay between frames to show.
+ ''')
+ args = parser.parse_args()
+
+ env = get_player(args.rom, viz=args.viz)
+
+ place = fluid.CUDAPlace(0) if args.use_cuda else fluid.CPUPlace()
+ exe = fluid.Executor(place)
+ inference_scope = fluid.core.Scope()
+ with fluid.scope_guard(inference_scope):
+ [predict_program, feed_names,
+ fetch_targets] = fluid.io.load_inference_model(args.model_path, exe)
+
+ episode_reward = []
+ for _ in tqdm(xrange(30), desc='eval agent'):
+ state = env.reset()
+ total_reward = 0
+ while True:
+ action = predict_action(exe, state, predict_program, feed_names,
+ fetch_targets, env.action_space.n)
+ state, reward, isOver, info = env.step(action)
+ total_reward += reward
+ if isOver:
+ break
+ episode_reward.append(total_reward)
+ eval_reward = np.mean(episode_reward)
+ print('Average reward of 30 epidose: {}'.format(eval_reward))
diff --git a/fluid/DeepQNetwork/rom_files/breakout.bin b/fluid/DeepQNetwork/rom_files/breakout.bin
new file mode 100644
index 0000000000000000000000000000000000000000..abab5a8c0a1890461a11b78d4265f1b794327793
Binary files /dev/null and b/fluid/DeepQNetwork/rom_files/breakout.bin differ
diff --git a/fluid/DeepQNetwork/rom_files/pong.bin b/fluid/DeepQNetwork/rom_files/pong.bin
new file mode 100644
index 0000000000000000000000000000000000000000..14a5bdfc72548613c059938bdf712efdbb5d3806
Binary files /dev/null and b/fluid/DeepQNetwork/rom_files/pong.bin differ
diff --git a/fluid/DeepQNetwork/train.py b/fluid/DeepQNetwork/train.py
new file mode 100644
index 0000000000000000000000000000000000000000..6e75fe77bc53df24cab2f5bebad9f59ee88a8a3e
--- /dev/null
+++ b/fluid/DeepQNetwork/train.py
@@ -0,0 +1,187 @@
+#-*- coding: utf-8 -*-
+
+from DQN_agent import DQNModel
+from DoubleDQN_agent import DoubleDQNModel
+from DuelingDQN_agent import DuelingDQNModel
+from atari import AtariPlayer
+import paddle.fluid as fluid
+import gym
+import argparse
+import cv2
+from tqdm import tqdm
+from expreplay import ReplayMemory, Experience
+import numpy as np
+import os
+
+from datetime import datetime
+from atari_wrapper import FrameStack, MapState, FireResetEnv, LimitLength
+from collections import deque
+
+UPDATE_FREQ = 4
+
+#MEMORY_WARMUP_SIZE = 2000
+MEMORY_SIZE = 1e6
+MEMORY_WARMUP_SIZE = MEMORY_SIZE // 20
+IMAGE_SIZE = (84, 84)
+CONTEXT_LEN = 4
+ACTION_REPEAT = 4 # aka FRAME_SKIP
+UPDATE_FREQ = 4
+
+
+def run_train_episode(agent, env, exp):
+ total_reward = 0
+ state = env.reset()
+ step = 0
+ while True:
+ step += 1
+ context = exp.recent_state()
+ context.append(state)
+ context = np.stack(context, axis=0)
+ action = agent.act(context, train_or_test='train')
+ next_state, reward, isOver, _ = env.step(action)
+ exp.append(Experience(state, action, reward, isOver))
+ # train model
+ # start training
+ if len(exp) > MEMORY_WARMUP_SIZE:
+ if step % UPDATE_FREQ == 0:
+ batch_all_state, batch_action, batch_reward, batch_isOver = exp.sample_batch(
+ args.batch_size)
+ batch_state = batch_all_state[:, :CONTEXT_LEN, :, :]
+ batch_next_state = batch_all_state[:, 1:, :, :]
+ agent.train(batch_state, batch_action, batch_reward,
+ batch_next_state, batch_isOver)
+ total_reward += reward
+ state = next_state
+ if isOver:
+ break
+ return total_reward, step
+
+
+def get_player(rom, viz=False, train=False):
+ env = AtariPlayer(
+ rom,
+ frame_skip=ACTION_REPEAT,
+ viz=viz,
+ live_lost_as_eoe=train,
+ max_num_frames=60000)
+ env = FireResetEnv(env)
+ env = MapState(env, lambda im: cv2.resize(im, IMAGE_SIZE))
+ if not train:
+ # in training, context is taken care of in expreplay buffer
+ env = FrameStack(env, CONTEXT_LEN)
+ return env
+
+
+def eval_agent(agent, env):
+ episode_reward = []
+ for _ in tqdm(xrange(30), desc='eval agent'):
+ state = env.reset()
+ total_reward = 0
+ step = 0
+ while True:
+ step += 1
+ action = agent.act(state, train_or_test='test')
+ state, reward, isOver, info = env.step(action)
+ total_reward += reward
+ if isOver:
+ break
+ episode_reward.append(total_reward)
+ eval_reward = np.mean(episode_reward)
+ return eval_reward
+
+
+def train_agent():
+ env = get_player(args.rom, train=True)
+ test_env = get_player(args.rom)
+ exp = ReplayMemory(args.mem_size, IMAGE_SIZE, CONTEXT_LEN)
+ action_dim = env.action_space.n
+
+ if args.alg == 'DQN':
+ agent = DQNModel(IMAGE_SIZE, action_dim, args.gamma, CONTEXT_LEN,
+ args.use_cuda)
+ elif args.alg == 'DoubleDQN':
+ agent = DoubleDQNModel(IMAGE_SIZE, action_dim, args.gamma, CONTEXT_LEN,
+ args.use_cuda)
+ elif args.alg == 'DuelingDQN':
+ agent = DuelingDQNModel(IMAGE_SIZE, action_dim, args.gamma, CONTEXT_LEN,
+ args.use_cuda)
+ else:
+ print('Input algorithm name error!')
+ return
+
+ with tqdm(total=MEMORY_WARMUP_SIZE) as pbar:
+ while len(exp) < MEMORY_WARMUP_SIZE:
+ total_reward, step = run_train_episode(agent, env, exp)
+ pbar.update(step)
+
+ # train
+ test_flag = 0
+ save_flag = 0
+ pbar = tqdm(total=1e8)
+ recent_100_reward = []
+ total_step = 0
+ while True:
+ # start epoch
+ total_reward, step = run_train_episode(agent, env, exp)
+ total_step += step
+ pbar.set_description('[train]exploration:{}'.format(agent.exploration))
+ pbar.update(step)
+
+ if total_step // args.test_every_steps == test_flag:
+ pbar.write("testing")
+ eval_reward = eval_agent(agent, test_env)
+ test_flag += 1
+ print("eval_agent done, (steps, eval_reward): ({}, {})".format(
+ total_step, eval_reward))
+
+ if total_step // args.save_every_steps == save_flag:
+ save_flag += 1
+ save_path = os.path.join(args.model_dirname, '{}-{}'.format(
+ args.alg, os.path.basename(args.rom).split('.')[0]),
+ 'step{}'.format(total_step))
+ fluid.io.save_inference_model(save_path, ['state'],
+ agent.pred_value, agent.exe,
+ agent.predict_program)
+ pbar.close()
+
+
+if __name__ == '__main__':
+ parser = argparse.ArgumentParser()
+ parser.add_argument(
+ '--alg',
+ type=str,
+ default='DQN',
+ help='Reinforcement learning algorithm, support: DQN, DoubleDQN, DuelingDQN'
+ )
+ parser.add_argument(
+ '--use_cuda', action='store_true', help='if set, use cuda')
+ parser.add_argument(
+ '--gamma',
+ type=float,
+ default=0.99,
+ help='discount factor for accumulated reward computation')
+ parser.add_argument(
+ '--mem_size',
+ type=int,
+ default=1000000,
+ help='memory size for experience replay')
+ parser.add_argument(
+ '--batch_size', type=int, default=64, help='batch size for training')
+ parser.add_argument('--rom', help='atari rom', required=True)
+ parser.add_argument(
+ '--model_dirname',
+ type=str,
+ default='saved_model',
+ help='dirname to save model')
+ parser.add_argument(
+ '--save_every_steps',
+ type=int,
+ default=100000,
+ help='every steps number to save model')
+ parser.add_argument(
+ '--test_every_steps',
+ type=int,
+ default=100000,
+ help='every steps number to run test')
+ args = parser.parse_args()
+ train_agent()
diff --git a/fluid/DeepQNetwork/utils.py b/fluid/DeepQNetwork/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..26ed7fbdb54494c3cf9a983f8ecafdfbcd4d2719
--- /dev/null
+++ b/fluid/DeepQNetwork/utils.py
@@ -0,0 +1,20 @@
+#-*- coding: utf-8 -*-
+#File: utils.py
+
+import paddle.fluid as fluid
+import numpy as np
+
+
+def fluid_argmax(x):
+ """
+ Get index of max value for the last dimension
+ """
+ _, max_index = fluid.layers.topk(x, k=1)
+ return max_index
+
+
+def fluid_flatten(x):
+ """
+ Flatten fluid variable along the first dimension
+ """
+ return fluid.layers.reshape(x, shape=[-1, np.prod(x.shape[1:])])
diff --git a/fluid/face_detection/.gitignore b/fluid/face_detection/.gitignore
index 27735faca6e555e439300fca5dccd893f70ef9a0..13d42af893162c1908a39fea1d072a22929e5430 100644
--- a/fluid/face_detection/.gitignore
+++ b/fluid/face_detection/.gitignore
@@ -1,5 +1,7 @@
model/
+pretrained/
data/
label/
-pretrained/
*.swp
+*.log
+infer_results/
diff --git a/fluid/face_detection/infer.py b/fluid/face_detection/infer.py
new file mode 100644
index 0000000000000000000000000000000000000000..71a878cb39f9888e3c308ee24e34dd6c3a073d33
--- /dev/null
+++ b/fluid/face_detection/infer.py
@@ -0,0 +1,303 @@
+import os
+import time
+import numpy as np
+import argparse
+import functools
+from PIL import Image
+from PIL import ImageDraw
+
+import paddle
+import paddle.fluid as fluid
+import reader
+from pyramidbox import PyramidBox
+from utility import add_arguments, print_arguments
+parser = argparse.ArgumentParser(description=__doc__)
+add_arg = functools.partial(add_arguments, argparser=parser)
+# yapf: disable
+add_arg('use_gpu', bool, True, "Whether use GPU.")
+add_arg('use_pyramidbox', bool, False, "Whether use PyramidBox model.")
+add_arg('confs_threshold', float, 0.25, "Confidence threshold to draw bbox.")
+add_arg('image_path', str, '', "The data root path.")
+add_arg('model_dir', str, '', "The model path.")
+# yapf: enable
+
+
+def draw_bounding_box_on_image(image_path, nms_out, confs_threshold):
+ image = Image.open(image_path)
+ draw = ImageDraw.Draw(image)
+ for dt in nms_out:
+ xmin, ymin, xmax, ymax, score = dt
+ if score < confs_threshold:
+ continue
+ (left, right, top, bottom) = (xmin, xmax, ymin, ymax)
+ draw.line(
+ [(left, top), (left, bottom), (right, bottom), (right, top),
+ (left, top)],
+ width=4,
+ fill='red')
+ image_name = image_path.split('/')[-1]
+ image_class = image_path.split('/')[-2]
+ print("image with bbox drawed saved as {}".format(image_name))
+ image.save('./infer_results/' + image_class.encode('utf-8') + '/' +
+ image_name.encode('utf-8'))
+
+
+def write_to_txt(image_path, f, nms_out):
+ image_name = image_path.split('/')[-1]
+ image_class = image_path.split('/')[-2]
+ f.write('{:s}\n'.format(
+ image_class.encode('utf-8') + '/' + image_name.encode('utf-8')))
+ f.write('{:d}\n'.format(nms_out.shape[0]))
+ for dt in nms_out:
+ xmin, ymin, xmax, ymax, score = dt
+ f.write('{:.1f} {:.1f} {:.1f} {:.1f} {:.3f}\n'.format(xmin, ymin, (
+ xmax - xmin + 1), (ymax - ymin + 1), score))
+ print("image infer result saved {}".format(image_name[:-4]))
+
+
+def get_round(x, loc):
+ str_x = str(x)
+ if '.' in str_x:
+ len_after = len(str_x.split('.')[1])
+ str_before = str_x.split('.')[0]
+ str_after = str_x.split('.')[1]
+ if len_after >= 3:
+ str_final = str_before + '.' + str_after[0:loc]
+ return float(str_final)
+ else:
+ return x
+
+
+def bbox_vote(det):
+ order = det[:, 4].ravel().argsort()[::-1]
+ det = det[order, :]
+ if det.shape[0] == 0:
+ dets = np.array([[10, 10, 20, 20, 0.002]])
+ det = np.empty(shape=[0, 5])
+ while det.shape[0] > 0:
+ # IOU
+ area = (det[:, 2] - det[:, 0] + 1) * (det[:, 3] - det[:, 1] + 1)
+ xx1 = np.maximum(det[0, 0], det[:, 0])
+ yy1 = np.maximum(det[0, 1], det[:, 1])
+ xx2 = np.minimum(det[0, 2], det[:, 2])
+ yy2 = np.minimum(det[0, 3], det[:, 3])
+ w = np.maximum(0.0, xx2 - xx1 + 1)
+ h = np.maximum(0.0, yy2 - yy1 + 1)
+ inter = w * h
+ o = inter / (area[0] + area[:] - inter)
+
+ # get needed merge det and delete these det
+ merge_index = np.where(o >= 0.3)[0]
+ det_accu = det[merge_index, :]
+ det = np.delete(det, merge_index, 0)
+ if merge_index.shape[0] <= 1:
+ if det.shape[0] == 0:
+ try:
+ dets = np.row_stack((dets, det_accu))
+ except:
+ dets = det_accu
+ continue
+ det_accu[:, 0:4] = det_accu[:, 0:4] * np.tile(det_accu[:, -1:], (1, 4))
+ max_score = np.max(det_accu[:, 4])
+ det_accu_sum = np.zeros((1, 5))
+ det_accu_sum[:, 0:4] = np.sum(det_accu[:, 0:4],
+ axis=0) / np.sum(det_accu[:, -1:])
+ det_accu_sum[:, 4] = max_score
+ try:
+ dets = np.row_stack((dets, det_accu_sum))
+ except:
+ dets = det_accu_sum
+ dets = dets[0:750, :]
+ return dets
+
+
+def image_preprocess(image):
+ img = np.array(image)
+ # HWC to CHW
+ if len(img.shape) == 3:
+ img = np.swapaxes(img, 1, 2)
+ img = np.swapaxes(img, 1, 0)
+ # RBG to BGR
+ img = img[[2, 1, 0], :, :]
+ img = img.astype('float32')
+ img -= np.array(
+ [104., 117., 123.])[:, np.newaxis, np.newaxis].astype('float32')
+ img = img * 0.007843
+ img = [img]
+ img = np.array(img)
+ return img
+
+
+def detect_face(image, shrink):
+ image_shape = [3, image.size[1], image.size[0]]
+ num_classes = 2
+ place = fluid.CUDAPlace(0) if args.use_gpu else fluid.CPUPlace()
+ exe = fluid.Executor(place)
+
+ if shrink != 1:
+ image = image.resize((int(image_shape[2] * shrink),
+ int(image_shape[1] * shrink)), Image.ANTIALIAS)
+ image_shape = [
+ image_shape[0], int(image_shape[1] * shrink),
+ int(image_shape[2] * shrink)
+ ]
+ print "image_shape:", image_shape
+ img = image_preprocess(image)
+
+ scope = fluid.core.Scope()
+ main_program = fluid.Program()
+ startup_program = fluid.Program()
+
+ with fluid.scope_guard(scope):
+ with fluid.unique_name.guard():
+ with fluid.program_guard(main_program, startup_program):
+ fetches = []
+ network = PyramidBox(
+ image_shape,
+ num_classes,
+ sub_network=args.use_pyramidbox,
+ is_infer=True)
+ infer_program, nmsed_out = network.infer(main_program)
+ fetches = [nmsed_out]
+ fluid.io.load_persistables(
+ exe, args.model_dir, main_program=main_program)
+
+ detection, = exe.run(infer_program,
+ feed={'image': img},
+ fetch_list=fetches,
+ return_numpy=False)
+ detection = np.array(detection)
+ # layout: xmin, ymin, xmax. ymax, score
+ det_conf = detection[:, 1]
+ det_xmin = image_shape[2] * detection[:, 2] / shrink
+ det_ymin = image_shape[1] * detection[:, 3] / shrink
+ det_xmax = image_shape[2] * detection[:, 4] / shrink
+ det_ymax = image_shape[1] * detection[:, 5] / shrink
+
+ det = np.column_stack((det_xmin, det_ymin, det_xmax, det_ymax, det_conf))
+ keep_index = np.where(det[:, 4] >= 0)[0]
+ det = det[keep_index, :]
+ return det
+
+
+def flip_test(image, shrink):
+ img = image.transpose(Image.FLIP_LEFT_RIGHT)
+ det_f = detect_face(img, shrink)
+ det_t = np.zeros(det_f.shape)
+ # image.size: [width, height]
+ det_t[:, 0] = image.size[0] - det_f[:, 2]
+ det_t[:, 1] = det_f[:, 1]
+ det_t[:, 2] = image.size[0] - det_f[:, 0]
+ det_t[:, 3] = det_f[:, 3]
+ det_t[:, 4] = det_f[:, 4]
+ return det_t
+
+
+def multi_scale_test(image, max_shrink):
+ # shrink detecting and shrink only detect big face
+ st = 0.5 if max_shrink >= 0.75 else 0.5 * max_shrink
+ det_s = detect_face(image, st)
+ index = np.where(
+ np.maximum(det_s[:, 2] - det_s[:, 0] + 1, det_s[:, 3] - det_s[:, 1] + 1)
+ > 30)[0]
+ det_s = det_s[index, :]
+ # enlarge one times
+ bt = min(2, max_shrink) if max_shrink > 1 else (st + max_shrink) / 2
+ det_b = detect_face(image, bt)
+
+ # enlarge small image x times for small face
+ if max_shrink > 2:
+ bt *= 2
+ while bt < max_shrink:
+ det_b = np.row_stack((det_b, detect_face(image, bt)))
+ bt *= 2
+ det_b = np.row_stack((det_b, detect_face(image, max_shrink)))
+
+ # enlarge only detect small face
+ if bt > 1:
+ index = np.where(
+ np.minimum(det_b[:, 2] - det_b[:, 0] + 1,
+ det_b[:, 3] - det_b[:, 1] + 1) < 100)[0]
+ det_b = det_b[index, :]
+ else:
+ index = np.where(
+ np.maximum(det_b[:, 2] - det_b[:, 0] + 1,
+ det_b[:, 3] - det_b[:, 1] + 1) > 30)[0]
+ det_b = det_b[index, :]
+ return det_s, det_b
+
+
+def get_im_shrink(image_shape):
+ max_shrink_v1 = (0x7fffffff / 577.0 /
+ (image_shape[1] * image_shape[2]))**0.5
+ max_shrink_v2 = (
+ (678 * 1024 * 2.0 * 2.0) / (image_shape[1] * image_shape[2]))**0.5
+ max_shrink = get_round(min(max_shrink_v1, max_shrink_v2), 2) - 0.3
+
+ if max_shrink >= 1.5 and max_shrink < 2:
+ max_shrink = max_shrink - 0.1
+ elif max_shrink >= 2 and max_shrink < 3:
+ max_shrink = max_shrink - 0.2
+ elif max_shrink >= 3 and max_shrink < 4:
+ max_shrink = max_shrink - 0.3
+ elif max_shrink >= 4 and max_shrink < 5:
+ max_shrink = max_shrink - 0.4
+ elif max_shrink >= 5:
+ max_shrink = max_shrink - 0.5
+
+ print 'max_shrink = ', max_shrink
+ shrink = max_shrink if max_shrink < 1 else 1
+ print "shrink = ", shrink
+
+ return shrink, max_shrink
+
+
+def infer(args, batch_size, data_args):
+ if not os.path.exists(args.model_dir):
+ raise ValueError("The model path [%s] does not exist." %
+ (args.model_dir))
+
+ infer_reader = paddle.batch(
+ reader.test(data_args, file_list), batch_size=batch_size)
+
+ for batch_id, img in enumerate(infer_reader()):
+ image = img[0][0]
+ image_path = img[0][1]
+
+ # image.size: [width, height]
+ image_shape = [3, image.size[1], image.size[0]]
+
+ shrink, max_shrink = get_im_shrink(image_shape)
+
+ det0 = detect_face(image, shrink)
+ det1 = flip_test(image, shrink)
+ [det2, det3] = multi_scale_test(image, max_shrink)
+ det = np.row_stack((det0, det1, det2, det3))
+ dets = bbox_vote(det)
+
+ image_name = image_path.split('/')[-1]
+ image_class = image_path.split('/')[-2]
+ if not os.path.exists('./infer_results/' + image_class.encode('utf-8')):
+ os.makedirs('./infer_results/' + image_class.encode('utf-8'))
+
+ f = open('./infer_results/' + image_class.encode('utf-8') + '/' +
+ image_name.encode('utf-8')[:-4] + '.txt', 'w')
+ write_to_txt(image_path, f, dets)
+ # draw_bounding_box_on_image(image_path, dets, args.confs_threshold)
+ print "Done"
+
+
+if __name__ == '__main__':
+ args = parser.parse_args()
+ print_arguments(args)
+
+ data_dir = 'data/WIDERFACE/WIDER_val/images/'
+ file_list = 'label/val_gt_widerface.res'
+
+ data_args = reader.Settings(
+ data_dir=data_dir,
+ mean_value=[104., 117., 123],
+ apply_distort=False,
+ apply_expand=False,
+ ap_version='11point')
+ infer(args, batch_size=1, data_args=data_args)
diff --git a/fluid/face_detection/pyramidbox.py b/fluid/face_detection/pyramidbox.py
index 6e38dabb3570646d35c8b41e39c39d17a7b3f190..ce01cb7a113219e08d4deb2984d2a12b2590faa5 100644
--- a/fluid/face_detection/pyramidbox.py
+++ b/fluid/face_detection/pyramidbox.py
@@ -4,6 +4,7 @@ import paddle.fluid as fluid
from paddle.fluid.param_attr import ParamAttr
from paddle.fluid.initializer import Xavier
from paddle.fluid.initializer import Constant
+from paddle.fluid.initializer import Bilinear
from paddle.fluid.regularizer import L2Decay
@@ -38,17 +39,31 @@ def conv_block(input, groups, filters, ksizes, strides=None, with_pool=True):
act='relu')
if with_pool:
pool = fluid.layers.pool2d(
- input=conv, pool_size=2, pool_type='max', pool_stride=2)
+ input=conv,
+ pool_size=2,
+ pool_type='max',
+ pool_stride=2,
+ ceil_mode=True)
return conv, pool
else:
return conv
class PyramidBox(object):
- def __init__(self, data_shape, is_infer=False, sub_network=False):
+ def __init__(self,
+ data_shape,
+ num_classes,
+ use_transposed_conv2d=True,
+ is_infer=False,
+ sub_network=False):
+ """
+ TODO(qingqing): add comments.
+ """
self.data_shape = data_shape
self.min_sizes = [16., 32., 64., 128., 256., 512.]
self.steps = [4., 8., 16., 32., 64., 128.]
+ self.num_classes = num_classes
+ self.use_transposed_conv2d = use_transposed_conv2d
self.is_infer = is_infer
self.sub_network = sub_network
@@ -59,6 +74,8 @@ class PyramidBox(object):
self._low_level_fpn()
self._cpm_module()
self._pyramidbox()
+ else:
+ self._vgg_ssd()
def feeds(self):
if self.is_infer:
@@ -113,20 +130,32 @@ class PyramidBox(object):
b_attr = ParamAttr(learning_rate=2., regularizer=L2Decay(0.))
conv1 = fluid.layers.conv2d(
up_from, ch, 1, act='relu', bias_attr=b_attr)
- conv_trans = fluid.layers.conv2d_transpose(
- conv1,
- ch,
- output_size=None,
- filter_size=4,
- padding=1,
- stride=2,
- groups=ch,
- bias_attr=False)
+ if self.use_transposed_conv2d:
+ w_attr = ParamAttr(
+ learning_rate=0.,
+ regularizer=L2Decay(0.),
+ initializer=Bilinear())
+ upsampling = fluid.layers.conv2d_transpose(
+ conv1,
+ ch,
+ output_size=None,
+ filter_size=4,
+ padding=1,
+ stride=2,
+ groups=ch,
+ param_attr=w_attr,
+ bias_attr=False)
+ else:
+ upsampling = fluid.layers.resize_bilinear(
+ conv1, out_shape=up_to.shape[2:])
+
b_attr = ParamAttr(learning_rate=2., regularizer=L2Decay(0.))
conv2 = fluid.layers.conv2d(
up_to, ch, 1, act='relu', bias_attr=b_attr)
+ if self.is_infer:
+ upsampling = fluid.layers.crop(upsampling, shape=conv2)
# eltwise mul
- conv_fuse = conv_trans * conv2
+ conv_fuse = upsampling * conv2
return conv_fuse
self.lfpn2_on_conv5 = fpn(self.conv6, self.conv5)
@@ -188,9 +217,10 @@ class PyramidBox(object):
"""
Get prior-boxes and pyramid-box
"""
- self.ssh_conv3_norm = self._l2_norm_scale(self.ssh_conv3)
- self.ssh_conv4_norm = self._l2_norm_scale(self.ssh_conv4)
- self.ssh_conv5_norm = self._l2_norm_scale(self.ssh_conv5)
+ self.ssh_conv3_norm = self._l2_norm_scale(
+ self.ssh_conv3, init_scale=10.)
+ self.ssh_conv4_norm = self._l2_norm_scale(self.ssh_conv4, init_scale=8.)
+ self.ssh_conv5_norm = self._l2_norm_scale(self.ssh_conv5, init_scale=5.)
def permute_and_reshape(input, last_dim):
trans = fluid.layers.transpose(input, perm=[0, 2, 3, 1])
@@ -234,9 +264,11 @@ class PyramidBox(object):
box, var = fluid.layers.prior_box(
input,
self.image,
- min_sizes=[self.min_sizes[1]],
+ min_sizes=[self.min_sizes[i]],
steps=[self.steps[i]] * 2,
aspect_ratios=[1.],
+ clip=False,
+ flip=True,
offset=0.5)
box = fluid.layers.reshape(box, shape=[-1, 4])
var = fluid.layers.reshape(var, shape=[-1, 4])
@@ -253,52 +285,125 @@ class PyramidBox(object):
self.prior_boxes = fluid.layers.concat(boxes)
self.box_vars = fluid.layers.concat(vars)
- def vgg_ssd(self, num_classes, image_shape):
- self.conv3_norm = self._l2_norm_scale(self.conv3)
- self.conv4_norm = self._l2_norm_scale(self.conv4)
- self.conv5_norm = self._l2_norm_scale(self.conv5)
-
- mbox_locs, mbox_confs, box, box_var = fluid.layers.multi_box_head(
- inputs=[
- self.conv3_norm, self.conv4_norm, self.conv5_norm, self.conv6,
- self.conv7, self.conv8
- ],
- image=self.image,
- num_classes=num_classes,
- # min_ratio=20,
- # max_ratio=90,
- min_sizes=[16.0, 32.0, 64.0, 128.0, 256.0, 512.0],
- max_sizes=[[], [], [], [], [], []],
- # max_sizes=[[], 150.0, 195.0, 240.0, 285.0, 300.0],
- aspect_ratios=[[1.], [1.], [1.], [1.], [1.], [1.]],
- steps=[4.0, 8.0, 16.0, 32.0, 64.0, 128.0],
- base_size=image_shape[2],
- offset=0.5,
- flip=False)
-
- # locs, confs, box, box_var = vgg_extra_net(num_classes, image, image_shape)
- # nmsed_out = fluid.layers.detection_output(
- # locs, confs, box, box_var, nms_threshold=args.nms_threshold)
- loss = fluid.layers.ssd_loss(mbox_locs, mbox_confs, self.face_box,
- self.gt_label, box, box_var)
- loss = fluid.layers.reduce_sum(loss)
+ def _vgg_ssd(self):
+ self.conv3_norm = self._l2_norm_scale(self.conv3, init_scale=10.)
+ self.conv4_norm = self._l2_norm_scale(self.conv4, init_scale=8.)
+ self.conv5_norm = self._l2_norm_scale(self.conv5, init_scale=5.)
+
+ def permute_and_reshape(input, last_dim):
+ trans = fluid.layers.transpose(input, perm=[0, 2, 3, 1])
+ new_shape = [
+ trans.shape[0], np.prod(trans.shape[1:]) / last_dim, last_dim
+ ]
+ return fluid.layers.reshape(trans, shape=new_shape)
+
+ locs, confs = [], []
+ boxes, vars = [], []
+ b_attr = ParamAttr(learning_rate=2., regularizer=L2Decay(0.))
+
+ # conv3
+ mbox_loc = fluid.layers.conv2d(
+ self.conv3_norm, 4, 3, 1, 1, bias_attr=b_attr)
+ loc = permute_and_reshape(mbox_loc, 4)
+ mbox_conf = fluid.layers.conv2d(
+ self.conv3_norm, 4, 3, 1, 1, bias_attr=b_attr)
+ conf1, conf3 = fluid.layers.split(
+ mbox_conf, num_or_sections=[1, 3], dim=1)
+ conf3_maxin = fluid.layers.reduce_max(conf3, dim=1, keep_dim=True)
+ conf = fluid.layers.concat([conf1, conf3_maxin], axis=1)
+ conf = permute_and_reshape(conf, 2)
+ box, var = fluid.layers.prior_box(
+ self.conv3_norm,
+ self.image,
+ min_sizes=[16.],
+ steps=[4, 4],
+ aspect_ratios=[1.],
+ clip=False,
+ flip=True,
+ offset=0.5)
+ box = fluid.layers.reshape(box, shape=[-1, 4])
+ var = fluid.layers.reshape(var, shape=[-1, 4])
+
+ locs.append(loc)
+ confs.append(conf)
+ boxes.append(box)
+ vars.append(var)
+
+ min_sizes = [32., 64., 128., 256., 512.]
+ steps = [8., 16., 32., 64., 128.]
+ inputs = [
+ self.conv4_norm, self.conv5_norm, self.conv6, self.conv7, self.conv8
+ ]
+ for i, input in enumerate(inputs):
+ mbox_loc = fluid.layers.conv2d(input, 4, 3, 1, 1, bias_attr=b_attr)
+ loc = permute_and_reshape(mbox_loc, 4)
+ mbox_conf = fluid.layers.conv2d(input, 2, 3, 1, 1, bias_attr=b_attr)
+ conf = permute_and_reshape(mbox_conf, 2)
+ box, var = fluid.layers.prior_box(
+ input,
+ self.image,
+ min_sizes=[min_sizes[i]],
+ steps=[steps[i]] * 2,
+ aspect_ratios=[1.],
+ clip=False,
+ flip=True,
+ offset=0.5)
+ box = fluid.layers.reshape(box, shape=[-1, 4])
+ var = fluid.layers.reshape(var, shape=[-1, 4])
+
+ locs.append(loc)
+ confs.append(conf)
+ boxes.append(box)
+ vars.append(var)
+
+ self.face_mbox_loc = fluid.layers.concat(locs, axis=1)
+ self.face_mbox_conf = fluid.layers.concat(confs, axis=1)
+ self.prior_boxes = fluid.layers.concat(boxes)
+ self.box_vars = fluid.layers.concat(vars)
+
+ def vgg_ssd_loss(self):
+ loss = fluid.layers.ssd_loss(
+ self.face_mbox_loc,
+ self.face_mbox_conf,
+ self.face_box,
+ self.gt_label,
+ self.prior_boxes,
+ self.box_vars,
+ overlap_threshold=0.35,
+ neg_overlap=0.35)
+ loss = fluid.layers.reduce_sum(loss)
return loss
def train(self):
face_loss = fluid.layers.ssd_loss(
- self.face_mbox_loc, self.face_mbox_conf, self.face_box,
- self.gt_label, self.prior_boxes, self.box_vars)
+ self.face_mbox_loc,
+ self.face_mbox_conf,
+ self.face_box,
+ self.gt_label,
+ self.prior_boxes,
+ self.box_vars,
+ overlap_threshold=0.35,
+ neg_overlap=0.35)
head_loss = fluid.layers.ssd_loss(
- self.head_mbox_loc, self.head_mbox_conf, self.head_box,
- self.gt_label, self.prior_boxes, self.box_vars)
+ self.head_mbox_loc,
+ self.head_mbox_conf,
+ self.head_box,
+ self.gt_label,
+ self.prior_boxes,
+ self.box_vars,
+ overlap_threshold=0.35,
+ neg_overlap=0.35)
face_loss = fluid.layers.reduce_sum(face_loss)
head_loss = fluid.layers.reduce_sum(head_loss)
total_loss = face_loss + head_loss
return face_loss, head_loss, total_loss
- def test(self):
- test_program = fluid.default_main_program().clone(for_test=True)
+ def infer(self, main_program=None):
+ if main_program is None:
+ test_program = fluid.default_main_program().clone(for_test=True)
+ else:
+ test_program = main_program.clone(for_test=True)
with fluid.program_guard(test_program):
face_nmsed_out = fluid.layers.detection_output(
self.face_mbox_loc,
@@ -306,24 +411,4 @@ class PyramidBox(object):
self.prior_boxes,
self.box_vars,
nms_threshold=0.45)
- head_nmsed_out = fluid.layers.detection_output(
- self.head_mbox_loc,
- self.head_mbox_conf,
- self.prior_boxes,
- self.box_vars,
- nms_threshold=0.45)
- face_map_eval = fluid.evaluator.DetectionMAP(
- face_nmsed_out,
- self.gt_label,
- self.face_box,
- class_num=2,
- overlap_threshold=0.5,
- ap_version='11point')
- head_map_eval = fluid.evaluator.DetectionMAP(
- head_nmsed_out,
- self.gt_label,
- self.head_box,
- class_num=2,
- overlap_threshold=0.5,
- ap_version='11point')
- return test_program, face_map_eval, head_map_eval
+ return test_program, face_nmsed_out
diff --git a/fluid/face_detection/reader.py b/fluid/face_detection/reader.py
index f41f6cfc3cc1d7df2a05aa4bab1bad817c5f7889..42109b1194cad071c6571ffa1eb590526a688033 100644
--- a/fluid/face_detection/reader.py
+++ b/fluid/face_detection/reader.py
@@ -238,37 +238,71 @@ def pyramidbox(settings, file_list, mode, shuffle):
im_width, im_height = im.size
# layout: label | xmin | ymin | xmax | ymax
- bbox_labels = []
- for index_box in range(len(dict_input_txt[index_image])):
- if index_box >= 2:
- bbox_sample = []
- temp_info_box = dict_input_txt[index_image][
- index_box].split(' ')
- xmin = float(temp_info_box[0])
- ymin = float(temp_info_box[1])
- w = float(temp_info_box[2])
- h = float(temp_info_box[3])
- xmax = xmin + w
- ymax = ymin + h
-
- bbox_sample.append(1)
- bbox_sample.append(float(xmin) / im_width)
- bbox_sample.append(float(ymin) / im_height)
- bbox_sample.append(float(xmax) / im_width)
- bbox_sample.append(float(ymax) / im_height)
- bbox_labels.append(bbox_sample)
-
- im, sample_labels = preprocess(im, bbox_labels, mode, settings)
- sample_labels = np.array(sample_labels)
- if len(sample_labels) == 0: continue
- im = im.astype('float32')
- boxes = sample_labels[:, 1:5]
- lbls = [1] * len(boxes)
- difficults = [1] * len(boxes)
- yield im, boxes, expand_bboxes(boxes), lbls, difficults
+ if mode == 'train':
+ bbox_labels = []
+ for index_box in range(len(dict_input_txt[index_image])):
+ if index_box >= 2:
+ bbox_sample = []
+ temp_info_box = dict_input_txt[index_image][
+ index_box].split(' ')
+ xmin = float(temp_info_box[0])
+ ymin = float(temp_info_box[1])
+ w = float(temp_info_box[2])
+ h = float(temp_info_box[3])
+ xmax = xmin + w
+ ymax = ymin + h
+
+ bbox_sample.append(1)
+ bbox_sample.append(float(xmin) / im_width)
+ bbox_sample.append(float(ymin) / im_height)
+ bbox_sample.append(float(xmax) / im_width)
+ bbox_sample.append(float(ymax) / im_height)
+ bbox_labels.append(bbox_sample)
+
+ im, sample_labels = preprocess(im, bbox_labels, mode, settings)
+ sample_labels = np.array(sample_labels)
+ if len(sample_labels) == 0: continue
+ im = im.astype('float32')
+ boxes = sample_labels[:, 1:5]
+ lbls = [1] * len(boxes)
+ difficults = [1] * len(boxes)
+ yield im, boxes, expand_bboxes(boxes), lbls, difficults
+
+ if mode == 'test':
+ yield im, image_path
return reader
def train(settings, file_list, shuffle=True):
return pyramidbox(settings, file_list, 'train', shuffle)
+
+
+def test(settings, file_list):
+ return pyramidbox(settings, file_list, 'test', False)
+
+
+def infer(settings, image_path):
+ def batch_reader():
+ img = Image.open(image_path)
+ if img.mode == 'L':
+ img = im.convert('RGB')
+ im_width, im_height = img.size
+ if settings.resize_w and settings.resize_h:
+ img = img.resize((settings.resize_w, settings.resize_h),
+ Image.ANTIALIAS)
+ img = np.array(img)
+ # HWC to CHW
+ if len(img.shape) == 3:
+ img = np.swapaxes(img, 1, 2)
+ img = np.swapaxes(img, 1, 0)
+ # RBG to BGR
+ img = img[[2, 1, 0], :, :]
+ img = img.astype('float32')
+ img -= settings.img_mean
+ img = img * 0.007843
+ img = [img]
+ img = np.array(img)
+ return img
+
+ return batch_reader
diff --git a/fluid/face_detection/train.py b/fluid/face_detection/train.py
index e0643cfe494a9a40c7f4ae8c17506572cb0df89c..c10722b9e33d6c9d05f961d3b2cf73a859b9da3c 100644
--- a/fluid/face_detection/train.py
+++ b/fluid/face_detection/train.py
@@ -16,11 +16,11 @@ add_arg = functools.partial(add_arguments, argparser=parser)
# yapf: disable
add_arg('parallel', bool, True, "parallel")
-add_arg('learning_rate', float, 0.0001, "Learning rate.")
-add_arg('batch_size', int, 16, "Minibatch size.")
+add_arg('learning_rate', float, 0.001, "Learning rate.")
+add_arg('batch_size', int, 12, "Minibatch size.")
add_arg('num_passes', int, 120, "Epoch number.")
add_arg('use_gpu', bool, True, "Whether use GPU.")
-add_arg('use_pyramidbox', bool, False, "Whether use PyramidBox model.")
+add_arg('use_pyramidbox', bool, True, "Whether use PyramidBox model.")
add_arg('dataset', str, 'WIDERFACE', "coco2014, coco2017, and pascalvoc.")
add_arg('model_save_dir', str, 'model', "The path to save model.")
add_arg('pretrained_model', str, './pretrained/', "The init model path.")
@@ -40,20 +40,20 @@ def train(args, data_args, learning_rate, batch_size, pretrained_model,
image_shape = [3, data_args.resize_h, data_args.resize_w]
fetches = []
+ network = PyramidBox(image_shape, num_classes,
+ sub_network=args.use_pyramidbox)
if args.use_pyramidbox:
- network = PyramidBox(image_shape, sub_network=args.use_pyramidbox)
face_loss, head_loss, loss = network.train()
fetches = [face_loss, head_loss]
else:
- network = PyramidBox(image_shape, sub_network=args.use_pyramidbox)
- loss = network.vgg_ssd(num_classes, image_shape)
+ loss = network.vgg_ssd_loss()
fetches = [loss]
epocs = 12880 / batch_size
- boundaries = [epocs * 100, epocs * 125, epocs * 150]
+ boundaries = [epocs * 40, epocs * 60, epocs * 80, epocs * 100]
values = [
- learning_rate, learning_rate * 0.1, learning_rate * 0.01,
- learning_rate * 0.001
+ learning_rate, learning_rate * 0.5, learning_rate * 0.25,
+ learning_rate * 0.1, learning_rate * 0.01
]
if optimizer_method == "momentum":
@@ -70,12 +70,19 @@ def train(args, data_args, learning_rate, batch_size, pretrained_model,
)
optimizer.minimize(loss)
+ # fluid.memory_optimize(fluid.default_main_program())
place = fluid.CUDAPlace(0) if args.use_gpu else fluid.CPUPlace()
exe = fluid.Executor(place)
exe.run(fluid.default_startup_program())
+ start_pass = 0
if pretrained_model:
+ if pretrained_model.isdigit():
+ start_pass = int(pretrained_model) + 1
+ pretrained_model = os.path.join(args.model_save_dir, pretrained_model)
+ print("Resume from %s " %(pretrained_model))
+
if not os.path.exists(pretrained_model):
raise ValueError("The pre-trained model path [%s] does not exist." %
(pretrained_model))
@@ -98,14 +105,14 @@ def train(args, data_args, learning_rate, batch_size, pretrained_model,
print 'save models to %s' % (model_path)
fluid.io.save_persistables(exe, model_path)
- for pass_id in range(num_passes):
+ for pass_id in range(start_pass, num_passes):
start_time = time.time()
prev_start_time = start_time
end_time = 0
for batch_id, data in enumerate(train_reader()):
prev_start_time = start_time
start_time = time.time()
- if len(data) < devices_num: continue
+ if len(data) < 2 * devices_num: continue
if args.parallel:
fetch_vars = train_exe.run(fetch_list=[v.name for v in fetches],
feed=feeder.feed(data))
@@ -126,7 +133,7 @@ def train(args, data_args, learning_rate, batch_size, pretrained_model,
batch_id, fetch_vars[0], fetch_vars[1],
start_time - prev_start_time))
- if pass_id % 10 == 0 or pass_id == num_passes - 1:
+ if pass_id % 1 == 0 or pass_id == num_passes - 1:
save_model(str(pass_id))
diff --git a/fluid/image_classification/README.md b/fluid/image_classification/README.md
index 1000717c87fb60763cdfad78967ad6ec867f5120..b8cd82a68acf4abfd868f70042c7a66facfd5030 100644
--- a/fluid/image_classification/README.md
+++ b/fluid/image_classification/README.md
@@ -1,38 +1,37 @@
-The minimum PaddlePaddle version needed for the code sample in this directory is the lastest develop branch. If you are on a version of PaddlePaddle earlier than this, [please update your installation](http://www.paddlepaddle.org/docs/develop/documentation/en/build_and_install/pip_install_en.html).
+# Image Classification and Model Zoo
+Image classification, which is an important field of computer vision, is to classify an image into pre-defined labels. Recently, many researchers developed different kinds of neural networks and highly improve the classification performance. This page introduces how to do image classification with PaddlePaddle Fluid, including [data preparation](#data-preparation), [training](#training-a-model), [finetuning](#finetuning), [evaluation](#evaluation) and [inference](#inference).
---
+## Table of Contents
+- [Installation](#installation)
+- [Data preparation](#data-preparation)
+- [Training a model with flexible parameters](#training-a-model)
+- [Finetuning](#finetuning)
+- [Evaluation](#evaluation)
+- [Inference](#inference)
+- [Supported models and performances](#supported-models)
-# SE-ResNeXt for image classification
+## Installation
-This model built with paddle fluid is still under active development and is not
-the final version. We welcome feedbacks.
+Running sample code in this directory requires PaddelPaddle Fluid v0.13.0 and later. If the PaddlePaddle on your device is lower than this version, please follow the instructions in [installation document](http://www.paddlepaddle.org/docs/develop/documentation/zh/build_and_install/pip_install_cn.html) and make an update.
-## Introduction
+## Data preparation
-The current code support the training of [SE-ResNeXt](https://arxiv.org/abs/1709.01507) (50/152 layers).
+An example for ImageNet classification is as follows. First of all, preparation of imagenet data can be done as:
+```
+cd data/ILSVRC2012/
+sh download_imagenet2012.sh
+```
-## Data Preparation
+In the shell script ```download_imagenet2012.sh```, there are three steps to prepare data:
-1. Download ImageNet-2012 dataset
-```
-cd data/
-mkdir -p ILSVRC2012/
-cd ILSVRC2012/
-# get training set
-wget http://www.image-net.org/challenges/LSVRC/2012/nnoupb/ILSVRC2012_img_train.tar
-# get validation set
-wget http://www.image-net.org/challenges/LSVRC/2012/nnoupb/ILSVRC2012_img_val.tar
-# prepare directory
-tar xf ILSVRC2012_img_train.tar
-tar xf ILSVRC2012_img_val.tar
+**step-1:** Register at ```image-net.org``` first in order to get a pair of ```Username``` and ```AccessKey```, which are used to download ImageNet data.
-# unzip all classes data using unzip.sh
-sh unzip.sh
-```
+**step-2:** Download ImageNet-2012 dataset from website. The training and validation data will be downloaded into folder "train" and "val" respectively. Please note that the size of data is more than 40 GB, it will take much time to download. Users who have downloaded the ImageNet data can organize it into ```data/ILSVRC2012``` directly.
-2. Download training and validation label files from [ImageNet2012 url](https://pan.baidu.com/s/1Y6BCo0nmxsm_FsEqmx2hKQ)(password:```wx99```). Untar it into workspace ```ILSVRC2012/```. The files include
+**step-3:** Download training and validation label files. There are two label files which contain train and validation image labels respectively:
-**train_list.txt**: training list of imagenet 2012 classification task, with each line seperated by SPACE.
+* *train_list.txt*: label file of imagenet-2012 training set, with each line seperated by ```SPACE```, like:
```
train/n02483708/n02483708_2436.jpeg 369
train/n03998194/n03998194_7015.jpeg 741
@@ -41,7 +40,7 @@ train/n04596742/n04596742_3032.jpeg 909
train/n03208938/n03208938_7065.jpeg 535
...
```
-**val_list.txt**: validation list of imagenet 2012 classification task, with each line seperated by SPACE.
+* *val_list.txt*: label file of imagenet-2012 validation set, with each line seperated by ```SPACE```, like.
```
val/ILSVRC2012_val_00000001.jpeg 65
val/ILSVRC2012_val_00000002.jpeg 970
@@ -50,38 +49,160 @@ val/ILSVRC2012_val_00000004.jpeg 809
val/ILSVRC2012_val_00000005.jpeg 516
...
```
-**synset_words.txt**: the semantic label of each class.
-## Training a model
+## Training a model with flexible parameters
-To start a training task, one can use command line as:
+After data preparation, one can start the training step by:
```
-python train.py --num_layers=50 --batch_size=8 --with_mem_opt=True --parallel_exe=False
+python train.py \
+ --model=SE_ResNeXt50_32x4d \
+ --batch_size=32 \
+ --total_images=1281167 \
+ --class_dim=1000
+ --image_shape=3,224,224 \
+ --model_save_dir=output/ \
+ --with_mem_opt=False \
+ --lr_strategy=piecewise_decay \
+ --lr=0.1
```
-## Finetune a model
+**parameter introduction:**
+* **model**: name model to use. Default: "SE_ResNeXt50_32x4d".
+* **num_epochs**: the number of epochs. Default: 120.
+* **batch_size**: the size of each mini-batch. Default: 256.
+* **use_gpu**: whether to use GPU or not. Default: True.
+* **total_images**: total number of images in the training set. Default: 1281167.
+* **class_dim**: the class number of the classification task. Default: 1000.
+* **image_shape**: input size of the network. Default: "3,224,224".
+* **model_save_dir**: the directory to save trained model. Default: "output".
+* **with_mem_opt**: whether to use memory optimization or not. Default: False.
+* **lr_strategy**: learning rate changing strategy. Default: "piecewise_decay".
+* **lr**: initialized learning rate. Default: 0.1.
+* **pretrained_model**: model path for pretraining. Default: None.
+* **checkpoint**: the checkpoint path to resume. Default: None.
+
+**data reader introduction:** Data reader is defined in ```reader.py```. In [training stage](#training-a-model), random crop and flipping are used, while center crop is used in [evaluation](#inference) and [inference](#inference) stages. Supported data augmentation includes:
+* rotation
+* color jitter
+* random crop
+* center crop
+* resize
+* flipping
+
+**training curve:** The training curve can be drawn based on training log. For example, the log from training AlexNet is like:
```
-python train.py --num_layers=50 --batch_size=8 --with_mem_opt=True --parallel_exe=False --pretrained_model="pretrain/96/"
+End pass 1, train_loss 6.23153877258, train_acc1 0.0150696625933, train_acc5 0.0552518665791, test_loss 5.41981744766, test_acc1 0.0519132651389, test_acc5 0.156150355935
+End pass 2, train_loss 5.15442800522, train_acc1 0.0784279331565, train_acc5 0.211050540209, test_loss 4.45795249939, test_acc1 0.140469551086, test_acc5 0.333163291216
+End pass 3, train_loss 4.51505613327, train_acc1 0.145300447941, train_acc5 0.331567406654, test_loss 3.86548018456, test_acc1 0.219443559647, test_acc5 0.446448504925
+End pass 4, train_loss 4.12735557556, train_acc1 0.19437250495, train_acc5 0.405713528395, test_loss 3.56990146637, test_acc1 0.264536827803, test_acc5 0.507190704346
+End pass 5, train_loss 3.87505435944, train_acc1 0.229518383741, train_acc5 0.453582793474, test_loss 3.35345435143, test_acc1 0.297349333763, test_acc5 0.54753267765
+End pass 6, train_loss 3.6929500103, train_acc1 0.255628824234, train_acc5 0.487188398838, test_loss 3.17112898827, test_acc1 0.326953113079, test_acc5 0.581780135632
+End pass 7, train_loss 3.55882954597, train_acc1 0.275381118059, train_acc5 0.511990904808, test_loss 3.03736782074, test_acc1 0.349035382271, test_acc5 0.606293857098
+End pass 8, train_loss 3.45595097542, train_acc1 0.291462600231, train_acc5 0.530815005302, test_loss 2.96034455299, test_acc1 0.362228929996, test_acc5 0.617390751839
+End pass 9, train_loss 3.3745200634, train_acc1 0.303871691227, train_acc5 0.545210540295, test_loss 2.93932366371, test_acc1 0.37129303813, test_acc5 0.623573005199
+...
```
-TBD
-## Inference
+
+The error rate curves of AlexNet, ResNet50 and SE-ResNeXt-50 are shown in the figure below.
+
+
+Training and validation Curves
+
+
+训练集合与验证集合上的错误率曲线
+
+
+The Single Shot MultiBox Detector (SSD)
+
-
-
-
-
-MobileNet-SSD300x300 Visualization Examples
+
+
+
+
+MobileNet-v1-SSD 300x300 Visualization Examples
+
+SSD 目标检测模型
+
+
+
+
+
+MobileNet-v1-SSD 300x300 预测可视化
+