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

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

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

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

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

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

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

आपको क्या सीखने को मिलेगा

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

आपको किन चीज़ों की ज़रूरत होगी

• Flutter SDK
• Flutter के लिए Android और iOS सेटअप करना
• Flutter के लिए डेस्कटॉप सेटअप करना
• Flutter के लिए वेब सेटअप करना
• Flutter और Dart के लिए Visual Studio Code (VS Code) सेटअप करना
• Docker
• Bash
• Python 3.7+

2. The Plane Strike Game

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

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

यहां गेमप्ले का एक सैंपल दिया गया है:

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. VS Code में, File > Open folder पर क्लिक करें. इसके बाद, सोर्स कोड से step0 फ़ोल्डर चुनें. यह वही फ़ोल्डर होना चाहिए जिसे आपने पहले डाउनलोड किया था.
2. step0/frontend/lib/main.dart फ़ाइल खोलें. अगर आपको VS Code का कोई ऐसा डायलॉग दिखता है जिसमें आपको स्टार्टर ऐप्लिकेशन के लिए ज़रूरी पैकेज डाउनलोड करने के लिए कहा गया है, तो Get packages पर क्लिक करें.
3. अगर आपको यह डायलॉग नहीं दिखता है, तो अपना टर्मिनल खोलें. इसके बाद, step0/frontend फ़ोल्डर में flutter pub get कमांड चलाएं.

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

1. VS Code में 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 Serving चलाती है.

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

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

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

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

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

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

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

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

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

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

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

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

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 ऑब्जेक्ट दिखाता है. Plane Strike गेम में, आपके पास एक गेम बोर्ड होता है. जब स्ट्राइक की नई पोज़िशन आती है, तो गेम बोर्ड की स्थिति के आधार पर एनवायरमेंट यह पता लगाता है कि:

• गेम बोर्ड कैसा दिखना चाहिए (क्या छिपे हुए विमान की जगह को देखते हुए, सेल का रंग लाल या पीला होना चाहिए?)
• उस पोज़िशन के लिए खिलाड़ी को कौन-सा इनाम मिलना चाहिए (हिट का इनाम या चूक की पेनल्टी?)
• क्या गेम खत्म हो गया है (क्या कोई जीता?)
• _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 Agents की मदद से गेम एजेंट को ट्रेन करना

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

• सबसे पहले, आपको ट्रेनिंग और आकलन के एनवायरमेंट को इंस्टैंशिएट करना होगा. 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 Agents की मदद से REINFORCE एजेंट को ट्रेन करने के बारे में ज़्यादा जानने के लिए, TensorFlow Agents का यह ट्यूटोरियल देखें.

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

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

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

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

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 Serving शुरू हो जाना चाहिए. लॉग, इस कोड स्निपेट जैसा दिखना चाहिए:

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 Serving की Docker इमेज शुरू करने के बाद, इनपुट और आउटपुट टेंसर की जानकारी देखने के लिए, http://localhost:8501/v1/models/<MODEL_NAME>/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 ऐप्लिकेशन से स्ट्राइक की स्थिति के अनुमानों को वापस पाया जा सके.

• सबसे पहले, आपको एक ऐसी क्लास तय करनी होगी जो भेजे जाने वाले इनपुट को रैप करती हो. 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 ऐप्लिकेशन चालू करना

Android और iOS के अलावा, Flutter डेस्कटॉप प्लैटफ़ॉर्म के साथ भी काम करता है. जैसे, 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 का होम पेज
• Flutter का होम पेज
• Flutter कैज़ुअल गेम टूलकिट
• TensorFlow की मदद से रीइन्फ़ोर्समेंट लर्निंग के बारे में वीडियो सीरीज़
• DeepMind और UCL की रीइन्फ़ोर्समेंट लर्निंग लेक्चर सीरीज़ 2021