code: def test_serialization(learn_fn, network_fn):
      """
      Test if the trained model can be serialized
      """
  
      if network_fn.endswith("lstm") and learn_fn in [
          "acer",
          "acktr",
          "trpo_mpi",
          "deepq",
      ]:
          # TODO make acktr work with recurrent policies
          # and test
          # github issue: https://github.com/openai/baselines/issues/660
          return
  
      def make_env():
          env = MnistEnv(episode_len=100)
          env.seed(10)
          return env
  
      env = DummyVecEnv([make_env])
      ob = env.reset().copy()
      learn = get_learn_function(learn_fn)
  
      kwargs = {}
      kwargs.update(network_kwargs[network_fn])
      kwargs.update(learn_kwargs[learn_fn])
  
      learn = partial(
          learn, env=env, network=network_fn, seed=0, **kwargs
      )
  
      with tempfile.TemporaryDirectory() as td:
          model_path = os.path.join(td, "serialization_test_model")
  
          with tf.Graph().as_default(), make_session().as_default():
              model = learn(total_timesteps=100)
              model.save(model_path)
              mean1, std1 = _get_action_stats(model, ob)
              variables_dict1 = _serialize_variables()
  
          with tf.Graph().as_default(), make_session().as_default():
              model = learn(total_timesteps=0, load_path=model_path)
              mean2, std2 = _get_action_stats(model, ob)
              variables_dict2 = _serialize_variables()
  
          for k, v in variables_dict1.items():
              np.testing.assert_allclose(
                  v,
                  variables_dict2[k],
                  atol=0.01,
                  err_msg="saved and loaded variable {} value mismatch".format(
                      k
                  ),
              )
  
          np.testing.assert_allclose(mean1, mean2, atol=0.5)
          np.testing.assert_allclose(std1, std2, atol=0.5)
  
file_path: baselines/baselines/common/tests/test_serialization.py
imports: import os
  import gym
  import tempfile
  import pytest
  import tensorflow
  import numpy
  from baselines.common.tests.envs.mnist_env import MnistEnv
  from baselines.common.vec_env.dummy_vec_env import DummyVecEnv
  from baselines.run import get_learn_function
  from baselines.common.tf_util import make_session, get_session
  from functools import partial
label_desc: Use image node_id 1 for calling a global function with example usage: test_serialization(learn_fn, network_fn) and returns: env