ホーム » Dopamine

「Dopamine」カテゴリーアーカイブ

TensorFlow : Dopamine : 実験スタッツのロード & Tensorboard による可視化

09/01/2018

TensorFlow : Dopamine : 実験スタッツのロード & Tensorboard による可視化 (翻訳/解説)

翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 09/01/2018

* 本ページは、Dopamin レポジトリ の以下のページを翻訳した上で適宜、補足説明したものです：

* サンプルコードの動作確認はしておりますが、必要な場合には適宜、追加改変しています。
* ご自由にリンクを張って頂いてかまいませんが、sales-info@classcat.com までご一報いただけると嬉しいです。

 

Dopamine : 実験スタッツのロード

この colab はどのように実験のスタッツをロードしてそれをプロットできるかを示します。Dopamine 上で訓練された、修正された Rainbow エージェントのためのサンプル・スタッツファイルを提供します。このサンプルデータのパフォーマンスは標準的な設定を反映してはいないことに注意してください、それは説明のためだけにコンパイルされています。

  • 例 1 は baseline をロードしてそれらを貴方の実験に対してプロットするためにどのように colab を使用するかを示します。
  • 例 2 は違うパッケージを使用して生実験スタッツをどのようにロードしてプロットするかを示します。

この colab を再実行するためには、各セルを順番に実行します。

# @title Install necessary packages.
!pip install --upgrade --no-cache-dir dopamine-rl
!pip install cmake
!pip install atari_py

# @title Necessary imports and globals.

import numpy as np
import os
from dopamine.agents.dqn import dqn_agent
from dopamine.atari import run_experiment
from dopamine.colab import utils as colab_utils
from absl import flags

BASE_PATH = '/tmp/colab_dope_run'  # @param
GAMES = ['Asterix', 'Pong', 'SpaceInvaders']  # @param

# @title Load the sample log files.

# For illustrative purposes, we are providing sample logs of the Rainbow agent
# trained without sticky actions.
!gsutil -q -m cp -R gs://download-dopamine-rl/colab/* /content/

 

例 1: Dopamine baseline に対してプロットする

# @title Load the baseline data

!gsutil -q -m cp -R gs://download-dopamine-rl/preprocessed-benchmarks/* /content/
experimental_data = colab_utils.load_baselines('/content')

# @title Load the summarized sample data and add it to the global data frame.
import collections

# Now read the data for our samples in a summarized fashion. The files will be
# in the local directory /content/samples/rainbow/GAME_v4, so we make use of
# the parameter_set and job_descriptor parameters.
parameter_set = collections.OrderedDict([
    ('agent', ['rainbow']),
    ('game', GAMES)
])
sample_data = colab_utils.read_experiment(
    '/content/samples',
    parameter_set=parameter_set,
    job_descriptor='{}/{}_v4',
    summary_keys=['train_episode_returns'])
sample_data['agent'] = 'Sample Rainbow'
sample_data['run_number'] = 1
for game in GAMES:
  experimental_data[game] = experimental_data[game].merge(
      sample_data[sample_data.game == game], how='outer')

# @title Plot the sample agent data against the baselines.# @title 

import seaborn as sns
import matplotlib.pyplot as plt

for game in GAMES:
  fig, ax = plt.subplots(figsize=(16,8))
  sns.tsplot(data=experimental_data[game], time='iteration', unit='run_number',
             condition='agent', value='train_episode_returns', ax=ax)
  plt.title(game)
  plt.show()

 

例 2 : 違うパッケージを使用してサンプル実験のための生データをロードしてプロットする

import matplotlib.pyplot as plt

for game in GAMES:
  # Use our provided colab utils to load this log file. The second returned 
  raw_data, _ = colab_utils.load_statistics(
      '/content/samples/rainbow/{}_v4/logs'.format(game), verbose=False)
  summarized_data = colab_utils.summarize_data(
      raw_data, ['train_episode_returns'])
  plt.plot(summarized_data['train_episode_returns'], label='episode returns')
  plt.plot()
  plt.title('Rainbow training - {}'.format(game))
  plt.xlabel('Iteration')
  plt.ylabel('Return')
  plt.legend()
  plt.show()

 

Dopamine : Dopamine baseline を Tensorboard で可視化する

この colab は訓練された baseline を TensorBoard で簡単に可視化することを可能にします (貴方のローカルマシンに Tensorboard を持たない場合でさえも！)。

単純に可視化したいゲームを指定してからセルを順番に実行します。

Tensorboard のセットアップのための手順は https://www.dlology.com/blog/quick-guide-to-run-tensorboard-in-google-colab/ で得られます。

# @title Prepare all necessary files and binaries.
!wget https://bin.equinox.io/c/4VmDzA7iaHb/ngrok-stable-linux-amd64.zip
!unzip ngrok-stable-linux-amd64.zip
!gsutil -q -m cp -R gs://download-dopamine-rl/compiled_tb_event_files.tar.gz /content/
!tar -xvzf /content/compiled_tb_event_files.tar.gz

# @title Select which game to visualize.
game = 'Asterix'  # @param['AirRaid', 'Alien', 'Amidar', 'Assault', 'Asterix', 'Asteroids', 'Atlantis', 'BankHeist', 'BattleZone', 'BeamRider', 'Berzerk', 'Bowling', 'Boxing', 'Breakout', 'Carnival', 'Centipede', 'ChopperCommand', 'CrazyClimber', 'DemonAttack', 'DoubleDunk', 'ElevatorAction', 'Enduro', 'FishingDerby', 'Freeway', 'Frostbite', 'Gopher', 'Gravitar', 'Hero', 'IceHockey', 'Jamesbond', 'JourneyEscape', 'Kangaroo', 'Krull', 'KungFuMaster', 'MontezumaRevenge', 'MsPacman', 'NameThisGame', 'Phoenix', 'Pitfall', 'Pong', 'Pooyan', 'PrivateEye', 'Qbert', 'Riverraid', 'RoadRunner', 'Robotank', 'Seaquest', 'Skiing', 'Solaris', 'SpaceInvaders', 'StarGunner', 'Tennis', 'TimePilot', 'Tutankham', 'UpNDown', 'Venture', 'VideoPinball', 'WizardOfWor', 'YarsRevenge', 'Zaxxon']
agents = ['dqn', 'c51', 'rainbow', 'implicit_quantile']
for agent in agents:
  for run in range(1, 6):
    !mkdir -p "/content/$game/$agent/$run"
    !cp -r "/content/$agent/$game/$run" "/content/$game/$agent/$run"
LOG_DIR = '/content/{}'.format(game)
get_ipython().system_raw(
    'tensorboard --logdir {} --host 0.0.0.0 --port 6006 &'
    .format(LOG_DIR)
)

# @title Start the tensorboard
get_ipython().system_raw('./ngrok http 6006 &')
! curl -s http://localhost:4040/api/tunnels | python3 -c \
    "import sys, json; print(json.load(sys.stdin)['tunnels'][0]['public_url'])"
 

以上



TensorFlow : Dopamine : カスタム・エージェントの作成と訓練

08/31/2018

TensorFlow : Dopamine : カスタム・エージェントの作成と訓練 (翻訳/解説)

翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 08/31/2018

* 本ページは、Dopamin レポジトリ の以下のページを翻訳した上で適宜、補足説明したものです：

* サンプルコードの動作確認はしておりますが、必要な場合には適宜、追加改変しています。
* ご自由にリンクを張って頂いてかまいませんが、sales-info@classcat.com までご一報いただけると嬉しいです。

 

Dopamine : カスタム・エージェントをどのように作成して訓練するか

この colab は提供されたエージェントの変種をどのように作成するか (例 1) そしてスクラッチから新しいエージェントをどのように作成するか (例 2) を示します。

下のセルを順番に実行します。

# @title Install necessary packages.
!pip install --upgrade --no-cache-dir dopamine-rl
!pip install cmake
!pip install atari_py

# @title Necessary imports and globals.# @titl 

import numpy as np
import os
from dopamine.agents.dqn import dqn_agent
from dopamine.atari import run_experiment
from dopamine.colab import utils as colab_utils
from absl import flags

BASE_PATH = '/tmp/colab_dope_run'  # @param
GAME = 'Asterix'  # @param

# @title Load baseline data
!gsutil -q -m cp -R gs://download-dopamine-rl/preprocessed-benchmarks/* /content/
experimental_data = colab_utils.load_baselines('/content')

 

例 1: DQN の修正バージョンを訓練する

Asterix は Dopamine で提供される標準的なエージェントの一つです。このサンプルの目的は既存のエージェントをどのように修正するかを示すことです。ここで行なう修正 (アクションをランダムに選択します) は説明のためです : それは明らかに非常に貧弱に遂行するでしょう。

# @title Create an agent based on DQN, but choosing actions randomly.

LOG_PATH = os.path.join(BASE_PATH, 'random_dqn', GAME)

class MyRandomDQNAgent(dqn_agent.DQNAgent):
  def __init__(self, sess, num_actions):
    """This maintains all the DQN default argument values."""
    super(MyRandomDQNAgent, self).__init__(sess, num_actions)
    
  def step(self, reward, observation):
    """Calls the step function of the parent class, but returns a random action.
    """
    _ = super(MyRandomDQNAgent, self).step(reward, observation)
    return np.random.randint(self.num_actions)

def create_random_dqn_agent(sess, environment):
  """The Runner class will expect a function of this type to create an agent."""
  return MyRandomDQNAgent(sess, num_actions=environment.action_space.n)

# Create the runner class with this agent. We use very small numbers of steps
# to terminate quickly, as this is mostly meant for demonstrating how one can
# use the framework. We also explicitly terminate after 110 iterations (instead
# of the standard 200) to demonstrate the plotting of partial runs.
random_dqn_runner = run_experiment.Runner(LOG_PATH,
                                          create_random_dqn_agent,
                                          game_name=GAME,
                                          num_iterations=200,
                                          training_steps=10,
                                          evaluation_steps=10,
                                          max_steps_per_episode=100)

INFO:tensorflow:Creating MyRandomDQNAgent agent with the following parameters:
INFO:tensorflow:	 gamma: 0.990000
INFO:tensorflow:	 update_horizon: 1.000000
INFO:tensorflow:	 min_replay_history: 20000
INFO:tensorflow:	 update_period: 4
INFO:tensorflow:	 target_update_period: 8000
INFO:tensorflow:	 epsilon_train: 0.010000
INFO:tensorflow:	 epsilon_eval: 0.001000
INFO:tensorflow:	 epsilon_decay_period: 250000
INFO:tensorflow:	 tf_device: /cpu:*
INFO:tensorflow:	 use_staging: True
INFO:tensorflow:	 optimizer: 
INFO:tensorflow:Creating a OutOfGraphReplayBuffer replay memory with the following parameters:
INFO:tensorflow:	 observation_shape: 84
INFO:tensorflow:	 stack_size: 4
INFO:tensorflow:	 replay_capacity: 1000000
INFO:tensorflow:	 batch_size: 32
INFO:tensorflow:	 update_horizon: 1
INFO:tensorflow:	 gamma: 0.990000

# @title Train MyRandomDQNAgent.
print('Will train agent, please be patient, may be a while...')
random_dqn_runner.run_experiment()
print('Done training!')

# @title Load the training logs.
random_dqn_data = colab_utils.read_experiment(LOG_PATH, verbose=True)
random_dqn_data['agent'] = 'MyRandomDQN'
random_dqn_data['run_number'] = 1
experimental_data[GAME] = experimental_data[GAME].merge(random_dqn_data,
                                                        how='outer')

# @title Plot training results.# @title 

import seaborn as sns
import matplotlib.pyplot as plt

fig, ax = plt.subplots(figsize=(16,8))
sns.tsplot(data=experimental_data[GAME], time='iteration', unit='run_number',
           condition='agent', value='train_episode_returns', ax=ax)
plt.title(GAME)
plt.show()

 

例 2: スクラッチから構築されたエージェントを訓練する

このサンプルの目的はエージェントをどのようにスクラッチから作成できるかを示すことです。ここで作成されるエージェントは (エージェントから想定される) 最小限の機能を示すことを意図しています。それはアクションを非常に最適ではない方法で選択しますので、それは明らかに貧弱に遂行します。

# @title Create a completely new agent from scratch.

LOG_PATH = os.path.join(BASE_PATH, 'sticky_agent', GAME)

class StickyAgent(object):
  """This agent randomly selects an action and sticks to it. It will change
  actions with probability switch_prob."""
  def __init__(self, sess, num_actions, switch_prob=0.1):
    self._sess = sess
    self._num_actions = num_actions
    self._switch_prob = switch_prob
    self._last_action = np.random.randint(num_actions)
    self.eval_mode = False
    
  def _choose_action(self):
    if np.random.random() <= self._switch_prob:
      self._last_action = np.random.randint(self._num_actions)
    return self._last_action
    
  def bundle_and_checkpoint(self, unused_checkpoint_dir, unused_iteration):
    pass
    
  def unbundle(self, unused_checkpoint_dir, unused_checkpoint_version,
               unused_data):
    pass
  
  def begin_episode(self, unused_observation):
    return self._choose_action()
  
  def end_episode(self, unused_reward):
    pass
  
  def step(self, reward, observation):
    return self._choose_action()
  
def create_sticky_agent(sess, environment):
  """The Runner class will expect a function of this type to create an agent."""
  return StickyAgent(sess, num_actions=environment.action_space.n,
                     switch_prob=0.2)

# Create the runner class with this agent. We use very small numbers of steps
# to terminate quickly, as this is mostly meant for demonstrating how one can
# use the framework. We also explicitly terminate after 110 iterations (instead
# of the standard 200) to demonstrate the plotting of partial runs.
sticky_runner = run_experiment.Runner(LOG_PATH,
                                      create_sticky_agent,
                                      game_name=GAME,
                                      num_iterations=200,
                                      training_steps=10,
                                      evaluation_steps=10,
                                      max_steps_per_episode=100)

# @title Train StickyAgent.
print('Will train sticky agent, please be patient, may be a while...')
sticky_runner.run_experiment()
print('Done training!')

# @title Load the training logs.
sticky_data = colab_utils.read_experiment(log_path=LOG_PATH, verbose=True)
sticky_data['agent'] = 'StickyAgent'
sticky_data['run_number'] = 1
experimental_data[GAME] = experimental_data[GAME].merge(sticky_data,
                                                        how='outer')

# @title Plot training results.

import seaborn as sns
import matplotlib.pyplot as plt

fig, ax = plt.subplots(figsize=(16,8))
sns.tsplot(data=experimental_data[GAME], time='iteration', unit='run_number',
           condition='agent', value='train_episode_returns', ax=ax)
plt.title(GAME)
plt.show()

 

以上



TensorFlow : Dopamine 概要

08/31/2018

TensorFlow : Dopamine 概要 (翻訳/解説)

翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 08/31/2018

* 本ページは、Dopamin レポジトリ の以下のページを翻訳した上で適宜、補足説明したものです：

* サンプルコードの動作確認はしておりますが、必要な場合には適宜、追加改変しています。
* ご自由にリンクを張って頂いてかまいませんが、sales-info@classcat.com までご一報いただけると嬉しいです。

 

Dopamine 概要

どのように (Dopamine で) 実験して Dopamine を拡張するかについてのサンプルと指針を与えます。

各モジュールに対するドキュメントを API ドキュメント のコードベースで見つけることができます。

 

ファイル構成

Dopamine は次のように構成されます :

  • agents はエージェント実装を含みます。
  • atari は、実験を実行するコードと前処理コードを含む、Atari 固有コードを含みます、
  • common はロギングやチェックポインティングを含む、追加のヘルパー機能を含みます。
  • replay_memory は Dopamine で使用されるリプレー・メモリ・スキームを含みます。
  • colab はサンプル colab ノートブックに加えて、実験結果を調べるために使用されるコードを含みます。
  • tests は総てのテストファイルを含みます。

 

エージェントを configure する

Dopamine の全体は gin configuration フレームワーク を使用して簡単に configure できます。
エージェントの各々に対して多くの configuration ファイルを提供します。

各エージェントに対する主要な configuration ファイルは同一条件での比較に対応し、そこではエージェント間で標準化されたパフォーマンス比較を与えるためにハイパーパラメータが選択されています。これらは :

これらのパラメータの裏の正確な選択についてのより詳細は baselines ページ で与えられます。

論文で以前に使用した設定に対応する configuration ファイルもまた提供します。これらは :

これらの総ては Arcade Learning Environment (ALE) の決定論的バージョン、そして僅かに異なるハイパーパラメータを使用しています。

 

チェックポインティングとロギング

Dopamine は実験を遂行するための基本的な機能を提供します。この機能は 2 つの主要なコンポーネントに分解されます : チェックポインティングとロギングです。両者のコンポーネントはコマンドライン・パラメータ base_dir に依拠します、これは実験データをどこにストアするべきかを Dopamine に知らせます。

 

チェックポインティング

デフォルトでは、Dopamine は総ての反復で実験チェックポイントをセーブします : 1 訓練と 1 評価フェイズで、Mnih et al による標準的なセットに従っています。チェックポイントは base_dir 下のチェック checkpoints サブディレクトリに保存されます。高位には、以下がチェックポイントされます :

興味があれば、チェックポインティング・コード自身は dopamine/common/checkpointer.py にあります。

 

ロギング

各反復の最後に、訓練の間と (有効であれば) オプションの評価フェイズの間の両者で、Dopamine はまたエージェントのパフォーマンスを記録します。ログファイルは dopamine/atari/run_experiment.py で、より具体的には、dopamine/common/logger.py で生成され、そしてそれは iteration キー (e.g., “iteration_47”) をデータを含む辞書にマッピングする辞書を含む pickle ファイルです。

複数の実験からログデータを読む単純な方法は colab/utils.py の提供されている read_experiment メソッドを使用することです。

実験からどのようにスタッツをロードしてそれらを提供された baseline 実行に対してプロットできるかを示すために colab を提供します。

 

エージェントを修正して拡張する

Dopamine はアルゴリズム的な研究を単純にするように設計されています。この点を考慮して、抽象基底クラスなしに、比較的フラットなクラス階層を保持することを決めました ; 単純化と使いやすさの追加された利益を伴い、研究目的ではこれで十分であることを見出しました。最初に、貴方の研究目的に適合するようにエージェント・コードを直接的に変更することを勧めます。

DQN エージェントをどのように拡張できるか、スクラッチから新しいエージェントをどのように作成できるか、そして提供された baseline に対する実験結果をどのようにプロットするかを示すために colab を提供しています。

 

DQN

DQN エージェントは 2 つのファイルに含まれます :

The DQN agent is contained in two files:

エージェントのクラスは DQN ネットワーク、更新ルール、そしてまた RL エージェントの基本的な演算 (epsilon-greedy アクション選択、遷移のストア (= storing transitions)、エピソード記録 (= episode bookkeeping) , etc.) を定義します。例えば、DQN で使用される Q 学習更新ルールは 2 つのメソッド, _build_target_q_op と _build_train_op で定義されます。

 

Rainbow と C51

Rainbow エージェントは 2 つのファイルに含まれます :

C51 エージェントは Rainbow エージェントの特定のパラメータ化で、そこでは update_horizon は 1 に設定されて uniform リプレー・スキームが使用されます。

 

Implicit quantile networks (IQN)

IQN エージェントは一つの追加ファイルで定義されます :

 

ダウンロード

全部で 60 ゲーム上の 4 つのエージェント総てのための一連のファイルを提供します。これらは総て *.tar.gz ファイルで解凍する必要があります :

  • 生ログは ここ で利用可能です
    • それらをどのようにロードして可視化するかの手順についてはこの colab を見ることができます。
  • コンパイルされた pickle ファイルは ここ で利用可能です
  • Tensorboard イベントファイルは ここ で利用可能です
    • ngrok を使用した colab から直接 TensorBoard を開始できる colab を提供します。提供されたサンプルで TensorBoard はこのようなものに見えます :

       

       
      ◇ 貴方のマシン上でこれらを TensorBoard で見ることもできます。例えば、ファイルを解凍後に次を実行できます :

      tensorboard --logdir c51/Asterix/

      Asterix 上で C51 のための訓練実行を表示するために :

       

     

  • 全部で 60 ゲーム上の 4 エージェントの 5 つの独立した実行のための TensorFlow チェックポイント・ファイルは下で利用可能です。Note: これらのファイルは非常に巨大で、それぞれ 15 GB を超えます。
 

以上



TensorFlow : Dopamine : README.md

08/30/2018

TensorFlow : Dopamine : README.md (翻訳/解説)

翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 08/30/2018

* 本ページは、Dopamin レポジトリ の以下のページを翻訳した上で適宜、補足説明したものです：

* サンプルコードの動作確認はしておりますが、必要な場合には適宜、追加改変しています。
* ご自由にリンクを張って頂いてかまいませんが、sales-info@classcat.com までご一報いただけると嬉しいです。

 

Dopamine

Dopamine は強化学習アルゴリズムの高速なプロトタイピングのための研究用フレームワークです。それは小さくて、簡単に理解可能なコードベースの必要性を満たすことを目的にしています、そこではユーザは大胆なアイデア (推論的な研究) で自由に実験できます。

私達の設計原理は :

  • 簡単な実験: 新しいユーザがベンチマーク実験を実行することを容易にします。
  • 柔軟な開発: 新しいユーザが研究アイデアを試すことを容易にします。
  • コンパクトで信頼性が高い: 幾つかの徹底的に試されたアルゴリズムのための実装を提供します。
  • 再現可能: 結果の再現性を容易にする。

これらの原理の精神で、この最初のバージョンは Atari 2600 ゲーム-playing (Bellemare et al., 2013) に適用された、先端技術の、単一 GPU Rainbow エージェント (Hessel et al., 2018) をサポートすることにフォーカスしました。特に、私達の Rainbow エージェントは Hessel et al. により最も重要として識別される 3 つのコンポーネントを実装しています :

完全を期すため、DQN (Mnih et al., 2015) の実装もまた提供します。追加の詳細については、ドキュメント を見てください。

 

手順

ソースによるイントール

ソースからのインストールはエージェントと実験を貴方が好ましいように変更することを可能にし、長期間の使用のための選択の経路となる可能性が高まります。これらの手順はお気に入りのパッケージ・マネージャ (e.g. apt on Ubuntu, homebrew on Mac OS X) を既にセットアップして C++ コンパイラがコマンドラインから利用可能であることを仮定します (お気に入りのパッケージ・マネージャが動作していればほぼ確実に当てはまるでしょう)。

下のこれらの手順は仮想環境で Dopamine を動作することを仮定しています。仮想環境はどの依存性がどのプログラムのためにインストールされたかを貴方に制御させます ; けれども、このステップはオプションでそれを無視することを選択しても良いです。

Dopamine は TensorFlow ベースのフレームワークで、追加の詳細については TensorFlow ドキュメントも参考にすることを推奨します。

最後に、これらの手順は Python 2.7 のためです。Dopamine は Python 3 互換である一方で、インストールの間に必要な幾つかの追加のステップがあるかもしれません。

 

Ubuntu

最初に仮想環境をセットアップします :

sudo apt-get install virtualenv
virtualenv --python=python2.7 dopamine-env
source dopamine-env/bin/activate

これは dopamine-env という名前のディレクトリを作成してそこでは仮想環境が活性化してます。最後のコマンドは環境を有効にします。

それから、Dopamine の依存性をインストールします :

sudo apt-get install cmake zlib1g-dev
pip install absl-py atari-py gin-config gym opencv-python tensorflow

インストールの間、次のエラーメッセージは安全に無視して良いです : tensorflow 1.10.1 has requirement numpy<=1.14.5,>=1.13.3, but you’ll have numpy 1.15.1 which is incompatible.

最後に、Dopamine ソースをダウンロードします, e.g. 

git clone https://github.com/google/dopamine.git

 

テストを実行する

次を実行してインストールが成功したかテストすることができます :

cd dopamine
export PYTHONPATH=${PYTHONPATH}:.
python tests/atari_init_test.py

標準的な Atari 2600 実験へのエントリポイントは dopamine/atari/train.py です。基本的な DQN エージェントを実行するには、

python -um dopamine.atari.train \
  --agent_name=dqn \
  --base_dir=/tmp/dopamine \
  --gin_files='dopamine/agents/dqn/configs/dqn.gin'

デフォルトでは、これは 2 億フレーム存続する実験を開始します。コマンドライン・インターフェイスは最新の訓練エピソードについてのスタッツを出力します :

[...]
I0824 17:13:33.078342 140196395337472 tf_logging.py:115] gamma: 0.990000
I0824 17:13:33.795608 140196395337472 tf_logging.py:115] Beginning training...
Steps executed: 5903 Episode length: 1203 Return: -19.

プロセスの微細な情報を得るためには、dopamine/agents/dqn/configs/dqn.gin の実験パラメータを調整することができます。特に、反復を完了するために必要な総ステップ数を一緒に決定する Runner.training_steps と Runner.evaluation_steps を減じることによって調整できます。これは、各反復の最後に生成されるログファイルやチェックポイントを調べることを望む場合に有用です。

より一般的には、Dopamine 全体は gin configuration フレームワーク を使用して用意に configure されます。

 

ライブラリとしてインストールする

Dopamine をインストールする簡単で、代わりの方法は Python ライブラリとしてです :

sudo apt-get install cmake  # Or brew install, see Mac OS X instructions above.
pip install dopamine-rl
pip install atari-py

特定のシステム構成に依存して、zlib もまたインストールする必要があるかもしれません。

テストを実行する

ルート・ディレクトリから、次のようなコマンドでテストが実行できます :

python -um tests.agents.rainbow.rainbow_agent_test

 

リファレンス

 

以上



AI導入支援 #2 ウェビナー

スモールスタートを可能としたAI導入支援   Vol.2
[無料 WEB セミナー] [詳細]
◆ 「画像認識 AI PoC スターターパック」の紹介
既に AI 技術を実ビジネスで活用し、成果を上げている日本企業も多く存在しており、競争優位なビジネスを展開しております。
しかしながら AI を導入したくとも PoC (概念実証) だけでも高額な費用がかかり取組めていない企業も少なくないようです。A I導入時には欠かせない PoC を手軽にしかも短期間で認知度を確認可能とするサービの紹介と共に、AI 技術の特性と具体的な導入プロセスに加え運用時のポイントについても解説いたします。
日時：2021年10月13日(水)
会場：WEBセミナー
共催：クラスキャット、日本FLOW(株)
後援：働き方改革推進コンソーシアム
参加費： 無料 (事前登録制)
人工知能開発支援
◆ クラスキャットは 人工知能研究開発支援 サービスを提供しています :
  • テクニカルコンサルティングサービス
  • 実証実験 (プロトタイプ構築)
  • アプリケーションへの実装
  • 人工知能研修サービス
◆ お問合せ先 ◆
(株)クラスキャット
セールス・インフォメーション
E-Mail：sales-info@classcat.com
クラスキャット