アームごとの機能を備えた多腕バンディットに関するチュートリアル

はじめに

TensorFlow.orgで表示 GoogleColabで実行 GitHubでソースを表示 ノートブックをダウンロード

このチュートリアルは、アクション(腕)が機能(ジャンル、リリース年、 ...)。

前提条件

それは読者がTF-エージェントの強盗ライブラリと多少精通していると仮定される、特にを通して働いているTF-剤中強盗のためのチュートリアルこのチュートリアルを読む前に。

アーム機能を備えた多腕バンディット

「古典的な」コンテキスト多腕バンディット設定では、エージェントはすべてのタイムステップでコンテキストベクトル(別名観測)を受け取り、累積報酬を最大化するために、番号付きアクション(アーム)の有限セットから選択する必要があります。

次に、エージェントがユーザーに次に見る映画を勧めるシナリオを考えてみましょう。決定を下す必要があるたびに、エージェントはコンテキストとしてユーザーに関する情報(視聴履歴、ジャンルの好みなど)と、選択する映画のリストを受け取ります。

私たちは、コンテキストなどのユーザー情報を持っていることによって、この問題を定式化しようとすることができますし、腕は次のようになりmovie_1, movie_2, ..., movie_Kが、このアプローチは、複数の欠点があります。

  • アクションの数はシステム内のすべての映画である必要があり、新しい映画を追加するのは面倒です。
  • エージェントは、すべての映画のモデルを学習する必要があります。
  • 映画間の類似性は考慮されていません。

映画に番号を付ける代わりに、より直感的なことを行うことができます。ジャンル、長さ、キャスト、評価、年などの一連の機能で映画を表すことができます。このアプローチの利点は多岐にわたります。

  • 映画全体の一般化。
  • エージェントは、ユーザーと映画の機能で報酬をモデル化する1つの報酬関数のみを学習します。
  • システムから簡単に削除したり、新しい映画をシステムに導入したりできます。

この新しい設定では、アクションの数はすべてのタイムステップで同じである必要はありません。

TFエージェントのアームごとの盗賊

TF-Agents Banditスイートは、腕ごとのケースにも使用できるように開発されています。アームごとの環境があり、ほとんどのポリシーとエージェントはアームごとのモードで動作できます。

例のコーディングに飛び込む前に、必要なインポートが必要です。

インストール

pip install tf-agents

輸入

import functools
import matplotlib.pyplot as plt
import numpy as np
import tensorflow as tf

from tf_agents.bandits.agents import lin_ucb_agent
from tf_agents.bandits.environments import stationary_stochastic_per_arm_py_environment as p_a_env
from tf_agents.bandits.metrics import tf_metrics as tf_bandit_metrics
from tf_agents.drivers import dynamic_step_driver
from tf_agents.environments import tf_py_environment
from tf_agents.replay_buffers import tf_uniform_replay_buffer
from tf_agents.specs import tensor_spec
from tf_agents.trajectories import time_step as ts

nest = tf.nest

パラメータ-気軽に遊んでください

# The dimension of the global features.
GLOBAL_DIM = 40 
# The elements of the global feature will be integers in [-GLOBAL_BOUND, GLOBAL_BOUND).
GLOBAL_BOUND = 10 
# The dimension of the per-arm features.
PER_ARM_DIM = 50 
# The elements of the PER-ARM feature will be integers in [-PER_ARM_BOUND, PER_ARM_BOUND).
PER_ARM_BOUND = 6 
# The variance of the Gaussian distribution that generates the rewards.
VARIANCE = 100.0 
# The elements of the linear reward parameter will be integers in [-PARAM_BOUND, PARAM_BOUND).
PARAM_BOUND = 10 

NUM_ACTIONS = 70 
BATCH_SIZE = 20 

# Parameter for linear reward function acting on the
# concatenation of global and per-arm features.
reward_param = list(np.random.randint(
      -PARAM_BOUND, PARAM_BOUND, [GLOBAL_DIM + PER_ARM_DIM]))

シンプルなアームごとの環境

定常確率的環境は、他で説明チュートリアルごとのアームの対応を有します。

アームごとの環境を初期化するには、生成する関数を定義する必要があります

  • グローバルごとのアームの機能がこれらの機能には、入力パラメータを持たず、呼び出されたときに(グローバルまたはごとアーム)は、単一の特徴ベクトルを生成します。
  • 報酬:この関数は、グローバルごとのアームの特徴ベクトルの連結パラメータとして受け取り、報酬を生成します。基本的に、これはエージェントが「推測」しなければならない機能です。ここで注目に値するのは、腕ごとの場合、報酬関数はすべての腕で同じです。これは、エージェントが各アームの報酬関数を個別に推定する必要がある従来の盗賊の場合との根本的な違いです。
def global_context_sampling_fn():
  """This function generates a single global observation vector."""
  return np.random.randint(
      -GLOBAL_BOUND, GLOBAL_BOUND, [GLOBAL_DIM]).astype(np.float32)

def per_arm_context_sampling_fn():
  """"This function generates a single per-arm observation vector."""
  return np.random.randint(
      -PER_ARM_BOUND, PER_ARM_BOUND, [PER_ARM_DIM]).astype(np.float32)

def linear_normal_reward_fn(x):
  """This function generates a reward from the concatenated global and per-arm observations."""
  mu = np.dot(x, reward_param)
  return np.random.normal(mu, VARIANCE)

これで、環境を初期化する準備が整いました。

per_arm_py_env = p_a_env.StationaryStochasticPerArmPyEnvironment(
    global_context_sampling_fn,
    per_arm_context_sampling_fn,
    NUM_ACTIONS,
    linear_normal_reward_fn,
    batch_size=BATCH_SIZE
)
per_arm_tf_env = tf_py_environment.TFPyEnvironment(per_arm_py_env)

以下では、この環境が何を生成するかを確認できます。

print('observation spec: ', per_arm_tf_env.observation_spec())
print('\nAn observation: ', per_arm_tf_env.reset().observation)

action = tf.zeros(BATCH_SIZE, dtype=tf.int32)
time_step = per_arm_tf_env.step(action)
print('\nRewards after taking an action: ', time_step.reward)
observation spec:  {'global': TensorSpec(shape=(40,), dtype=tf.float32, name=None), 'per_arm': TensorSpec(shape=(70, 50), dtype=tf.float32, name=None)}

An observation:  {'global': <tf.Tensor: shape=(20, 40), dtype=float32, numpy=
array([[  6.,  -6.,   9.,  -6.,   4.,   2.,  -2.,  -6.,  -9.,   0.,  -4.,
        -10.,   0.,   7.,   2.,   5.,  -5.,   4.,   6.,   8.,  -9.,   7.,
         -9.,   1.,  -6.,  -4.,   9.,   7.,  -9.,   9.,  -1.,  -5.,   1.,
         -8.,  -4.,   0.,  -7.,   9.,   0.,  -3.],
       [ -2.,  -7.,  -3.,  -2.,  -6.,  -8.,   5.,   1.,   6.,   5.,  -6.,
          2.,   8.,  -7.,  -6.,  -6.,   6.,   8.,   5.,   0.,  -9.,   3.,
         -9.,  -6.,   4.,  -5.,   1.,  -9.,  -9.,   1.,  -2.,   2.,   8.,
          3.,  -3.,  -3.,  -6.,   2.,  -5.,   4.],
       [  9.,  -2.,   7.,   4.,  -2.,   9.,   4., -10.,   4.,  -3.,  -9.,
          0.,   0.,   9.,  -3., -10.,  -1.,   8., -10.,   8.,  -7.,   6.,
          3., -10.,  -6.,   5.,   9., -10.,   4.,   9.,   9.,   0.,   1.,
         -1.,  -2.,  -2.,   9.,  -6.,   4.,  -1.],
       [  0.,  -7.,   8., -10.,   9.,   4.,  -2.,   0.,   9.,  -8.,  -9.,
          7.,   0.,  -4.,  -8.,   0.,   2.,   2.,   4.,  -6.,   4.,   2.,
          3.,  -5.,  -1.,   7.,  -3.,  -6.,   5.,  -8.,  -2., -10.,   1.,
         -2.,  -1.,   4.,  -7.,  -6.,  -7.,   4.],
       [ -2.,   3.,   5.,  -4.,  -4.,  -4.,  -9.,  -7.,  -7.,  -8.,  -1.,
         -7.,   6.,  -3.,  -3.,   6.,   7.,   6., -10.,  -1.,  -6.,   0.,
         -3.,   2.,  -2., -10.,  -8.,   5.,  -2.,  -2.,   2.,  -8., -10.,
         -4.,  -6.,   0.,  -8.,   1.,   9.,  -4.],
       [ -9.,  -9.,   8.,  -9.,   9.,  -9.,   1.,   1.,   4.,   9.,   8.,
          8.,  -6.,   2.,   6.,   0., -10.,  -2.,  -9.,   4., -10.,   0.,
          1.,  -1.,  -4., -10.,  -3.,  -9.,   4.,   6.,   7.,  -1.,   7.,
          9.,  -9.,   9.,   5.,  -6.,  -3.,   8.],
       [ -4.,   9.,   3.,   8.,   8.,  -7.,   4.,  -8.,  -5.,  -1., -10.,
        -10.,   2.,  -7.,  -7., -10., -10.,  -1.,  -9.,   1., -10.,  -6.,
          6.,   9.,   6.,  -7.,  -4.,  -6.,  -8.,  -6.,  -1.,   7.,   8.,
         -4.,  -5.,   8.,   5.,   9.,  -3.,  -4.],
       [ -2.,  -1.,  -3.,  -4.,   1.,   5.,  -8., -10.,  -7.,   3.,   4.,
         -6.,   1.,  -7.,   6.,  -5.,  -3.,  -1.,   6.,  -8.,  -1.,   7.,
         -8.,   1., -10.,  -5., -10.,  -1.,  -1.,  -9., -10.,   4.,  -7.,
          9.,   5.,  -8.,  -5.,   8.,   3.,   8.],
       [  9.,  -5.,  -9.,  -7.,   4.,   4.,  -9.,  -2.,  -2.,  -8.,   1.,
        -10.,  -8.,   8.,   8.,   6.,  -8.,   6.,  -9.,   4.,   9.,  -5.,
        -10.,   8.,  -9.,   1.,   4.,  -2.,  -3.,  -5.,  -3., -10.,   4.,
         -5.,  -5.,   2.,   3.,  -8.,   9.,   4.],
       [ -2.,  -7.,   3.,  -3.,  -1.,  -5.,  -2.,   2.,   7.,  -6.,  -4.,
         -1.,   5.,   1.,  -1.,   7.,  -3.,  -9.,   4.,  -6.,  -7.,   8.,
          4.,  -5.,   5.,  -4.,   5.,   8.,   3.,  -2.,  -3.,   6.,  -4.,
          0.,   3.,  -3.,  -8.,  -6.,   7.,   5.],
       [ -6.,  -3.,   9.,  -1.,   3.,   6.,   1.,  -2.,   4.,  -3.,  -5.,
         -3.,  -1.,   9.,  -6.,   7.,  -4.,  -8.,  -2.,   4.,  -2.,  -2.,
          3.,  -5.,  -8.,  -5.,   1.,  -1.,  -8.,   1.,  -5.,   1.,  -6.,
          1.,   1.,   1.,   0.,  -1.,  -1.,  -3.],
       [ -6.,   4.,  -6.,   1.,  -3.,  -4.,  -1.,  -9.,  -2.,  -6.,  -8.,
          3.,  -8.,  -3.,   7.,   9.,   2.,   7.,   5.,   3.,   9.,   3.,
         -8.,   0.,   8., -10.,  -3.,  -2., -10.,  -1.,  -4., -10.,  -5.,
         -9.,  -2.,   9., -10.,   3.,  -3.,  -2.],
       [  2.,   9.,   2.,  -5.,   1.,   1.,  -1.,   2.,   4.,   8.,   3.,
         -4.,   7.,  -1.,  -2.,   8.,  -1.,  -3.,   6.,   6.,   1.,  -7.,
          3.,   4.,  -9.,  -2.,  -7.,   2.,   0.,  -4.,   9.,   8.,   5.,
         -3.,   6.,   4.,  -7.,  -6.,   3.,   5.],
       [  8.,  -1.,  -4.,   3.,  -1.,   7.,   5.,  -2.,  -9.,   2.,  -6.,
        -10.,  -8.,   4.,   5.,  -7.,  -6.,   5.,   8.,  -5.,   1.,   2.,
        -10.,  -6., -10.,  -4.,  -9.,  -7.,   4.,   2.,  -1.,   6.,   6.,
          6.,  -1.,   6.,   1.,   8.,   4.,  -7.],
       [ -2.,   8.,   0.,   0.,  -7.,  -5.,  -2.,  -5.,  -1.,   6.,   7.,
         -4.,  -3.,   1.,  -9.,   4.,   0.,  -9.,  -8.,   5., -10.,  -5.,
          5.,  -4.,   5.,   2.,  -3.,   8.,   9.,  -8.,   4.,  -1.,   0.,
         -2.,  -2.,  -5., -10.,   2.,   2.,   6.],
       [ -7.,  -5.,   2.,  -3.,   5.,   6.,  -2.,  -4.,   7.,   3.,   2.,
         -8.,   3.,   3.,  -7.,   4.,  -8.,   4.,   1.,  -6.,   8.,   6.,
         -9.,   5.,  -8.,   0.,  -9.,   9.,  -2.,   4.,   7.,   8.,   6.,
         -3.,   6.,   9.,   0.,   0.,   5.,  -7.],
       [  6.,   1.,   9.,   0.,   9.,  -2.,   7.,  -4.,   9.,  -5.,   9.,
         -2.,   1.,   0.,  -6.,   0.,  -2., -10.,  -6.,  -4.,  -2.,   0.,
          8.,   8.,   4.,  -1.,   0.,   2.,  -3.,   7.,  -9.,   4.,  -4.,
         -6.,   4.,  -2.,  -1.,   5.,  -8.,   5.],
       [  9.,   9.,  -6.,  -8.,   3.,   4.,  -7.,  -2.,  -8., -10.,  -8.,
         -7.,   2.,   5.,   6.,   1.,   7.,  -4., -10.,   1.,   4.,  -6.,
        -10.,  -3.,  -6.,   0.,  -3.,   4.,   7.,  -1.,   5.,   5.,   0.,
         -7.,   4.,   4.,  -6.,   8.,   6.,  -6.],
       [ -8.,  -2.,   8.,   1.,  -5.,  -8.,  -3., -10.,  -7.,   1.,   3.,
         -8.,   8.,  -8.,  -3.,  -8.,   0., -10.,   7.,   9.,   1.,   7.,
         -4.,   7.,   5.,  -6.,  -6.,   9.,  -6.,  -2.,   4.,   0., -10.,
         -7.,  -8.,   2.,  -4.,   8.,   7.,   6.],
       [  8.,   2.,  -3.,  -3.,  -9.,  -9.,   2.,  -4.,   8.,   1.,   2.,
          0.,  -9.,   6.,   3.,   8.,  -6.,  -2.,  -1., -10.,   8.,  -1.,
          1.,   9.,  -3.,   0.,  -1.,   5.,  -3.,   3.,  -3.,   9.,   1.,
         -5., -10.,  -1.,  -3.,  -4.,   7.,  -5.]], dtype=float32)>, 'per_arm': <tf.Tensor: shape=(20, 70, 50), dtype=float32, numpy=
array([[[ 5.,  3.,  1., ..., -2., -4., -1.],
        [ 0., -2.,  0., ..., -3., -3.,  0.],
        [ 4., -2.,  1., ..., -6., -3., -5.],
        ...,
        [ 3.,  4., -1., ...,  4., -2., -5.],
        [ 4., -5.,  4., ..., -3.,  1., -3.],
        [-3., -2.,  5., ...,  5., -1.,  3.]],

       [[ 0.,  1., -1., ..., -5., -2., -5.],
        [-1., -5.,  1., ...,  2., -4., -1.],
        [-4.,  1., -1., ...,  3.,  5., -6.],
        ...,
        [ 0.,  3., -1., ...,  2., -2., -3.],
        [ 5.,  0.,  5., ..., -5.,  0.,  1.],
        [-3., -6.,  0., ...,  1.,  3., -5.]],

       [[ 4.,  0., -2., ...,  3., -4.,  1.],
        [ 4.,  1., -2., ..., -4., -4., -1.],
        [ 5.,  4., -6., ...,  3., -3.,  5.],
        ...,
        [ 3.,  0., -4., ..., -2., -1., -3.],
        [ 1.,  5.,  3., ..., -2., -3.,  0.],
        [ 5.,  5.,  0., ...,  3., -6.,  2.]],

       ...,

       [[-4., -1., -3., ..., -6.,  5.,  2.],
        [-4., -4., -2., ..., -4.,  1.,  1.],
        [-2.,  3.,  0., ..., -2., -3., -4.],
        ...,
        [ 1.,  0.,  5., ...,  3., -2.,  3.],
        [-3.,  1.,  0., ...,  1., -5.,  0.],
        [-6., -3., -4., ...,  4.,  0.,  5.]],

       [[ 2., -3., -3., ...,  4., -4., -6.],
        [ 3.,  2., -3., ...,  2., -5., -1.],
        [ 2., -3.,  1., ...,  5., -5., -2.],
        ...,
        [ 5., -3.,  0., ..., -6., -5.,  5.],
        [ 4.,  4., -1., ..., -2., -3., -5.],
        [ 4.,  3.,  3., ..., -1., -5., -2.]],

       [[ 1., -3., -3., ..., -5., -4., -1.],
        [ 5.,  3., -4., ..., -6.,  1., -3.],
        [-4., -6., -3., ...,  2., -4.,  3.],
        ...,
        [-1.,  4.,  3., ...,  3., -2.,  4.],
        [-6., -5.,  4., ...,  1.,  0.,  5.],
        [ 5.,  0.,  4., ...,  1.,  1., -1.]]], dtype=float32)>}

Rewards after taking an action:  tf.Tensor(
[ 349.21698  -231.26328   236.99551   -35.370384  132.45038   -48.371754
  279.89905   311.39346   557.91455    33.078026  -90.893456   57.347527
 -238.55692   530.80756  -405.56125  -117.39989  -380.8877    -23.846714
 -135.49667    68.06569 ], shape=(20,), dtype=float32)

観測仕様は、次の2つの要素を持つ辞書であることがわかります。

  • キーの一つの'global' :これは、形状パラメータのマッチングで、グローバルコンテキストの一部であるGLOBAL_DIM
  • 鍵と一'per_arm' :これはあたりアーム文脈であり、その形状は[NUM_ACTIONS, PER_ARM_DIM]この部分は、タイムステップ内のすべてのアームのアーム機能のプレースホルダーです。

LinUCBエージェント

LinUCBエージェントは、同じ名前のBanditアルゴリズムを実装します。このアルゴリズムは、線形報酬関数のパラメーターを推定すると同時に、推定値の周囲の信頼楕円体を維持します。エージェントは、パラメーターが信頼楕円体内にあると仮定して、予想される報酬が最も高いアームを選択します。

エージェントを作成するには、観察とアクションの仕様に関する知識が必要です。エージェントを定義するとき、私たちは、ブール・パラメータが設定さaccepts_per_arm_featuresに設定True

observation_spec = per_arm_tf_env.observation_spec()
time_step_spec = ts.time_step_spec(observation_spec)
action_spec = tensor_spec.BoundedTensorSpec(
    dtype=tf.int32, shape=(), minimum=0, maximum=NUM_ACTIONS - 1)

agent = lin_ucb_agent.LinearUCBAgent(time_step_spec=time_step_spec,
                                     action_spec=action_spec,
                                     accepts_per_arm_features=True)

トレーニングデータの流れ

このセクションでは、アームごとの機能がポリシーからトレーニングにどのように移行するかについての仕組みを簡単に説明します。次のセクション(後悔指標の定義)にジャンプして、興味があれば後でここに戻ってください。

まず、エージェントのデータ仕様を見てみましょう。 training_data_specトレーニングデータが持つべき要素と構造エージェントの指定の属性。

print('training data spec: ', agent.training_data_spec)
training data spec:  Trajectory(
{'action': BoundedTensorSpec(shape=(), dtype=tf.int32, name=None, minimum=array(0, dtype=int32), maximum=array(69, dtype=int32)),
 'discount': BoundedTensorSpec(shape=(), dtype=tf.float32, name='discount', minimum=array(0., dtype=float32), maximum=array(1., dtype=float32)),
 'next_step_type': TensorSpec(shape=(), dtype=tf.int32, name='step_type'),
 'observation': {'global': TensorSpec(shape=(40,), dtype=tf.float32, name=None)},
 'policy_info': PerArmPolicyInfo(log_probability=(), predicted_rewards_mean=(), multiobjective_scalarized_predicted_rewards_mean=(), predicted_rewards_optimistic=(), predicted_rewards_sampled=(), bandit_policy_type=(), chosen_arm_features=TensorSpec(shape=(50,), dtype=tf.float32, name=None)),
 'reward': TensorSpec(shape=(), dtype=tf.float32, name='reward'),
 'step_type': TensorSpec(shape=(), dtype=tf.int32, name='step_type')})

我々はに近い見ている場合はobservation仕様の一部を、我々はそれがあたり、腕の機能が含まれていないことを参照してください!

print('observation spec in training: ', agent.training_data_spec.observation)
observation spec in training:  {'global': TensorSpec(shape=(40,), dtype=tf.float32, name=None)}

アームごとの機能はどうなりましたか?この質問に答えるために、まず私たちはLinUCBエージェントの列車が、それはすべての腕のあたりのアームの機能を必要としないとき、それが唯一選ばれた腕のそれらを必要とすることに注意してください。したがって、形状のテンソルをドロップすることは理にかなって[BATCH_SIZE, NUM_ACTIONS, PER_ARM_DIM]それはアクションの数が多い場合は特に、非常に無駄であるように、。

しかし、それでも、選択したアームのアームごとの機能はどこかにあるはずです!この目的のために、我々は確認してLinUCBポリシー店その内の選ばれたアームの機能policy_infoトレーニングデータのフィールド:

print('chosen arm features: ', agent.training_data_spec.policy_info.chosen_arm_features)
chosen arm features:  TensorSpec(shape=(50,), dtype=tf.float32, name=None)

我々はその形状から見chosen_arm_featuresフィールドは、一方のアームの唯一の特徴ベクトルを持っており、それは、選択されたアームになります。そのノートpolicy_info 、およびそれにchosen_arm_features私たちがトレーニングデータの仕様を検査から見たように、トレーニングデータの一部であり、したがって、それは、トレーニング時に使用できます。

後悔指標の定義

トレーニングループを開始する前に、エージェントの後悔を計算するのに役立ついくつかの効用関数を定義します。これらの関数は、一連のアクション(アームの機能によって与えられる)とエージェントから隠されている線形パラメーターを指定して、最適な期待報酬を決定するのに役立ちます。

def _all_rewards(observation, hidden_param):
  """Outputs rewards for all actions, given an observation."""
  hidden_param = tf.cast(hidden_param, dtype=tf.float32)
  global_obs = observation['global']
  per_arm_obs = observation['per_arm']
  num_actions = tf.shape(per_arm_obs)[1]
  tiled_global = tf.tile(
      tf.expand_dims(global_obs, axis=1), [1, num_actions, 1])
  concatenated = tf.concat([tiled_global, per_arm_obs], axis=-1)
  rewards = tf.linalg.matvec(concatenated, hidden_param)
  return rewards

def optimal_reward(observation):
  """Outputs the maximum expected reward for every element in the batch."""
  return tf.reduce_max(_all_rewards(observation, reward_param), axis=1)

regret_metric = tf_bandit_metrics.RegretMetric(optimal_reward)

これで、盗賊のトレーニングループを開始する準備が整いました。以下のドライバーは、ポリシーを使用したアクションの選択、選択したアクションの報酬のリプレイバッファーへの保存、事前定義された後悔メトリックの計算、およびエージェントのトレーニングステップの実行を処理します。

num_iterations = 20 # @param
steps_per_loop = 1 # @param

replay_buffer = tf_uniform_replay_buffer.TFUniformReplayBuffer(
    data_spec=agent.policy.trajectory_spec,
    batch_size=BATCH_SIZE,
    max_length=steps_per_loop)

observers = [replay_buffer.add_batch, regret_metric]

driver = dynamic_step_driver.DynamicStepDriver(
    env=per_arm_tf_env,
    policy=agent.collect_policy,
    num_steps=steps_per_loop * BATCH_SIZE,
    observers=observers)

regret_values = []

for _ in range(num_iterations):
  driver.run()
  loss_info = agent.train(replay_buffer.gather_all())
  replay_buffer.clear()
  regret_values.append(regret_metric.result())
WARNING:tensorflow:From /tmp/ipykernel_11710/1190294793.py:21: ReplayBuffer.gather_all (from tf_agents.replay_buffers.replay_buffer) is deprecated and will be removed in a future version.
Instructions for updating:
Use `as_dataset(..., single_deterministic_pass=True)` instead.

結果を見てみましょう。すべてが正しく行われた場合、エージェントは線形報酬関数を適切に推定できるため、ポリシーは、期待される報酬が最適なものに近いアクションを選択できます。これは、上で定義した後悔の指標によって示されます。この指標は低下し、ゼロに近づきます。

plt.plot(regret_values)
plt.title('Regret of LinUCB on the Linear per-arm environment')
plt.xlabel('Number of Iterations')
_ = plt.ylabel('Average Regret')

png

次は何ですか?

上記の例では、されて実装されますを含む、同様に他の薬剤から選択することができます私たちのコードベースにニューラルイプシロン-貪欲エージェント