easy-rl/notebooks/SAC.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "6218efae",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from torch.optim import Adam\n",
    "from torch.distributions import Normal\n",
    "import random\n",
    "import numpy as np\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a207689",
   "metadata": {},
   "source": [
    "## 1.定义算法\n",
    "### 1.1 建立Q网络和策略网络"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "5955151d",
   "metadata": {},
   "outputs": [],
   "source": [
    "class ValueNet(nn.Module):\n",
    "    def __init__(self, n_states, hidden_dim, init_w=3e-3):\n",
    "        super(ValueNet, self).__init__()\n",
    "        '''定义值网络\n",
    "        '''\n",
    "        self.linear1 = nn.Linear(n_states, hidden_dim) # 输入层\n",
    "        self.linear2 = nn.Linear(hidden_dim, hidden_dim) # 隐藏层\n",
    "        self.linear3 = nn.Linear(hidden_dim, 1)\n",
    "\n",
    "        self.linear3.weight.data.uniform_(-init_w, init_w) # 初始化权重\n",
    "        self.linear3.bias.data.uniform_(-init_w, init_w)\n",
    "        \n",
    "    def forward(self, state):\n",
    "        x = F.relu(self.linear1(state))\n",
    "        x = F.relu(self.linear2(x))\n",
    "        x = self.linear3(x)\n",
    "        return x\n",
    "        \n",
    "        \n",
    "class SoftQNet(nn.Module):\n",
    "    def __init__(self, n_states, n_actions, hidden_dim, init_w=3e-3):\n",
    "        super(SoftQNet, self).__init__()\n",
    "        '''定义Q网络，n_states, n_actions, hidden_dim, init_w分别为状态维度、动作维度隐藏层维度和初始化权重\n",
    "        '''\n",
    "        self.linear1 = nn.Linear(n_states + n_actions, hidden_dim)\n",
    "        self.linear2 = nn.Linear(hidden_dim, hidden_dim)\n",
    "        self.linear3 = nn.Linear(hidden_dim, 1)\n",
    "        \n",
    "        self.linear3.weight.data.uniform_(-init_w, init_w)\n",
    "        self.linear3.bias.data.uniform_(-init_w, init_w)\n",
    "        \n",
    "    def forward(self, state, action):\n",
    "        x = torch.cat([state, action], 1)\n",
    "        x = F.relu(self.linear1(x))\n",
    "        x = F.relu(self.linear2(x))\n",
    "        x = self.linear3(x)\n",
    "        return x\n",
    "        \n",
    "        \n",
    "class PolicyNet(nn.Module):\n",
    "    def __init__(self, n_states, n_actions, hidden_dim, init_w=3e-3, log_std_min=-20, log_std_max=2):\n",
    "        super(PolicyNet, self).__init__()\n",
    "        '''定义策略网络，n_states, n_actions, hidden_dim, init_w分别为状态维度、动作维度隐藏层维度和初始化权重\n",
    "        log_std_min和log_std_max为标准差对数的最大值和最小值\n",
    "        '''\n",
    "        self.log_std_min = log_std_min\n",
    "        self.log_std_max = log_std_max\n",
    "        \n",
    "        self.linear1 = nn.Linear(n_states, hidden_dim)\n",
    "        self.linear2 = nn.Linear(hidden_dim, hidden_dim)\n",
    "        \n",
    "        self.mean_linear = nn.Linear(hidden_dim, n_actions)\n",
    "        self.mean_linear.weight.data.uniform_(-init_w, init_w)\n",
    "        self.mean_linear.bias.data.uniform_(-init_w, init_w)\n",
    "        \n",
    "        self.log_std_linear = nn.Linear(hidden_dim, n_actions)\n",
    "        self.log_std_linear.weight.data.uniform_(-init_w, init_w)\n",
    "        self.log_std_linear.bias.data.uniform_(-init_w, init_w)\n",
    "        \n",
    "    def forward(self, state):\n",
    "        x = F.relu(self.linear1(state))\n",
    "        x = F.relu(self.linear2(x))\n",
    "        \n",
    "        mean    = self.mean_linear(x)\n",
    "        log_std = self.log_std_linear(x)\n",
    "        log_std = torch.clamp(log_std, self.log_std_min, self.log_std_max)\n",
    "        \n",
    "        return mean, log_std\n",
    "    \n",
    "    def evaluate(self, state, epsilon=1e-6):\n",
    "        mean, log_std = self.forward(state)\n",
    "        std = log_std.exp()\n",
    "        ## 计算动作\n",
    "        normal = Normal(mean, std)\n",
    "        z = normal.sample()\n",
    "        action = torch.tanh(z)\n",
    "        ## 计算动作概率\n",
    "        log_prob = normal.log_prob(z) - torch.log(1 - action.pow(2) + epsilon)\n",
    "        log_prob = log_prob.sum(-1, keepdim=True)\n",
    "        \n",
    "        return action, log_prob, z, mean, log_std\n",
    "        \n",
    "    \n",
    "    def get_action(self, state):\n",
    "        state = torch.FloatTensor(state).unsqueeze(0)\n",
    "        mean, log_std = self.forward(state)\n",
    "        std = log_std.exp()\n",
    "        \n",
    "        normal = Normal(mean, std)\n",
    "        z      = normal.sample()\n",
    "        action = torch.tanh(z)\n",
    "        \n",
    "        action  = action.detach().cpu().numpy()\n",
    "        return action[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "debce530",
   "metadata": {},
   "source": [
    "### 1.2 定义经验回放池"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "1c740ca0",
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReplayBuffer:\n",
    "    def __init__(self, capacity):\n",
    "        self.capacity = capacity # 经验回放的容量\n",
    "        self.buffer = [] # 缓冲区\n",
    "        self.position = 0 \n",
    "    \n",
    "    def push(self, state, action, reward, next_state, done):\n",
    "        ''' 缓冲区是一个队列，容量超出时去掉开始存入的转移(transition)\n",
    "        '''\n",
    "        if len(self.buffer) < self.capacity:\n",
    "            self.buffer.append(None)\n",
    "        self.buffer[self.position] = (state, action, reward, next_state, done)\n",
    "        self.position = (self.position + 1) % self.capacity \n",
    "    \n",
    "    def sample(self, batch_size):\n",
    "        batch = random.sample(self.buffer, batch_size) # 随机采出小批量转移\n",
    "        state, action, reward, next_state, done =  zip(*batch) # 解压成状态，动作等\n",
    "        return state, action, reward, next_state, done\n",
    "    \n",
    "    def __len__(self):\n",
    "        ''' 返回当前存储的量\n",
    "        '''\n",
    "        return len(self.buffer)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "32a65b71",
   "metadata": {},
   "source": [
    "### 1.3 SAC算法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "5a86f725",
   "metadata": {},
   "outputs": [],
   "source": [
    "class SAC:\n",
    "    def __init__(self,cfg) -> None:\n",
    "        self.n_states = cfg.n_states\n",
    "        self.n_actions = cfg.n_actions\n",
    "        self.batch_size  = cfg.batch_size \n",
    "        self.memory = ReplayBuffer(cfg.capacity)\n",
    "        self.device = cfg.device\n",
    "        self.action_space = cfg.action_space\n",
    "        self.value_net  = ValueNet(self.n_states, cfg.hidden_dim).to(self.device)\n",
    "        self.target_value_net = ValueNet(self.n_states, cfg.hidden_dim).to(self.device)\n",
    "        self.soft_q_net = SoftQNet(self.n_states, self.n_actions, cfg.hidden_dim).to(self.device)\n",
    "        self.policy_net = PolicyNet(self.n_states, self.n_actions, cfg.hidden_dim).to(self.device)  \n",
    "        self.value_optimizer  = Adam(self.value_net.parameters(), lr=cfg.value_lr)\n",
    "        self.soft_q_optimizer = Adam(self.soft_q_net.parameters(), lr=cfg.soft_q_lr)\n",
    "        self.policy_optimizer = Adam(self.policy_net.parameters(), lr=cfg.policy_lr)  \n",
    "        for target_param, param in zip(self.target_value_net.parameters(), self.value_net.parameters()):\n",
    "            target_param.data.copy_(param.data)\n",
    "        self.value_criterion  = nn.MSELoss()\n",
    "        self.soft_q_criterion = nn.MSELoss()\n",
    "    def update(self, gamma=0.99,mean_lambda=1e-3,\n",
    "        std_lambda=1e-3,\n",
    "        z_lambda=0.0,\n",
    "        soft_tau=1e-2,\n",
    "        ):\n",
    "        if len(self.memory) < self.batch_size: # 当经验回放中不满足一个批量时，不更新策略\n",
    "            return \n",
    "        state, action, reward, next_state, done = self.memory.sample(self.batch_size) # 从经验回放中随机采样一个批量的转移(transition)\n",
    "        # 将数据转换为tensor\n",
    "        state      = torch.FloatTensor(state).to(self.device)\n",
    "        next_state = torch.FloatTensor(next_state).to(self.device)\n",
    "        action     = torch.FloatTensor(action).to(self.device)\n",
    "        reward     = torch.FloatTensor(reward).unsqueeze(1).to(self.device)\n",
    "        done       = torch.FloatTensor(np.float32(done)).unsqueeze(1).to(self.device)\n",
    "        \n",
    "        expected_q_value = self.soft_q_net(state, action) #计算t时刻的状态-动作Q值\n",
    "        expected_value   = self.value_net(state) #计算t时刻的状态值\n",
    "        new_action, log_prob, z, mean, log_std = self.policy_net.evaluate(state) #计算t时刻的动作、动作似然概率、正态分布抽样、分布均值和标准差\n",
    "\n",
    "\n",
    "        target_value = self.target_value_net(next_state) #计算t+1时刻的状态值\n",
    "        next_q_value = reward + (1 - done) * gamma * target_value # 时序差分计算t+1时刻的Q值\n",
    "        # JQ = 𝔼(st,at)~D[0.5(Q1(st,at) - r(st,at) - γ(𝔼st+1~p[V(st+1)]))^2]\n",
    "        q_value_loss = self.soft_q_criterion(expected_q_value, next_q_value.detach()) #计算q网路的损失函数\n",
    "\n",
    "        expected_new_q_value = self.soft_q_net(state, new_action) #计算t时刻动作对应的q值\n",
    "        next_value = expected_new_q_value - log_prob # 计算t时刻的v值\n",
    "        value_loss = self.value_criterion(expected_value, next_value.detach()) #计算值网络损失函数\n",
    "        \n",
    "        ## 计算策略损失\n",
    "        log_prob_target = expected_new_q_value - expected_value \n",
    "        # Jπ = 𝔼st∼D,εt∼N[α * logπ(f(εt;st)|st) − Q(st,f(εt;st))]\n",
    "        policy_loss = (log_prob * (log_prob - log_prob_target).detach()).mean()\n",
    "\n",
    "        ## 计算reparameterization参数损失\n",
    "        mean_loss = mean_lambda * mean.pow(2).mean()\n",
    "        std_loss  = std_lambda  * log_std.pow(2).mean()\n",
    "        z_loss    = z_lambda    * z.pow(2).sum(1).mean()\n",
    "\n",
    "        policy_loss += mean_loss + std_loss + z_loss\n",
    "\n",
    "        self.soft_q_optimizer.zero_grad()\n",
    "        q_value_loss.backward()\n",
    "        self.soft_q_optimizer.step()\n",
    "\n",
    "        self.value_optimizer.zero_grad()\n",
    "        value_loss.backward()\n",
    "        self.value_optimizer.step()\n",
    "\n",
    "        self.policy_optimizer.zero_grad()\n",
    "        policy_loss.backward()\n",
    "        self.policy_optimizer.step()\n",
    "        ## 更新目标值网络参数\n",
    "        for target_param, param in zip(self.target_value_net.parameters(), self.value_net.parameters()):\n",
    "            target_param.data.copy_(\n",
    "                target_param.data * (1.0 - soft_tau) + param.data * soft_tau\n",
    "            )\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2581771",
   "metadata": {},
   "source": [
    "## 2.模型训练与测试"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "0a3e3413",
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(cfg, env, agent):\n",
    "    print(\"开始训练！\")\n",
    "    rewards = [] # 记录所有回合的奖励\n",
    "    for i_ep in range(cfg.train_eps):\n",
    "        state = env.reset() # 重置环境，返回初始状态\n",
    "        ep_reward = 0 # 记录一回合内的奖励\n",
    "        for i_step in range(cfg.max_steps):\n",
    "            action = agent.policy_net.get_action(state)  # 抽样动作\n",
    "            next_state, reward, terminated, info = env.step(action)  # 更新环境，返回transitions\n",
    "            agent.memory.push(state, action, reward,next_state, terminated)  # 保存transition\n",
    "            agent.update()  # 更新智能体\n",
    "            state = next_state  # 更新下一个状态\n",
    "            ep_reward += reward  # 累加奖励\n",
    "            if terminated:\n",
    "                break\n",
    "        if (i_ep+1)%10 == 0:\n",
    "            print(f\"回合：{i_ep+1}/{cfg.train_eps}，奖励：{ep_reward:.2f}\")\n",
    "        rewards.append(ep_reward)\n",
    "    print(\"完成训练！\")\n",
    "    return {'rewards':rewards}\n",
    "def test(cfg, env, agent):\n",
    "    print(\"开始测试！\")\n",
    "    rewards = [] # 记录所有回合的奖励\n",
    "    for i_ep in range(cfg.test_eps):\n",
    "        state = env.reset() # 重置环境，返回初始状态\n",
    "        ep_reward = 0\n",
    "        for i_step in range(cfg.max_steps):\n",
    "            action = agent.policy_net.get_action(state)  # 抽样动作\n",
    "            next_state, reward, terminated, info = env.step(action)  # 更新环境，返回transitions\n",
    "            state = next_state  # 更新下一个状态\n",
    "            ep_reward += reward  # 累加奖励\n",
    "            if terminated:\n",
    "                break\n",
    "        rewards.append(ep_reward)\n",
    "        print(f\"回合：{i_ep+1}/{cfg.test_eps}，奖励：{ep_reward:.2f}\")\n",
    "    print(\"完成测试！\")\n",
    "    return {'rewards':rewards}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4d45832",
   "metadata": {},
   "source": [
    "## 3.定义环境"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "15b94efa",
   "metadata": {},
   "outputs": [],
   "source": [
    "import gym\n",
    "import os\n",
    "import numpy as np\n",
    "\n",
    "class NormalizedActions(gym.ActionWrapper):\n",
    "    def action(self, action):\n",
    "        low  = self.action_space.low\n",
    "        high = self.action_space.high\n",
    "        \n",
    "        action = low + (action + 1.0) * 0.5 * (high - low)\n",
    "        action = np.clip(action, low, high)\n",
    "        \n",
    "        return action\n",
    "\n",
    "    def reverse_action(self, action):\n",
    "        low  = self.action_space.low\n",
    "        high = self.action_space.high\n",
    "        action = 2 * (action - low) / (high - low) - 1\n",
    "        action = np.clip(action, low, high)\n",
    "        return action\n",
    "    \n",
    "def all_seed(env,seed = 1):\n",
    "    ''' 万能的seed函数\n",
    "    '''\n",
    "    env.seed(seed) # env config\n",
    "    np.random.seed(seed)\n",
    "    random.seed(seed)\n",
    "    torch.manual_seed(seed) # config for CPU\n",
    "    torch.cuda.manual_seed(seed) # config for GPU\n",
    "    os.environ['PYTHONHASHSEED'] = str(seed) # config for python scripts\n",
    "    # config for cudnn\n",
    "    torch.backends.cudnn.deterministic = True\n",
    "    torch.backends.cudnn.benchmark = False\n",
    "    torch.backends.cudnn.enabled = False\n",
    "def env_agent_config(cfg):\n",
    "    env = NormalizedActions(gym.make(cfg.env_name)) # 创建环境\n",
    "    all_seed(env,seed=cfg.seed)\n",
    "    n_states = env.observation_space.shape[0]\n",
    "    n_actions = env.action_space.shape[0]\n",
    "    print(f\"状态空间维度：{n_states}，动作空间维度：{n_actions}\")\n",
    "    # 更新n_states和n_actions到cfg参数中\n",
    "    setattr(cfg, 'n_states', n_states)\n",
    "    setattr(cfg, 'n_actions', n_actions) \n",
    "    setattr(cfg, 'action_space', env.action_space) \n",
    "    agent = SAC(cfg)\n",
    "    return env,agent"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "87423249",
   "metadata": {},
   "source": [
    "## 4.设置参数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "fbd710ef",
   "metadata": {},
   "outputs": [],
   "source": [
    "import argparse\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "class Config:\n",
    "    def __init__(self):\n",
    "        self.algo_name = 'SAC'\n",
    "        self.env_name = 'Pendulum-v1'\n",
    "        self.seed = 50 # 随机种子\n",
    "        self.train_eps = 400 # 训练迭代次数\n",
    "        self.test_eps = 10 # 测试迭代次数\n",
    "        self.eval_eps = 10 # 评估迭代次数\n",
    "        self.max_steps = 200 # 每次迭代最大时间步\n",
    "        self.gamma = 0.99 #折扣因子\n",
    "        self.mean_lambda=1e-3 # 重参数化分布均值的损失权重\n",
    "        self.std_lambda=1e-3 # 重参数化分布标准差的损失权重\n",
    "        self.z_lambda=0.0 # 重参数化分布抽样值的损失权重\n",
    "        self.soft_tau=1e-2 # 目标网络软更新系数\n",
    "        self.value_lr  = 3e-4 # 值网络的学习率\n",
    "        self.soft_q_lr = 3e-4 # Q网络的学习率\n",
    "        self.policy_lr = 3e-4 # 策略网络的学习率\n",
    "        self.capacity = 1000000 # 经验缓存池的大小\n",
    "        self.hidden_dim = 256 # 隐藏层维度\n",
    "        self.batch_size  = 128 # 批次大小\n",
    "        self.start_steps = 1000 # 利用前的探索步数\n",
    "        self.buffer_size = 1000000 # 经验回放池大小\n",
    "        self.device=torch.device(\"cpu\") # 使用设备\n",
    "\n",
    "def smooth(data, weight=0.9):  \n",
    "    '''用于平滑曲线，类似于Tensorboard中的smooth曲线\n",
    "    '''\n",
    "    last = data[0] \n",
    "    smoothed = []\n",
    "    for point in data:\n",
    "        smoothed_val = last * weight + (1 - weight) * point  # 计算平滑值\n",
    "        smoothed.append(smoothed_val)                    \n",
    "        last = smoothed_val                                \n",
    "    return smoothed\n",
    "\n",
    "def plot_rewards(rewards,title=\"learning curve\"):\n",
    "    sns.set()\n",
    "    plt.figure()  # 创建一个图形实例，方便同时多画几个图\n",
    "    plt.title(f\"{title}\")\n",
    "    plt.xlim(0, len(rewards), 10)  # 设置x轴的范围\n",
    "    plt.xlabel('epsiodes')\n",
    "    plt.plot(rewards, label='rewards')\n",
    "    plt.plot(smooth(rewards), label='smoothed')\n",
    "    plt.legend()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2bc3f1c6",
   "metadata": {},
   "source": [
    "## 5.开始训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "80de3242",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "状态空间维度：3，动作空间维度：1\n",
      "开始训练！\n",
      "回合：10/400，奖励：-1165.43\n",
      "回合：20/400，奖励：-994.18\n",
      "回合：30/400，奖励：-634.86\n",
      "回合：40/400，奖励：-883.46\n",
      "回合：50/400，奖励：-745.16\n",
      "回合：60/400，奖励：-617.77\n",
      "回合：70/400，奖励：-0.98\n",
      "回合：80/400，奖励：-386.85\n",
      "回合：90/400，奖励：-245.64\n",
      "回合：100/400，奖励：-118.91\n",
      "回合：110/400，奖励：-250.71\n",
      "回合：120/400，奖励：-245.33\n",
      "回合：130/400，奖励：-125.58\n",
      "回合：140/400，奖励：-124.50\n",
      "回合：150/400，奖励：-121.64\n",
      "回合：160/400，奖励：-244.01\n",
      "回合：170/400，奖励：-121.33\n",
      "回合：180/400，奖励：-239.27\n",
      "回合：190/400，奖励：-127.06\n",
      "回合：200/400，奖励：-122.01\n",
      "回合：210/400，奖励：-126.99\n",
      "回合：220/400，奖励：-348.44\n",
      "回合：230/400，奖励：-116.88\n",
      "回合：240/400，奖励：-124.86\n",
      "回合：250/400，奖励：-121.31\n",
      "回合：260/400，奖励：-3.03\n",
      "回合：270/400，奖励：-125.63\n",
      "回合：280/400，奖励：-244.81\n",
      "回合：290/400，奖励：-123.32\n",
      "回合：300/400，奖励：-119.85\n",
      "回合：310/400，奖励：-121.64\n",
      "回合：320/400，奖励：-4.73\n",
      "回合：330/400，奖励：-127.96\n",
      "回合：340/400，奖励：-119.40\n",
      "回合：350/400，奖励：-244.30\n",
      "回合：360/400，奖励：-121.79\n",
      "回合：370/400，奖励：-244.21\n",
      "回合：380/400，奖励：-123.19\n",
      "回合：390/400，奖励：-341.91\n",
      "回合：400/400，奖励：-117.78\n",
      "完成训练！\n",
      "开始测试！\n",
      "回合：1/10，奖励：-123.43\n",
      "回合：2/10，奖励：-245.39\n",
      "回合：3/10，奖励：-366.64\n",
      "回合：4/10，奖励：-121.86\n",
      "回合：5/10，奖励：-124.73\n",
      "回合：6/10，奖励：-359.53\n",
      "回合：7/10，奖励：-125.78\n",
      "回合：8/10，奖励：-2.40\n",
      "回合：9/10，奖励：-348.00\n",
      "回合：10/10，奖励：-361.15\n",
      "完成测试！\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 获取参数\n",
    "cfg = Config() \n",
    "# 训练\n",
    "env, agent = env_agent_config(cfg)\n",
    "res_dic = train(cfg, env, agent)\n",
    " \n",
    "plot_rewards(res_dic['rewards'], title=f\"training curve on {cfg.device} of {cfg.algo_name} for {cfg.env_name}\")  \n",
    "# 测试\n",
    "res_dic = test(cfg, env, agent)\n",
    "plot_rewards(res_dic['rewards'], title=f\"testing curve on {cfg.device} of {cfg.algo_name} for {cfg.env_name}\")  # 画出结果"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "46214798",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "badea21e",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python (tensorflowenv)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}