TensorFlow Agents और Flutter के साथ मिलकर बोर्ड गेम बनाना

1. शुरू करने से पहले

AlphaGo और AlphaStar की शानदार सफलता ने मशीन लर्निंग के इस्तेमाल से, सुपरह्यूमन-लेवल के गेम एजेंट बनाने की क्षमता को दिखाया. यह एक छोटा सा गेम है, जिसे मशीन लर्निंग का इस्तेमाल करके बनाया जाता है. इससे अपने ताकतवर गेम एजेंट बनाने के लिए ज़रूरी स्किल सीखी जा सकती हैं.

इस कोडलैब में, आपको इन चीज़ों का इस्तेमाल करके बोर्ड गेम बनाने का तरीका पता चलेगा:

• गेम एजेंट को रीइन्फ़ोर्समेंट लर्निंग के लिए ट्रेनिंग देने के लिए TensorFlow एजेंट
• मॉडल को पूरा करने के लिए TensorFlow की सेवा
• क्रॉस-प्लैटफ़ॉर्म बोर्ड गेम ऐप्लिकेशन बनाने के लिए Flutter

ज़रूरी शर्तें

• Dart के साथ Flutter के विकास की बुनियादी जानकारी
• TensorFlow की मदद से मशीन लर्निंग की बुनियादी जानकारी, जैसे कि ट्रेनिंग बनाम डिप्लॉयमेंट
• Python, टर्मिनल, और Docker की बुनियादी जानकारी

आप इन चीज़ों के बारे में जानेंगे

• TensorFlow एजेंट का इस्तेमाल करके, नॉन-प्लेयर कैरेक्टर (एनपीसी) एजेंट को ट्रेनिंग देने का तरीका
• TensorFlow Serving का इस्तेमाल करके, ट्रेन किए गए मॉडल को इस्तेमाल करने का तरीका
• क्रॉस-प्लैटफ़ॉर्म Flutter बोर्ड गेम बनाने का तरीका

आपको इनकी ज़रूरत होगी

• Flutter का SDK टूल
• Flutter के लिए Android और iOS सेटअप
• Flutter के लिए डेस्कटॉप सेटअप
• Flutter के लिए वेब सेटअप
• Flutter और Dart के लिए विज़ुअल स्टूडियो कोड (वीएस कोड) का सेटअप
• डॉकर
• बैश
• Python 3.7 और उसके बाद के वर्शन

2. The Plane Strike गेम

इस कोडलैब में बनाए गए गेम को 'प्लेन स्ट्राइक' कहा जाता है. यह दो खिलाड़ियों वाला एक छोटा बोर्ड गेम है, जो 'बैटलशिप' बोर्ड गेम से मिलता-जुलता है. नियम बहुत आसान हैं:

• खिलाड़ी एक ऐसे एनपीसी एजेंट से खेल रहा है जिसे मशीन लर्निंग ने ट्रेनिंग दी है. खिलाड़ी, एजेंट के बोर्ड में किसी भी सेल पर टैप करके गेम शुरू कर सकता है.
• गेम की शुरुआत में, खिलाड़ी और एजेंट, दोनों के पास एक 'प्लेन' होता है ऑब्जेक्ट (8 हरे रंग की सेल, जो एक 'प्लेन' बनाती हैं, जैसा कि नीचे दिए गए ऐनिमेशन में दिखाया गया है) और उनके खुद के बोर्ड पर मौजूद हैं; ये 'प्लेन' टेबल को किसी भी क्रम में लगाया जा सकता है और ये सिर्फ़ बोर्ड के मालिकों को दिख सकते हैं और विरोधियों से छिपा दिए जाते हैं.
• खिलाड़ी और एजेंट, बारी-बारी से एक-दूसरे के बोर्ड के एक सेल पर हमला करते हैं. खिलाड़ी, एजेंट के बोर्ड में किसी भी सेल पर टैप कर सकता है. इस दौरान, एजेंट अपने-आप मशीन लर्निंग मॉडल के अनुमान के हिसाब से विकल्प चुनता है. प्रयास किया गया सेल लाल हो जाता है यदि यह एक 'प्लेन' है सेल (‘hit'); ऐसा न होने पर, यह पीला (‘चूक’) हो जाता है.
• जो भी पहले आठ रेड सेल हासिल करता है वह गेम जीत जाता है; इसके बाद, गेम नए बोर्ड के साथ रीस्टार्ट किया जाता है.

यहां इस गेम के गेमप्ले का उदाहरण दिया गया है:

3. Flutter डेवलपमेंट एनवायरमेंट को सेट अप करें

Flutter डेवलपमेंट के लिए आपको इस कोडलैब को पूरा करने के लिए दो सॉफ़्टवेयर की ज़रूरत होगी—Flutter SDK टूल और एडिटर.

इनमें से किसी भी डिवाइस का इस्तेमाल करके, कोडलैब चलाया जा सकता है:

• iOS सिम्युलेटर (Xcode टूल इंस्टॉल करना ज़रूरी है).
• Android Emulator (Android Studio में सेटअप करना ज़रूरी है).
• ब्राउज़र (डीबग करने के लिए Chrome ज़रूरी है).
• Windows, Linux या macOS डेस्कटॉप ऐप्लिकेशन के तौर पर. आपको उस प्लैटफ़ॉर्म पर गेम बनाना होगा जहां आपको इसे डिप्लॉय करना है. इसलिए, अगर आपको Windows डेस्कटॉप ऐप्लिकेशन डेवलप करना है, तो आपको सही बिल्ड चेन ऐक्सेस करने के लिए Windows पर डेवलप करना होगा. ऑपरेटिंग सिस्टम से जुड़ी कुछ खास शर्तें हैं, जिनके बारे में docs.flutter.dev/desktop पर जानकारी दी गई है.

4. सेट अप करें

इस कोडलैब का कोड डाउनलोड करने के लिए:

1. इस कोडलैब के लिए, GitHub रिपॉज़िटरी पर जाएं.
2. कोड > पर क्लिक करें इस कोडलैब के लिए सभी कोड डाउनलोड करने के लिए, पिन कोड डाउनलोड करें.

3. डाउनलोड की गई ZIP फ़ाइल को अनज़िप करके, codelabs-main रूट फ़ोल्डर को अपनी ज़रूरत के सभी संसाधनों के साथ अनपैक करें.

इस कोडलैब के लिए, आपको रिपॉज़िटरी की tfagents-flutter/ सबडायरेक्ट्री में मौजूद फ़ाइलों की ज़रूरत होगी. सबडायरेक्ट्री में एक से ज़्यादा फ़ोल्डर होते हैं:

• step0 से step6 फ़ोल्डर में वह स्टार्टर कोड होता है जिसे आपने इस कोडलैब के हर चरण के लिए बनाया है.
• finished फ़ोल्डर में, तैयार हो चुके सैंपल ऐप्लिकेशन का पूरा कोड शामिल होता है.
• हर फ़ोल्डर में एक backbend सब-फ़ोल्डर होता है, जिसमें बैकएंड कोड और frontend सब-फ़ोल्डर होता है. इस सब-फ़ोल्डर में Flutter फ़्रंटएंड कोड भी शामिल होता है

5. प्रोजेक्ट के लिए डिपेंडेंसी डाउनलोड करें

बैकएंड

अपना टर्मिनल खोलें और tfagents-flutter सब-फ़ोल्डर में जाएं. इन्हें चलाएं:

pip install -r requirements.txt

फ़्रंटएंड

1. बनाम कोड में, फ़ाइल > फ़ोल्डर खोलें और फिर उस सोर्स कोड से step0 फ़ोल्डर चुनें जिसे आपने पहले डाउनलोड किया था.
2. step0/frontend/lib/main.dart फ़ाइल खोलें. अगर आपको 'VS कोड' डायलॉग दिखता है, जिसमें आपसे स्टार्टर ऐप्लिकेशन के लिए ज़रूरी पैकेज डाउनलोड करने के लिए कहा जाता है, तो पैकेज पाएं पर क्लिक करें.
3. अगर आपको यह डायलॉग नहीं दिखता है, तो अपना टर्मिनल खोलें. इसके बाद, step0/frontend फ़ोल्डर में flutter pub get कमांड चलाएं.

6. चरण 0: स्टार्टर ऐप्लिकेशन चलाएं

1. step0/frontend/lib/main.dart फ़ाइल को बनाम कोड में खोलें. पक्का करें कि Android Emulator या iOS Simulator सही तरीके से सेट अप किया गया है और वह स्टेटस बार में दिखता है.

उदाहरण के लिए, Android Emulator के साथ Pixel 5 का इस्तेमाल करने पर आपको यह दिखता है:

iOS सिम्युलेटर के साथ iPhone 13 का इस्तेमाल करने पर आपको यह दिखता है:

2. डीबग करना शुरू करें पर क्लिक करें.

ध्यान दें: इस कोडलैब के लिए, यह माना जाता है कि मॉडल को अपने लोकल कंप्यूटर पर डिप्लॉय किया जाता है. अगर मॉडल को किसी दूसरी रिमोट मशीन पर डिप्लॉय किया जाता है, तो कोड में मौजूद 10.0.2.2 या 127.0.0.1 आईपी पते को रिमोट मशीन के आईपी पते से बदलें. यह मशीन, TensorFlow की सेवा देती है.

ऐप्लिकेशन चलाएं और उसे एक्सप्लोर करें

ऐप्लिकेशन आपके Android Emulator या iOS Simulator पर लॉन्च होना चाहिए. इसका यूज़र इंटरफ़ेस (यूआई) काफ़ी आसान है. यहां दो गेम बोर्ड हैं; एजेंट के बोर्ड में सबसे ऊपर, स्ट्राइक पोज़िशन के तौर पर मौजूद किसी भी सेल पर टैप किया जा सकता है. खिलाड़ी के बोर्ड के आधार पर, आप एक स्मार्ट एजेंट को अपने-आप यह अनुमान लगाने की ट्रेनिंग देंगे कि उसे कहां हमला करना है.

हुड के तहत, Flutter ऐप्लिकेशन खिलाड़ी के मौजूदा बोर्ड को बैकएंड पर भेजेगा. यह बोर्ड रीइन्फ़ोर्समेंट लर्निंग मॉडल चलाता है और अगले स्ट्राइक के लिए सेल की अनुमानित पोज़िशन दिखाता है. जवाब मिलने के बाद, फ़्रंटएंड, यूज़र इंटरफ़ेस (यूआई) में नतीजे दिखाएगा.

अब एजेंट के बोर्ड में किसी भी सेल पर क्लिक करने पर, कुछ नहीं होता है, क्योंकि ऐप्लिकेशन अभी बैकएंड से कनेक्ट नहीं कर सकता.

7. पहला चरण: TensorFlow Agents Python का एनवायरमेंट बनाना

इस कोडलैब का मुख्य मकसद ऐसा एजेंट डिज़ाइन करना है जो किसी एनवायरमेंट से इंटरैक्ट करके सीखता है. हालांकि, Plane Strike गेम थोड़ा आसान है और इसके ज़रिए एनपीसी एजेंट के लिए नियम बनाए जा सकते हैं, लेकिन एजेंट को ट्रेनिंग देने के लिए रीइन्फ़ोर्समेंट लर्निंग का इस्तेमाल किया जा सकता है, ताकि नई स्किल सीखी जा सकें और आने वाले समय में दूसरे गेम के लिए आसानी से एजेंट बनाए जा सकें.

स्टैंडर्ड रीइन्फ़ोर्समेंट लर्निंग (आरएल) सेटिंग में, एजेंट को हर कदम पर एक निगरानी मिलती है और वह कोई कार्रवाई चुनता है. यह कार्रवाई पर्यावरण पर लागू की जाती है और एनवायरमेंट के ज़रिए एक इनाम और एक नई निगरानी मिलती है. एजेंट, एक नीति तैयार करता है, ताकि इनामों का ज़्यादा से ज़्यादा फ़ायदा पाने के लिए कार्रवाइयां की जा सकें. इसे रिटर्न भी कहा जाता है. कई बार गेम खेलकर, एजेंट पैटर्न समझ पाता है और गेम में महारत हासिल करने का अपना हुनर निखारता है. प्लेन स्ट्राइक गेम को एक आरएल समस्या के तौर पर तैयार करने के लिए, बोर्ड की स्थिति को निगरानी, कार्रवाई के तौर पर स्ट्राइक की पोज़िशन, और हिट/मिस सिग्नल को इनाम के तौर पर देखने के लिए देखें.

ध्यान दें: रीइन्फ़ोर्समेंट लर्निंग के बारे में गहराई से बातचीत करने के लिए, कृपया DeepMind और UCL की ओर से रीइन्फ़ोर्समेंट लर्निंग लेक्चर सीरीज़ 2021 देखें.

NPC एजेंट को ट्रेनिंग देने के लिए, TensorFlow Agents की मदद ली जाती है. यह TensorFlow के लिए बनी भरोसेमंद, इस्तेमाल में आसान, और बढ़ाने लायक लर्निंग लाइब्रेरी है.

TF एजेंट, रीइन्फ़ोर्समेंट लर्निंग के लिए एक बेहतरीन विकल्प है. इसकी वजह यह है कि इसमें कोडलैब का एक बड़ा सेट, उदाहरण, और काफ़ी दस्तावेज़ दिए गए हैं, ताकि आप शुरुआत कर सकें. TF Agents का इस्तेमाल करके, RL से जुड़ी मुश्किल समस्याओं को हल किया जा सकता है. इन समस्याओं को बड़े स्तर पर इस्तेमाल किया जा सकता है. साथ ही, इससे RL के नए एल्गोरिदम भी जल्दी तैयार किए जा सकते हैं. एक्सपेरिमेंट के लिए, अलग-अलग एजेंट और एल्गोरिदम के बीच आसानी से स्विच किया जा सकता है. इसे अच्छी तरह से टेस्ट किया गया है और इसे कॉन्फ़िगर करना भी आसान है.

OpenAI जिम में पहले से बने कई गेम एनवायरमेंट मौजूद हैं (जैसे, Atari गेम), Mujuco वगैरह. इनका इस्तेमाल TF Agents आसानी से कर सकते हैं. हालांकि, Plane Strike गेम पूरी तरह से आपकी पसंद के मुताबिक बनाया गया गेम है, इसलिए आपको सबसे पहले गेम को अपने हिसाब से सेट करना होगा.

ध्यान दें: TensorFlow के एजेंट के बारे में ज़्यादा जानने के लिए, TensorFlow एजेंट का ट्यूटोरियल देखें.

TF Agents Python एनवायरमेंट लागू करने के लिए, आपको ये तरीके लागू करने होंगे:

class YourGameEnv(py_environment.PyEnvironment):

  def __init__(self):
    """Initialize environment."""


  def action_spec(self):
    """Return action_spec."""


  def observation_spec(self):
    """Return observation_spec."""


  def _reset(self):
    """Return initial_time_step."""


  def _step(self, action):
    """Apply action and return new time_step."""

_step() फ़ंक्शन सबसे ज़रूरी है, जो कार्रवाई करता है और नया time_step ऑब्जेक्ट दिखाता है. प्लेन स्ट्राइक गेम के मामले में, आपके पास एक गेम बोर्ड होगा; जब गेम बोर्ड की स्थिति के आधार पर कोई नई स्ट्राइक मिलती है, तो एनवायरमेंट का यह पता चलता है:

• गेम बोर्ड आगे कैसा दिखना चाहिए (छिपे हुए मैदान की जगह के आधार पर, क्या सेल का रंग लाल या पीले में बदलना चाहिए?)
• उस पद के लिए खिलाड़ी को क्या इनाम मिलना चाहिए (इनाम देना या पेनल्टी छोड़ना चाहिए?)
• क्या गेम खत्म हो जाना चाहिए (क्या कोई जीत गया?)
• _planestrike_py_environment.py फ़ाइल के _step() फ़ंक्शन में, यह कोड जोड़ें:

if self._hit_count == self._plane_size:
    self._episode_ended = True
    return self.reset()

if self._strike_count + 1 == self._max_steps:
    self.reset()
    return ts.termination(
        np.array(self._visible_board, dtype=np.float32), UNFINISHED_GAME_REWARD
    )

self._strike_count += 1
action_x = action // self._board_size
action_y = action % self._board_size
# Hit
if self._hidden_board[action_x][action_y] == HIDDEN_BOARD_CELL_OCCUPIED:
    # Non-repeat move
    if self._visible_board[action_x][action_y] == VISIBLE_BOARD_CELL_UNTRIED:
        self._hit_count += 1
        self._visible_board[action_x][action_y] = VISIBLE_BOARD_CELL_HIT
        # Successful strike
        if self._hit_count == self._plane_size:
            # Game finished
            self._episode_ended = True
            return ts.termination(
                np.array(self._visible_board, dtype=np.float32),
                FINISHED_GAME_REWARD,
            )
        else:
            self._episode_ended = False
            return ts.transition(
                np.array(self._visible_board, dtype=np.float32),
                HIT_REWARD,
                self._discount,
            )
    # Repeat strike
    else:
        self._episode_ended = False
        return ts.transition(
            np.array(self._visible_board, dtype=np.float32),
            REPEAT_STRIKE_REWARD,
            self._discount,
        )
# Miss
else:
    # Unsuccessful strike
    self._episode_ended = False
    self._visible_board[action_x][action_y] = VISIBLE_BOARD_CELL_MISS
    return ts.transition(
        np.array(self._visible_board, dtype=np.float32),
        MISS_REWARD,
        self._discount,

8. दूसरा चरण: TensorFlow के एजेंट की मदद से, गेम एजेंट को ट्रेनिंग दें

TF Agents एनवायरमेंट की मदद से, गेम एजेंट को ट्रेनिंग दी जा सकती है. इस कोडलैब के लिए, REINFORCE एजेंट का इस्तेमाल किया जाता है. REINFORCE, RL में पॉलिसी ग्रेडिएंट एल्गोरिदम है. इसका बुनियादी आइडिया यह है कि गेमप्ले के दौरान इकट्ठा किए गए इनाम के सिग्नल के आधार पर, पॉलिसी न्यूरल नेटवर्क के पैरामीटर में बदलाव किया जाए. इससे पॉलिसी नेटवर्क को आने वाले समय में होने वाले गेम के मुकाबले ज़्यादा रिटर्न मिल पाएगा.

• सबसे पहले, आपको ट्रेनिंग और आकलन वाले माहौल को इंस्टैंशिएट करना होगा. step2/backend/training.py फ़ाइल के train_agent() फ़ंक्शन में यह कोड जोड़ें:

train_py_env = planestrike_py_environment.PlaneStrikePyEnvironment(
    board_size=BOARD_SIZE, discount=DISCOUNT, max_steps=BOARD_SIZE**2
)
eval_py_env = planestrike_py_environment.PlaneStrikePyEnvironment(
    board_size=BOARD_SIZE, discount=DISCOUNT, max_steps=BOARD_SIZE**2
)

train_env = tf_py_environment.TFPyEnvironment(train_py_env)
eval_env = tf_py_environment.TFPyEnvironment(eval_py_env)

• इसके बाद, आपको एक रीइन्फ़ोर्समेंट लर्निंग एजेंट बनाना होगा, जिसे ट्रेनिंग दी जाएगी. इस कोडलैब में, REINFORCE एजेंट का इस्तेमाल किया जाता है, जो कि नीति पर आधारित एजेंट होता है. ऊपर दिए गए कोड के ठीक नीचे यह कोड जोड़ें:

actor_net = tfa.networks.Sequential(
    [
        tfa.keras_layers.InnerReshape([BOARD_SIZE, BOARD_SIZE], [BOARD_SIZE**2]),
        tf.keras.layers.Dense(FC_LAYER_PARAMS, activation="relu"),
        tf.keras.layers.Dense(BOARD_SIZE**2),
        tf.keras.layers.Lambda(lambda t: tfp.distributions.Categorical(logits=t)),
    ],
    input_spec=train_py_env.observation_spec(),
)

optimizer = tf.keras.optimizers.Adam(learning_rate=LEARNING_RATE)

train_step_counter = tf.Variable(0)

tf_agent = reinforce_agent.ReinforceAgent(
    train_env.time_step_spec(),
    train_env.action_spec(),
    actor_network=actor_net,
    optimizer=optimizer,
    normalize_returns=True,
    train_step_counter=train_step_counter,
)

• आखिर में, ट्रेनिंग लूप में एजेंट को ट्रेनिंग दें. लूप में, सबसे पहले गेम प्ले के कुछ एपिसोड बफ़र में जमा किए जाते हैं. इसके बाद, बफ़र किए गए डेटा की मदद से एजेंट को ट्रेनिंग दी जाती है. step2/backend/training.py फ़ाइल के train_agent() फ़ंक्शन में यह कोड जोड़ें:

# Collect a few episodes using collect_policy and save to the replay buffer.
collect_episode(
    train_py_env,
    collect_policy,
    COLLECT_EPISODES_PER_ITERATION,
    replay_buffer_observer,
)

# Use data from the buffer and update the agent's network.
iterator = iter(replay_buffer.as_dataset(sample_batch_size=1))
trajectories, _ = next(iterator)
tf_agent.train(experience=trajectories)
replay_buffer.clear()

• अब आप ट्रेनिंग शुरू कर सकते हैं. अपने टर्मिनल में, कंप्यूटर पर step2/backend फ़ोल्डर में जाकर यह चलाएं:

python training.py

आपके हार्डवेयर कॉन्फ़िगरेशन के आधार पर, ट्रेनिंग खत्म होने में 8 से 12 घंटे लगते हैं. आपको पूरी ट्रेनिंग खुद पूरी करने की ज़रूरत नहीं है, क्योंकि step3 में पहले से ट्रेनिंग वाला मॉडल दिया जाता है. इस दौरान, TensorBoard की मदद से प्रोग्रेस को मॉनिटर किया जा सकता है. एक नया टर्मिनल खोलें, अपने कंप्यूटर पर step2/backend फ़ोल्डर में जाएं और चलाएं:

tensorboard --logdir tf_agents_log/

tf_agents_log वह फ़ोल्डर है जिसमें ट्रेनिंग लॉग होता है. ट्रेनिंग रन का सैंपल कुछ इस तरह है:

ट्रेनिंग के आगे बढ़ने के साथ-साथ, एपिसोड की औसत लंबाई और औसत रिटर्न बढ़ते हुए दिखते हैं. आप आसानी से यह समझ सकते हैं कि अगर एजेंट ज़्यादा समझदार है और बेहतर अनुमान लगाता है, तो गेम की अवधि छोटी हो जाती है और एजेंट ज़्यादा इनाम इकट्ठा करता है. इसकी वजह यह है कि एजेंट कम चरणों में गेम को खत्म करना चाहता है, ताकि बाद के चरणों में इनाम पर भारी छूट को कम से कम रखा जा सके.

ट्रेनिंग पूरी होने के बाद, ट्रेन किए गए मॉडल को policy_model फ़ोल्डर में एक्सपोर्ट कर दिया जाता है.

ध्यान दें: TensorFlow के एजेंट के साथ REINFORCE एजेंट को ट्रेनिंग देने के बारे में ज़्यादा जानने के लिए, TensorFlow एजेंट का यह ट्यूटोरियल देखें.

9. तीसरा चरण: TensorFlow की मदद से, ट्रेन किए गए मॉडल को डिप्लॉय करना

आपने गेम एजेंट को ट्रेनिंग दे दी है, अब इसे TensorFlow Serving के साथ डिप्लॉय किया जा सकता है.

ध्यान दें: आपकी सुविधा के लिए, पहले से ट्रेन किया गया सेव मॉडल, step3/policy_model फ़ोल्डर में दिया गया है.

• अपने टर्मिनल में, कंप्यूटर पर step3/backend फ़ोल्डर में जाएं और Docker की मदद से TensorFlow की सेवा देना शुरू करें:

docker run -t --rm -p 8501:8501 -p 8500:8500 -v "$(pwd)/backend/policy_model:/models/policy_model" -e MODEL_NAME=policy_model tensorflow/serving

Docker, पहले TensorFlow Serving इमेज को अपने-आप डाउनलोड करता है. इसमें एक मिनट लगता है. इसके बाद, TensorFlow की सेवा शुरू हो जाएगी. लॉग इस कोड स्निपेट की तरह दिखना चाहिए:

2022-05-30 02:38:54.147771: I tensorflow_serving/model_servers/server.cc:89] Building single TensorFlow model file config:  model_name: policy_model model_base_path: /models/policy_model
2022-05-30 02:38:54.148222: I tensorflow_serving/model_servers/server_core.cc:465] Adding/updating models.
2022-05-30 02:38:54.148273: I tensorflow_serving/model_servers/server_core.cc:591]  (Re-)adding model: policy_model
2022-05-30 02:38:54.262684: I tensorflow_serving/core/basic_manager.cc:740] Successfully reserved resources to load servable {name: policy_model version: 123}
2022-05-30 02:38:54.262768: I tensorflow_serving/core/loader_harness.cc:66] Approving load for servable version {name: policy_model version: 123}
2022-05-30 02:38:54.262787: I tensorflow_serving/core/loader_harness.cc:74] Loading servable version {name: policy_model version: 123}
2022-05-30 02:38:54.265010: I external/org_tensorflow/tensorflow/cc/saved_model/reader.cc:38] Reading SavedModel from: /models/policy_model/123
2022-05-30 02:38:54.277811: I external/org_tensorflow/tensorflow/cc/saved_model/reader.cc:90] Reading meta graph with tags { serve }
2022-05-30 02:38:54.278116: I external/org_tensorflow/tensorflow/cc/saved_model/reader.cc:132] Reading SavedModel debug info (if present) from: /models/policy_model/123
2022-05-30 02:38:54.280229: I external/org_tensorflow/tensorflow/core/platform/cpu_feature_guard.cc:142] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 FMA
To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.
2022-05-30 02:38:54.332352: I external/org_tensorflow/tensorflow/cc/saved_model/loader.cc:206] Restoring SavedModel bundle.
2022-05-30 02:38:54.337000: I external/org_tensorflow/tensorflow/core/platform/profile_utils/cpu_utils.cc:114] CPU Frequency: 2193480000 Hz
2022-05-30 02:38:54.402803: I external/org_tensorflow/tensorflow/cc/saved_model/loader.cc:190] Running initialization op on SavedModel bundle at path: /models/policy_model/123
2022-05-30 02:38:54.410707: I external/org_tensorflow/tensorflow/cc/saved_model/loader.cc:277] SavedModel load for tags { serve }; Status: success: OK. Took 145695 microseconds.
2022-05-30 02:38:54.412726: I tensorflow_serving/servables/tensorflow/saved_model_warmup_util.cc:59] No warmup data file found at /models/policy_model/123/assets.extra/tf_serving_warmup_requests
2022-05-30 02:38:54.417277: I tensorflow_serving/core/loader_harness.cc:87] Successfully loaded servable version {name: policy_model version: 123}
2022-05-30 02:38:54.419846: I tensorflow_serving/model_servers/server_core.cc:486] Finished adding/updating models
2022-05-30 02:38:54.420066: I tensorflow_serving/model_servers/server.cc:367] Profiler service is enabled
2022-05-30 02:38:54.428339: I tensorflow_serving/model_servers/server.cc:393] Running gRPC ModelServer at 0.0.0.0:8500 ...
[warn] getaddrinfo: address family for nodename not supported
2022-05-30 02:38:54.431620: I tensorflow_serving/model_servers/server.cc:414] Exporting HTTP/REST API at:localhost:8501 ...
[evhttp_server.cc : 245] NET_LOG: Entering the event loop ...

ध्यान दें: TensorFlow की सेवा देने वाले डॉकर इमेज को शुरू करने के बाद, इनपुट और आउटपुट टेंसर की जानकारी की जांच करने के लिए http://localhost:8501/v1/models/&lt;MODEL_NAME&gt;/metadata पर जाएं. इस कोडलैब में, <MODEL_NAME> बदलें policy_model के साथ.

एंडपॉइंट पर सैंपल अनुरोध भेजा जा सकता है, ताकि यह पक्का किया जा सके कि यह उम्मीद के मुताबिक काम कर रहा है या नहीं:

curl -d '{"signature_name":"action","instances":[{"0/discount":0.0,"0/observation":[[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,     0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]],"0/reward":0.0,"0/step_type":0}]}'     -X POST http://localhost:8501/v1/models/policy_model:predict

एंडपॉइंट, बोर्ड के बीच में, अनुमानित पोज़िशन 45 दिखाएगा. यह (5, 5) बोर्ड के बीच में है. अगर आपको जानना है कि पहली स्ट्राइक की पोज़िशन के लिए, बोर्ड का बीच वाला हिस्सा क्यों सही है, तो यह जानने की कोशिश करें.

{
    "predictions": [45]
}

हो गया! आपने एनपीसी एजेंट के लिए अगली स्ट्राइक स्थिति का अनुमान लगाने के लिए एक बैकएंड तैयार कर लिया है..

ध्यान दें: इस खास रीइन्फ़ोर्समेंट लर्निंग मॉडल के लिए, इनपुट में मौजूद discount, reward, और step_type पैरामीटर से कोई फ़र्क़ नहीं पड़ता. ऐसा इसलिए, क्योंकि ये पैरामीटर सिर्फ़ ट्रेनिंग की प्रोसेस पर असर डालते हैं. अनुमान के नतीजे पर असर डालने वाला पैरामीटर सिर्फ़ observation है.

10. चौथा चरण: Android और iOS के लिए Flutter ऐप्लिकेशन बनाना

बैकएंड तैयार है. Flutter ऐप्लिकेशन से स्ट्राइक की पोज़िशन के अनुमान फिर से पाने के लिए, Google को अनुरोध भेजना शुरू किया जा सकता है.

• सबसे पहले, आपको एक ऐसी क्लास तय करनी होगी जो भेजने के लिए इनपुट को रैप करे. step4/frontend/lib/game_agent.dart फ़ाइल में यह कोड जोड़ें:

class Inputs {
  final List<double> _boardState;
  Inputs(this._boardState);

  Map<String, dynamic> toJson() {
    final Map<String, dynamic> data = <String, dynamic>{};
    data['0/discount'] = [0.0];
    data['0/observation'] = [_boardState];
    data['0/reward'] = [0.0];
    data['0/step_type'] = [0];
    return data;
  }
}

अब अनुमान लगाने के लिए, TensorFlow Serving को अनुरोध भेजा जा सकता है.

• step4/frontend/lib/game_agent.dart फ़ाइल के predict() फ़ंक्शन में यह कोड जोड़ें:

var flattenedBoardState = boardState.expand((i) => i).toList();
final response = await http.post(
  Uri.parse('http://$server:8501/v1/models/policy_model:predict'),
  body: jsonEncode(<String, dynamic>{
    'signature_name': 'action',
    'instances': [Inputs(flattenedBoardState)]
  }),
);

if (response.statusCode == 200) {
  var output = List<int>.from(
      jsonDecode(response.body)['predictions'] as List<dynamic>);
  return output[0];
} else {
  throw Exception('Error response');
}

ऐप्लिकेशन को बैकएंड से जवाब मिलने के बाद, गेम के यूज़र इंटरफ़ेस (यूआई) को अपडेट किया जा सकता है, ताकि गेम की प्रोग्रेस देखी जा सके.

• step4/frontend/lib/main.dart फ़ाइल के _gridItemTapped() फ़ंक्शन में यह कोड जोड़ें:

int agentAction =
    await _policyGradientAgent.predict(_playerVisibleBoardState);
_agentActionX = agentAction ~/ _boardSize;
_agentActionY = agentAction % _boardSize;
if (_playerHiddenBoardState[_agentActionX][_agentActionY] ==
    hiddenBoardCellOccupied) {
  // Non-repeat move
  if (_playerVisibleBoardState[_agentActionX][_agentActionY] ==
      visibleBoardCellUntried) {
    _agentHitCount++;
  }
  _playerVisibleBoardState[_agentActionX][_agentActionY] =
      visibleBoardCellHit;
} else {
  _playerVisibleBoardState[_agentActionX][_agentActionY] =
      visibleBoardCellMiss;
}
setState(() {});

इसे चलाएं

1. डीबग करना शुरू करें पर क्लिक करें. इसके बाद, ऐप्लिकेशन के लोड होने का इंतज़ार करें.
2. गेम शुरू करने के लिए, एजेंट के बोर्ड में किसी भी सेल पर टैप करें.

11. पांचवां चरण: डेस्कटॉप प्लैटफ़ॉर्म के लिए Flutter ऐप्लिकेशन चालू करना

Flutter, Android और iOS के अलावा, Linux, Mac, और Windows जैसे डेस्कटॉप प्लैटफ़ॉर्म पर भी काम करता है.

Linux

1. पक्का करें कि VSCode के स्टेटस बार में, टारगेट डिवाइस पर सेट हो.
2. डीबग करना शुरू करें पर क्लिक करें. इसके बाद, ऐप्लिकेशन के लोड होने का इंतज़ार करें.
3. गेम शुरू करने के लिए, एजेंट के बोर्ड में किसी भी सेल पर क्लिक करें.

Mac

1. Mac के लिए आपको सही एनटाइटलमेंट सेट अप करने होंगे, क्योंकि ऐप्लिकेशन, बैकएंड पर एचटीटीपी अनुरोध भेजेगा. ज़्यादा जानकारी के लिए, एनटाइटलमेंट और ऐप्लिकेशन सैंडबॉक्स देखें.

इस कोड को क्रम से step4/frontend/macOS/Runner/DebugProfile.entitlements और step4/frontend/macOS/Runner/Release.entitlements में जोड़ें:

<key>com.apple.security.network.client</key>
<true/>

2. पक्का करें कि VSCode के स्टेटस बार में, टारगेट डिवाइस पर सेट हो.
3. डीबग करना शुरू करें पर क्लिक करें. इसके बाद, ऐप्लिकेशन के लोड होने का इंतज़ार करें.
4. गेम शुरू करने के लिए, एजेंट के बोर्ड में किसी भी सेल पर क्लिक करें.

Windows

1. पक्का करें कि VSCode के स्टेटस बार में, टारगेट डिवाइस पर सेट हो.
2. डीबग करना शुरू करें पर क्लिक करें. इसके बाद, ऐप्लिकेशन के लोड होने का इंतज़ार करें.
3. गेम शुरू करने के लिए, एजेंट के बोर्ड में किसी भी सेल पर क्लिक करें.

12. छठा चरण: वेब प्लैटफ़ॉर्म के लिए Flutter ऐप्लिकेशन चालू करना

इसके अलावा, आपके पास ऐसा करने का एक अन्य तरीका भी है. जैसे, Flutter ऐप्लिकेशन में वेब सहायता जोड़ना. डिफ़ॉल्ट रूप से, वेब प्लैटफ़ॉर्म Flutter ऐप्लिकेशन के लिए अपने-आप चालू रहता है. इसलिए, आपको बस इसे लॉन्च करना होता है.

1. पक्का करें कि VSCode के स्टेटस बार में, टारगेट डिवाइस पर सेट हो.
2. डीबग करना शुरू करें पर क्लिक करें और फिर Chrome ब्राउज़र में ऐप्लिकेशन के लोड होने की इंतज़ार करें.
3. गेम शुरू करने के लिए, एजेंट के बोर्ड में किसी भी सेल पर क्लिक करें.

13. बधाई हो

आपने मशीन प्लेयर के साथ खेलने के लिए, मशीन लर्निंग वाले एजेंट की मदद से बोर्ड गेम ऐप्लिकेशन बनाया है!

ध्यान दें: Flutter में कैज़ुअल गेम टूलकिट उपलब्ध है. इसमें विज्ञापन, साउंड और संगीत, इन-ऐप्लिकेशन खरीदारी वगैरह शामिल हैं. हालांकि, यह कोडलैब टूलकिट का फ़ायदा नहीं लेता, लेकिन अगर आपको अपना गेम बनाना है, तो कैज़ुअल गेम टूलकिट का इस्तेमाल करना बेहतर साबित हो सकता है.

ज़्यादा जानें

• TensorFlow Agents का होम पेज
• TensorFlow Serving का होम पेज
• फ़्लटर होम पेज
• फ़्लटर कैज़ुअल गेम टूलकिट
• TensorFlow की वीडियो सीरीज़ की मदद से, बेहतर तरीके से सीखें
• DeepMind और UCL की ओर से रीइन्फ़ोर्समेंट लर्निंग लेक्चर सीरीज़ 2021