diff --git a/tutorial/English/00-PixyzOverview.ipynb b/tutorial/English/00-PixyzOverview.ipynb new file mode 100644 index 00000000..aaa7eb24 --- /dev/null +++ b/tutorial/English/00-PixyzOverview.ipynb @@ -0,0 +1,1352 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Pixyz API takes into account the features of deep generative models\n", + "- The Deep Neural Network that composes the generative model is hidden by the probability distribution\n", + " - A framework that can separate defining DNNs and operating probability distributions(Distribution API) \n", + "- Model types and regularization of random variables are described as objective functions(error functions)\n", + " - A framework that receives probability distribution and define objective function(Loss API) \n", + "- Deep generative models learn by defining objective function and using gradient descent method\n", + " - A framework in which objective function and optimization algorithm can be set independently(Model API)\n", + "" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from __future__ import print_function\n", + "import torch\n", + "import torch.utils.data\n", + "from torch import nn, optim\n", + "from torch.nn import functional as F\n", + "from torchvision import datasets, transforms\n", + "from tensorboardX import SummaryWriter\n", + "\n", + "from tqdm import tqdm\n", + "\n", + "if torch.cuda.is_available():\n", + " device = \"cuda\"\n", + "else:\n", + " device = \"cpu\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Overviewing relationships between each APIs through implementing VAE" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1. Distribution API\n", + "- A framework that can separate defining DNNs and operating probability distributions(Distribution API)\n", + "- https://pixyz.readthedocs.io/en/latest/distributions.html" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We define these three probability distributions\n", + "\n", + "Prior: $p(z) = N(z; 0, 1)$\n", + "\n", + "Generator: $p_{\\theta}(x|z) = B(x; \\lambda = g(z))$\n", + "\n", + "Inference: $q_{\\phi}(z|x) = N(z; µ = f_{\\mu}(x), \\sigma^2 = f_{\\sigma^2}(x))$" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from pixyz.distributions import Normal, Bernoulli\n", + "from pixyz.utils import print_latex" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Define prior probability distribution\n", + "\n", + "prior is a gaussian distribution with mean 0 and variance 1\n", + "\n", + "$p(z) = N(z; 0, 1)$" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Distribution:\n", + " p_{prior}(z)\n", + "Network architecture:\n", + " Normal(\n", + " name=p_{prior}, distribution_name=Normal,\n", + " var=['z'], cond_var=[], input_var=[], features_shape=torch.Size([64])\n", + " (loc): torch.Size([1, 64])\n", + " (scale): torch.Size([1, 64])\n", + " )\n" + ] + }, + { + "data": { + "text/latex": [ + "$\\displaystyle p_{prior}(z)$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# prior\n", + "z_dim = 64\n", + "prior = Normal(loc=torch.tensor(0.), scale=torch.tensor(1.),\n", + " var=[\"z\"], features_shape=[z_dim], name=\"p_{prior}\").to(device)\n", + "print(prior)\n", + "print_latex(prior)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Define generator probability distribution\n", + "Generator is a bernoulli distribution over x given z\n", + "\n", + "$p_{\\theta}(x|z) = B(x; \\lambda = g(z))$\n", + "\n", + "Inherit pixyz.Distribution class to define a distribution with Deep neural networks" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Distribution:\n", + " p(x|z)\n", + "Network architecture:\n", + " Generator(\n", + " name=p, distribution_name=Bernoulli,\n", + " var=['x'], cond_var=['z'], input_var=['z'], features_shape=torch.Size([])\n", + " (fc1): Linear(in_features=64, out_features=512, bias=True)\n", + " (fc2): Linear(in_features=512, out_features=512, bias=True)\n", + " (fc3): Linear(in_features=512, out_features=784, bias=True)\n", + " )\n" + ] + }, + { + "data": { + "text/latex": [ + "$\\displaystyle p(x|z)$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x_dim = 784\n", + "# generative model p(x|z)\n", + "# inherit pixyz.Distribution Bernoulli class\n", + "class Generator(Bernoulli):\n", + " def __init__(self):\n", + " super(Generator, self).__init__(var=[\"x\"], cond_var=[\"z\"], name=\"p\")\n", + "\n", + " self.fc1 = nn.Linear(z_dim, 512)\n", + " self.fc2 = nn.Linear(512, 512)\n", + " self.fc3 = nn.Linear(512, x_dim)\n", + "\n", + " def forward(self, z):\n", + " h = F.relu(self.fc1(z))\n", + " h = F.relu(self.fc2(h))\n", + " return {\"probs\": torch.sigmoid(self.fc3(h))}\n", + "p = Generator().to(device)\n", + "print(p)\n", + "print_latex(p)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Define Inference probability distribution\n", + "\n", + "Inference is a gaussian distribution over z given x \n", + "$\\mu$ and $\\sigma$ are parameterized by $\\phi$\n", + "\n", + "$q_{\\phi}(z|x) = N(z; µ = f_{\\mu}(x), \\sigma^2 = f_{\\sigma^2}(x))$" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Distribution:\n", + " q(z|x)\n", + "Network architecture:\n", + " Inference(\n", + " name=q, distribution_name=Normal,\n", + " var=['z'], cond_var=['x'], input_var=['x'], features_shape=torch.Size([])\n", + " (fc1): Linear(in_features=784, out_features=512, bias=True)\n", + " (fc2): Linear(in_features=512, out_features=512, bias=True)\n", + " (fc31): Linear(in_features=512, out_features=64, bias=True)\n", + " (fc32): Linear(in_features=512, out_features=64, bias=True)\n", + " )\n" + ] + }, + { + "data": { + "text/latex": [ + "$\\displaystyle q(z|x)$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# inference model q(z|x)\n", + "# inherit pixyz.Distribution Normal class\n", + "class Inference(Normal):\n", + " def __init__(self):\n", + " super(Inference, self).__init__(var=[\"z\"], cond_var=[\"x\"], name=\"q\")\n", + "\n", + " self.fc1 = nn.Linear(x_dim, 512)\n", + " self.fc2 = nn.Linear(512, 512)\n", + " self.fc31 = nn.Linear(512, z_dim)\n", + " self.fc32 = nn.Linear(512, z_dim)\n", + "\n", + " def forward(self, x):\n", + " h = F.relu(self.fc1(x))\n", + " h = F.relu(self.fc2(h))\n", + " return {\"loc\": self.fc31(h), \"scale\": F.softplus(self.fc32(h))}\n", + "\n", + "q = Inference().to(device)\n", + "print(q)\n", + "print_latex(q)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Sampling from a probability distribution\n", + "- Sampling can be done by .sample() in defined Distribution class regardless of DNN architecture or distribution type\n", + "- In Pixyz, samples are dict type(key is variable name, value is sample)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "$z\\sim p(z)$" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'z': tensor([[-0.5438, 0.5853, 0.9415, 1.0591, 1.4031, -0.0520, 0.7588, -1.3387,\n", + " 0.4586, 0.2402, 0.6899, -1.4430, 0.8306, 1.6975, 0.3532, -0.3980,\n", + " -1.5879, 0.8015, -0.7279, 1.2902, 0.6434, -0.4299, -0.0147, -0.7769,\n", + " -0.2355, 0.8801, -0.8768, -0.0911, -0.8140, -0.2988, -0.5511, -0.1526,\n", + " -0.1219, -0.3171, -0.2924, 0.3731, 1.8659, 1.3274, 2.4092, -0.4386,\n", + " 0.4175, -0.9096, 0.4095, 2.1348, 0.2795, 0.4564, -2.5351, 1.5394,\n", + " -1.2816, 0.4562, 0.5690, -0.8027, -0.4947, -0.7010, -1.6218, -0.7865,\n", + " -0.4135, -0.4891, 0.0258, -0.3843, 0.8516, -0.1511, -0.0327, -0.9058]],\n", + " device='cuda:0')}\n", + "dict_keys(['z'])\n", + "torch.Size([1, 64])\n" + ] + } + ], + "source": [ + "# z ~ p(z)\n", + "prior_samples = prior.sample(batch_n=1)\n", + "print(prior_samples)\n", + "print(prior_samples.keys())\n", + "print(prior_samples['z'].shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Define joint distribution\n", + "- joint distribution can be difined by multiplying distributions\n", + " - Sampling can be done by .sample()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "$p_{\\theta}(x, z) = p_{\\theta}(x|z)p(z)$" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Distribution:\n", + " p(x,z) = p(x|z)p_{prior}(z)\n", + "Network architecture:\n", + " Normal(\n", + " name=p_{prior}, distribution_name=Normal,\n", + " var=['z'], cond_var=[], input_var=[], features_shape=torch.Size([64])\n", + " (loc): torch.Size([1, 64])\n", + " (scale): torch.Size([1, 64])\n", + " )\n", + " Generator(\n", + " name=p, distribution_name=Bernoulli,\n", + " var=['x'], cond_var=['z'], input_var=['z'], features_shape=torch.Size([])\n", + " (fc1): Linear(in_features=64, out_features=512, bias=True)\n", + " (fc2): Linear(in_features=512, out_features=512, bias=True)\n", + " (fc3): Linear(in_features=512, out_features=784, bias=True)\n", + " )\n" + ] + }, + { + "data": { + "text/latex": [ + "$\\displaystyle p(x,z) = p(x|z)p_{prior}(z)$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "p_joint = p * prior\n", + "print(p_joint)\n", + "print_latex(p_joint)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Sampling from a joint distribution" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "$x, z \\sim p_{\\theta}(x, z) $" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'z': tensor([[ 0.1798, -0.2534, 1.9239, 0.7444, -0.2541, -0.5951, 1.1151, 0.4059,\n", + " 0.5807, -0.8940, -0.7727, 0.1663, -0.0572, 2.3262, 2.4288, 1.1539,\n", + " -1.7565, -0.0071, -0.7027, 0.9958, -0.5287, -1.2675, 0.7315, 0.6763,\n", + " 0.2179, 0.6958, 0.2657, 0.2117, -1.2440, -0.1694, 0.9022, -1.0702,\n", + " -0.3973, 0.7750, -1.2522, 0.2898, 0.3006, 0.7156, -0.0205, -0.2505,\n", + " -1.0893, -1.0576, -1.1959, -0.3639, -0.5362, 0.7473, 0.0541, 2.0923,\n", + " -0.4051, 0.8123, 1.8256, 0.5847, 1.4084, -0.3716, -1.0299, 1.4635,\n", + " -0.0438, -0.0964, 0.4627, -1.2500, -2.2660, -0.3602, 1.6857, -0.4131]],\n", + " device='cuda:0'), 'x': tensor([[1., 0., 1., 0., 0., 1., 0., 1., 1., 0., 1., 1., 1., 1., 1., 1., 0., 1.,\n", + " 0., 1., 0., 1., 0., 0., 0., 1., 1., 1., 0., 0., 0., 0., 0., 0., 1., 1.,\n", + " 0., 0., 0., 0., 1., 1., 0., 0., 1., 0., 0., 0., 1., 1., 0., 0., 1., 0.,\n", + " 1., 1., 0., 1., 1., 1., 1., 1., 1., 0., 0., 1., 1., 1., 0., 0., 1., 1.,\n", + " 1., 1., 1., 1., 0., 0., 1., 1., 1., 0., 0., 1., 1., 0., 1., 1., 0., 0.,\n", + " 1., 0., 1., 1., 0., 1., 1., 1., 1., 1., 1., 0., 0., 0., 1., 0., 1., 1.,\n", + " 1., 0., 0., 1., 0., 1., 0., 1., 1., 1., 0., 0., 1., 0., 0., 1., 0., 0.,\n", + " 1., 1., 0., 1., 0., 0., 0., 0., 0., 0., 1., 1., 1., 1., 0., 1., 1., 0.,\n", + " 0., 1., 1., 1., 0., 1., 0., 0., 0., 0., 1., 1., 1., 1., 0., 0., 1., 1.,\n", + " 0., 1., 1., 0., 1., 0., 1., 1., 0., 1., 1., 0., 1., 1., 1., 1., 1., 0.,\n", + " 0., 1., 1., 1., 0., 0., 0., 1., 1., 0., 1., 0., 0., 0., 0., 1., 0., 1.,\n", + " 0., 1., 0., 0., 1., 1., 1., 1., 0., 0., 0., 0., 1., 1., 1., 0., 0., 1.,\n", + " 1., 0., 1., 0., 1., 1., 0., 0., 0., 0., 0., 0., 1., 0., 1., 0., 0., 0.,\n", + " 1., 0., 1., 1., 1., 1., 0., 1., 1., 1., 0., 0., 0., 0., 1., 1., 1., 0.,\n", + " 0., 0., 0., 0., 0., 0., 1., 1., 1., 0., 1., 0., 1., 0., 1., 1., 0., 0.,\n", + " 1., 1., 1., 1., 1., 1., 0., 0., 1., 1., 0., 0., 0., 1., 0., 0., 0., 0.,\n", + " 1., 1., 0., 1., 0., 0., 0., 0., 1., 0., 1., 0., 1., 1., 0., 1., 0., 1.,\n", + " 1., 1., 0., 1., 0., 0., 1., 1., 1., 0., 1., 1., 1., 0., 0., 1., 0., 0.,\n", + " 1., 1., 0., 0., 1., 0., 0., 0., 1., 1., 0., 1., 1., 1., 1., 0., 1., 0.,\n", + " 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 1., 1., 0., 1., 0., 0., 0., 0.,\n", + " 1., 1., 1., 1., 0., 0., 0., 0., 1., 0., 0., 0., 1., 1., 0., 0., 0., 1.,\n", + " 1., 0., 0., 0., 1., 1., 1., 0., 1., 1., 0., 0., 1., 0., 0., 1., 0., 0.,\n", + " 1., 1., 0., 1., 0., 0., 1., 0., 1., 1., 1., 0., 0., 0., 1., 1., 1., 0.,\n", + " 0., 0., 0., 1., 0., 0., 0., 1., 1., 1., 0., 1., 0., 0., 1., 1., 1., 0.,\n", + " 1., 0., 0., 0., 0., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 1., 0., 1., 0., 0., 1., 1., 1., 0., 1., 1., 0., 0., 1., 0., 1., 1.,\n", + " 0., 1., 0., 1., 0., 1., 0., 0., 0., 1., 0., 1., 0., 1., 0., 0., 1., 1.,\n", + " 1., 1., 0., 0., 1., 0., 1., 1., 1., 1., 1., 0., 0., 1., 1., 1., 0., 0.,\n", + " 1., 0., 1., 1., 0., 1., 1., 1., 0., 1., 1., 0., 1., 1., 0., 1., 1., 1.,\n", + " 0., 0., 1., 1., 1., 1., 0., 1., 0., 0., 1., 0., 1., 1., 1., 0., 0., 1.,\n", + " 1., 1., 0., 1., 1., 1., 0., 0., 0., 0., 0., 1., 0., 1., 0., 0., 0., 0.,\n", + " 0., 0., 1., 0., 0., 1., 1., 1., 1., 0., 0., 0., 0., 1., 0., 1., 0., 1.,\n", + " 1., 0., 0., 1., 0., 1., 0., 0., 0., 1., 0., 0., 0., 1., 0., 0., 0., 1.,\n", + " 1., 0., 1., 0., 1., 1., 0., 1., 0., 0., 0., 1., 0., 1., 1., 0., 1., 1.,\n", + " 1., 1., 1., 1., 1., 0., 0., 1., 0., 1., 0., 0., 0., 1., 0., 0., 0., 1.,\n", + " 1., 1., 0., 1., 1., 1., 0., 0., 0., 1., 0., 1., 0., 0., 0., 1., 0., 0.,\n", + " 0., 1., 1., 0., 1., 1., 1., 0., 1., 0., 1., 1., 0., 1., 1., 0., 0., 0.,\n", + " 0., 0., 1., 0., 0., 0., 1., 0., 1., 0., 1., 1., 1., 1., 1., 1., 1., 1.,\n", + " 0., 1., 1., 1., 0., 0., 1., 0., 1., 0., 1., 0., 0., 1., 1., 1., 0., 1.,\n", + " 0., 0., 0., 0., 0., 1., 1., 1., 1., 1., 0., 1., 1., 1., 0., 0., 1., 0.,\n", + " 1., 0., 1., 1., 0., 0., 1., 1., 1., 1., 1., 0., 0., 0., 1., 1., 1., 0.,\n", + " 0., 0., 1., 1., 0., 0., 1., 0., 1., 0., 0., 0., 1., 0., 0., 0., 0., 0.,\n", + " 0., 1., 0., 1., 0., 1., 1., 0., 1., 0., 1., 1., 1., 1., 1., 1., 0., 1.,\n", + " 1., 0., 0., 1., 0., 0., 1., 0., 1., 1.]], device='cuda:0')}\n", + "dict_keys(['z', 'x'])\n", + "torch.Size([1, 784])\n", + "torch.Size([1, 64])\n" + ] + } + ], + "source": [ + "p_joint_samples = p_joint.sample(batch_n=1)\n", + "print(p_joint_samples)\n", + "print(p_joint_samples.keys())\n", + "print(p_joint_samples['x'].shape)\n", + "print(p_joint_samples['z'].shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### For more detailed Distribution API Turorial\n", + "- 01-DistributionAPITutorial.ipynb" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2. Loss API\n", + "- A framework that receives probability distribution and define objective function(Loss API)\n", + " - pixyz.Loss receives Distribution and defines Loss\n", + " - Arithmetic operations can be done between Loss classes, so any Loss can be designed\n", + " - -> Paper's formula can be put into codes easily\n", + "- Loss value is evaluated by inputting the data\n", + " - Each Loss is treated as symbol\n", + " - Independent of data or DNN, we can design probabilistic model explicitly ->Define-and-run like framework" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "VAE Loss\n", + "$$\n", + "\\mathcal { L } _ { \\mathrm { VAE } } ( \\theta , \\phi ) = \\mathbb { E } _ { p_{data}( x ) } \\left [D _ { \\mathrm { KL } } \\left[ q _ \\phi ( z | x ) \\| p ( z ) \\right] - \\mathbb { E } _ { q _ { \\phi } ( z | x ) } \\left[\\log p _ { \\theta } ( x | z ) \\right]\\right]\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Define loss using pixyz.loss" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "$D _ { \\mathrm { KL } } \\left[ q _ \\phi ( z | x ) \\| p ( z ) \\right]$" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle D_{KL} \\left[q(z|x)||p_{prior}(z) \\right]$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from pixyz.losses import KullbackLeibler\n", + "kl = KullbackLeibler(q, prior)\n", + "print_latex(kl)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle - \\mathbb{E}_{q(z|x)} \\left[\\log p(x|z) \\right]$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "reconst = -p.log_prob().expectation(q)\n", + "print_latex(reconst)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Operations between Loss classes" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle mean \\left(D_{KL} \\left[q(z|x)||p_{prior}(z) \\right] - \\mathbb{E}_{q(z|x)} \\left[\\log p(x|z) \\right] \\right)$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "vae_loss = (kl + reconst).mean()\n", + "print_latex(vae_loss)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Input data and loss is evaluated\n", + "- loss is calculated by .eval()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor(550.8093, device='cuda:0', grad_fn=)" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# dummy_x for data\n", + "dummy_x = torch.randn([4, 784]).to(device)\n", + "vae_loss.eval({\"x\": dummy_x})" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### For more detailed Loss API Turorial\n", + "- 02-LossAPITutorial.ipynb" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 3. Model API\n", + "- A framework in which objective function and optimization algorithm can be set independently\n", + "- Set loss and optimization algorithm, then train with data" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Distributions (for training):\n", + " p(x|z), q(z|x)\n", + "Loss function:\n", + " mean \\left(D_{KL} \\left[q(z|x)||p_{prior}(z) \\right] - \\mathbb{E}_{q(z|x)} \\left[\\log p(x|z) \\right] \\right)\n", + "Optimizer:\n", + " Adam (\n", + " Parameter Group 0\n", + " amsgrad: False\n", + " betas: (0.9, 0.999)\n", + " eps: 1e-08\n", + " lr: 0.001\n", + " weight_decay: 0\n", + " )\n" + ] + }, + { + "data": { + "text/latex": [ + "$\\displaystyle mean \\left(D_{KL} \\left[q(z|x)||p_{prior}(z) \\right] - \\mathbb{E}_{q(z|x)} \\left[\\log p(x|z) \\right] \\right)$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from pixyz.models import Model\n", + "model = Model(loss=vae_loss, distributions=[p, q],\n", + " optimizer=optim.Adam, optimizer_params={\"lr\": 1e-3})\n", + "print(model)\n", + "print_latex(model)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "dummy_x = torch.randn([10, 784])\n", + "def train_dummy(epoch):\n", + " global dummy_x\n", + " dummy_x = dummy_x.to(device)\n", + " loss = model.train({\"x\": dummy_x})\n", + " print('Epoch: {} Train Loss: {:4f}'.format(epoch, loss))" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 0 Train Loss: 554.029114\n", + "Epoch: 1 Train Loss: 530.868591\n", + "Epoch: 2 Train Loss: 499.061432\n", + "Epoch: 3 Train Loss: 442.698639\n", + "Epoch: 4 Train Loss: 340.971588\n", + "Epoch: 5 Train Loss: 176.686768\n", + "Epoch: 6 Train Loss: 26.550779\n", + "Epoch: 7 Train Loss: -125.541313\n", + "Epoch: 8 Train Loss: -347.148285\n", + "Epoch: 9 Train Loss: -607.047791\n" + ] + } + ], + "source": [ + "for epoch in range(10):\n", + " train_dummy(epoch)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### For more detailed Model API Turorial\n", + "- 03-ModelAPITutorial.ipynb" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Training VAE with MNIST dataset" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Install modules" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "from __future__ import print_function\n", + "import torch\n", + "import torch.utils.data\n", + "from torch import nn, optim\n", + "from torch.nn import functional as F\n", + "import torchvision\n", + "from torchvision import datasets, transforms\n", + "from tensorboardX import SummaryWriter\n", + "\n", + "from tqdm import tqdm\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "\n", + "batch_size = 256\n", + "epochs = 3\n", + "seed = 1\n", + "torch.manual_seed(seed)\n", + "\n", + "if torch.cuda.is_available():\n", + " device = \"cuda\"\n", + "else:\n", + " device = \"cpu\"\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Prepare MNIST dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "root = '../data'\n", + "transform = transforms.Compose([transforms.ToTensor(),\n", + " transforms.Lambda(lambd=lambda x: x.view(-1))])\n", + "kwargs = {'batch_size': batch_size, 'num_workers': 1, 'pin_memory': True}\n", + "\n", + "train_loader = torch.utils.data.DataLoader(\n", + " datasets.MNIST(root=root, train=True, transform=transform, download=True),\n", + " shuffle=True, **kwargs)\n", + "test_loader = torch.utils.data.DataLoader(\n", + " datasets.MNIST(root=root, train=False, transform=transform),\n", + " shuffle=False, **kwargs)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Install Pixyz modules" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "from pixyz.distributions import Normal, Bernoulli\n", + "from pixyz.losses import KullbackLeibler, Expectation as E\n", + "from pixyz.models import Model\n", + "from pixyz.utils import print_latex" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Define probability distributions" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "x_dim = 784\n", + "z_dim = 64\n", + "\n", + "\n", + "# inference model q(z|x)\n", + "class Inference(Normal):\n", + " def __init__(self):\n", + " super(Inference, self).__init__(var=[\"z\"], cond_var=[\"x\"], name=\"q\")\n", + "\n", + " self.fc1 = nn.Linear(x_dim, 512)\n", + " self.fc2 = nn.Linear(512, 512)\n", + " self.fc31 = nn.Linear(512, z_dim)\n", + " self.fc32 = nn.Linear(512, z_dim)\n", + "\n", + " def forward(self, x):\n", + " h = F.relu(self.fc1(x))\n", + " h = F.relu(self.fc2(h))\n", + " return {\"loc\": self.fc31(h), \"scale\": F.softplus(self.fc32(h))}\n", + "\n", + " \n", + "# generative model p(x|z) \n", + "class Generator(Bernoulli):\n", + " def __init__(self):\n", + " super(Generator, self).__init__(var=[\"x\"], cond_var=[\"z\"], name=\"p\")\n", + "\n", + " self.fc1 = nn.Linear(z_dim, 512)\n", + " self.fc2 = nn.Linear(512, 512)\n", + " self.fc3 = nn.Linear(512, x_dim)\n", + "\n", + " def forward(self, z):\n", + " h = F.relu(self.fc1(z))\n", + " h = F.relu(self.fc2(h))\n", + " return {\"probs\": torch.sigmoid(self.fc3(h))}\n", + " \n", + "p = Generator().to(device)\n", + "q = Inference().to(device)\n", + "\n", + "prior = Normal(loc=torch.tensor(0.), scale=torch.tensor(1.),\n", + " var=[\"z\"], features_shape=[z_dim], name=\"p_{prior}\").to(device)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Distribution:\n", + " p_{prior}(z)\n", + "Network architecture:\n", + " Normal(\n", + " name=p_{prior}, distribution_name=Normal,\n", + " var=['z'], cond_var=[], input_var=[], features_shape=torch.Size([64])\n", + " (loc): torch.Size([1, 64])\n", + " (scale): torch.Size([1, 64])\n", + " )\n" + ] + }, + { + "data": { + "text/latex": [ + "$\\displaystyle p_{prior}(z)$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(prior)\n", + "print_latex(prior)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Distribution:\n", + " p(x|z)\n", + "Network architecture:\n", + " Generator(\n", + " name=p, distribution_name=Bernoulli,\n", + " var=['x'], cond_var=['z'], input_var=['z'], features_shape=torch.Size([])\n", + " (fc1): Linear(in_features=64, out_features=512, bias=True)\n", + " (fc2): Linear(in_features=512, out_features=512, bias=True)\n", + " (fc3): Linear(in_features=512, out_features=784, bias=True)\n", + " )\n" + ] + }, + { + "data": { + "text/latex": [ + "$\\displaystyle p(x|z)$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(p)\n", + "print_latex(p)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Distribution:\n", + " q(z|x)\n", + "Network architecture:\n", + " Inference(\n", + " name=q, distribution_name=Normal,\n", + " var=['z'], cond_var=['x'], input_var=['x'], features_shape=torch.Size([])\n", + " (fc1): Linear(in_features=784, out_features=512, bias=True)\n", + " (fc2): Linear(in_features=512, out_features=512, bias=True)\n", + " (fc31): Linear(in_features=512, out_features=64, bias=True)\n", + " (fc32): Linear(in_features=512, out_features=64, bias=True)\n", + " )\n" + ] + }, + { + "data": { + "text/latex": [ + "$\\displaystyle q(z|x)$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(q)\n", + "print_latex(q)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Define Loss" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle mean \\left(D_{KL} \\left[q(z|x)||p_{prior}(z) \\right] - \\mathbb{E}_{q(z|x)} \\left[\\log p(x|z) \\right] \\right)$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "kl = KullbackLeibler(q, prior)\n", + "reconst = -p.log_prob().expectation(q)\n", + "vae_loss = (kl + reconst).mean()\n", + "print_latex(vae_loss)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Set optimization algorithm and model" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Distributions (for training):\n", + " p(x|z), q(z|x)\n", + "Loss function:\n", + " mean \\left(D_{KL} \\left[q(z|x)||p_{prior}(z) \\right] - \\mathbb{E}_{q(z|x)} \\left[\\log p(x|z) \\right] \\right)\n", + "Optimizer:\n", + " Adam (\n", + " Parameter Group 0\n", + " amsgrad: False\n", + " betas: (0.9, 0.999)\n", + " eps: 1e-08\n", + " lr: 0.001\n", + " weight_decay: 0\n", + " )\n" + ] + }, + { + "data": { + "text/latex": [ + "$\\displaystyle mean \\left(D_{KL} \\left[q(z|x)||p_{prior}(z) \\right] - \\mathbb{E}_{q(z|x)} \\left[\\log p(x|z) \\right] \\right)$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model = Model(loss=vae_loss, distributions=[p, q],\n", + " optimizer=optim.Adam, optimizer_params={\"lr\": 1e-3})\n", + "print(model)\n", + "print_latex(model)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "def train(epoch):\n", + " train_loss = 0\n", + " #for x, _ in tqdm(train_loader):\n", + " for x, _ in train_loader:\n", + " x = x.to(device)\n", + " loss = model.train({\"x\": x})\n", + " train_loss += loss\n", + " \n", + " train_loss = train_loss * train_loader.batch_size / len(train_loader.dataset)\n", + " print('Epoch: {} Train loss: {:.4f}'.format(epoch, train_loss))\n", + " return train_loss\n", + "\n", + "def test(epoch):\n", + " test_loss = 0\n", + " #for x, _ in tqdm(test_loader):\n", + " for x, _ in test_loader:\n", + " x = x.to(device)\n", + " loss = model.test({\"x\": x})\n", + " test_loss += loss\n", + "\n", + " test_loss = test_loss * test_loader.batch_size / len(test_loader.dataset)\n", + " print('Test loss: {:.4f}'.format(test_loss))\n", + " return test_loss" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Reconstruction" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "def plot_reconstrunction(x):\n", + " with torch.no_grad():\n", + " z = q.sample({\"x\": x}, return_all=False)\n", + " recon_batch = p.sample_mean(z).view(-1, 1, 28, 28)\n", + " \n", + " comparison = torch.cat([x.view(-1, 1, 28, 28), recon_batch]).cpu()\n", + " return comparison" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### generate images from latent variable space" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "def plot_image_from_latent(z_sample):\n", + " with torch.no_grad():\n", + " sample = p.sample_mean({\"z\": z_sample}).view(-1, 1, 28, 28).cpu()\n", + " return sample" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "# functions to show an image\n", + "def imshow(img):\n", + " npimg = img.numpy()\n", + " plt.imshow(np.transpose(npimg, (1, 2, 0)))\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 1 Train loss: 201.0661\n", + "Test loss: 172.5077\n", + "Epoch: 1\n", + "Reconstruction\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "generate from prior z:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 2 Train loss: 148.8094\n", + "Test loss: 136.5518\n", + "Epoch: 2\n", + "Reconstruction\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "generate from prior z:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 3 Train loss: 128.4078\n", + "Test loss: 124.8055\n", + "Epoch: 3\n", + "Reconstruction\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "generate from prior z:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# z_sample for generate imgs from prior\n", + "z_sample = 0.5 * torch.randn(64, z_dim).to(device)\n", + "\n", + "# fixed _x for watching reconstruction improvement\n", + "_x, _ = iter(test_loader).next()\n", + "_x = _x.to(device)\n", + "\n", + "for epoch in range(1, epochs + 1):\n", + " train_loss = train(epoch)\n", + " test_loss = test(epoch)\n", + " \n", + " recon = plot_reconstrunction(_x[:8])\n", + " sample = plot_image_from_latent(z_sample)\n", + " \n", + " print('Epoch: {}'.format(epoch))\n", + " print('Reconstruction')\n", + " imshow(torchvision.utils.make_grid(recon))\n", + " print('generate from prior z:')\n", + " imshow(torchvision.utils.make_grid(sample))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.4" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/tutorial/English/01-DistributionAPITutorial.ipynb b/tutorial/English/01-DistributionAPITutorial.ipynb new file mode 100644 index 00000000..062c64d6 --- /dev/null +++ b/tutorial/English/01-DistributionAPITutorial.ipynb @@ -0,0 +1,724 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Define probability distribution by using Distribution API\n", + "\n", + "\n", + "Distribution API document: https://docs.pixyz.io/en/latest/distributions.html" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from __future__ import print_function\n", + "import torch\n", + "from torch import nn\n", + "from torch.nn import functional as F\n", + "import numpy as np\n", + "\n", + "torch.manual_seed(1)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from pixyz.utils import print_latex" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Define probability distribution without Deep Neural Networks" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.1 Define a simple probability distribution" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To define a Gaussian distribution, we need to\n", + "1. import `pixyz.distributions.Normal` class\n", + "2. set mean (loc) & variance(scale)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "from pixyz.distributions import Normal\n", + "\n", + "x_dim = 50\n", + "p1_nor_x = Normal(loc=torch.tensor(0.), scale=torch.tensor(1.), var=['x'], features_shape=[x_dim], name='p_{1}')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We define a variable name in `var` (in this example, variable name is x), and specify the number of dimensions in `features_shape`(in this example, the number of dimensions 50(x_dim)). \n", + "\n", + "We can check defined probability distribution's information." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Normal\n", + "p_{1}(x)\n" + ] + } + ], + "source": [ + "print(p1_nor_x.distribution_name) \n", + "print(p1_nor_x.prob_text)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In `distribution_name`, we can check the name of distribution.\n", + "\n", + "In `prob_text`, we can check the probability distribution in text and random variable shows `var` defined above(x).\n", + "\n", + "By printing p1_nor_x，we can overview the features of the distribution." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Distribution:\n", + " p_{1}(x)\n", + "Network architecture:\n", + " Normal(\n", + " name=p_{1}, distribution_name=Normal,\n", + " var=['x'], cond_var=[], input_var=[], features_shape=torch.Size([50])\n", + " (loc): torch.Size([1, 50])\n", + " (scale): torch.Size([1, 50])\n", + " )\n" + ] + } + ], + "source": [ + "print(p1_nor_x)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can check the defined probability distribution in LaTeX format. \n", + "Note: We use external library SymPy(https://www.sympy.org/en/index.html) for outputting LaTeX format. The order of the terms in the formula can be changed(but not affecting the result) due to the SymPy." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle p_{1}(x)$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print_latex(p1_nor_x)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can sample from the defined probability distribution by `.sample()`." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'x': tensor([[-1.5256, -0.7502, -0.6540, -1.6095, -0.1002, -0.6092, -0.9798, -1.6091,\n", + " -0.7121, 0.3037, -0.7773, -0.2515, -0.2223, 1.6871, 0.2284, 0.4676,\n", + " -0.6970, -1.1608, 0.6995, 0.1991, 0.8657, 0.2444, -0.6629, 0.8073,\n", + " 1.1017, -0.1759, -2.2456, -1.4465, 0.0612, -0.6177, -0.7981, -0.1316,\n", + " 1.8793, -0.0721, 0.0663, -0.4370, 0.7626, 0.4415, 1.1651, 2.0154,\n", + " 0.2152, -0.5242, -0.1860, -0.6446, 1.5392, -0.8696, -3.3312, -0.7479,\n", + " 1.1173, 0.2981]])}\n", + "--------------------------------------------------------------------------\n", + "tensor([[-1.5256, -0.7502, -0.6540, -1.6095, -0.1002, -0.6092, -0.9798, -1.6091,\n", + " -0.7121, 0.3037, -0.7773, -0.2515, -0.2223, 1.6871, 0.2284, 0.4676,\n", + " -0.6970, -1.1608, 0.6995, 0.1991, 0.8657, 0.2444, -0.6629, 0.8073,\n", + " 1.1017, -0.1759, -2.2456, -1.4465, 0.0612, -0.6177, -0.7981, -0.1316,\n", + " 1.8793, -0.0721, 0.0663, -0.4370, 0.7626, 0.4415, 1.1651, 2.0154,\n", + " 0.2152, -0.5242, -0.1860, -0.6446, 1.5392, -0.8696, -3.3312, -0.7479,\n", + " 1.1173, 0.2981]])\n" + ] + } + ], + "source": [ + "p1_nor_x_samples = p1_nor_x.sample()\n", + "print(p1_nor_x_samples)\n", + "print('--------------------------------------------------------------------------')\n", + "print(p1_nor_x_samples[\"x\"])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Output is dict type.\n", + "\n", + "We can check specific variable's sampling output by specifying the variable name in output dict.\n", + "\n", + "Sampling result is a PyTorch Tensor." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.2 Define conditional probability distribution" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we define a conditional probability distribution using an example of a Gaussian distribution.\n", + "\n", + "In Gaussian distribution, parameters are mean($\\mu$) and variance($\\sigma^2$). In this example, we define a Gaussian distribution conditioned by $\\mu$." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "$p(x|\\mu_{var}) = \\cal N(x; \\mu=\\mu_{var}, \\sigma^2=1)$\n", + "\n", + "We set conditional variables to `cond_var`. \n", + "In this example, we set mu_var to a Gaussian distribution's mean, so in the distribution argument, we set \n", + "- cond_var=['mu_var'] \n", + "- loc='mu_var' " + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "x_dim = 50\n", + "p1_nor_x__mu = Normal(loc='mu_var', scale=torch.tensor(1.), var=['x'], cond_var=['mu_var'], features_shape=[x_dim])" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Distribution:\n", + " p(x|\\mu_{var})\n", + "Network architecture:\n", + " Normal(\n", + " name=p, distribution_name=Normal,\n", + " var=['x'], cond_var=['mu_var'], input_var=['mu_var'], features_shape=torch.Size([50])\n", + " (scale): torch.Size([1, 50])\n", + " )\n" + ] + }, + { + "data": { + "text/latex": [ + "$\\displaystyle p(x|\\mu_{var})$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(p1_nor_x__mu)\n", + "print_latex(p1_nor_x__mu)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We successfully define a Gaussian distribution whose mean conditioned by $\\mu_{var}$. \n", + "Let's try sampling x setting $\\mu_{var}=0$. \n", + "We set variable in sample method argument dict. " + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'mu_var': 0,\n", + " 'x': tensor([[-0.5962, -1.0055, -0.2106, -0.0075, 1.6734, 0.0103, 0.9837, 0.8793,\n", + " -0.9962, -0.8313, -0.4610, -0.5601, 0.3956, -0.9823, 1.3264, 0.8547,\n", + " -0.6540, 0.7317, -1.4344, -0.5008, 0.1716, -0.1600, -0.5047, -1.4746,\n", + " -1.0412, 0.7323, -1.0483, -0.4709, 0.2911, 1.9907, -0.9247, -0.9301,\n", + " 0.8165, -0.9135, 0.2053, 0.3051, 0.5357, -0.4312, 0.1573, 1.2540,\n", + " 1.3275, -0.4954, -1.9804, 1.7986, 0.1018, 0.3400, -0.6447, -0.2870,\n", + " 3.3212, -0.4021]])}" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "p1_nor_x__mu.sample({\"mu_var\": 0})" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we assume $\\mu_{var}$ itsself is conditioned by some probability distribution. \n", + "We assume $\\mu_{var}$ follows Bernoulli distribution. \n", + "$p(\\mu_{var}) = \\cal B(\\mu_{var};p=0.3)$" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "from pixyz.distributions import Bernoulli\n", + "p2_ber_mu = Bernoulli(probs=torch.tensor(0.3), var=['mu_var'], features_shape=[x_dim])" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Distribution:\n", + " p(\\mu_{var})\n", + "Network architecture:\n", + " Bernoulli(\n", + " name=p, distribution_name=Bernoulli,\n", + " var=['mu_var'], cond_var=[], input_var=[], features_shape=torch.Size([50])\n", + " (probs): torch.Size([1, 50])\n", + " )\n", + "{'mu_var': tensor([[0., 0., 0., 0., 0., 0., 1., 1., 1., 0., 1., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 1., 1., 1., 1., 0., 0., 1., 0., 0., 0., 1., 0., 0., 0.,\n", + " 1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0.]])}\n" + ] + }, + { + "data": { + "text/latex": [ + "$\\displaystyle p(\\mu_{var})$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(p2_ber_mu)\n", + "print(p2_ber_mu.sample())\n", + "print_latex(p2_ber_mu)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In Pixyz Distribution API, joint distribution can be defined by multiplying distributions. \n", + "Let's define the joint distribution $p(x, \\mu_{var})$ multiplying $p(\\mu_{var})$ and $p(x|\\mu_{var})$. \n", + "$p(x, \\mu_{var}) = p(x|\\mu_{var}) p(\\mu_{var})$\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Distribution:\n", + " p(x,\\mu_{var}) = p(x|\\mu_{var})p(\\mu_{var})\n", + "Network architecture:\n", + " Bernoulli(\n", + " name=p, distribution_name=Bernoulli,\n", + " var=['mu_var'], cond_var=[], input_var=[], features_shape=torch.Size([50])\n", + " (probs): torch.Size([1, 50])\n", + " )\n", + " Normal(\n", + " name=p, distribution_name=Normal,\n", + " var=['x'], cond_var=['mu_var'], input_var=['mu_var'], features_shape=torch.Size([50])\n", + " (scale): torch.Size([1, 50])\n", + " )\n" + ] + }, + { + "data": { + "text/latex": [ + "$\\displaystyle p(x,\\mu_{var}) = p(x|\\mu_{var})p(\\mu_{var})$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "p_joint_mu_x = p1_nor_x__mu * p2_ber_mu\n", + "print(p_joint_mu_x) \n", + "print_latex(p_joint_mu_x)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Sampling from joint distributions also can be done using `.sample()`. \n", + "All variables and values are output in dict type." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'mu_var': tensor([[1., 0., 1., 0., 1., 1., 0., 1., 0., 0., 1., 0., 0., 1., 0., 0., 0., 1.,\n", + " 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 1.,\n", + " 0., 0., 1., 0., 1., 1., 0., 1., 0., 0., 0., 0., 0., 1.]]),\n", + " 'x': tensor([[ 3.6415, -0.9624, 0.7924, -1.3889, 1.0127, -0.8734, 1.7997, 1.2824,\n", + " 1.6604, 0.2717, 0.1913, 0.1267, 0.5707, 0.8652, 0.3437, 0.3718,\n", + " 0.1444, 1.7772, -2.3381, 0.1709, 1.1661, 1.4787, 0.2676, 0.7561,\n", + " -0.5873, -2.0619, 0.4305, 0.3377, -0.3438, -0.6172, 2.2530, -0.0514,\n", + " -1.0257, 0.5213, -2.3065, 1.6037, 0.1794, 0.1447, 0.6411, 0.4793,\n", + " 0.7617, -0.3542, -0.2693, 2.3120, -0.8920, -0.7529, -0.0573, 2.2000,\n", + " 0.9912, 0.9414]])}" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "p_joint_mu_x.sample()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. Define probability distribution with Deep Neural Networks" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this section, we master how to define probability distributions with deep neural networks.\n", + "\n", + "For example, a Gaussian distribution's mean $\\mu$ and variance $\\sigma^2$ can be parameterized by $\\theta$ like this way: \n", + "$\\mu=f(x;\\theta)$ \n", + "$\\sigma^2=g(x;\\theta)$ \n", + "$f(x;\\theta)$ and $g(x;\\theta)$ stands for deep neural networks.\n", + "\n", + "${\\cal N}(\\mu=f(x;\\theta),\\sigma^2=g(x;\\theta))$ \n", + "\n", + "Let's define\n", + "$p(a) = {\\cal N}(a; \\mu=f(x;\\theta),\\sigma^2=g(x;\\theta))$.\n", + "\n", + "In Pixyz, we can define this kind of probability distribution by inheriting `pixyz.distributions` class." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "from pixyz.distributions import Normal\n", + "a_dim = 20\n", + "\n", + "class ProbNorAgivX(Normal):\n", + " \"\"\"\n", + " Probability distrituion Normal A given X\n", + " p(a) = {\\cal N}(a; \\mu=f(x;\\theta),\\sigma^2=g(x;\\theta)\n", + " loc and scale are parameterized by theta given x\n", + " \"\"\"\n", + " def __init__(self):\n", + " super(ProbNorAgivX, self).__init__(var=['a'], cond_var=['x'])\n", + " \n", + " self.fc1 = nn.Linear(x_dim, 10)\n", + " self.fc_loc = nn.Linear(10, a_dim)\n", + " self.fc_scale = nn.Linear(10, a_dim)\n", + " \n", + " def forward(self, x):\n", + " h1 = F.relu(self.fc1(x))\n", + " return {'loc': self.fc_loc(h1), 'scale': F.softplus(self.fc_scale(h1))}\n", + "p_nor_a__x = ProbNorAgivX()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First, clarify that the parameters of the Gaussian distribution are defiend by the deep neural networks by inheriting the Gaussian distribution. \n", + "\n", + "\n", + "Next, describe the neural network architecture in constructor just like when we are writing PyTorch.\n", + "\n", + "\n", + "The only difference is that we set `var` and `cond_var` to `super()` args.\n", + "\n", + "We set the output variable name to `var`. And we set the NN's input variable name to `cond_var`. We regard this input variable as conditioning variable of this Gaussian distribution. \n", + "\n", + "In forward method, there are two caveats．\n", + "\n", + "* `forward()` args's variable name and variable number shold be the same as those set in `cond_var`. For example, if we set `cond_var=[\"x\", \"y\"]`, we must set `forward(self, x, y)`\n", + "* return output should be parameters of the distribution as dict type. In this Gaussian distribution example, we set parameters `loc` and `scale` in dict type.\n", + "\n", + "Finally, make an instance of defined probability distribution.\n", + "\n", + "Let's check the distribution features by `print()`." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Distribution:\n", + " p(a|x)\n", + "Network architecture:\n", + " ProbNorAgivX(\n", + " name=p, distribution_name=Normal,\n", + " var=['a'], cond_var=['x'], input_var=['x'], features_shape=torch.Size([])\n", + " (fc1): Linear(in_features=50, out_features=10, bias=True)\n", + " (fc_loc): Linear(in_features=10, out_features=20, bias=True)\n", + " (fc_scale): Linear(in_features=10, out_features=20, bias=True)\n", + " )\n" + ] + }, + { + "data": { + "text/latex": [ + "$\\displaystyle p(a|x)$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(p_nor_a__x)\n", + "print_latex(p_nor_a__x)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This distribution is conditioned by x like we set `cond_var` when defining constructor." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can do sampling by `.sample()` but there is one point to be care about.\n", + "\n", + "This is conditional probability distribution, so we explicitly input conditional variable when sampling.\n", + "\n", + "We prepare `x_samples` and set `x_samples` to conditional variable `x`." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "x_samples = torch.Tensor([[-0.3030, -1.7618, 0.6348, -0.8044, -1.0371, -1.0669, -0.2085,\n", + " -0.2155, 2.2952, 0.6749, 1.7133, -1.7943, -1.5208, 0.9196,\n", + " -0.5484, -0.3472, 0.4730, -0.4286, 0.5514, -1.5474, 0.7575,\n", + " -0.4068, -0.1277, 0.2804, 1.7460, 1.8550, -0.7064, 2.5571,\n", + " 0.7705, -1.0739, -0.2015, -0.5603, -0.6240, -0.9773, -0.1637,\n", + " -0.3582, -0.0594, -2.4919, 0.2423, 0.2883, -0.1095, 0.3126,\n", + " -0.3417, 0.9473, 0.6223, -0.4481, -0.2856, 0.3880, -1.1435,\n", + " -0.6512]])" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'x': tensor([[-0.3030, -1.7618, 0.6348, -0.8044, -1.0371, -1.0669, -0.2085, -0.2155,\n", + " 2.2952, 0.6749, 1.7133, -1.7943, -1.5208, 0.9196, -0.5484, -0.3472,\n", + " 0.4730, -0.4286, 0.5514, -1.5474, 0.7575, -0.4068, -0.1277, 0.2804,\n", + " 1.7460, 1.8550, -0.7064, 2.5571, 0.7705, -1.0739, -0.2015, -0.5603,\n", + " -0.6240, -0.9773, -0.1637, -0.3582, -0.0594, -2.4919, 0.2423, 0.2883,\n", + " -0.1095, 0.3126, -0.3417, 0.9473, 0.6223, -0.4481, -0.2856, 0.3880,\n", + " -1.1435, -0.6512]]), 'a': tensor([[-1.7231e-01, -5.0856e-01, 1.3573e+00, -7.1246e-01, 3.8644e-01,\n", + " 1.1225e+00, 1.4864e-01, 6.8819e-02, -5.6884e-01, -2.4427e+00,\n", + " 1.2279e-03, -9.0337e-01, 5.3217e-02, 6.0509e-01, -3.8033e-01,\n", + " 6.5706e-02, -2.3049e-01, 3.4607e-01, 2.6745e-02, -3.9659e-01]])}\n", + "tensor([[-1.7231e-01, -5.0856e-01, 1.3573e+00, -7.1246e-01, 3.8644e-01,\n", + " 1.1225e+00, 1.4864e-01, 6.8819e-02, -5.6884e-01, -2.4427e+00,\n", + " 1.2279e-03, -9.0337e-01, 5.3217e-02, 6.0509e-01, -3.8033e-01,\n", + " 6.5706e-02, -2.3049e-01, 3.4607e-01, 2.6745e-02, -3.9659e-01]])\n", + "tensor([[-0.3030, -1.7618, 0.6348, -0.8044, -1.0371, -1.0669, -0.2085, -0.2155,\n", + " 2.2952, 0.6749, 1.7133, -1.7943, -1.5208, 0.9196, -0.5484, -0.3472,\n", + " 0.4730, -0.4286, 0.5514, -1.5474, 0.7575, -0.4068, -0.1277, 0.2804,\n", + " 1.7460, 1.8550, -0.7064, 2.5571, 0.7705, -1.0739, -0.2015, -0.5603,\n", + " -0.6240, -0.9773, -0.1637, -0.3582, -0.0594, -2.4919, 0.2423, 0.2883,\n", + " -0.1095, 0.3126, -0.3417, 0.9473, 0.6223, -0.4481, -0.2856, 0.3880,\n", + " -1.1435, -0.6512]])\n" + ] + } + ], + "source": [ + "p_nor_a__x_samples = p_nor_a__x.sample({'x': x_samples})\n", + "print(p_nor_a__x_samples)\n", + "print(p_nor_a__x_samples['a'])\n", + "print(p_nor_a__x_samples['x'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Output contains samples of a and x.\n", + "\n", + "a is samples by `.sample()` from the distribution and x is feeded `x_samples`." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Next Tutorial\n", + "02-LossAPITutorial.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/tutorial/English/02-LossAPITutorial.ipynb b/tutorial/English/02-LossAPITutorial.ipynb new file mode 100644 index 00000000..d2671352 --- /dev/null +++ b/tutorial/English/02-LossAPITutorial.ipynb @@ -0,0 +1,859 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## In deep generative models, model design means defining objective functions\n", + "- Any deep generative models explicitly set the objective function to optimize\n", + " - Autoregressive models・Flow models: Kullback-Leibler divergence(log likelihood)\n", + " - VAE: Evidence lower bound\n", + " - GAN: Jensen-Shannon divergence(GAN also needs update of objective function itsself(=adversarial learning))\n", + "- Regularization terms of inference or random variable representation is incorporated in the objective function\n", + "\n", + " \n", + " - In deep generative models, model design means defining objective functions\n", + " - Unlike traditional generative models, deep generative models don't inference by sampling\n", + "- A framework that receives probability distributions and defines the objective functions\n", + " - LossAPI \n", + "" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Receive probability distribution and define the objective function\n", + "- Loss API document: https://pixyz.readthedocs.io/en/latest/losses.html#\n", + "\n", + "We take probability distributions defined in Distribution API and define the objective function. \n", + "In order to define the objective function, it needs these elements. \n", + "1. Calculate likelihood\n", + "1. Calculate the distance between probability distribution\n", + "1. Calculate the expected value\n", + "1. Calculation considering data distribution(mean, sum) \n", + "\n", + "In VAE loss, each elements corresponds as follows\n", + "" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Evaluate the loss\n", + "Loss API needs input variable(`input_var`). The value of loss is calculated not until the input variable feeds into the loss.\n", + "```python\n", + "p = DistributionAPI()\n", + "# define the objective function receiving distribution\n", + "loss = LossAPI(p)\n", + "# the value of loss is calculated when input_var is feeded\n", + "loss_value = loss.eval({'input_var': input_data})\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from __future__ import print_function\n", + "import torch\n", + "from torch import nn\n", + "from torch.nn import functional as F\n", + "import numpy as np\n", + "\n", + "torch.manual_seed(1)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Pixyz module\n", + "from pixyz.distributions import Normal\n", + "from pixyz.utils import print_latex" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Calculate likelihood\n", + "When the observation $x_1$, ...., $x_N$ is obtained, we calculate the likelihood of the probability distribution p, which we assume x follows. \n", + "Here, we assume x follows a Gaussian distribution with mean=0, variance = 1. \n", + "$p(x) = \\cal N(\\mu=0, \\sigma^2=1)$" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Distribution:\n", + " p(x)\n", + "Network architecture:\n", + " Normal(\n", + " name=p, distribution_name=Normal,\n", + " var=['x'], cond_var=[], input_var=[], features_shape=torch.Size([5])\n", + " (loc): torch.Size([1, 5])\n", + " (scale): torch.Size([1, 5])\n", + " )\n" + ] + }, + { + "data": { + "text/latex": [ + "$\\displaystyle p(x)$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# define probability distribution p\n", + "x_dim = 5\n", + "p_nor_x = Normal(var=['x'], loc=torch.tensor(0.), scale=torch.tensor(1.), features_shape=[x_dim])\n", + "print(p_nor_x)\n", + "print_latex(p_nor_x)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([100, 5])\n" + ] + } + ], + "source": [ + "# observe x\n", + "observed_x_num = 100\n", + "observed_x = torch.randn(observed_x_num, x_dim)\n", + "print(observed_x.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Log likelihood is calculated as follows: \n", + "$L=\\sum_{i=1}^{100} \\log p\\left(x_{i}\\right)$ \n", + "We can calculate log likelihood easily by using `LogProb()`. \n", + "To define log likelihood, We set the probability distribution defined in Pixyz distribution to `LogProb()`'s argument. \n", + "The value is calculated when observed data feeded into `LogProb.eval()`. \n", + "Pixyz document: https://docs.pixyz.io/en/latest/losses.html#probability-density-function" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle \\log p(x)$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from pixyz.losses import LogProb\n", + "# set the probability distribution to LogProb()'s arg\n", + "log_likelihood_x = LogProb(p_nor_x)\n", + "print_latex(log_likelihood_x)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor([ -7.5539, -6.8545, -6.4024, -5.8851, -6.1517, -8.3702, -6.7028,\n", + " -5.0395, -7.4346, -7.1497, -5.7594, -7.3006, -11.9857, -5.8238,\n", + " -6.7561, -5.7640, -6.2382, -4.9060, -6.1076, -8.2535, -7.8250,\n", + " -7.1956, -7.6949, -5.2324, -11.5860, -8.1068, -7.1763, -8.3332,\n", + " -11.4631, -6.6297, -6.1200, -12.2358, -5.3402, -7.1465, -7.5106,\n", + " -7.0829, -6.6300, -6.1832, -7.2049, -10.8676, -6.8674, -5.8339,\n", + " -9.1939, -7.5965, -8.7743, -7.3492, -5.2578, -10.3097, -6.5646,\n", + " -4.8807, -5.9738, -6.2394, -10.3945, -9.1760, -9.2957, -5.5627,\n", + " -7.1047, -6.4066, -6.8100, -6.0878, -6.8835, -7.9132, -5.0738,\n", + " -8.8378, -6.2286, -5.8401, -5.9691, -5.6857, -7.6903, -6.4982,\n", + " -7.1259, -8.7953, -10.5572, -5.9161, -7.0649, -6.1292, -6.0871,\n", + " -7.2513, -7.2517, -7.1378, -6.4228, -5.5728, -5.6155, -5.1962,\n", + " -8.3940, -7.8178, -9.8129, -6.1119, -5.0492, -8.9898, -6.9675,\n", + " -8.0218, -13.9816, -6.8575, -5.1304, -5.5069, -5.0561, -5.1264,\n", + " -4.8489, -5.4876])\n", + "observed_x_num: 100\n" + ] + } + ], + "source": [ + "# The likelihood for each observation is calculated\n", + "print(log_likelihood_x.eval({'x': observed_x}))\n", + "# observed_x_num = 100\n", + "print('observed_x_num: ', len(log_likelihood_x.eval({'x': observed_x})))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`log_likelihood_x.eval({'x': observed_x})`'s output has the calculated result of \n", + "$\\log p(x_{1})$, $\\log p(x_{2})$, ...., $\\log p(x_{100})$ \n", + "\n", + "log_likelihood_x.eval({'x': observed_x})[i] = $\\log p(x_{i})$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, calculate \n", + "$L=\\sum_{i=1}^{100} \\log p\\left(x_{i}\\right)$" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "log likelihood result: tensor(-715.5875)\n" + ] + } + ], + "source": [ + "# sum\n", + "print('log likelihood result:', log_likelihood_x.eval({'x': observed_x}).sum())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As shown above, we can easily calculate log likelihood by using pixyz.losses `LogProb()`. \n", + "The same calculation can be performed by defined probability distribution method `p.log_prob().eval()` " + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "LogProb()\n", + "tensor(-715.5875)\n", + ".log_prob()\n", + "tensor(-715.5875)\n" + ] + } + ], + "source": [ + "print('LogProb()')\n", + "print(LogProb(p_nor_x).eval({'x': observed_x}).sum())\n", + "print('.log_prob()')\n", + "print(p_nor_x.log_prob().eval({'x': observed_x}).sum())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For more Loss API related to probability density function: \n", + "https://docs.pixyz.io/en/latest/losses.html#probability-density-function" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Calculate the distance between probability distributions\n", + "In the learning of generative models, we consider $p_{\\theta}(x)$ that is closed to the true distribution(data distribution) $p_{data}(x)$. \n", + "To find the appropriate parameter $\\theta$, we measure the distance between distributions.\n", + "\n", + "In VAE models we calculate Kullback-Leibler divergence, and in GAN models we calculate Jensen-Shannon divergence. \n", + "We can easily calculte the distance between distributions by Loss API \n", + "Pixyz document: \n", + "https://docs.pixyz.io/en/latest/losses.html#statistical-distance \n", + "https://pixyz.readthedocs.io/en/latest/losses.html#adversarial-statistical-distance\n", + "\n", + "Here, we calculate the Kullback-Leibler divergence between a Gaussian distribution with mean=0, variance=1 and a Gaussian distribution with mean=5, variance=0.1 \n", + "$p(x) = \\cal N(\\mu=0, \\sigma^2=1)$ \n", + "$q(x) = \\cal N(\\mu=5, \\sigma^2=0.1)$ \n", + "$KL(q(x) || p(x))$" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle p(x)$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# define probability distribution\n", + "x_dim = 10\n", + "# p \n", + "p_nor_x = Normal(var=['x'], loc=torch.tensor(0.), scale=torch.tensor(1.), features_shape=[x_dim])\n", + "print_latex(p_nor_x)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle q(x)$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# q\n", + "q_nor_x = Normal(var=['x'], loc=torch.tensor(5.), scale=torch.tensor(0.1), features_shape=[x_dim], name='q')\n", + "print_latex(q_nor_x)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To calculate Kullback-Leibler divergence, we use pixyz.losses `KullbackLeibler`. \n", + "We set the probability distribution defined in Pixyz distribution to `KullbackLeibler()`'s argument. \n", + "The value is calculated by `.eval()` method \n", + "Pixyz document: https://docs.pixyz.io/en/latest/losses.html#kullbackleibler " + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle D_{KL} \\left[q(x)||p(x) \\right]$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from pixyz.losses import KullbackLeibler\n", + "\n", + "kl_q_p = KullbackLeibler(q_nor_x, p_nor_x)\n", + "print_latex(kl_q_p)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([143.0759])" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# calculte the value\n", + "kl_q_p.eval()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For more Loss API related to statistical distance: \n", + "https://docs.pixyz.io/en/latest/losses.html#statistical-distance \n", + "https://docs.pixyz.io/en/latest/losses.html#adversarial-statistical-distance " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Calculate the expected value\n", + "Expected value is a weighted average of all values of a random variable with a probability weight.\n", + "In Pixyz, we calculate expected values of the variables which we can't feed as `input_var` like latent variable(Because it does't exist explicitly in the observation). \n", + "We can easily calculte the expected value of the random variables by Loss API. \n", + "Pixyz document: \n", + "https://docs.pixyz.io/en/latest/losses.html#expected-value" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here, we consider these two probability distributions \n", + "$q(z|x) = \\cal N(\\mu=x, \\sigma^2=1)$ \n", + "$p(x|z) = \\cal N(\\mu=z, \\sigma^2=1)$ \n", + "and calculate following expected value \n", + "$\\mathbb{E}_{q(z|x)} \\left[\\log p(x|z) \\right]$" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "# define probability distributions\n", + "from pixyz.distributions import Normal\n", + "\n", + "q_nor_z__x = Normal(loc=\"x\", scale=torch.tensor(1.), var=[\"z\"], cond_var=[\"x\"],\n", + " features_shape=[10], name='q') # q(z|x)\n", + "p_nor_x__z = Normal(loc=\"z\", scale=torch.tensor(1.), var=[\"x\"], cond_var=[\"z\"],\n", + " features_shape=[10]) # p(x|z)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle \\log p(x|z)$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Caltulate the Log likelihood of p(x|z)\n", + "from pixyz.losses import LogProb\n", + "\n", + "p_log_likelihood = LogProb(p_nor_x__z)\n", + "print_latex(p_log_likelihood)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To calculate expected values, we use pixyz.losses `Expectation`. \n", + "`Expectation()` has argument `p` and `f`. \n", + "We set the function of which we want to calculate expected values to argument `f`, and we set probability distributions which `f` function's random variable follows to argument `p`. \n", + "The value is calculated by `.eval()` method. \n", + "Pixyz document: https://docs.pixyz.io/en/latest/losses.html#expected-value" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle \\mathbb{E}_{q(z|x)} \\left[\\log p(x|z) \\right]$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from pixyz.losses import Expectation as E\n", + "\n", + "E_q_logprob_p = E(q_nor_z__x, LogProb(p_nor_x__z))\n", + "print_latex(E_q_logprob_p)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([-10.7006, -11.9861])" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sample_x = torch.randn(2, 10)\n", + "E_q_logprob_p.eval({'x': sample_x})" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For more details about Expectatoin API: \n", + "https://docs.pixyz.io/en/latest/losses.html#expected-value" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Calculation considering data distribution(mean, sum) \n", + "In theory, it is necessary to take the expected value of x, but since the data distribution is not actually given, we need to do calculations such as average and sum in the ovserved x batch direction. \n", + "We can easily calculte average and sum by Loss API. \n", + "Here, we calculate likelihood of training data observed_x and calculate its mean. \n", + "$p(x) = \\cal N(\\mu=0, \\sigma^2=1)$ \n", + "$\\frac{1}{N} \\sum_{i=1}^N\\left[\\log p\\left(x^{(i)}\\right)\\right]$" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([100, 5])\n" + ] + } + ], + "source": [ + "# observe x\n", + "observed_x_num = 100\n", + "x_dim = 5\n", + "observed_x = torch.randn(observed_x_num, x_dim)\n", + "print(observed_x.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Distribution:\n", + " p(x)\n", + "Network architecture:\n", + " Normal(\n", + " name=p, distribution_name=Normal,\n", + " var=['x'], cond_var=[], input_var=[], features_shape=torch.Size([5])\n", + " (loc): torch.Size([1, 5])\n", + " (scale): torch.Size([1, 5])\n", + " )\n" + ] + }, + { + "data": { + "text/latex": [ + "$\\displaystyle p(x)$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# define probability distribution\n", + "p_nor_x = Normal(var=['x'], loc=torch.tensor(0.), scale=torch.tensor(1.), features_shape=[x_dim])\n", + "print(p_nor_x)\n", + "print_latex(p_nor_x)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can calculate sum or mean by `Loss.mean()` or `Loss.sum()`." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle mean \\left(\\log p(x) \\right)$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from pixyz.losses import LogProb\n", + "# calculate mean\n", + "mean_log_likelihood_x = LogProb(p_nor_x).mean() # .mean()\n", + "print_latex(mean_log_likelihood_x)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor(-7.1973)" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mean_log_likelihood_x.eval({'x': observed_x})" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Combine Loss\n", + "We can do arithmetic operations between losses. \n", + "As an example, we define the following Loss by combining losses. \n", + "$\\frac{1}{N} \\sum_{i=1}^{N}\\left[\\mathbb{E}_{q\\left(z | x^{(i)}\\right)}\\left[\\log p\\left(x^{(i)} | z\\right)\\right]-K L\\left(q\\left(z | x^{(i)}\\right) \\| p(z)\\right)\\right]$" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "# define probability distributions\n", + "from pixyz.distributions import Normal\n", + "\n", + "# p(x|z)\n", + "p_nor_x__z = Normal(loc=\"z\", scale=torch.tensor(1.), var=[\"x\"], cond_var=[\"z\"],\n", + " features_shape=[10])\n", + "\n", + "# p(z)\n", + "p_nor_z = Normal(loc=torch.tensor(0.), scale=torch.tensor(1.), var=[\"z\"],\n", + " features_shape=[10])\n", + "\n", + "# q(z|x)\n", + "q_nor_z__x = Normal(loc=\"x\", scale=torch.tensor(1.), var=[\"z\"], cond_var=[\"x\"],\n", + " features_shape=[10], name='q')" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle mean \\left(- D_{KL} \\left[q(z|x)||p(z) \\right] + \\mathbb{E}_{q(z|x)} \\left[\\log p(x|z) \\right] \\right)$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# define Loss\n", + "from pixyz.losses import LogProb\n", + "from pixyz.losses import Expectation as E\n", + "from pixyz.losses import KullbackLeibler\n", + "\n", + "# Log likelihood \n", + "logprob_p_x__z = LogProb(p_nor_x__z)# input_var: x, z\n", + "\n", + "# Expecration\n", + "E_q_z__x_logprob_p__z = E(q_nor_z__x, logprob_p_x__z)# input_car: x(z is not needed because of Expectation)\n", + "\n", + "# KL divergence\n", + "KL_q_z__x_p_z = KullbackLeibler(q_nor_z__x, p_nor_z)\n", + "\n", + "# Subtraction between losses\n", + "total_loss = E_q_z__x_logprob_p__z - KL_q_z__x_p_z# input_var: x(E_q_z__x_logprob_p__z needs x as input_var)\n", + "\n", + "# mean of loss\n", + "total_loss = total_loss.mean()\n", + "\n", + "# check the loss\n", + "print_latex(total_loss)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor(-18.9965)" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# calculate the loss value\n", + "# observe x\n", + "observed_x_num = 100\n", + "x_dim = 10\n", + "observed_x = torch.randn(observed_x_num, x_dim)\n", + "\n", + "# calculate the loss given observed x\n", + "total_loss.eval({'x': observed_x})" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As shown above, we can define loss flexibly wth arithemtic operations between the Pixyz Loss API. \n", + "We can convert formulas to codes easily and intuitively with Pixyz Loss API." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Loss API(ELBO)\n", + "Pixyz Loss API has `ELBO` loss class. \n", + "\n", + "Evidence Lower Bound ELBO: https://docs.pixyz.io/en/latest/losses.html#lower-bound" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Next Tutorial\n", + "ModelAPITutorial.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/tutorial/English/03-ModelAPITutorial.ipynb b/tutorial/English/03-ModelAPITutorial.ipynb new file mode 100644 index 00000000..ced6e643 --- /dev/null +++ b/tutorial/English/03-ModelAPITutorial.ipynb @@ -0,0 +1,531 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Deep generative models learn by defining objective function and using gradient descent method\n", + "- Unlike traditional generative models, deep generative models don't learn by sampling\n", + "\n", + "\n", + "" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## A framework in which objective function and optimization algorithm can be set independently(Model API)\n", + "- Model API document: https://docs.pixyz.io/en/v0.0.4/models.html \n", + "\n", + "Here, we train the model with defined probability distributions and loss function by using Model API." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import torch\n", + "import torch.utils.data\n", + "from torch import nn, optim\n", + "from torch.nn import functional as F\n", + "import torchvision\n", + "from torchvision import datasets, transforms\n", + "\n", + "if torch.cuda.is_available():\n", + " device = \"cuda\"\n", + "else:\n", + " device = \"cpu\"\n", + "\n", + "batch_size = 256\n", + "seed = 1\n", + "torch.manual_seed(seed)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# MNIST dataset\n", + "root = '../data'\n", + "transform = transforms.Compose([transforms.ToTensor(),\n", + " transforms.Lambda(lambd=lambda x: x.view(-1))])\n", + "kwargs = {'batch_size': batch_size, 'num_workers': 1, 'pin_memory': True}\n", + "\n", + "train_loader = torch.utils.data.DataLoader(\n", + " datasets.MNIST(root=root, train=True, transform=transform, download=True),\n", + " shuffle=True, **kwargs)\n", + "test_loader = torch.utils.data.DataLoader(\n", + " datasets.MNIST(root=root, train=False, transform=transform),\n", + " shuffle=False, **kwargs)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Define probability distributions" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "from pixyz.distributions import Normal, Bernoulli\n", + "\n", + "x_dim = 784\n", + "z_dim = 64\n", + "\n", + "# inference model q(z|x)\n", + "class Inference(Normal):\n", + " def __init__(self):\n", + " super(Inference, self).__init__(var=[\"z\"], cond_var=[\"x\"], name=\"q\")\n", + "\n", + " self.fc1 = nn.Linear(x_dim, 512)\n", + " self.fc2 = nn.Linear(512, 512)\n", + " self.fc31 = nn.Linear(512, z_dim)\n", + " self.fc32 = nn.Linear(512, z_dim)\n", + "\n", + " def forward(self, x):\n", + " h = F.relu(self.fc1(x))\n", + " h = F.relu(self.fc2(h))\n", + " return {\"loc\": self.fc31(h), \"scale\": F.softplus(self.fc32(h))}\n", + "\n", + " \n", + "# generative model p(x|z) \n", + "class Generator(Bernoulli):\n", + " def __init__(self):\n", + " super(Generator, self).__init__(var=[\"x\"], cond_var=[\"z\"], name=\"p\")\n", + "\n", + " self.fc1 = nn.Linear(z_dim, 512)\n", + " self.fc2 = nn.Linear(512, 512)\n", + " self.fc3 = nn.Linear(512, x_dim)\n", + "\n", + " def forward(self, z):\n", + " h = F.relu(self.fc1(z))\n", + " h = F.relu(self.fc2(h))\n", + " return {\"probs\": torch.sigmoid(self.fc3(h))}\n", + " \n", + "gen_ber_x__z = Generator().to(device)\n", + "infer_nor_z__x = Inference().to(device)\n", + "\n", + "prior_nor_z = Normal(loc=torch.tensor(0.), scale=torch.tensor(1.),\n", + " var=[\"z\"], features_shape=[z_dim], name=\"p_{prior}\").to(device)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Define Loss" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle mean \\left(D_{KL} \\left[q(z|x)||p_{prior}(z) \\right] - \\mathbb{E}_{q(z|x)} \\left[\\log p(x|z) \\right] \\right)$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from pixyz.losses import LogProb\n", + "from pixyz.losses import Expectation as E\n", + "from pixyz.losses import KullbackLeibler\n", + "from pixyz.utils import print_latex\n", + "\n", + "# log likelihood\n", + "logprob_gen_x__z = LogProb(gen_ber_x__z)\n", + "\n", + "# Expectation\n", + "E_infer_z__x_logprob_gen_x__z = E(infer_nor_z__x, logprob_gen_x__z)\n", + "\n", + "# KL divergence\n", + "KL_infer_nor_z__x_prior_nor_z = KullbackLeibler(infer_nor_z__x, prior_nor_z)\n", + "\n", + "# Subtraction between losses\n", + "total_loss = KL_infer_nor_z__x_prior_nor_z - E_infer_z__x_logprob_gen_x__z\n", + "\n", + "# mean of loss\n", + "total_loss = total_loss.mean()\n", + "\n", + "\n", + "# check the loss\n", + "print_latex(total_loss)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Model API: Set probability distributions and loss, and optimization algorithm" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We use pixyz.models Model. \n", + "Main arguments are `loss`, `distributions`, `optimizer`, `optimzer_params`. We set each arguments as follows. \n", + "- loss: Set defined loss function defined by Loss API\n", + "- distributions: Set defined probability distributions which have parameters supposed to be learned defined by Distribution API \n", + "- optimizer, optimizer_params: Set optimization algorithms and parameters of the algorithm \n", + "\n", + "For more details about Model: https://docs.pixyz.io/en/v0.0.4/_modules/pixyz/models/model.html#Model" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "from pixyz.models import Model\n", + "from torch import optim\n", + "\n", + "optimizer = optim.Adam\n", + "optimizer_params = {'lr': 1e-3}\n", + "\n", + "vae_model = Model(loss=total_loss, \n", + " distributions=[gen_ber_x__z, infer_nor_z__x],\n", + " optimizer=optimizer,\n", + " optimizer_params=optimizer_params\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We have defined Model. \n", + "As shown above, we can set objective function and optimization algorithm independently. \n", + "Next, we train the model using `train()` method. \n", + "Model Class `train()` processes are following. \n", + "source code: https://docs.pixyz.io/en/v0.0.4/_modules/pixyz/models/model.html#Model.train\n", + "1. Receive observed data x(.train({\"x\": x})) \n", + "2. Calculate loss \n", + "3. 1 step update of parameters \n", + "4. Return the loss value " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "```python\n", + "def train(self, train_x={}, **kwargs):\n", + " self.distributions.train()\n", + "\n", + " self.optimizer.zero_grad()\n", + " loss = self.loss_cls.estimate(train_x, **kwargs)\n", + "\n", + " # backprop\n", + " loss.backward()\n", + "\n", + " # update params\n", + " self.optimizer.step()\n", + "\n", + " return loss\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Training" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 0, Loss 199.86109924316406 \n", + "Epoch 1, Loss 147.0438690185547 \n", + "Epoch 2, Loss 126.67538452148438 \n" + ] + } + ], + "source": [ + "epoch_loss = []\n", + "for epoch in range(3):\n", + " train_loss = 0\n", + " for x, _ in train_loader:\n", + " x = x.to(device)\n", + " loss = vae_model.train({\"x\": x})\n", + " train_loss += loss\n", + " train_loss = train_loss * train_loader.batch_size / len(train_loader.dataset)\n", + " print('Epoch {}, Loss {} '.format(epoch, train_loss))\n", + " epoch_loss.append(train_loss)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Use more {abstract} Model API\n", + "We can define models more easily by using more {abstract} Model API. \n", + "We need to set: \n", + "- define probability distributions \n", + "- (define additional loss functions)\n", + "- select the optimization algorithm\n", + "\n", + "Here, we use VAE model as an example. " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "from pixyz.distributions import Normal, Bernoulli\n", + "from pixyz.losses import KullbackLeibler\n", + "# more {abstract} Model API VAE\n", + "from pixyz.models import VAE" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Define probability distributions" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "x_dim = 784\n", + "z_dim = 64\n", + "\n", + "\n", + "# inference model q(z|x)\n", + "class Inference(Normal):\n", + " def __init__(self):\n", + " super(Inference, self).__init__(var=[\"z\"], cond_var=[\"x\"], name=\"q\")\n", + "\n", + " self.fc1 = nn.Linear(x_dim, 512)\n", + " self.fc2 = nn.Linear(512, 512)\n", + " self.fc31 = nn.Linear(512, z_dim)\n", + " self.fc32 = nn.Linear(512, z_dim)\n", + "\n", + " def forward(self, x):\n", + " h = F.relu(self.fc1(x))\n", + " h = F.relu(self.fc2(h))\n", + " return {\"loc\": self.fc31(h), \"scale\": F.softplus(self.fc32(h))}\n", + "\n", + " \n", + "# generative model p(x|z) \n", + "class Generator(Bernoulli):\n", + " def __init__(self):\n", + " super(Generator, self).__init__(var=[\"x\"], cond_var=[\"z\"], name=\"p\")\n", + "\n", + " self.fc1 = nn.Linear(z_dim, 512)\n", + " self.fc2 = nn.Linear(512, 512)\n", + " self.fc3 = nn.Linear(512, x_dim)\n", + "\n", + " def forward(self, z):\n", + " h = F.relu(self.fc1(z))\n", + " h = F.relu(self.fc2(h))\n", + " return {\"probs\": torch.sigmoid(self.fc3(h))}\n", + " \n", + "p = Generator().to(device)\n", + "q = Inference().to(device)\n", + "\n", + "prior = Normal(loc=torch.tensor(0.), scale=torch.tensor(1.),\n", + " var=[\"z\"], features_shape=[z_dim], name=\"p_{prior}\").to(device)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Add regularization terms to the loss function" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle D_{KL} \\left[q(z|x)||p_{prior}(z) \\right]$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "kl = KullbackLeibler(q, prior)\n", + "print_latex(kl)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### VAE Model: Set additional loss function and select the optimazation algorithm " + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle mean \\left(D_{KL} \\left[q(z|x)||p_{prior}(z) \\right] - \\mathbb{E}_{q(z|x)} \\left[\\log p(x|z) \\right] \\right)$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model = VAE(encoder=q, decoder=p, regularizer=kl, \n", + " optimizer=optim.Adam, optimizer_params={\"lr\":1e-3})\n", + "print_latex(model)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Training" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "def train(epoch):\n", + " train_loss = 0\n", + " for x, _ in train_loader:\n", + " x = x.to(device)\n", + " loss = model.train({\"x\": x})\n", + " train_loss += loss\n", + " \n", + " train_loss = train_loss * train_loader.batch_size / len(train_loader.dataset)\n", + " print('Epoch: {} Train loss: {:.4f}'.format(epoch, train_loss))\n", + " return train_loss" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 1 Train loss: 200.3801\n", + "Epoch: 2 Train loss: 147.1353\n", + "Epoch: 3 Train loss: 127.9876\n" + ] + } + ], + "source": [ + "epochs = 3\n", + "train_losses = []\n", + "for epoch in range(1, epochs + 1):\n", + " train_loss = train(epoch)\n", + " train_losses.append(train_loss)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For more {abstract} Model\n", + "- Pre-implementation models: https://docs.pixyz.io/en/v0.0.4/models.html#pre-implementation-models" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Pixyz implementations\n", + "There are more complexed models written in pixyz in the following links. \n", + "- Pixyz examples: https://github.com/masa-su/pixyz/tree/master/examples\n", + "- Pixyzoo: https://github.com/masa-su/pixyzoo\n", + "\n", + "Pixyz implementation work flow is the same for all models \n", + "1. Define probability distributions using `Distribution API` \n", + "1. Define the loss function based on the defined probability distributions using `Loss API`\n", + "1. Set probability distributions and loss, and optimization algorithm using `Model API`, and train" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/tutorial/English/04-DeepMarkovModel.ipynb b/tutorial/English/04-DeepMarkovModel.ipynb new file mode 100644 index 00000000..1e02b337 --- /dev/null +++ b/tutorial/English/04-DeepMarkovModel.ipynb @@ -0,0 +1,3551 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Action Conditional Deep Markov Model using cartpole dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/ubuntu/anaconda3/lib/python3.6/site-packages/matplotlib/__init__.py:1067: UserWarning: Duplicate key in file \"/home/ubuntu/.config/matplotlib/matplotlibrc\", line #2\n", + " (fname, cnt))\n", + "/home/ubuntu/anaconda3/lib/python3.6/site-packages/matplotlib/__init__.py:1067: UserWarning: Duplicate key in file \"/home/ubuntu/.config/matplotlib/matplotlibrc\", line #3\n", + " (fname, cnt))\n" + ] + } + ], + "source": [ + "from tqdm import tqdm\n", + "\n", + "import torch\n", + "from torch import optim\n", + "import torch.nn as nn\n", + "import torch.nn.functional as F\n", + "from torchvision import transforms, datasets\n", + "from tensorboardX import SummaryWriter\n", + "import numpy as np\n", + "\n", + "from utils import DMMDataset, imshow\n", + "from torch.utils.data import DataLoader\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "\n", + "seed = 1\n", + "torch.manual_seed(seed)\n", + "if torch.cuda.is_available():\n", + " device = \"cuda\"\n", + "else:\n", + " device = \"cpu\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Prepare Dataset \n", + "you have to run prepare_cartpole_dataset.py or download from : \n", + "https://drive.google.com/drive/folders/1w_97RLFS--CpdUCNw1C-3yPLhceZxkO2?usp=sharing" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# you have to run prepare_cartpole_dataset.py or download from :\n", + "batch_size = 256\n", + "train_loader = DataLoader(DMMDataset(), batch_size=batch_size, shuffle=True, drop_last=True)\n", + "# test_loader = DataLoader(DMMTestDataset(), batch_size=batch_size, shuffle=False, drop_last=True)\n", + "\n", + "_x = iter(train_loader).next()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor([[0.],\n", + " [0.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [0.],\n", + " [0.],\n", + " [1.],\n", + " [0.],\n", + " [0.],\n", + " [1.],\n", + " [1.],\n", + " [0.],\n", + " [1.],\n", + " [1.],\n", + " [0.],\n", + " [1.],\n", + " [0.],\n", + " [0.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.]])\n" + ] + } + ], + "source": [ + "imshow(_x['episode_frames'][0][0:30])\n", + "\n", + "# 0: Push cart to the left\n", + "# 1:Push cart to the right\n", + "print(_x['actions'][0][0:30])\n", + "\n", + "# for more details about actions: https://github.com/openai/gym/blob/38a1f630dc9815a567aaf299ae5844c8f8b9a6fa/gym/envs/classic_control/cartpole.py#L37\n", + "# for more details about CartPole-v1: https://gym.openai.com/envs/CartPole-v1/" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "from pixyz.utils import print_latex\n", + "from pixyz.distributions import Bernoulli, Normal, Deterministic\n", + "\n", + "\n", + "h_dim = 32\n", + "hidden_dim = 32\n", + "z_dim = 16\n", + "t_max = 30\n", + "u_dim = 1" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Deep Markov Model\n", + "* Original paper: Structured Inference Networks for Nonlinear State Space Models (https://arxiv.org/abs/1609.09869)\n", + "* Original code: https://github.com/clinicalml/dmm\n", + "\n", + "\n", + "Prior(Transition model): $p_{\\theta}(z_{t} | z_{t-1}, u) = \\cal{N}(\\mu = f_{prior_\\mu}(z_{t-1}, u), \\sigma^2 = f_{prior_\\sigma^2}(z_{t-1}, u)$ \n", + "Generator(Emission): $p_{\\theta}(x | z)=\\mathscr{B}\\left(x ; \\lambda=g_{x}(z)\\right)$ \n", + "\n", + "RNN: $p(h) = RNN(x)$ \n", + "Inference(Combiner): $p_{\\phi}(z | h, z_{t-1}, u) = \\cal{N}(\\mu = f_{\\mu}(h, z_{t-1}, u), \\sigma^2 = f_{\\sigma^2}(h, z_{t-1}, u)$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Define probability distributions" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# RNN\n", + "class RNN(Deterministic):\n", + " \"\"\"\n", + " h = RNN(x)\n", + " Given observed x, RNN output hidden state\n", + " \"\"\"\n", + " def __init__(self):\n", + " super(RNN, self).__init__(var=[\"h\"], cond_var=[\"x\"])\n", + " \n", + " # 28x28x3 → 32\n", + " self.conv1 = nn.Conv2d(3, 64, kernel_size=4, stride=2, padding=1)\n", + " self.conv2 = nn.Conv2d(64, 128, kernel_size=4, stride=2, padding=1)\n", + " self.fc1 = nn.Linear(128*7*7, 256)\n", + " self.fc2 = nn.Linear(256, 32)\n", + " \n", + " self.rnn = nn.GRU(32, h_dim, bidirectional=True)\n", + " self.h0 = nn.Parameter(torch.zeros(2, 1, self.rnn.hidden_size))\n", + " self.hidden_size = self.rnn.hidden_size\n", + " \n", + " def forward(self, x):\n", + " \n", + " h0 = self.h0.expand(2, x.size(1), self.rnn.hidden_size).contiguous()\n", + " x = x.reshape(-1, 3, 28, 28) # Nx3x28x28\n", + "\n", + " h = F.relu(self.conv1(x)) # Nx64x14x14\n", + " h = F.relu(self.conv2(h)) # Nx128x7x7\n", + " h = h.view(h.shape[0], 128*7*7) # Nx128*7*7\n", + " h = F.relu(self.fc1(h)) # Nx256\n", + " h = F.relu(self.fc2(h)) # Nx32\n", + " h = h.reshape(30, -1, 32) # 30x128x32\n", + "\n", + " h, _ = self.rnn(h, h0) # 30x128x32, 1x128x32\n", + " return {\"h\": h}\n", + "\n", + "\n", + "# Emission p(x_t | z_t)\n", + "class Generator(Bernoulli):\n", + " \"\"\"\n", + " Given the latent z at time step t, return the vector of\n", + " probabilities that parameterizes the bernlulli distribution p(x_t | z_t)\n", + " \"\"\"\n", + " def __init__(self):\n", + " super(Generator, self).__init__(var=[\"x\"], cond_var=[\"z\"])\n", + " self.fc1 = nn.Linear(z_dim, 256)\n", + " self.fc2 = nn.Linear(256, 128*7*7)\n", + " self.conv1 = nn.ConvTranspose2d(128, 64, kernel_size=4, stride=2, padding=1)\n", + " self.conv2 = nn.ConvTranspose2d(64, 3, kernel_size=4, stride=2, padding=1) \n", + "\n", + " def forward(self, z):\n", + " h = F.relu(self.fc1(z))\n", + " h = F.relu(self.fc2(h))\n", + " h = h.view(h.shape[0], 128, 7, 7) # 128*7*7\n", + " h = F.relu(self.conv1(h)) # 64x14x14\n", + " generated_x = self.conv2(h) # 3x28x28\n", + " return {\"probs\": torch.sigmoid(generated_x)}\n", + "\n", + "\n", + "class Inference(Normal):\n", + " \"\"\"\n", + " given the latent z at time step t-1, the hidden state of the RNN h(x_{0:T} and u\n", + " return the loc and scale vectors that\n", + " parameterize the gaussian distribution q(z_t | z_{t-1}, x_{t:T}, u)\n", + " \"\"\"\n", + " def __init__(self):\n", + " super(Inference, self).__init__(var=[\"z\"], cond_var=[\"h\", \"z_prev\", \"u\"])\n", + " self.fc1 = nn.Linear(z_dim+u_dim, h_dim*2)\n", + " self.fc21 = nn.Linear(h_dim*2, z_dim)\n", + " self.fc22 = nn.Linear(h_dim*2, z_dim)\n", + "\n", + " \n", + " def forward(self, h, z_prev, u):\n", + " feature = torch.cat((z_prev, u), 1)\n", + " h_z = torch.tanh(self.fc1(feature))\n", + " h = 0.5 * (h + h_z)\n", + " return {\"loc\": self.fc21(h), \"scale\": F.softplus(self.fc22(h))}\n", + "\n", + "\n", + "class Prior(Normal):\n", + " \"\"\"\n", + " Given the latent variable at the time step t-1 and u,\n", + " return the mean and scale vectors that parameterize the\n", + " gaussian distribution p(z_t | z_{t-1}, u)\n", + " \"\"\"\n", + " def __init__(self):\n", + " super(Prior, self).__init__(var=[\"z\"], cond_var=[\"z_prev\", \"u\"])\n", + " self.fc1 = nn.Linear(z_dim+u_dim, hidden_dim)\n", + " self.fc21 = nn.Linear(hidden_dim, z_dim)\n", + " self.fc22 = nn.Linear(hidden_dim, z_dim)\n", + " \n", + " def forward(self, z_prev, u):\n", + " feature = torch.cat((z_prev, u), 1)\n", + " h = F.relu(self.fc1(feature))\n", + " return {\"loc\": self.fc21(h), \"scale\": F.softplus(self.fc22(h))}" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$$p(x,z|z_{prev},u) = p(x|z)p(z|z_{prev},u)$$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "prior = Prior().to(device)\n", + "encoder = Inference().to(device)\n", + "decoder = Generator().to(device)\n", + "rnn = RNN().to(device)\n", + "generate_from_prior = prior * decoder\n", + "\n", + "print_latex(generate_from_prior)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Define loss" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "from pixyz.losses import KullbackLeibler\n", + "from pixyz.losses import Expectation as E\n", + "from pixyz.losses import LogProb\n", + "from pixyz.losses import IterativeLoss\n", + "\n", + "step_loss = - E(encoder, LogProb(decoder)) + KullbackLeibler(encoder, prior)\n", + "\n", + "# IterativeLoss: https://docs.pixyz.io/en/latest/losses.html#pixyz.losses.IterativeLoss\n", + "_loss = IterativeLoss(step_loss, max_iter=t_max, \n", + " series_var=[\"x\", \"h\", \"u\"], update_value={\"z\": \"z_prev\"})\n", + "loss = E(rnn, _loss).mean()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Distributions (for training): \n", + " p(h|x), p(z|h,z_{prev},u), p(x|z), p(z|z_{prev},u) \n", + "Loss function: \n", + " mean \\left(\\mathbb{E}_{p(h|x)} \\left[\\sum_{t=1}^{30} \\left(D_{KL} \\left[p(z|h,z_{prev},u)||p(z|z_{prev},u) \\right] - \\mathbb{E}_{p(z|h,z_{prev},u)} \\left[\\log p(x|z) \\right]\\right) \\right] \\right) \n", + "Optimizer: \n", + " RMSprop (\n", + " Parameter Group 0\n", + " alpha: 0.99\n", + " centered: False\n", + " eps: 1e-08\n", + " lr: 0.0005\n", + " momentum: 0\n", + " weight_decay: 0\n", + " )\n" + ] + }, + { + "data": { + "text/latex": [ + "$$mean \\left(\\mathbb{E}_{p(h|x)} \\left[\\sum_{t=1}^{30} \\left(D_{KL} \\left[p(z|h,z_{prev},u)||p(z|z_{prev},u) \\right] - \\mathbb{E}_{p(z|h,z_{prev},u)} \\left[\\log p(x|z) \\right]\\right) \\right] \\right)$$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from pixyz.models import Model\n", + "\n", + "dmm = Model(loss, distributions=[rnn, encoder, decoder, prior], \n", + " optimizer=optim.RMSprop, optimizer_params={\"lr\": 5e-4}, clip_grad_value=10)\n", + "\n", + "print(dmm)\n", + "print_latex(dmm)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Sampling code" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "def data_loop(epoch, loader, model, device, train_mode=False):\n", + " mean_loss = 0\n", + " for data in loader:\n", + " x = data['episode_frames'].to(device) # 256,30,3,28,28\n", + " u = data['actions'].to(device) # 256,30,1\n", + " batch_size = x.size()[0]\n", + " x = x.transpose(0, 1) # 30,256,3,28,28\n", + " u = u.transpose(0, 1) # 30,256,1\n", + " z_prev = torch.zeros(batch_size, z_dim).to(device)\n", + " if train_mode:\n", + " mean_loss += model.train({'x': x, 'z_prev': z_prev, 'u': u}).item() * batch_size\n", + " else:\n", + " mean_loss += model.test({'x': x, 'z_prev': z_prev, 'u': u}).item() * batch_size\n", + " mean_loss /= len(loader.dataset)\n", + " if train_mode:\n", + " print('Epoch: {} Train loss: {:.4f}'.format(epoch, mean_loss))\n", + " else:\n", + " print('Test loss: {:.4f}'.format(mean_loss))\n", + " return mean_loss\n", + "\n", + "_data = iter(train_loader).next()\n", + "_u = _data['actions'].to(device) # 256,30,1\n", + "_u = _u.transpose(0, 1) # 30,256,1\n", + "\n", + "def plot_video_from_latent(batch_size):\n", + " x = []\n", + " z_prev = torch.zeros(batch_size, z_dim).to(device)\n", + " for step in range(t_max):\n", + " samples = generate_from_prior.sample({'z_prev': z_prev, 'u': _u[step]})\n", + " x_t = decoder.sample_mean({\"z\": samples[\"z\"]})\n", + " z_prev = samples[\"z\"]\n", + " x.append(x_t[None, :])\n", + " x = torch.cat(x, dim=0).transpose(0, 1)\n", + " return x" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Train" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 1/200 [00:03<11:42, 3.53s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 1 Train loss: 25165.2360\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 1%| | 2/200 [00:07<11:43, 3.55s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 2 Train loss: 9130.1990\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 2%|▏ | 3/200 [00:10<11:37, 3.54s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 3 Train loss: 6401.8344\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 2%|▏ | 4/200 [00:14<11:33, 3.54s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 4 Train loss: 5604.6350\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 2%|▎ | 5/200 [00:17<11:30, 3.54s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 5 Train loss: 5250.0818\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 3%|▎ | 6/200 [00:21<11:25, 3.54s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 6 Train loss: 5136.6165\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 4%|▎ | 7/200 [00:24<11:22, 3.53s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 7 Train loss: 5041.2250\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 4%|▍ | 8/200 [00:28<11:18, 3.53s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 8 Train loss: 4976.7343\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 4%|▍ | 9/200 [00:31<11:14, 3.53s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 9 Train loss: 4947.8100\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 5%|▌ | 10/200 [00:35<11:11, 3.53s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 10 Train loss: 4868.6670\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 6%|▌ | 11/200 [00:38<11:08, 3.54s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 11 Train loss: 4887.0091\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 6%|▌ | 12/200 [00:42<11:05, 3.54s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 12 Train loss: 4818.7775\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 6%|▋ | 13/200 [00:46<11:01, 3.54s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 13 Train loss: 4782.6232\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 7%|▋ | 14/200 [00:49<10:58, 3.54s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 14 Train loss: 4773.8522\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 8%|▊ | 15/200 [00:53<10:55, 3.54s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 15 Train loss: 4742.7823\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 8%|▊ | 16/200 [00:56<10:52, 3.54s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 16 Train loss: 4727.1570\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 8%|▊ | 17/200 [01:00<10:48, 3.54s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 17 Train loss: 4696.7326\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 9%|▉ | 18/200 [01:03<10:45, 3.55s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 18 Train loss: 4734.9274\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 10%|▉ | 19/200 [01:07<10:41, 3.55s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 19 Train loss: 4708.8597\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 10%|█ | 20/200 [01:10<10:38, 3.55s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 20 Train loss: 4635.5423\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 10%|█ | 21/200 [01:14<10:35, 3.55s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 21 Train loss: 4662.6501\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 11%|█ | 22/200 [01:18<10:31, 3.55s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 22 Train loss: 4617.7811\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 12%|█▏ | 23/200 [01:21<10:28, 3.55s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 23 Train loss: 4629.0972\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 12%|█▏ | 24/200 [01:25<10:25, 3.55s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 24 Train loss: 4630.6133\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 12%|█▎ | 25/200 [01:28<10:21, 3.55s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 25 Train loss: 4623.1689\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 13%|█▎ | 26/200 [01:32<10:18, 3.55s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 26 Train loss: 4580.3945\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 14%|█▎ | 27/200 [01:35<10:14, 3.55s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 27 Train loss: 4583.2993\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 14%|█▍ | 28/200 [01:39<10:11, 3.55s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 28 Train loss: 4596.0267\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 14%|█▍ | 29/200 [01:43<10:07, 3.56s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 29 Train loss: 4537.0640\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 15%|█▌ | 30/200 [01:46<10:04, 3.56s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 30 Train loss: 4525.9952\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 16%|█▌ | 31/200 [01:50<10:01, 3.56s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 31 Train loss: 4490.8614\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 16%|█▌ | 32/200 [01:53<09:57, 3.56s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 32 Train loss: 4462.6433\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 16%|█▋ | 33/200 [01:57<09:54, 3.56s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 33 Train loss: 4387.5721\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 17%|█▋ | 34/200 [02:01<09:51, 3.56s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 34 Train loss: 4267.6621\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 18%|█▊ | 35/200 [02:04<09:47, 3.56s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 35 Train loss: 4188.8135\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 18%|█▊ | 36/200 [02:08<09:44, 3.56s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 36 Train loss: 4096.4102\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 18%|█▊ | 37/200 [02:11<09:40, 3.56s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 37 Train loss: 4677.2219\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 19%|█▉ | 38/200 [02:15<09:37, 3.56s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 38 Train loss: 3991.7929\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 20%|█▉ | 39/200 [02:19<09:34, 3.57s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 39 Train loss: 3994.9256\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 20%|██ | 40/200 [02:22<09:30, 3.57s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 40 Train loss: 3920.9626\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 20%|██ | 41/200 [02:26<09:27, 3.57s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 41 Train loss: 3933.4977\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 21%|██ | 42/200 [02:29<09:23, 3.57s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 42 Train loss: 3915.6800\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 22%|██▏ | 43/200 [02:33<09:20, 3.57s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 43 Train loss: 3884.8615\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 22%|██▏ | 44/200 [02:37<09:16, 3.57s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 44 Train loss: 3864.7660\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 22%|██▎ | 45/200 [02:40<09:13, 3.57s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 45 Train loss: 3851.0302\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 23%|██▎ | 46/200 [02:44<09:09, 3.57s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 46 Train loss: 3855.2326\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 24%|██▎ | 47/200 [02:47<09:06, 3.57s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 47 Train loss: 3830.1528\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 24%|██▍ | 48/200 [02:51<09:02, 3.57s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 48 Train loss: 3800.6746\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 24%|██▍ | 49/200 [02:55<08:59, 3.57s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 49 Train loss: 3800.0325\n", + "Epoch: 50 Train loss: 3764.9729\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 26%|██▌ | 51/200 [03:03<08:56, 3.60s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 51 Train loss: 3750.0143\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 26%|██▌ | 52/200 [03:07<08:52, 3.60s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 52 Train loss: 3748.5434\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 26%|██▋ | 53/200 [03:10<08:49, 3.60s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 53 Train loss: 3768.5098\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 27%|██▋ | 54/200 [03:14<08:45, 3.60s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 54 Train loss: 3756.0228\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 28%|██▊ | 55/200 [03:17<08:41, 3.60s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 55 Train loss: 3723.4896\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 28%|██▊ | 56/200 [03:21<08:38, 3.60s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 56 Train loss: 3716.0842\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 28%|██▊ | 57/200 [03:25<08:34, 3.60s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 57 Train loss: 3680.9559\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 29%|██▉ | 58/200 [03:28<08:31, 3.60s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 58 Train loss: 3692.5682\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 30%|██▉ | 59/200 [03:32<08:27, 3.60s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 59 Train loss: 3692.8695\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 30%|███ | 60/200 [03:36<08:24, 3.60s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 60 Train loss: 3680.1582\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 30%|███ | 61/200 [03:39<08:20, 3.60s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 61 Train loss: 3683.7855\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 31%|███ | 62/200 [03:43<08:16, 3.60s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 62 Train loss: 3668.7942\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 32%|███▏ | 63/200 [03:46<08:13, 3.60s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 63 Train loss: 3624.9806\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 32%|███▏ | 64/200 [03:50<08:09, 3.60s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 64 Train loss: 3645.8128\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 32%|███▎ | 65/200 [03:54<08:06, 3.60s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 65 Train loss: 3618.8245\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 33%|███▎ | 66/200 [03:57<08:02, 3.60s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 66 Train loss: 3585.8390\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 34%|███▎ | 67/200 [04:01<07:58, 3.60s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 67 Train loss: 3569.0584\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 34%|███▍ | 68/200 [04:04<07:55, 3.60s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 68 Train loss: 3492.4459\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 34%|███▍ | 69/200 [04:08<07:51, 3.60s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 69 Train loss: 3481.0924\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 35%|███▌ | 70/200 [04:12<07:48, 3.60s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 70 Train loss: 3413.0706\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 36%|███▌ | 71/200 [04:15<07:44, 3.60s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 71 Train loss: 3370.1745\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 36%|███▌ | 72/200 [04:19<07:41, 3.60s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 72 Train loss: 3317.5028\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 36%|███▋ | 73/200 [04:22<07:37, 3.60s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 73 Train loss: 3274.7025\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 37%|███▋ | 74/200 [04:26<07:33, 3.60s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 74 Train loss: 3227.9801\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 38%|███▊ | 75/200 [04:30<07:30, 3.60s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 75 Train loss: 3152.3159\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 38%|███▊ | 76/200 [04:33<07:26, 3.60s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 76 Train loss: 3171.5020\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 38%|███▊ | 77/200 [04:37<07:23, 3.60s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 77 Train loss: 3127.4684\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 39%|███▉ | 78/200 [04:40<07:19, 3.60s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 78 Train loss: 3017.8191\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 40%|███▉ | 79/200 [04:44<07:15, 3.60s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 79 Train loss: 2907.3863\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 40%|████ | 80/200 [04:48<07:12, 3.60s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 80 Train loss: 2952.3883\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 40%|████ | 81/200 [04:51<07:08, 3.60s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 81 Train loss: 2840.3833\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 41%|████ | 82/200 [04:55<07:05, 3.60s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 82 Train loss: 2835.3773\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 42%|████▏ | 83/200 [04:58<07:01, 3.60s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 83 Train loss: 2698.7593\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 42%|████▏ | 84/200 [05:02<06:57, 3.60s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 84 Train loss: 2676.6835\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 42%|████▎ | 85/200 [05:06<06:54, 3.60s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 85 Train loss: 2686.4679\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 43%|████▎ | 86/200 [05:09<06:50, 3.60s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 86 Train loss: 2650.6864\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 44%|████▎ | 87/200 [05:13<06:46, 3.60s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 87 Train loss: 2555.5597\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 44%|████▍ | 88/200 [05:16<06:43, 3.60s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 88 Train loss: 2559.2596\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 44%|████▍ | 89/200 [05:20<06:39, 3.60s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 89 Train loss: 2559.2467\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 45%|████▌ | 90/200 [05:24<06:36, 3.60s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 90 Train loss: 2520.3299\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 46%|████▌ | 91/200 [05:27<06:32, 3.60s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 91 Train loss: 2491.7058\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 46%|████▌ | 92/200 [05:31<06:28, 3.60s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 92 Train loss: 2460.3424\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 46%|████▋ | 93/200 [05:34<06:25, 3.60s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 93 Train loss: 2464.5741\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 47%|████▋ | 94/200 [05:38<06:21, 3.60s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 94 Train loss: 2425.3397\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 48%|████▊ | 95/200 [05:42<06:18, 3.60s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 95 Train loss: 2405.2165\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 48%|████▊ | 96/200 [05:45<06:14, 3.60s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 96 Train loss: 2389.1514\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 48%|████▊ | 97/200 [05:49<06:10, 3.60s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 97 Train loss: 2378.5552\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 49%|████▉ | 98/200 [05:52<06:07, 3.60s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 98 Train loss: 2372.0996\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 50%|████▉ | 99/200 [05:56<06:03, 3.60s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 99 Train loss: 2331.8757\n", + "Epoch: 100 Train loss: 2327.7387\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 50%|█████ | 101/200 [06:05<05:57, 3.61s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 101 Train loss: 2308.0462\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 51%|█████ | 102/200 [06:08<05:54, 3.61s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 102 Train loss: 2324.2892\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 52%|█████▏ | 103/200 [06:12<05:50, 3.61s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 103 Train loss: 2284.1214\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 52%|█████▏ | 104/200 [06:15<05:46, 3.61s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 104 Train loss: 2265.7720\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 52%|█████▎ | 105/200 [06:19<05:43, 3.61s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 105 Train loss: 2280.9683\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 53%|█████▎ | 106/200 [06:23<05:39, 3.61s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 106 Train loss: 2278.7626\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 54%|█████▎ | 107/200 [06:26<05:36, 3.61s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 107 Train loss: 2257.5211\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 54%|█████▍ | 108/200 [06:30<05:32, 3.61s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 108 Train loss: 2234.3032\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 55%|█████▍ | 109/200 [06:33<05:28, 3.61s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 109 Train loss: 2229.8583\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 55%|█████▌ | 110/200 [06:37<05:25, 3.61s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 110 Train loss: 2219.9134\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 56%|█████▌ | 111/200 [06:41<05:21, 3.61s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 111 Train loss: 2224.8225\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 56%|█████▌ | 112/200 [06:44<05:17, 3.61s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 112 Train loss: 2214.2873\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 56%|█████▋ | 113/200 [06:48<05:14, 3.61s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 113 Train loss: 2215.9229\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 57%|█████▋ | 114/200 [06:51<05:10, 3.61s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 114 Train loss: 2185.8746\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 57%|█████▊ | 115/200 [06:55<05:07, 3.61s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 115 Train loss: 2155.6337\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 58%|█████▊ | 116/200 [06:59<05:03, 3.61s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 116 Train loss: 2166.5751\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 58%|█████▊ | 117/200 [07:02<04:59, 3.61s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 117 Train loss: 2183.6833\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 59%|█████▉ | 118/200 [07:06<04:56, 3.61s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 118 Train loss: 2178.7413\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 60%|█████▉ | 119/200 [07:09<04:52, 3.61s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 119 Train loss: 2176.9099\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 60%|██████ | 120/200 [07:13<04:48, 3.61s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 120 Train loss: 2140.1265\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 60%|██████ | 121/200 [07:17<04:45, 3.61s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 121 Train loss: 2156.4029\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 61%|██████ | 122/200 [07:20<04:41, 3.61s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 122 Train loss: 2173.6097\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 62%|██████▏ | 123/200 [07:24<04:38, 3.61s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 123 Train loss: 2193.6018\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 62%|██████▏ | 124/200 [07:27<04:34, 3.61s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 124 Train loss: 2173.5100\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 62%|██████▎ | 125/200 [07:31<04:30, 3.61s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 125 Train loss: 2156.6492\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 63%|██████▎ | 126/200 [07:34<04:27, 3.61s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 126 Train loss: 2154.5458\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 64%|██████▎ | 127/200 [07:38<04:23, 3.61s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 127 Train loss: 2150.1409\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 64%|██████▍ | 128/200 [07:42<04:19, 3.61s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 128 Train loss: 2116.7759\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 64%|██████▍ | 129/200 [07:45<04:16, 3.61s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 129 Train loss: 2135.7731\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 65%|██████▌ | 130/200 [07:49<04:12, 3.61s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 130 Train loss: 2134.5957\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 66%|██████▌ | 131/200 [07:52<04:09, 3.61s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 131 Train loss: 2127.2941\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 66%|██████▌ | 132/200 [07:56<04:05, 3.61s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 132 Train loss: 2134.8713\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 66%|██████▋ | 133/200 [08:00<04:01, 3.61s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 133 Train loss: 2120.6945\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 67%|██████▋ | 134/200 [08:03<03:58, 3.61s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 134 Train loss: 2106.6445\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 68%|██████▊ | 135/200 [08:07<03:54, 3.61s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 135 Train loss: 2097.3347\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 68%|██████▊ | 136/200 [08:10<03:51, 3.61s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 136 Train loss: 2101.1914\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 68%|██████▊ | 137/200 [08:14<03:47, 3.61s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 137 Train loss: 2117.9972\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 69%|██████▉ | 138/200 [08:18<03:43, 3.61s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 138 Train loss: 2132.0983\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 70%|██████▉ | 139/200 [08:21<03:40, 3.61s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 139 Train loss: 2101.7289\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 70%|███████ | 140/200 [08:25<03:36, 3.61s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 140 Train loss: 2107.9268\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 70%|███████ | 141/200 [08:29<03:33, 3.61s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 141 Train loss: 2086.3469\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 71%|███████ | 142/200 [08:32<03:29, 3.61s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 142 Train loss: 2075.3563\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 72%|███████▏ | 143/200 [08:36<03:25, 3.61s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 143 Train loss: 2090.5236\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 72%|███████▏ | 144/200 [08:39<03:22, 3.61s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 144 Train loss: 2110.3560\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 72%|███████▎ | 145/200 [08:43<03:18, 3.61s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 145 Train loss: 2131.0744\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 73%|███████▎ | 146/200 [08:47<03:15, 3.61s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 146 Train loss: 2099.7526\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 74%|███████▎ | 147/200 [08:50<03:11, 3.61s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 147 Train loss: 2102.8599\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 74%|███████▍ | 148/200 [08:54<03:07, 3.61s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 148 Train loss: 2086.2113\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 74%|███████▍ | 149/200 [08:58<03:04, 3.61s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 149 Train loss: 2083.9986\n", + "Epoch: 150 Train loss: 2059.0031\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 76%|███████▌ | 151/200 [09:07<02:57, 3.62s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 151 Train loss: 2065.1667\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 76%|███████▌ | 152/200 [09:10<02:53, 3.62s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 152 Train loss: 2061.5811\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 76%|███████▋ | 153/200 [09:14<02:50, 3.62s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 153 Train loss: 2064.1517\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 77%|███████▋ | 154/200 [09:17<02:46, 3.62s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 154 Train loss: 2077.5969\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 78%|███████▊ | 155/200 [09:21<02:43, 3.62s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 155 Train loss: 2072.4356\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 78%|███████▊ | 156/200 [09:25<02:39, 3.62s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 156 Train loss: 2047.8531\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 78%|███████▊ | 157/200 [09:28<02:35, 3.62s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 157 Train loss: 2061.1302\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 79%|███████▉ | 158/200 [09:32<02:32, 3.62s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 158 Train loss: 2069.8052\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 80%|███████▉ | 159/200 [09:36<02:28, 3.62s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 159 Train loss: 2069.3980\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 80%|████████ | 160/200 [09:39<02:24, 3.62s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 160 Train loss: 2065.0577\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 80%|████████ | 161/200 [09:43<02:21, 3.62s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 161 Train loss: 2066.5313\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 81%|████████ | 162/200 [09:46<02:17, 3.62s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 162 Train loss: 2059.9744\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 82%|████████▏ | 163/200 [09:50<02:14, 3.62s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 163 Train loss: 2054.1571\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 82%|████████▏ | 164/200 [09:54<02:10, 3.62s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 164 Train loss: 2056.8596\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 82%|████████▎ | 165/200 [09:57<02:06, 3.62s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 165 Train loss: 2045.7509\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 83%|████████▎ | 166/200 [10:01<02:03, 3.62s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 166 Train loss: 2044.3063\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 84%|████████▎ | 167/200 [10:04<01:59, 3.62s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 167 Train loss: 2059.9163\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 84%|████████▍ | 168/200 [10:08<01:55, 3.62s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 168 Train loss: 2055.8316\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 84%|████████▍ | 169/200 [10:12<01:52, 3.62s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 169 Train loss: 2054.1673\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 85%|████████▌ | 170/200 [10:15<01:48, 3.62s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 170 Train loss: 2057.5113\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 86%|████████▌ | 171/200 [10:19<01:45, 3.62s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 171 Train loss: 2039.2451\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 86%|████████▌ | 172/200 [10:22<01:41, 3.62s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 172 Train loss: 2048.7624\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 86%|████████▋ | 173/200 [10:26<01:37, 3.62s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 173 Train loss: 2038.8059\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 87%|████████▋ | 174/200 [10:30<01:34, 3.62s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 174 Train loss: 2045.0179\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 88%|████████▊ | 175/200 [10:33<01:30, 3.62s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 175 Train loss: 2051.1847\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 88%|████████▊ | 176/200 [10:37<01:26, 3.62s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 176 Train loss: 2047.7569\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 88%|████████▊ | 177/200 [10:41<01:23, 3.62s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 177 Train loss: 2054.5523\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 89%|████████▉ | 178/200 [10:44<01:19, 3.62s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 178 Train loss: 2054.5020\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 90%|████████▉ | 179/200 [10:48<01:16, 3.62s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 179 Train loss: 2039.3899\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 90%|█████████ | 180/200 [10:51<01:12, 3.62s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 180 Train loss: 2031.6774\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 90%|█████████ | 181/200 [10:55<01:08, 3.62s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 181 Train loss: 2032.9211\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 91%|█████████ | 182/200 [10:59<01:05, 3.62s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 182 Train loss: 2044.1339\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 92%|█████████▏| 183/200 [11:02<01:01, 3.62s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 183 Train loss: 2031.1374\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 92%|█████████▏| 184/200 [11:06<00:57, 3.62s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 184 Train loss: 2026.4737\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 92%|█████████▎| 185/200 [11:10<00:54, 3.62s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 185 Train loss: 2011.9869\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 93%|█████████▎| 186/200 [11:13<00:50, 3.62s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 186 Train loss: 2016.1472\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 94%|█████████▎| 187/200 [11:17<00:47, 3.62s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 187 Train loss: 2029.9464\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 94%|█████████▍| 188/200 [11:20<00:43, 3.62s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 188 Train loss: 2050.0365\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 94%|█████████▍| 189/200 [11:24<00:39, 3.62s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 189 Train loss: 2049.2701\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 95%|█████████▌| 190/200 [11:28<00:36, 3.62s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 190 Train loss: 2027.0438\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 96%|█████████▌| 191/200 [11:31<00:32, 3.62s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 191 Train loss: 2032.3673\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 96%|█████████▌| 192/200 [11:35<00:28, 3.62s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 192 Train loss: 2024.0881\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 96%|█████████▋| 193/200 [11:38<00:25, 3.62s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 193 Train loss: 2026.0871\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 97%|█████████▋| 194/200 [11:42<00:21, 3.62s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 194 Train loss: 2024.8037\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 98%|█████████▊| 195/200 [11:46<00:18, 3.62s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 195 Train loss: 2015.4725\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 98%|█████████▊| 196/200 [11:49<00:14, 3.62s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 196 Train loss: 2007.3981\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 98%|█████████▊| 197/200 [11:53<00:10, 3.62s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 197 Train loss: 2016.8807\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 99%|█████████▉| 198/200 [11:57<00:07, 3.62s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 198 Train loss: 2011.6728\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + "100%|█████████▉| 199/200 [12:00<00:03, 3.62s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 199 Train loss: 2007.1013\n", + "Epoch: 200 Train loss: 2017.4889\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 200/200 [12:06<00:00, 3.63s/it]\n" + ] + } + ], + "source": [ + "epochs = 200\n", + "for epoch in tqdm(range(1, epochs + 1)):\n", + " train_loss = data_loop(epoch, train_loader, dmm, device, train_mode=True)\n", + " # test_loss = data_loop(epoch, test_loader, dmm, device)\n", + " sample = plot_video_from_latent(batch_size)#[:, None][1,:] # 128, 30, 2352\n", + " if epoch % 50 == 0:\n", + " plt.figure(figsize=(10,3))\n", + " for i in range(30):\n", + " plt.subplot(3,10,i+1)\n", + " plt.imshow(sample[0][i].cpu().detach().numpy().astype(np.float).reshape(3,28,28).transpose(1,2,0))\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "imshow(sample[0].cpu().detach())" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor([[1.],\n", + " [1.],\n", + " [0.],\n", + " [1.],\n", + " [1.],\n", + " [0.],\n", + " [1.],\n", + " [0.],\n", + " [1.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [0.],\n", + " [1.],\n", + " [1.],\n", + " [0.],\n", + " [1.],\n", + " [1.],\n", + " [0.],\n", + " [0.],\n", + " [1.],\n", + " [0.],\n", + " [0.],\n", + " [1.],\n", + " [0.],\n", + " [0.]])\n" + ] + } + ], + "source": [ + "imshow(_data[\"episode_frames\"][0])\n", + "print(_data[\"actions\"][0])" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/tutorial/English/prepare_cartpole_dataset.py b/tutorial/English/prepare_cartpole_dataset.py new file mode 100644 index 00000000..5f2b0d6d --- /dev/null +++ b/tutorial/English/prepare_cartpole_dataset.py @@ -0,0 +1,34 @@ +import gym +import pickle +import numpy as np +import cv2 +env = gym.make("CartPole-v1") +observation = env.reset() + +episodes = {"frames":[], "actions":[]} + +# for 56 *56 episode num = 500 +# for 28 * 28 episode num = 1000 +for _episode in range(1000): + frames = [] + actions = [] + for _frame in range(30): + action = env.action_space.sample() # your agent here (this takes random actions) + frame = env.render(mode='rgb_array') + observation, reward, done, info = env.step(action) + + img = frame + img = img[150:350, 200:400] + img = cv2.resize(img, (28,28)) + + frames.append(img) + actions.append(action) + observation = env.reset() + episodes["frames"].append(frames) + episodes["actions"].append(actions) + env.close() + +data = [np.array(episodes["frames"]), np.array(episodes["actions"])] +print(data[0].shape, data[1].shape) +with open('cartpole_28.pickle', mode='wb') as f: + pickle.dump(data, f) diff --git a/tutorial/English/utils.py b/tutorial/English/utils.py new file mode 100644 index 00000000..d5470417 --- /dev/null +++ b/tutorial/English/utils.py @@ -0,0 +1,43 @@ +from torch.utils.data import Dataset +import pickle +import numpy as np +import torch +import torchvision +import matplotlib.pyplot as plt + +def imshow(img_tensors): + img = torchvision.utils.make_grid(img_tensors) + npimg = img.numpy() + plt.figure(figsize=(16, 12)) + plt.imshow(np.transpose(npimg, (1, 2, 0))) + plt.show() + + + +class DMMDataset(Dataset): + def __init__(self, pickle_path="cartpole_28.pickle"): + + with open(pickle_path, mode='rb') as f: + data = pickle.load(f) + episode_frames, actions = data + # episode_frames: np.array([episode_num, one_episode_length, height, width, Channels]) (10000, 30, 28, 28, 3) + # actions: np.array([episode_num, one_episode_length]) (10000, 30) + # HWC → CHW + episode_frames = episode_frames.transpose(0, 1, 4, 2, 3) + actions = actions[:, :, np.newaxis] + + self.episode_frames = torch.from_numpy(episode_frames.astype(np.float32)) + self.actions = torch.from_numpy(actions.astype(np.float32)) + + def __len__(self): + return len(self.episode_frames) + + def __getitem__(self, idx): + return { + "episode_frames": self.episode_frames[idx] / 255, + "actions": self.actions[idx] + } + + +if __name__ == "__main__": + pass diff --git a/tutorial/Japanese/00-PixyzOverview.ipynb b/tutorial/Japanese/00-PixyzOverview.ipynb new file mode 100644 index 00000000..85ab0b70 --- /dev/null +++ b/tutorial/Japanese/00-PixyzOverview.ipynb @@ -0,0 +1,1354 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 深層生成モデルの特徴を考慮したAPI\n", + "- 生成モデルを構成するDNNは確率分布によって隠蔽される\n", + " - DNNの定義と確率分布の操作を分離できる枠組み(Distribution API)\n", + "- モデルの種類や確率変数の正則化は目的関数(誤差関数)として記述される\n", + " - 確率分布を受け取って目的関数を定義できる枠組み(Loss API)\n", + "- 深層生成モデルの学習方法は目的関数を定義して勾配降下法で学習\n", + " - 目的関数と最適化アルゴリズムが独立に設定できる枠組み(Model API)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from __future__ import print_function\n", + "import torch\n", + "import torch.utils.data\n", + "from torch import nn, optim\n", + "from torch.nn import functional as F\n", + "from torchvision import datasets, transforms\n", + "from tensorboardX import SummaryWriter\n", + "\n", + "from tqdm import tqdm\n", + "\n", + "if torch.cuda.is_available():\n", + " device = \"cuda\"\n", + "else:\n", + " device = \"cpu\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## VAEの実装を通してそれぞれのAPIの関係を習得する" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1. Distribution API\n", + "- DNNの定義と確率分布の操作を分離できる枠組み(Distribution API)\n", + "- https://pixyz.readthedocs.io/en/latest/distributions.html" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "定義する確率分布は以下の通り\n", + "\n", + "Prior: $p(z) = N(z; 0, 1)$\n", + "\n", + "Generator: $p_{\\theta}(x|z) = B(x; \\lambda = g(z))$\n", + "\n", + "Inference: $q_{\\phi}(z|x) = N(z; µ = f_{\\mu}(x), \\sigma^2 = f_{\\sigma^2}(x))$" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from pixyz.distributions import Normal, Bernoulli\n", + "from pixyz.utils import print_latex" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### priorの確率分布を定義する\n", + "\n", + "priorは平均0, 分散1のガウス分布である\n", + "\n", + "$p(z) = N(z; 0, 1)$" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Distribution:\n", + " p_{prior}(z)\n", + "Network architecture:\n", + " Normal(\n", + " name=p_{prior}, distribution_name=Normal,\n", + " var=['z'], cond_var=[], input_var=[], features_shape=torch.Size([64])\n", + " (loc): torch.Size([1, 64])\n", + " (scale): torch.Size([1, 64])\n", + " )\n" + ] + }, + { + "data": { + "text/latex": [ + "$\\displaystyle p_{prior}(z)$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# prior\n", + "z_dim = 64\n", + "prior = Normal(loc=torch.tensor(0.), scale=torch.tensor(1.),\n", + " var=[\"z\"], features_shape=[z_dim], name=\"p_{prior}\").to(device)\n", + "print(prior)\n", + "print_latex(prior)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### generatorの確率分布を定義する\n", + "Generatorは$\\theta$によってパラメータが決まるベルヌーイ分布\n", + "\n", + "$p_{\\theta}(x|z) = B(x; \\lambda = g(z))$\n", + "\n", + "pixyz.Distributionクラスを継承してDNNによる確率分布を定義する" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Distribution:\n", + " p(x|z)\n", + "Network architecture:\n", + " Generator(\n", + " name=p, distribution_name=Bernoulli,\n", + " var=['x'], cond_var=['z'], input_var=['z'], features_shape=torch.Size([])\n", + " (fc1): Linear(in_features=64, out_features=512, bias=True)\n", + " (fc2): Linear(in_features=512, out_features=512, bias=True)\n", + " (fc3): Linear(in_features=512, out_features=784, bias=True)\n", + " )\n" + ] + }, + { + "data": { + "text/latex": [ + "$\\displaystyle p(x|z)$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x_dim = 784\n", + "# generative model p(x|z) \n", + "# inherit pixyz.Distribution Bernoulli class\n", + "class Generator(Bernoulli):\n", + " def __init__(self):\n", + " super(Generator, self).__init__(var=[\"x\"], cond_var=[\"z\"], name=\"p\")\n", + "\n", + " self.fc1 = nn.Linear(z_dim, 512)\n", + " self.fc2 = nn.Linear(512, 512)\n", + " self.fc3 = nn.Linear(512, x_dim)\n", + "\n", + " def forward(self, z):\n", + " h = F.relu(self.fc1(z))\n", + " h = F.relu(self.fc2(h))\n", + " return {\"probs\": torch.sigmoid(self.fc3(h))}\n", + "p = Generator().to(device)\n", + "print(p)\n", + "print_latex(p)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Inferenceの確率分布を定義する\n", + "\n", + "Inferenceは$\\mu$と$\\sigma$がパラメータ$\\phi$により決まるガウス分布\n", + "\n", + "$q_{\\phi}(z|x) = N(z; µ = f_{\\mu}(x), \\sigma^2 = f_{\\sigma^2}(x))$" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Distribution:\n", + " q(z|x)\n", + "Network architecture:\n", + " Inference(\n", + " name=q, distribution_name=Normal,\n", + " var=['z'], cond_var=['x'], input_var=['x'], features_shape=torch.Size([])\n", + " (fc1): Linear(in_features=784, out_features=512, bias=True)\n", + " (fc2): Linear(in_features=512, out_features=512, bias=True)\n", + " (fc31): Linear(in_features=512, out_features=64, bias=True)\n", + " (fc32): Linear(in_features=512, out_features=64, bias=True)\n", + " )\n" + ] + }, + { + "data": { + "text/latex": [ + "$\\displaystyle q(z|x)$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# inference model q(z|x)\n", + "# inherit pixyz.Distribution Normal class\n", + "class Inference(Normal):\n", + " def __init__(self):\n", + " super(Inference, self).__init__(var=[\"z\"], cond_var=[\"x\"], name=\"q\")\n", + "\n", + " self.fc1 = nn.Linear(x_dim, 512)\n", + " self.fc2 = nn.Linear(512, 512)\n", + " self.fc31 = nn.Linear(512, z_dim)\n", + " self.fc32 = nn.Linear(512, z_dim)\n", + "\n", + " def forward(self, x):\n", + " h = F.relu(self.fc1(x))\n", + " h = F.relu(self.fc2(h))\n", + " return {\"loc\": self.fc31(h), \"scale\": F.softplus(self.fc32(h))}\n", + "\n", + "q = Inference().to(device)\n", + "print(q)\n", + "print_latex(q)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 確率分布からのサンプリング\n", + "- 定義したDistributionクラスは，DNNの構造や分布に依存せず，同じAPI( .sample() )でサンプリングが可能\n", + "- Pixyzではサンプルは辞書形式で扱われる(keyが変数名, valueが実際のサンプル)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "$z\\sim p(z)$" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'z': tensor([[ 0.4864, 0.3463, -0.2116, -1.6100, -0.2685, -0.1989, 0.6314, 1.5996,\n", + " 0.7684, -0.5182, 0.3968, -0.0385, 0.4360, 1.4288, -0.9017, 0.6699,\n", + " -0.9554, -0.1915, -1.3265, -1.1500, 0.4051, -1.3572, 1.4759, 0.0580,\n", + " 0.9901, -1.1862, 0.5636, -0.1690, 0.5339, 1.5087, -1.0795, 1.3426,\n", + " -0.7732, -1.9224, -0.7196, 0.1051, -1.0382, -0.1006, 0.3543, 0.0793,\n", + " -1.2374, 1.7611, -1.1313, -0.4561, -0.0943, 0.6199, -0.4136, -0.4324,\n", + " 1.7052, -1.8582, 0.4568, 0.9151, -1.1936, -0.2273, 0.7298, -1.6876,\n", + " -0.8267, -0.2455, -0.4563, 0.5264, -0.4206, -0.4246, -0.4605, -1.2385]],\n", + " device='cuda:0')}\n", + "dict_keys(['z'])\n", + "torch.Size([1, 64])\n" + ] + } + ], + "source": [ + "# z ~ p(z)\n", + "prior_samples = prior.sample(batch_n=1)\n", + "print(prior_samples)\n", + "print(prior_samples.keys())\n", + "print(prior_samples['z'].shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 同時分布の定義\n", + "- Distribution APIでは分布同士の掛け算で同時分布を表現できる\n", + " - 掛け算の結果も同様にサンプリング可能" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "$p_{\\theta}(x, z) = p_{\\theta}(x|z)p(z)$" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Distribution:\n", + " p(x,z) = p(x|z)p_{prior}(z)\n", + "Network architecture:\n", + " Normal(\n", + " name=p_{prior}, distribution_name=Normal,\n", + " var=['z'], cond_var=[], input_var=[], features_shape=torch.Size([64])\n", + " (loc): torch.Size([1, 64])\n", + " (scale): torch.Size([1, 64])\n", + " )\n", + " Generator(\n", + " name=p, distribution_name=Bernoulli,\n", + " var=['x'], cond_var=['z'], input_var=['z'], features_shape=torch.Size([])\n", + " (fc1): Linear(in_features=64, out_features=512, bias=True)\n", + " (fc2): Linear(in_features=512, out_features=512, bias=True)\n", + " (fc3): Linear(in_features=512, out_features=784, bias=True)\n", + " )\n" + ] + }, + { + "data": { + "text/latex": [ + "$\\displaystyle p(x,z) = p(x|z)p_{prior}(z)$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "p_joint = p * prior\n", + "print(p_joint)\n", + "print_latex(p_joint)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 同時分布からのサンプリング" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "$x, z \\sim p_{\\theta}(x, z) $" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'z': tensor([[ 1.1201e+00, 1.5677e-01, 9.0874e-01, 6.8709e-01, -9.9205e-01,\n", + " -5.7528e-02, 6.1494e-01, -1.9103e+00, 8.4818e-01, -6.3063e-01,\n", + " 2.8868e-01, 6.5235e-01, -3.6048e-01, -2.1075e+00, 7.3561e-01,\n", + " 1.2284e+00, 9.4420e-01, 1.7631e+00, 4.1081e-01, 5.3408e-01,\n", + " 8.0302e-01, 2.7640e-01, 2.5316e+00, -1.2926e+00, -1.7300e+00,\n", + " 4.1832e-01, -8.8950e-01, -9.4023e-01, -8.7823e-01, 1.3775e-01,\n", + " 1.1756e-01, -7.7565e-01, -1.3138e+00, 1.3475e+00, -4.6472e-02,\n", + " -5.3134e-01, 3.1117e-01, -1.2415e+00, -7.1469e-01, -9.1732e-01,\n", + " -1.6107e-01, -8.3936e-01, 7.6674e-04, -4.5140e-02, 5.6405e-01,\n", + " 7.1174e-01, 9.7647e-01, -1.0728e-01, -1.2635e+00, 6.5263e-01,\n", + " -8.2264e-01, -7.0210e-01, 1.9668e+00, -2.3719e-01, 3.1376e-01,\n", + " -1.1728e+00, -2.9765e-01, -3.0023e-01, -3.3129e-01, 3.4532e-01,\n", + " 1.8916e+00, -1.2801e+00, -4.5738e-01, -6.8942e-01]], device='cuda:0'), 'x': tensor([[0., 0., 1., 1., 1., 1., 0., 1., 0., 0., 1., 1., 1., 0., 0., 0., 1., 1.,\n", + " 1., 0., 0., 1., 1., 1., 0., 0., 0., 0., 0., 0., 1., 0., 1., 1., 0., 0.,\n", + " 1., 1., 1., 1., 0., 1., 0., 0., 1., 1., 1., 1., 0., 1., 1., 0., 0., 1.,\n", + " 1., 0., 0., 0., 0., 0., 1., 0., 1., 0., 0., 0., 0., 0., 1., 1., 1., 0.,\n", + " 0., 1., 1., 1., 1., 1., 0., 1., 1., 1., 0., 1., 1., 1., 1., 0., 0., 0.,\n", + " 0., 0., 0., 1., 0., 1., 1., 1., 1., 0., 1., 1., 0., 0., 1., 1., 0., 1.,\n", + " 0., 0., 0., 0., 0., 1., 0., 0., 1., 0., 0., 0., 1., 1., 0., 0., 0., 0.,\n", + " 1., 1., 1., 0., 1., 1., 1., 0., 0., 0., 0., 0., 1., 1., 1., 1., 0., 1.,\n", + " 1., 0., 0., 0., 0., 1., 0., 1., 0., 1., 1., 1., 1., 1., 0., 0., 1., 1.,\n", + " 0., 0., 1., 0., 0., 1., 1., 0., 0., 0., 0., 1., 0., 1., 1., 1., 0., 1.,\n", + " 0., 0., 1., 0., 1., 0., 1., 0., 0., 1., 1., 0., 1., 0., 1., 1., 0., 1.,\n", + " 0., 1., 0., 1., 1., 0., 1., 0., 0., 0., 1., 0., 1., 1., 1., 0., 1., 0.,\n", + " 1., 0., 1., 0., 0., 0., 1., 0., 1., 0., 1., 1., 0., 0., 0., 0., 0., 0.,\n", + " 1., 1., 1., 0., 0., 0., 1., 0., 1., 1., 0., 0., 1., 0., 1., 1., 1., 1.,\n", + " 0., 1., 1., 0., 1., 1., 1., 0., 1., 0., 1., 1., 0., 0., 1., 0., 0., 1.,\n", + " 1., 0., 1., 1., 0., 1., 0., 1., 1., 1., 0., 0., 1., 0., 0., 0., 1., 1.,\n", + " 1., 0., 1., 0., 0., 0., 0., 1., 1., 0., 1., 0., 0., 0., 0., 1., 0., 1.,\n", + " 0., 1., 0., 0., 0., 1., 1., 1., 1., 0., 1., 1., 0., 0., 1., 1., 0., 1.,\n", + " 0., 0., 1., 0., 0., 0., 1., 1., 0., 1., 1., 0., 1., 0., 0., 0., 0., 0.,\n", + " 1., 1., 0., 0., 0., 0., 1., 1., 1., 1., 0., 1., 1., 0., 1., 0., 1., 0.,\n", + " 0., 0., 1., 1., 0., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 0., 0.,\n", + " 0., 0., 0., 0., 1., 1., 1., 0., 0., 1., 0., 0., 0., 1., 0., 1., 1., 0.,\n", + " 1., 1., 0., 1., 0., 1., 0., 0., 1., 0., 1., 1., 0., 0., 1., 0., 0., 1.,\n", + " 1., 1., 1., 0., 0., 0., 0., 1., 1., 1., 0., 1., 1., 0., 1., 1., 0., 1.,\n", + " 1., 0., 0., 0., 1., 1., 1., 0., 1., 1., 0., 1., 0., 0., 0., 1., 1., 0.,\n", + " 1., 1., 0., 1., 0., 1., 0., 0., 1., 1., 0., 1., 0., 1., 0., 0., 1., 1.,\n", + " 0., 0., 1., 1., 1., 1., 0., 0., 0., 1., 0., 1., 1., 0., 1., 0., 1., 0.,\n", + " 0., 1., 0., 1., 0., 0., 0., 1., 1., 1., 1., 1., 1., 0., 1., 0., 1., 0.,\n", + " 0., 1., 0., 1., 1., 0., 0., 0., 0., 0., 1., 0., 0., 1., 0., 0., 1., 1.,\n", + " 1., 0., 0., 1., 0., 1., 0., 1., 0., 1., 1., 0., 0., 0., 1., 1., 1., 0.,\n", + " 1., 1., 0., 0., 1., 1., 0., 1., 0., 0., 0., 1., 0., 0., 1., 0., 0., 0.,\n", + " 1., 0., 0., 1., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0.,\n", + " 0., 1., 0., 0., 0., 1., 0., 0., 0., 1., 0., 1., 0., 1., 1., 0., 1., 1.,\n", + " 0., 1., 0., 0., 1., 0., 0., 0., 0., 0., 1., 0., 1., 0., 1., 1., 1., 1.,\n", + " 1., 0., 1., 1., 0., 1., 0., 1., 0., 1., 1., 1., 1., 1., 1., 0., 0., 0.,\n", + " 1., 1., 1., 1., 0., 1., 0., 0., 0., 0., 1., 0., 0., 0., 1., 0., 0., 1.,\n", + " 1., 0., 1., 0., 1., 0., 0., 1., 1., 1., 0., 1., 1., 1., 1., 0., 0., 1.,\n", + " 1., 0., 1., 1., 1., 0., 0., 1., 0., 0., 1., 1., 1., 0., 0., 0., 1., 1.,\n", + " 1., 0., 0., 0., 1., 1., 1., 1., 1., 1., 1., 1., 1., 0., 0., 0., 1., 1.,\n", + " 0., 1., 0., 1., 0., 0., 0., 1., 0., 1., 1., 1., 0., 1., 0., 1., 0., 1.,\n", + " 1., 0., 1., 0., 0., 1., 1., 1., 0., 0., 0., 1., 1., 0., 1., 1., 1., 0.,\n", + " 0., 0., 0., 1., 1., 1., 1., 0., 1., 1., 0., 0., 1., 1., 0., 0., 0., 1.,\n", + " 1., 1., 1., 0., 1., 1., 1., 1., 0., 1., 0., 0., 0., 1., 1., 1., 0., 0.,\n", + " 0., 0., 0., 0., 0., 1., 1., 0., 0., 1.]], device='cuda:0')}\n", + "dict_keys(['z', 'x'])\n", + "torch.Size([1, 784])\n", + "torch.Size([1, 64])\n" + ] + } + ], + "source": [ + "p_joint_samples = p_joint.sample(batch_n=1)\n", + "print(p_joint_samples)\n", + "print(p_joint_samples.keys())\n", + "print(p_joint_samples['x'].shape)\n", + "print(p_joint_samples['z'].shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### より詳細なDistribution API Turorial\n", + "- 01-DistributionAPITutorial.ipynb" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2. Loss API\n", + "- 確率分布を受け取って目的関数を定義できる枠組み\n", + " - pixyz.Lossは，Distributionを受け取ってLossを定義する\n", + " - Lossクラス同士は演算が可能なため，任意のLossを設計することができる\n", + " - -> 論文の式を簡単に実装に落とし込める\n", + "- Lossの値は，データを与えると評価できる\n", + " - 各Lossはシンボルとして扱われる(式を定義し，あたいはデータを入れるまで評価されない)\n", + " - データやDNNに依存せずに，明示的に確率モデルを設計できる->Define-and-run的" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "VAEのLossは以下の通り\n", + "$$\n", + "\\mathcal { L } _ { \\mathrm { VAE } } ( \\theta , \\phi ) = \\mathbb { E } _ { p_{data}( x ) } \\left [D _ { \\mathrm { KL } } \\left[ q _ \\phi ( z | x ) \\| p ( z ) \\right] - \\mathbb { E } _ { q _ { \\phi } ( z | x ) } \\left[\\log p _ { \\theta } ( x | z ) \\right]\\right]\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Lossをpixyz.distributionとpixyz.lossで定義する" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "$D _ { \\mathrm { KL } } \\left[ q _ \\phi ( z | x ) \\| p ( z ) \\right]$" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle D_{KL} \\left[q(z|x)||p_{prior}(z) \\right]$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from pixyz.losses import KullbackLeibler\n", + "kl = KullbackLeibler(q, prior)\n", + "print_latex(kl)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle - \\mathbb{E}_{q(z|x)} \\left[\\log p(x|z) \\right]$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "reconst = -p.log_prob().expectation(q)\n", + "print_latex(reconst)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Lossクラス同士の演算" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle mean \\left(D_{KL} \\left[q(z|x)||p_{prior}(z) \\right] - \\mathbb{E}_{q(z|x)} \\left[\\log p(x|z) \\right] \\right)$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "vae_loss = (kl + reconst).mean()\n", + "print_latex(vae_loss)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### データを与え，Lossを評価する\n", + "- .eval()でLossの計算が行われる" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor(549.2543, device='cuda:0', grad_fn=)" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#Todo: 何をevalの時渡すのか\n", + "dummy_x = torch.randn([4, 784]).to(device)\n", + "vae_loss.eval({\"x\": dummy_x})" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### より詳細なLoss API Turorial\n", + "- 02-LossAPITutorial.ipynb" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 3. Model API\n", + "- 目的関数と最適化アルゴリズムが独立に設定できる枠組み\n", + "- Lossと最適化アルゴリズムを設定し，データを入れて訓練" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Distributions (for training):\n", + " p(x|z), q(z|x)\n", + "Loss function:\n", + " mean \\left(D_{KL} \\left[q(z|x)||p_{prior}(z) \\right] - \\mathbb{E}_{q(z|x)} \\left[\\log p(x|z) \\right] \\right)\n", + "Optimizer:\n", + " Adam (\n", + " Parameter Group 0\n", + " amsgrad: False\n", + " betas: (0.9, 0.999)\n", + " eps: 1e-08\n", + " lr: 0.001\n", + " weight_decay: 0\n", + " )\n" + ] + }, + { + "data": { + "text/latex": [ + "$\\displaystyle mean \\left(D_{KL} \\left[q(z|x)||p_{prior}(z) \\right] - \\mathbb{E}_{q(z|x)} \\left[\\log p(x|z) \\right] \\right)$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from pixyz.models import Model\n", + "model = Model(loss=vae_loss, distributions=[p, q],\n", + " optimizer=optim.Adam, optimizer_params={\"lr\": 1e-3})\n", + "print(model)\n", + "print_latex(model)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "dummy_x = torch.randn([10, 784])\n", + "def train_dummy(epoch):\n", + " global dummy_x\n", + " dummy_x = dummy_x.to(device)\n", + " loss = model.train({\"x\": dummy_x})\n", + " print('Epoch: {} Train Loss: {:4f}'.format(epoch, loss))" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 0 Train Loss: 551.915894\n", + "Epoch: 1 Train Loss: 531.631287\n", + "Epoch: 2 Train Loss: 497.277496\n", + "Epoch: 3 Train Loss: 432.524139\n", + "Epoch: 4 Train Loss: 331.488434\n", + "Epoch: 5 Train Loss: 181.967743\n", + "Epoch: 6 Train Loss: 14.416910\n", + "Epoch: 7 Train Loss: -127.738548\n", + "Epoch: 8 Train Loss: -382.702911\n", + "Epoch: 9 Train Loss: -599.516968\n" + ] + } + ], + "source": [ + "for epoch in range(10):\n", + " train_dummy(epoch)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### より詳細なModel API Turorial\n", + "- 03-ModelAPITutorial.ipynb" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### MNISTデータセットを用いてPixyz版VAEを学習する" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 必要なモジュールのインストールなど" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "from __future__ import print_function\n", + "import torch\n", + "import torch.utils.data\n", + "from torch import nn, optim\n", + "from torch.nn import functional as F\n", + "import torchvision\n", + "from torchvision import datasets, transforms\n", + "from tensorboardX import SummaryWriter\n", + "\n", + "from tqdm import tqdm\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "\n", + "batch_size = 256\n", + "epochs = 3\n", + "seed = 1\n", + "torch.manual_seed(seed)\n", + "\n", + "if torch.cuda.is_available():\n", + " device = \"cuda\"\n", + "else:\n", + " device = \"cpu\"\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### MNISTデータセットの準備" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "root = '../data'\n", + "transform = transforms.Compose([transforms.ToTensor(),\n", + " transforms.Lambda(lambd=lambda x: x.view(-1))])\n", + "kwargs = {'batch_size': batch_size, 'num_workers': 1, 'pin_memory': True}\n", + "\n", + "train_loader = torch.utils.data.DataLoader(\n", + " datasets.MNIST(root=root, train=True, transform=transform, download=True),\n", + " shuffle=True, **kwargs)\n", + "test_loader = torch.utils.data.DataLoader(\n", + " datasets.MNIST(root=root, train=False, transform=transform),\n", + " shuffle=False, **kwargs)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Pixyzモジュールのインストール" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "from pixyz.distributions import Normal, Bernoulli\n", + "from pixyz.losses import KullbackLeibler, Expectation as E\n", + "from pixyz.models import Model\n", + "from pixyz.utils import print_latex" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 確率分布の定義" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "x_dim = 784\n", + "z_dim = 64\n", + "\n", + "\n", + "# inference model q(z|x)\n", + "class Inference(Normal):\n", + " def __init__(self):\n", + " super(Inference, self).__init__(var=[\"z\"], cond_var=[\"x\"], name=\"q\")\n", + "\n", + " self.fc1 = nn.Linear(x_dim, 512)\n", + " self.fc2 = nn.Linear(512, 512)\n", + " self.fc31 = nn.Linear(512, z_dim)\n", + " self.fc32 = nn.Linear(512, z_dim)\n", + "\n", + " def forward(self, x):\n", + " h = F.relu(self.fc1(x))\n", + " h = F.relu(self.fc2(h))\n", + " return {\"loc\": self.fc31(h), \"scale\": F.softplus(self.fc32(h))}\n", + "\n", + " \n", + "# generative model p(x|z) \n", + "class Generator(Bernoulli):\n", + " def __init__(self):\n", + " super(Generator, self).__init__(var=[\"x\"], cond_var=[\"z\"], name=\"p\")\n", + "\n", + " self.fc1 = nn.Linear(z_dim, 512)\n", + " self.fc2 = nn.Linear(512, 512)\n", + " self.fc3 = nn.Linear(512, x_dim)\n", + "\n", + " def forward(self, z):\n", + " h = F.relu(self.fc1(z))\n", + " h = F.relu(self.fc2(h))\n", + " return {\"probs\": torch.sigmoid(self.fc3(h))}\n", + " \n", + "p = Generator().to(device)\n", + "q = Inference().to(device)\n", + "\n", + "prior = Normal(loc=torch.tensor(0.), scale=torch.tensor(1.),\n", + " var=[\"z\"], features_shape=[z_dim], name=\"p_{prior}\").to(device)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Distribution:\n", + " p_{prior}(z)\n", + "Network architecture:\n", + " Normal(\n", + " name=p_{prior}, distribution_name=Normal,\n", + " var=['z'], cond_var=[], input_var=[], features_shape=torch.Size([64])\n", + " (loc): torch.Size([1, 64])\n", + " (scale): torch.Size([1, 64])\n", + " )\n" + ] + }, + { + "data": { + "text/latex": [ + "$\\displaystyle p_{prior}(z)$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(prior)\n", + "print_latex(prior)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Distribution:\n", + " p(x|z)\n", + "Network architecture:\n", + " Generator(\n", + " name=p, distribution_name=Bernoulli,\n", + " var=['x'], cond_var=['z'], input_var=['z'], features_shape=torch.Size([])\n", + " (fc1): Linear(in_features=64, out_features=512, bias=True)\n", + " (fc2): Linear(in_features=512, out_features=512, bias=True)\n", + " (fc3): Linear(in_features=512, out_features=784, bias=True)\n", + " )\n" + ] + }, + { + "data": { + "text/latex": [ + "$\\displaystyle p(x|z)$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(p)\n", + "print_latex(p)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Distribution:\n", + " q(z|x)\n", + "Network architecture:\n", + " Inference(\n", + " name=q, distribution_name=Normal,\n", + " var=['z'], cond_var=['x'], input_var=['x'], features_shape=torch.Size([])\n", + " (fc1): Linear(in_features=784, out_features=512, bias=True)\n", + " (fc2): Linear(in_features=512, out_features=512, bias=True)\n", + " (fc31): Linear(in_features=512, out_features=64, bias=True)\n", + " (fc32): Linear(in_features=512, out_features=64, bias=True)\n", + " )\n" + ] + }, + { + "data": { + "text/latex": [ + "$\\displaystyle q(z|x)$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(q)\n", + "print_latex(q)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Lossの定義" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle mean \\left(D_{KL} \\left[q(z|x)||p_{prior}(z) \\right] - \\mathbb{E}_{q(z|x)} \\left[\\log p(x|z) \\right] \\right)$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "kl = KullbackLeibler(q, prior)\n", + "reconst = -p.log_prob().expectation(q)\n", + "vae_loss = (kl + reconst).mean()\n", + "print_latex(vae_loss)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 最適化アルゴリズムとモデルの設定" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Distributions (for training):\n", + " p(x|z), q(z|x)\n", + "Loss function:\n", + " mean \\left(D_{KL} \\left[q(z|x)||p_{prior}(z) \\right] - \\mathbb{E}_{q(z|x)} \\left[\\log p(x|z) \\right] \\right)\n", + "Optimizer:\n", + " Adam (\n", + " Parameter Group 0\n", + " amsgrad: False\n", + " betas: (0.9, 0.999)\n", + " eps: 1e-08\n", + " lr: 0.001\n", + " weight_decay: 0\n", + " )\n" + ] + }, + { + "data": { + "text/latex": [ + "$\\displaystyle mean \\left(D_{KL} \\left[q(z|x)||p_{prior}(z) \\right] - \\mathbb{E}_{q(z|x)} \\left[\\log p(x|z) \\right] \\right)$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model = Model(loss=vae_loss, distributions=[p, q],\n", + " optimizer=optim.Adam, optimizer_params={\"lr\": 1e-3})\n", + "print(model)\n", + "print_latex(model)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "def train(epoch):\n", + " train_loss = 0\n", + " #for x, _ in tqdm(train_loader):\n", + " for x, _ in train_loader:\n", + " x = x.to(device)\n", + " loss = model.train({\"x\": x})\n", + " train_loss += loss\n", + " \n", + " train_loss = train_loss * train_loader.batch_size / len(train_loader.dataset)\n", + " print('Epoch: {} Train loss: {:.4f}'.format(epoch, train_loss))\n", + " return train_loss\n", + "\n", + "def test(epoch):\n", + " test_loss = 0\n", + " #for x, _ in tqdm(test_loader):\n", + " for x, _ in test_loader:\n", + " x = x.to(device)\n", + " loss = model.test({\"x\": x})\n", + " test_loss += loss\n", + "\n", + " test_loss = test_loss * test_loader.batch_size / len(test_loader.dataset)\n", + " print('Test loss: {:.4f}'.format(test_loss))\n", + " return test_loss" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 再構成" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "def plot_reconstrunction(x):\n", + " with torch.no_grad():\n", + " z = q.sample({\"x\": x}, return_all=False)\n", + " recon_batch = p.sample_mean(z).view(-1, 1, 28, 28)\n", + " \n", + " comparison = torch.cat([x.view(-1, 1, 28, 28), recon_batch]).cpu()\n", + " return comparison" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 潜在変数空間からの生成" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "def plot_image_from_latent(z_sample):\n", + " with torch.no_grad():\n", + " sample = p.sample_mean({\"z\": z_sample}).view(-1, 1, 28, 28).cpu()\n", + " return sample" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "# functions to show an image\n", + "def imshow(img):\n", + " npimg = img.numpy()\n", + " plt.imshow(np.transpose(npimg, (1, 2, 0)))\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 1 Train loss: 201.0661\n", + "Test loss: 172.5077\n", + "Epoch: 1\n", + "Reconstruction\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "generate from prior z:\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQEAAAD8CAYAAAB3lxGOAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/d3fzzAAAACXBIWXMAAAsTAAALEwEAmpwYAACgzUlEQVR4nO39W4hs25rfB/5n5D0zIuOSl3XZ+5TPKVN6KBksC1H9oMaUEe22haHsB4lyQ3c1FH36QUJtcEMd2Q8WBkF1066mwWB8jIVLjaVSgS1UNMKyJCxEg2SpZGRJpWrZZenc9l5rZWbcI/IaGbMfMn9f/GOsOSMi9+XsWLVzQLIyc0XOMccY3/gu/++W5Xmu5/E8nsfXd1S+6hd4Hs/jeXy145kJPI/n8TUfz0zgeTyPr/l4ZgLP43l8zcczE3gez+NrPp6ZwPN4Hl/z8aUxgSzL/rUsy/5JlmW/k2XZd76seZ7H83gen29kX0acQJZlG5L+J0n/G0k/kvR3Jf3beZ7/4y98sufxPJ7H5xpflibwM5J+J8/zf5rn+a2kX5P0c1/SXM/jeTyPzzE2v6TnfiTph/bzjyT9r8o+nGXZc9ji83geX/64yPP8JP3ll8UEsoLfzV30LMu+LenbX9L8z+N5PI/3x/eLfvllMYEfSfqG/fyxpE/9A3mef1fSd6X11wSybMbTPiuGwjPyPC/8ftXB/FmWvfesH/dg7vQdnrKmsvfmGdPp9L250r/hd5VKZaV9KPvMU96/7DOrnsNTzmvZ+3zes/+ymMDflfRTWZZ9S9Inkn5e0v/ui3gwG7KxsaGNjY24CGzEdDpVnufK8zwI6LPM4V9bW1va2dmZm2cymej+/j6+mHfV9y+aJ8sybW5uamNjI959Op3GvKzp/v5+bt1PZSTMValUtLm5Ofdsvmctq16qdF38yzlVKhVtbGzEXrEGP6Oin4vmKpuHNfm60nPhd5PJ5Elr9H3zeTY2NrS1tRVrSvcwz/NY61OGr61SqQRtbG9vS1K8P89n3z7LXF8KE8jzfJJl2R+X9FckbUj6M3me/9ZnfZ5vBAe+s7OjnZ2d+Mz9/X18P5lMdHd3p9vb2ydtCvNAuGx6o9HQ0dGRKpWK7u/vdXt7q+vr6/h3PB7r+vp67mDS59rezK1jc3NTW1tb8e/u7q42Nzc1nU51d3enyWQiSXGBJpOJxuOx7u7udH9/vzIDYG08q1KpBHPzuVIGOp1OV2Jwvq7NzU1tbj6Qlq+tUqno+vpad3d38XfMgxSHuS6bz+fa2trS9va2tra2gjbYL/aJS5vnue7u7nR5eambm5uV6QO6gCaYd29vTzs7O7q9vdXl5aUmk0nsGft2d3enu7u7JwkKzgiGxly1Wk3T6TTozdcIffAOq9L9l6UJKM/zvyzpL3+eZ/hm7OzsaHNzU1mWaWdnR4eHhzo8PIzDvrm50e3tbRD0aDRSlmXBEJZpBVz8ra0t7e/va29vT1tbW6rVanrx4oVOT0+1s7Oj8XisTqejq6srXV1d6fLyMhjU7e1tMJ5kL96TWtvb29rZ2dHBwYEODg6UZZn29vbi542NDQ2HQ93d3c1Jk+FwqM3NTV1eXsaFWnTYqdTa3NwMBsAaJ5OJLi8v5yQnF4a/d2mzaA9hAFxILv/W1tacJsO+SIpzlR4uG2dWtC4+t7m5qd3dXe3u7qpWq+ng4CAYDhezUqno9vZWNzc38dw8z3V9fa1Op6PBYKCrq6ul9OHntb+/r1qtFgwbpn13d6fBYKDRaBTvznzQsDPassFebW5uamdnJ/bx4OBA9XpdBwcHur+/13A41HA41O3trSqVSuwrP8MMVmEEXxoT+LwjyzJtb28Hoe7t7QUzODk50evXr9VoNJRlma6vr3V9fa2bmxv1ej31er0gyJubG93c3Ojq6qr0oCuVira3t3VwcBDcdm9vT/V6Xa9evdLHH3+s4+NjSVKv11Or1dJwONT5+bl6vZ4mk4kqlYqurq7ifXwul9aVSkUHBwc6PDxUtVqNuXZ3d9VoNNRqteKgLy8vJSmkzHA4nJN4lUpFl5eXCy8M0h4i5t9ms6lWq6UsyzQcDoOxFWlR/C69LL6ujY0N7e7uqlqtqlqtant7OyQmDHwymWg4HGowGMSFQDuZTqdxUW5vb4OpFtnplUpF1WpVrVZL1WpVh4eH2tvb0/7+fgiHvb29uJwwguvra/X7fXW7XWVZNqe6+x66mQVzbjQaajQaqtfrajQacXa7u7vK81yXl5fqdDq6vLzUeDyO+dAYr66udH19LUlzmpDvJQKuWq1qd3c3hFG1WlWz2dTx8bEODg50dXWlbrerfr8f811dXenm5ka7u7sx76qmyNoyASTywcFBEBIH/vr1a71+/VqHh4dBmHd3dxoOh9ra2tLd3Z1ubm7iwiDtbm5u3psHlZJNPzw81O7uro6OjvT69etgANiYqFxZlun+/l5XV1fxfpLi/52onKB2dnZUq9VUq9WCkI6Pj1Wv1+MCwby4tPf39+r3+8qyTJeXl9rb2wtpuojjb21thQTZ3d3V9va2Tk9PdXh4qKOjI9XrdVUqFQ2HQ/V6PQ0GA11fX6vb7Wo0Gmk4HOr+/l7b29u6u7vTeDzW7e1tPN8vzd7enk5OTnR0dBREzF5ubW0pyzLd3NxoOBzGc9DgIFpUWi6/XxbmqlQqIf0PDw9jL1utlprNpvb397W/vx/mCFLy9vZWk8lkzqw6PDwMlRqzy+eSpJ2dHTUaDZ2cnKjVaqnVaunVq1c6OTkJ/AYGjQTmYvb7ffX7/fic00fZebGug4MD7e/v6+joSKenpzo6OlKj0QhhU6vVNBqN1O12NRwO1e12NRgM5s5nVaxqLZkA6ut0Og3VaH9/P6Tkzs5OEMlkMonLcnd3F9KHDXCTYtFcqG339/ehpu/u7oaahyouSTc3N3GQMAcuPZfdRwpm3t/fh4RuNpuq1WrKsixUUw6Ni5vneTAzV3mRLEWHjCoOYe3v7+vjjz9Ws9nUyclJqOl3d3exp61WS9fX1wE+IU18nxwcdUnpF6RWq+n09FTNZlNbW1shCcfjcTAwVPXxeKzz83N1u13d3NwEwHdzcxOakO8jZ8kebm9v6/j4OEwAVGXOAoaxvb2tq6srHR4eajAYxB7u7u5qNBq9t38OxKGON5tN/cRP/IRqtVrQwWg0Ck0NPAKTC+yBi8naiujDTSfMjqOjI3300Uc6OTkJJoJWu7W1pWq1Guba9fV1aIV+XquMtWMCLAoE9/LyMsyC6XQaG7+9vR0AyN3dXXD+yWQSoImkOZCmaC6IGvUbZB4p1W631e12g8sjGZn75uYmbF20kiLuywVCEiABLy8vg2nxN/v7+3ERIUIOFAJapOY5OMd7b2xsBL6ByeJAEgxnZ2dHw+FQFxcXcQ5FXgPG5ubmnCSu1+tBvFy48Xisy8tLZVkWkhpG/vbt2zksBVOqSFpyXvwfQgDN6+LiIv7WNRDWxfvDgG9ubgpdjszFpcULBdOvVCrq9/u6uLjQaDTSdDqd03wQDIPBQDs7O4WaYdlc7mXY3t7W/v5+aEa9Xi+AQIQDZpikYBTMUXReRWPtmADDL+ZkMtHW1pYODw+DEO7u7uakBpfj9vY2zAE2j2eVzQPhXF9fa2trK+aE40Io2KrSw0Udj8fxLny5WulzOOp+c3MTf7u9vT3HpCAiZ0bYtti3SNYiEFKa96bwbDwOSODRaKTLy8t4vgNRu7u72tnZifU4YaZjY2ND+/v7c2DW4eFhIPTYyqjL9Xo9zK9KpaJGoxE2OgQOwFt2XoB7CIPz8/OQiqyRi8V+oZGwP9BNit+k+5jn+Zzmh+Rvt9s6Pz/X7e1tMFDer1ar6erqSnt7e+p0OsGo3LVbNJekMF1gVqwJgQF93d/fxzkxV7vdnnNdr+oiX0smUORn3dvbCw4Pl8cM4ADOzs40Ho81Go3igCUVSuZ0PrflmYNLAXHilkSKcKjupilzEXLIAG3j8Tgup7u5+B6bcHd3N56PWwvPAMRSJM2YBxtyOBwGo+NZ/X5fGxsbOjw81Pb2tqrVahD81dVVSNtF2hT7ixrq3oRer6d3797pzZs3AVrt7+8HYOnaDcQPQ06Zm18c5ru8vAyQFCZ3cHAQ+4iKvbGxEXgEHh2A5DItIL2oV1dXwTgvLy81GAw0nU5jbgA8TBJnCs5EU1pM1+XeEzwcnAPm2c7OTtAnjA06SGlxlbF2TMAvUdGF2t/fV6PRmLuouNO63a663W5IyZubmzl/97J5+QwXsV6vx4VHpXakm7+BiF1yFj3f57m9vdXGxkYc2MHBgVqtVlx8MInNzU2dn58H+MS/gGtFajOMCS3l8vJS9Xo9LjdaEj5obNDt7W212+1gFO57LmMCPPPg4ECXl5cajUYaj8fa3t5Wt9vVxcVFMDwuozPLlNG4RrWMcaMR1Wo1TSaTYGR7e3vh1kPTYs8Gg4Fubm7U7/ffi+9IadAvMEwDU86FAuYqjAeGmAZ6FTE35mV/+JwzU94Ds9EZHOYIjJX3LaPDorF2TEAqj+Da2dlRvV5Xs9mcc0PhGnQJmQadlD0z/T3PdP8zhArX5+9ub2/V6/Xid247F82BquoXCvvdXV7Yedvb22G7Q3i4gzAFyhiOS5StrS1JmmNmeCJgdnt7e3MqaXoRivbPTTYQcfYfPzbgLq5RtDhiA5wJ+HMX7aGbSkg/SeF2RdvgvBw3QCNYFizE2pzh47XJ8zyEEGvCk0U8BoA1Kj1nXURzrMvPDPsek5E5MQMQELVaTbe3t8GEfI4PVhOQimPqOUhp5vqCcOHwqEZsqPt7yw469T/DZf1g+fsUwJtOp+r1egHeFamR6XyOrPMMuDh+dkfuIXrXNvh7BzbTwXPdlQkDAcDChUoshqRggB6SXTYHawLjACfpdDph2+/u7mpvby+QeJj33t5emDOYAL7/q+yfS1nO3FFxt+fv7+/jchIzgrQtmytV3/lbNCdcyuyfx7ZgwsLkF3mo0rkwAXh3Lr0HfEkKLTjP83BVQzvLaNHHWjKBdMCVsfMBeyDw8XgcAT8Q0KobAaFDgK4iE+UmKcAZ3EXSgwvNMQrcf4sujTRzFaYRdazHLwbvhyRLXaDL1uag52AwUKPRUK1WizmlBzDVg4kwA9yluUw1v7u7iyAWVHC0KkwcLgE2rYddu7rL2ZUNpLwzX0kRKQrYV6lUwjRwz4xfzEU04kwHk2B/fz+0KFyrgL0wcv97XJfQxyJQ0LVWgtyw8fkc/wcmtrm5GQwApr5s/9Kx1kyAy+nx/Pf39xoMBpJm4aYQecoAnPOWqUeuNnIJ/HDxvfIFEg5RQYwAfK7SFc3FPB6dWKvVwoWFNgMhczGw4bm8MIFVbL88z8NfzWV1lyjSGtCMICEuCJKpDKyDCeDO5fOo507IHgiEBofG416NRfSAj7zZbEaoNTERHh2aZQ9RhwTZwGDQQji3ZfNxxvwt4COeFhj0wcFBeKowHx3Ec8GUYhCpZufYCHuG4MuyTLVaLYLf3FxxWvTAoUVjLZmAE4O7uhztJTdgd3c3gngcEEOKL7NrOWS4NX+HSox9Ox6PY3PZcA99hZEUJfXws5sZqJK4PgloweyBGK6vr+PvMYNgXJKWHrRrA51OJ+Y5ODjQ9fW1Njc39fLlywjUQdvK8zz2mz0sI15JYXKgcrM32O/kWLRarVBfe72e2u127Dd4SRlNsIfVajUiE8mzIK6eC4NmyJmgNoPe84XwKHLtOtOBgWPruwC6vLwM+sQ+RxPZ39+PSNZlDM738u7uTv1+X41GI+gC5oz26WHdjiXgDv2gzQEulaTgbuQOeMIQHJdDhmBR6Rf5t6XiQya6jssAsWJLY4+hCeCGxJSQioEfGNPBwUGEPxOHjs0MDsAXB84B7+/vx7OQFmXDpTT25s3Njc7PzyN6jucTyUdgimszHmuwaC48HsQeuBni5sfe3l7gN1weJHSlUplLBCuaZ3t7OwKSTk5OQt0nnHhzc3POHODZMG7sd9deFtEGTN+1MDSe6XSq0Wikfr8vScHw2HsYDthAmZnoWgD7geni4Co5CdAaTAWmC/2tmonJWEsmwCay6QcHB2o0Gjo8PJSkCJpgEyAcOKWkkNTLYgTcHHDfNS5GzAESigALCYAhmxBVu8wUkGZYAOHCJKTU6/WQVFxWDtWZXJZlcVFXyRJz6e0eAycmV6F5ntvNEOQitNk1LTQX9n88Hoek998BHKJqg9xztmVah/vlj46O1Gw24/8JTkI4uPbg2iEMhsvD3xfRRrpOvoj1wMxCm4DhQEuo87gYy+byOdwlC+4EHcIAYEy4LLkDbr5+8EwAqU8iEYEYcMy9vT1tb2/HzwRy8HdsAipa2YZw6eH6HvdNgA32O4TcbrfV6XQ0Go0iO4z5ytxbvCfRcnt7ezo+Po6EEUmhVUBQqM0cODYul2SZhGZu/x4J4++Bv9tz7yXNSeRlBOUmg2cigq24VEVLQLUnZ2LRHvqAeW1tbanRaIQpd3V1FWAhz5MUDBXtDYbt0XVla2KP3SWLlwZ3oTN3TCLXRB3kW3Revm4PmsLkA2Alo3FraytMN1yfLoiW7WPs59JPfEWDy7y7uxuxAah/xJ5nWRaRXEg3P+BleIA02ygHIF2d4nCxxa+vr9Xr9XRxcRHBSUQoLpPO/h5wc5gb0sTj/ZEixD8QIOQekmVqOnO5WUVoL/H+jUYjpDTqJ0TuQVFl63JV18Fcj7kAUSc9lrNzYJeLsij+gUvh0ZoAuaDj4ERoauAV2NmkFOMyXaS9OY24d4G9dzyJKMFer6ebmxt1Oh1dXFyo0+nEXi4yTf1L0hwzQXsESyKIjUxFUrRZzzIt0cdaMgE2Ck3AI7M87py017OzM11cXGgwGIS96Smiiw6Zy8aFw8/NxuPywYakcIQfMFFnZbaY2/D460k1JSgJqUFIqjMX1HVPsoExLDN10D7Sy3h0dBQpqxsbG3PPTKskrSJRHF+B2YCkY/LABCTFZcdk4+IvYzi3t7fq9/s6Pz+fqxlQr9fjnPwcu91uMFI3e/CElNWZcPOJ92SPWB+4Ff/2er3Aka6vr/XmzRu12+1I0V6korPmFAzHQ0QkJIFDvV5Po9EohBFCEDpcZgb7WFsmwAUmGhB78/DwMLwBw+FQ7969i41GPXcsYBFA4pKFeQF72u12bPru7m7YmUiX4XAYGgjzLeO++LGZ6+rqShcXF6HmIRGHw2FIKg42VV9Tta9oD91N6kAmWgT2OReEMF/2cRXtRlKYEDAbmLWkUNsd+fYIPtcEXLspY6STyUSDwUA//OEPQyujuAfaIVK43W5rOBwGUyvaw2UXk3fk6/b2VoPBILRRsBw0O1Tz6+vroEt+XhSd6BGQ0H232w1zgt+xnzCkdrutXq8XQgMB+MEzAaQmC7m6utLZ2dlcpSFJc1ISVTLdgFVsWf4GtBgAii/UW9BmJ2KIqCxk2AcXH/Cv0+mEFMH3D3Gm9qpHlKXzlaHOMAJALEyKfr+vTqcTxT+oTTAYDEKtBGBaFofgqrKHT0P0XH5caYeHh2Fj53kel5TQ4zITx21lj3P49NNPg8lwEXl+mtrtoKC0vCgnNMH6uJhOGw46prgDAqksxyNdnwOwmC4XFxcRyEWUJ9opzHM8HkepsVXA8HSsJROQ5u1nUNfRaDSHort08b9ZlQGkc6UH4eiwh6OiqqWXcZX5YAAQCkTDZeUZRT5eB6pWWR/r4f2zLAu3HFGWxL+DXKPpkHy1DHhkcEkw4fAs3N3dqdPphBsSJgsDaLfbevv2bTCDMgJ2RudAHe/Ne/rf+x66rZ0yhkXDNTzOyWmPvQWkxk0IA0FYrEIbDpqmWkUKLEOLnl7unpynjC+lF+FTR7ak7wAbnkZV+f9Jn63cctFcDnKlczghPZXZFD0rBYPSdaF9FOEai7SAsnVBSCkABXE/pQJvEaPi+UhGciFYC8Fek8kkVFgnen+O/65sLl9H2R4SW+J7WKaWL5vLvUluw/tn0lTeRXMVjSKAsOw9VpnLxt/L8/wPvDffh8AEnsfzeB5fyChkAl9aa/Ln8Tyex4cx1goTcLWuDB0uUtV8LFORv0rN5/Osi7HMXnY1ctF7rPLcsoH9/UWc17L5P+t5rWomLfr7L2oU7QPv5pmF/rkyc9T/tmyu9G+K8iJ8rBUTYPhCfDPYME/YcbDIATpcLqsCdunwywQo6M9PbdZVALSyS+Fx4J6NyHOL1vZUPCJdC/vHHvqe+Zyr4ANlQJx7VdJkJEfqma8IG3jK2nxOcAifz+nhqQi6z+VfzOdgrT/3KXOlYGPRHnrUZfps9tDfZRVmtpZMgMEiyP32HHz8wmyC+3NBZD0KbdUD9033jXeAziWhx6EvmseZhjM1XJCAaYQne8ipX0iCmtLDXrYmL2xBlBsBPRAPc7mrFfT5KWChewjwa+OF4PleH5Hz8riIp4CdrAlXHUFRPNvdrXgs0j1Mn1u2LqdF9tXBQDwIHt+/iuvOGSlMjMCrdC89xkGaAZ+SIpflgy4v5tLfE3s8H9sj0jgw4sO9esx4PJ6rHrxoU/yieBsrimJQxozgmlSSeVLPslBez1MguIZcdZhApVKJKEHUOZgCueJF/ueUgNk/5oOh4W+mjgFJSzyD9FXOwKs3p+vxudJCIl6Ek7JfxHdIM+Y5Ho8jAYh1L2IEnHWlUomgHZgbNRq4gOPxOM4FJuoZmymDSyVoSocEJblg8mfDnHBnI4zY4zKTTlIwMeiA7FJnAnmex/m7JjKZTGL/2cdlIdHSGjIBd7uQdy9pzg9LUc5qtRquEq8ew8GPx+MI7iCaquwAINTd3V0dHx9Hx6NqtaoXL15oc3MzIgl7vV5UNeaAuSgkLPnmpy5OpLDH1m9vb+vw8FAnJycRPUjATpbNGpMQSky0Iqm7ReuCoXldPwjaOxMxV61Wi2ehBRB3T8qtd3FK1Vfv4EQZMRJejo6OQhOAoTDveDyOPaGFnPdhLDovtCaKtJCN2Gw29eLFCzUaDeV5HrklzEUMBEE2hPi63Vy0LgqJECkozRJ6yN8nvd0vJusbDAZzSWBFJtTGxkNvCArp1mq1YNzejcs1RPJM/JzYQ0lBH4vG2jEB6WFjPMMNyURFmVarpdPT07n4bYg8z/OItOKA4PplBTjooNNsNiM9lYYatAurVCoaj8eqVqs6Pj6OkNTz83MNh8MgAMyFIp+0q6toF3t7e5HMc3JyokajoY2Njbnw5yzL4tJvbm5GtqQ08xOX7SG9DtkfmmSQlEX2oFccmkwmUUMB6UJBDS8KyrqQxmR70lSV9G8qDKFdMEelUon8CelB06nVasrzPLSqonVxKWAC7CdJZq9evdLe3p4kBaNmfYPBIBqroEmUBdlAdxR9YU6akhLF51gG0X2EmF9cXLwnxb0OhAs9aIG6hZ667nUG2Rven1BqGA2aA5Gby8baMQEuiseeI/2r1arq9Xr0vKPgBhKWLC6Sizhcat8VDThtlmVqtVpqNBo6Pj7W8fFxEMhgMIi8e7SD3d1dvX37NpJuiJ9HRUvXJGnOpkQVPz4+jtRQipYQacbaPRZ/PB6HtrOoZh2XEsbJZWE+KjaTPAQmICnSYc/OziJTDiIumsuDg5D+FEyhLyDhvl4nsVKpRLSig4dofUXDU5IxPxAMR0dHoXFwEakA7CnmOzs7ur6+jmel5+XrQsuo1WrRvxEtznMmsiwLJgjdUCfBw7cpjZfOhZaxsfHQzAUmzRl6QJek+Lw0y91wk62IDsvGWjEBB5Wk9yUNFXnIqPJYfgjfgcN+v78wkxDCYB7CM2nU2ev1Ir7fVUIIBGkDETiAV7Y2aZYgBXHu7+8H4yJHHZUc8yKtY+iodzqQlF5vYXNzU61WS8fHxzo6Ogrb1hOEICrehV6MZZLZVV/2maKXJCtxARxIm06n0c33/n5WFQpCd7ylaA/5zGQy60PJxQSQI6fEwUe69LAn7g0pmstzIVDlyYz0LsNuw6PCY37Q78HzKIr2kJ4BvBeSHoyLMG/uQgr03t7eqlqtBjMv28OisVZMQNIcEQCqYF+x2Vwauujwf7QqB2gCHFyWTsw8V1dX6nQ6Ib36/b5ubm6iUIXXHySlU5qBW9jR6eaDEkszd5ir8RAAf+eFMg8PD9VoNHR9fR1MJ60ElA7Pc9ja2orCKPv7+4F3ONBJTgZqNRcTm7YMbU7BNEwuClxwGdgrVFee02w259KjSSTypjEpbbCHMAH20JvIgsZ7MlitVou+j3iOihqPFM3n2ZfUWwBj8kYnfLZer2s4HGp/f19nZ2fvpYKXgZAwr5ubG+3v72swGITnAYHAxZceNMt6vR4Vh7yCEdrpKmPtmAAMgMXDkZH0VJgFAEFKerovGWmdTidyvMu4orveSFEGUEPy8Q5++ZnHk0TKmE0qATxTkAuL1MZFJmkODKLnXtpGK12XuyJ5TyQkKbe7u7u6urpSv9+fa6jpEgZpxGUpImAnXhgbeAXMxAFJVHiKmrjEBqgD+FwmxTgzLgAgHWvjgoPoM7goq7jSPL4ARumpvXmeB5PlGZgckqIhDq3fKa2eAo8+F9qUa35oJJLm1kQtCNYEwwajSucqG2vFBNJAEi864RVcJMVB53kepbsBY7rdrjqdjjqdThQZKfIMMA+2PF1fseU2NzejIAaoN5z73bt30fIMzrvIRehrw2aTZskhnoYq6b2YASded6OlTIc1TSaTuRJXPA/bEcSalmF4Chio0F7JqAit96AlJCb2cp7n4bJDm6Ok2M7OTtRiYD0g6Yvm8r2FNgCAEQRgJpLCU4GW4iCoNyYpmos1gVm4OeLeCXdno2l0u131ej2dnZ3p/Pw89jplcK71wthwl3qpcipboaXBTAH/KDICY6cmxAfpIkxTZVGBQF3JHceltLOzo6OjI9VqtSgs4kUWvJgDUpLhDAfpi3txc3Mz3E2g6HB5r06D73dRRReP6OIgvfgG4N3t7W3Y8gcHB9EoFMmCtHWto0iV5RIgZUC1IWRpBkZNp9Nw7VHLfjQaRdyFB9mUrcvNB9R+7Fyey/8jtdEKWBfMBjNpGSNlLuiBgrSSogMQzG1nZyc0Hmm+mlRZAA9SmcF7wXiYD9MRwLhSqczRIC7lReXFOFe8WAgGaNbrW0oPAoI9Zd+oB0EtiKcEeK0dE5BmIbiAHu4K4fe4aHDXcDmRJtjVAEXL5vLorsvLy5AqjmQjwTkobHS47TLVy4E81GQYE3NUq1VJCiYHoISkcG9I2XwO5DnghvrsLko0KTQdCMfdeG6HLlsXjMbBQC/Txpo5S3AWN72WrS2di9/xrgDHvodpiLRH9ZWNVCChGXFhd3Z21Gq1grFBo5iqlP2CDp0JF83lZ+vnzVwEx+Eux9xzLIa5yjxHReNzMYEsy74naSjpXtIkz/M/kGVZS9JfkPRNSd+T9EfzPC/2z5UMDsbDT6VZxRqkDO6h3d3dUJUJoMGO9zzyZVwRicSGDgYDnZ2daTgcBpjG5vr3MKpVEVkPS3bXW6rt8FwYHI0ytre3gxhT7cb30L/cBYgERdXE0wGRIpn4HKDTKucFM+NZXHppFmbt/48k46yLgNWidcFgUnWad3EMB63IowVR21c5rzImiFvUS9XDPEej0VynLJ5TtB4/Q86c4e5l5vDLDdOhmxSmGB6zHxcm8K/keX5hP39H0l/P8/yXsyz7zuPPv/SUB7oLjggt1C6kCGAaKtFoNAoAhhJV7pJa5iFAMjDwMJyfn0fZc6QlFxTOTTy3NN+OumiAbQDCpW2teIa7EWFs7m5z+3PRwBYHQyC+APvcpQ72KMg3z17kT/f/R8MA+MPHDVbApcUbAkqfxghwdmXnxecBHL3kuIOPuNkQDqnLEsa9KMvOYy7If3BTzc0gTERAQPYPJg/dlrmroQcCvDA3CEhiPZ474Pkx0qzhCdrKKuPLMAd+TtLPPn7/q5L+hlZkAnAt1B82YX9/P+L/kX6SAhDqdrtzXW3wk3qBS2K608vJ5edCoD04MouEIeKNS4q7EKIFiEkvpktCkH40AG8XzmVlLggGnAKAChW/TL1MVUpKU79580ZbW1sRBwH4eXR0FIQEIx2NRnOYTJF6WXReBwcHqtVqc7asg3VeK5+LA4C4t7cXv/dchrLzYv1e8j3LZiXUqJ3owKO3WMM8gFEW0QYxCHgepFlDVegB9yB2OZ4OSbEmhBCxKG7S8A7EwnjHbW+PJ820LhiOx2Og2cFgXQtbND4vE8gl/bfZQ2Wg/zTP8+9KepHn+ZvHF36TZdnpUx6IZGUBHu8uKWxaLihIKAcAA/DIMqk81ReCkmbJNp6nwHM2Njbi2Xt7exF5RgIO9tkiuy9VKyE8EPrd3d0g/uvr69AWkPh+Id21VLaPuEyvr6+1tbWl0Wiks7MzXV9f6+DgIBgleQGYTl5l2F1xqK5F5wWSTaIQIBkMjUYuLh25HKixuGUX5Xg4w+Zn3LsEdUmzIpx+HgC6nLubEkUDhg3w565owEvOgZBkav9Pp9PAd4i3KDMHmIvwbhgOOAN77MyEOdgrmAUAptP+svF5mcAfzPP808eL/lezLPv/rfqHWZZ9W9K3/Xdc3lRy7uzsRMcVAlBQkW5vb0MTgNsj9V1zWKSiSwpC9NbTcFaPMWeAERAh5pmKZQRcZKO5Sk6RTy7b7e2tdnd3NRqNdH9/H2tb1niEOXhfknUIREFygEEgTQhrpdw5++vqZupd8YvJJaGhiUdC4tGQFBcXxgIzwj24zGzz+dlDzw2BkaN9gBchMDwHIs2DKDov5iR0HYbAWWNuYIqSRwKdeOBOkYfKGTt7CViLqYjGxDly/ph1/K2nnoPBLBufiwnkef7p479nWZb9RUk/I+ldlmWvHrWAV5LOSv72u5K++7gxuf0+FsRmIWVQw5DMk8lE/X4/mnUMh8PgzKiGfL/owvBFdl2j0QgmAB5AjACqH+4v9/s6Up2sde5nPg+3pjy1PwO8gbgH5uEyuRRbNJ9LcuIDcE963IWDWQ4OcnH9whTtobtysWchTnd7uXvO3beO45S5CNPhALETPutDUg4GA52fn88xMgcRy4DV9F+SrzAF8K7gVnUmTYdkf0YZLpWeoZtSLvh4b++jwN+CfbF/fnbLxmdmAlmWHUiq5Hk+fPz+X5X0H0r6DUm/IOmXH//9S099NoxAmnX79csP4V5fX0eTCbLeiOLzS7IIBXZJBmJ+enoayTwEm8B0Njc353yyNApxH/eytcGcXJLd3t7OuQw9tJXAD2rLp+Wly7AOt9mLsA/caFzC4XAYmIoXEwGkXOa7Zw43q6QZio4NC9Mj3RvQzuv0l10W1sa+OaAmKRgQ2ANZg97MBU1o0boYbrPz/FarFbEC0JjXk4AOuPT+VbaHfm7ugfJ6Av48j3PwDFAY64+FCUh6IekvPh7IpqQ/l+f5f5Nl2d+V9OtZlv2ipB9I+iNPeajbPRw2XM59u/hiPSLLi1VIsyCMRQUqsJ+4NB7BB0hDOjONO/ABv337NpjPKlVxIAIIgQuBnYztDzPjC3clqq2HKRdpAuxj0aXE3vQwazcDvCMye7LssqBlEFkIw/JnUAuByDlvOAID9RDisrlc4rM+vD8E0KAy93o9tdvt6KoEYu+MbVFADZeNPXZfPsDt3d1d0AX751GGuLVh5EVh3pLC9OJsHRdiH12bw6xhLtaV/v8q4zMzgTzP/6mkf7Hg921Jf+hzPDcWu7GxESoW4Jb0QAij0Ujv3r2Li4hNzgE7Mr7ooD08GcnxySefaDgcqtFohFQB3CEfwQuLcGjLpArzgGCTq3B/P+thj2sS9dLbc/G927RlDADAjS+AVaSH7w3eBy+uAfN0zSMdrrUQmwHhe3ELCJjuRt481guM8C6LGCkX3i9Fr9eL/yPak9wIzEXXAlxSLzsvCsbQ5ef8/FyTySRQf/oBvnv3LgBqGD1fvCd7W7Q2zsDdv9PpNOZHkxoOh9ERGxPK6c/dhmUCIh1rGTEICAZokue5Op1OqK+TySQuIpLDwUDn2ssuJkTM39zc3EQhCNBa99/jb/dYdHcZLppHUsyFZD8/Pw/7HCbAhXDzwi+KM7qygT3MZUEKIoFHo1EQGuuGCQyHw7g0XtykbE3sCwRJBiGuTOl9SQdj9vBnzmzZPnLGSDua0rKP7HMKbHJmfkGX7SESnbwS+l96EBeALutzQI6zcoZTZL5B86zx9vZWnU5nLj2as/M1QfO+nx4y/ONwEX6hw4E1IqFQuYbDYTAFiDPdaGk+0GbV2GmPkHNUleah0syVmBKs/7xoXelcvDdrRoKmZo8TlGs60vtVmYvWhUblGXBgKdi1ZMIBcnlfwGVeCObl2awPhgZQBTODqfv7u7nh0mvRuvxvAVBhOOke8nlnMssYAAN3XHrBQOK952KKjzgWkK6raBCsxfd4bqSZyeW0wmA9aASrro2xVh2IijbHQ2y5iH4Zpfm4/zLUtwy5L3iXOXsz/T3ff5bN9mextvT79J3h9OlcZRelKErM4y2yLIsyVQ5MQli46co8D9L7fQfK1pXuoQ/chI7YL0Lpi0bqwktjNPx7Z0Sr0EB6YR0zcm9IKnE5r0V4jb8DTDGlL8yCdC7/e3eNOgPi/x1veBzPbciex/P4mo/nNmTP43k8j/fHWmECv1uHq8dlmleRKbTMNuYz2J/p84piB1YBi9ZBOywbP651lZ3HKkDbonnTGJGnjkW08FnHB8cE3A70DUk3ZlX3yKrzuA2d2l7L5vODd4JNg148kw6wJ/VyFAFNRaPookjv5/unFYRT99aqdnTZmtN9TPfKz3AVjGWVdbGXRXYyX2XhwquuyQOwilqeOabi5/VURpLSIK5ef17RvE8ZHwQT8E33QwY5Z/EpuOauk1UHAKTPw5dfDA7SPRSrhLs6AyAk1NOKG42G6vV6uJXwo+MWIkTV4/mX7R3r8vRbqtNQ6w9iBdAiWhHX4qrEVbRvvqe+TwCW7IlX33nqXMzhST+OzkMXHkW6bK4UHPT943sSfSTNuT7xJhAe/ZRKP86k2TfoxAvZOCiJC/SpeyitORNgA5yg+L1XinG3lNcc4FAWubl8LjY9zWLE582z8L87Iyjy7ftw5gShej4EOQqtViuKi5IuysES2lupVCI9tqgWX7ou5iNSkBwJ+ixwYehW4+Wqsiyb84Evm4vQa2I6WK9LTJiNp2oTVedRkYvmKqonUKlUYl95Lm68VOMgsnDRupyBehEbfPckmxHVR6Snx15QQwDX9ip7yOcpaZdls74EBK9Bi3jGEBDEd3hE6bKxtkwgy7K4JNKMkMgjqNVqkV7pgR+4njh8Yg0WSU7monAkySEbGxvR64DqOjwzz/O5iC2X2mlbK2mmAZAhxkX3Mli1Wk0vX76MNFwPeCEngn6FvV5PWZZFtp+vxbUN8vz5O+Y+Pj6O+onkQxBp1u/31e1245INh8OIYCyTZoRZ0z0n7XpEXwA+C3O6vb2NUOydnZ0INMJVWXRWWZbNFZzx/H7aq9EajFJznE+e58E8icZLmWnqZqQbEFmE1Gw8PDyMJjh5nkctQRgokZ8UPCG8vKxKE9qht1XjDGq1mo6Pj6OcGVpGlmVzWhv5LF4qfhkjWFsm4NVc4Ppcznq9rqOjo2hwyeYRQERSEZeLcN8yCU12mLd7ojch1Ya3t7fnYtwhLqq7EtwBY0jjFfw9neEw99HRkY6Pj+M9PIQWJtbv9+OdYUJ8huEHTm46JdgwN46OjnRychJ9D13STCaTCJO+ubmJ8NhlWs7Ozs5c1yEYj/da9DRZpPdgMIj4ep5NFd2ysF46HFGBhzqTtVpN9Xp9riMxEaVczna7HTElnoGYXhbOjH4WhJDTMq5Wq0XGKZGXe3t7EchGoxMyKNEmXWtM9xCVnzgOhESz2VSr1dJHH32kZrMZ9ICJCrN5+/ZtzOVxGB8kE0CCVCqV4OpwYUpYk+4rKTKtNjY2NB6PdXh4qCzL1G63Q1sAUPHBxlPpp9lsand3Nw4ZIkYF9NLTtDbDJKF1l6T35oIBoP46UaDV0P8QzYeoNOxeCmZeXV0F8Ra1BWM+N5+Yn/JYMFZsVVePpVnaLJgLBFkWiOQAo3eJovovEXdoVrRcQ7M4ODhQt9sNLY+zLJoLJrq5uRmYBq3VyL9wAK3VagXDpBWdX0LW7gMGwBlJs+YmjUYj+jewh0hm3p9ITEwTLy+/KHjK6QdhBGN9+fJl0Mh0Oo0wc2l2X9BoYCRFe1g01o4JFEUIZlkWDUKRJKhlXCiaXWxubkZhUAqQYi6kw8E5DodCIY1GIwiFS4Q6i6lwd3enXq/3XsmsIi7PeqT5xBRvXcXv+XLwjPx8mMSipB6IA/CICjtI1uvra52fn8/VSWB92L+ozpLmzK2i+UDiyUbEXsaM6ff7yrJMzWZT9Xp9Li+DPAXW6XUgivbQ8xFS0wDthWelQGiePzSrhUF6nknRHnreA6YeNIrqLSkunHeqohNSWo+hbA89PwVNEm3YG9Cg/nP2CClMVJ7zFHBw7ZiAu+ModHF4eBhSi7ZPJMV4TvnBwUFkE3KRkDZFF4aL6Vl1ntXGgXh9Py6m58p7zfyiPG53DabouKf6UhMRUwOV9cWLFzGXuwp5RtFcfE/SEBmZNzc3IU15d89lOD4+jgInq3bq4W+9tt5kMlG1Wo3EG6pDgUlwYUlbhqlhbjkTYi3QB+u/urqK4h3+jvf393MME+zg8vIy3K8Ax6k55XsI6u4Zfkh66AcAmXLtMIGrq6tYl6f6LsuQBGPyWpcwAkmRjs1ajo+PA6gG3AUn+mC9A3BmiJzMKsARNptDQXJ7gszFxYUGg4E6nc5cLHzZXGw83JSCmRwE0glV2usKdjqduCiONKcBIn453ZVI63O0GkpgUWTEpTOFI7z7UJHW4etjT9CmptNp2Ol8HrW1Wq2GRkMas/fsK5KY0sxNShUfMusODw+DkAHSANg2NjbmajNQURkmXBYP4K7My8tLDQaDMKOyLIuzdu2N2oWcsXdxKpKYaUwD9IbWgarvkh8wFC8BblZchLhZy8Bp6GM6nc5VhGbfarVaYFAwdccOwD7IEP1d0YtQ0tzmoV6yOdjM7i4cDAZ68+aN3r17p/Pzc3W73diMogILHLB7D5Ceg8Eg6rtNp9MAf1BH6VgM53Vms6iYg6t+YB0QFpKQNVMZGD80UsfTmIuAHwckHYiCmdDKG9NgY2MjGJwjy6jzEHNKVKmkhkEhxZGQlGs/OjrS4eGhptOH1OPvf//7+uEPfxhp4TA/9qFoXawDRrG5uTlXNs1NSQeT6U4FSOgaThltePYmmIYX8gT7cC+PJHW73dhD97os0wT8vPI8D88Hz+YsYEZUdabWgQu+D9pF6AEd/FsUYAJqjUvq/v5e7XZbn376qdrtdhzEInTU7XdXs6+uruK5XnkYLAIi5PIv0gJ8TQ5CbW4+lPoGuacLbaVSCVWdgp0pKIjqx/6k0t81D94Freng4CCei0pONV1JgR9AjMuCavxi+vmgPW1sbOjw8FCvX7/Wq1evQts4Pz/XxcVFFGnxqjxFdjpze+CPNKtlQNchBEKlUgkEn/3xC7msDyFz+c+YEVk26xZdr9fn8ABUcb5g1m5eltG8g4YejFStVkODOzw8DMAcLAAzzIvQfPDBQq7OoSKh6tzc3KharQaYBtB0eXmpd+/eqd1uq9/vz6mUTjQ+nNgAVVAZIUjUSUfksUFdIqeXrmg46nx4eDjHaFDvcCPh0gMDAX0GzCQ4pghEc0aE5uEpsEgWLj9IOkg3fmppPhx30bo8vdhjJ7IsU7Va1YsXL3R0dKTNzU29fftWb968CU2N2gWOcRTtpZuK0AmFPTgD+lQAzqHB+cUGAylbl5sCjt0gydEM8VihgWDKuBnn+MKyPfQzA+uCmQC2cm6Yc2AxaDfQ8bLgOB9ryQR8OFFBMNiaXEpALxBb7FoOb9GGsPkcOCAfKiaXUJrVykfqQ7weq77soFHlaHJKgxXvQOReC0eE0TQAEsvcTen+pWGu/jNEDmF7bDrzLItK9Ln88hLFyaUE6EVlRduAyIu0qPT5fl7M4ZLXGQVRiZgGMADWvizMu+hdXCty1Z24BHc5o9V5abFF9CHNwEYG5g6YB5GlPBcNMfWwwLRWGWvLBJwbSrPy3BASYAx22tnZmTqdzlxkYFnST9Fc7imAGVxdXanT6UTACKXN2HRv/ex+3jKNAKAKIBCbEjsZgvQ8BVRWbG3URg8KKVuXg1YgzB526vawR1+CcvuXm2VFw0O8wR4ITgLMpflJt9uduxRF+7/ocvJ5mBfny9nc3t7GnGh3Hn7NZeEyl2E47ipkrz3wiYpXzpycwbAPRftdtoceMERcDDgVOAHnATBKqTrMTc/VWKadSmvMBFJC5wJ4QAsqX6/XC1TaA1Pcf70oZNiJClQXUMf7zcF9cdEQg4CqzbulBw33x21FBWNQ3UajEXMT9YhEQcqwNoApD+Bx6cL3fhGJccfdBOMEGCMuwLvrQHC4Ez0CreisXGvJsiz6Eb569SoiE7mgHlY9mUzmkG40Lcc8fF1u3njgFhIa8DjP84jyTKsYc9FgeosiIT13hMvsWhhMAFDQsQpyGVDdvU5kkfeDfcBT42HpeD4Ahz0E2bVED9xa5tZlrCUT8APmMrMJ0iwBh41qt9tz6Dx/j/RapILBNeHkTohpYxH69HmXFxgEUqlsLtaCxHVAbTQazbnZ+B5GQeago+dlxAvT8MQakOR6vS5pBq6Nx2Pd399HowskMB2PeAYaQJlEwcxwVXh/f38ujBjzikq5fiFhTDAaSRGrUHReabBQlmURT+IBYjAALh4XmHXgX1+mSTlDxR3tZipYAF2pYAD8DXMvUs/5PPvB99fX1+F69PcH5ATDcu3JMY1VxtoxgfQSAYhAVGAAENb5+bl+8IMfRNlxNgIblIu2aC7HD0B6XQOQFG5D6senoaDehiwdMBfXTtIeAtIsnJVnogJSvpskHi+0WkTEznAAGIm4pD2XZ7ixPklzjVRcXU6Rcp/L1VgQ+Vqtpo8//linp6fh1sT96OcESInURjNI1+UAm+MCjp0QLEPMCLgDTAIG427monVxXm4OeJISpmmv14v9cbeku7DT2hBFZqlronyPJ8CjFomK9FZxw+EwvhAY7jX6YF2EzuGxw2AEJIugXkK04/FYeZ5HU09/xiIp5qgt6p+rwahzlUolfLRc9u3t7bkknzJwi9/xLjAA6UHiMT9aDAk0Nzc3arfbkZGWZoeVrQsihvHABFBLUR3xeOB9oIkGROTRj8tcTuzd9va2Wq1WfKFhYL+ORqNgcLRyc7efd9NZNFKm7fgIocKu2XGuKbMuw4pSpB5th9gRNAHMJswGvEXgBr5vy+aCIXM2AIuYCewvIHin09HFxcWc94J1ffAuQmk+Vnx3d1enp6dqNps6OjpSq9XS3t5eNJnEHZi6j9zFuIyAfa56va5mszmXMQaRAixBSPiC3Q9cxOmlmXsK6T8ejyN2X5qphDyTXvdkENLw0vselJk7vItrIACTMBtiDugO1Ol0IhW11+sVNjsp2z830ZrNpj7++OPwgICae+9DtCH+5T34edFcaEoe+wDYSpqvh55jP2M+uS99kYfAJbQnsWESeL9F5uOs8GTR1AXmvyhi0CU42i6eI/ZvMnnouUGcBbkXHtXpmscqYy2ZgG8ECTb1el3Hx8c6Pj5WrVbT/f19ECudZjhcaXYJimLDfR6kBZtMUk2j0YiEF+ziPH9oGoJq7hIZ9HeRdObiAvKhTrqLEKyA9FBQbW864TkKZQzOOwh5jjuSi3e6vr6OrjYwAOZlnkWFN7hoaEOor0hfd3tyHsPhcK5tGYzM8+LLmLZjMWhrSGgyF2E0aE+j0Sga1nqvxbKoOmfajjExJpPJnBtQUuA2nCt0yfk54ylbl19gmAVzgR0Nh0O9efNGn3766Vz/Tf7GNbgPWhNgMW5LO5Lb7/c1HA71gx/8QG/evNH5+fkcMMiXB3csmssvEmoVoJLHmhMqzPxe3ccvZdHgsrg9LClQeRB47HVsZ/eBe5LSouo7MBLMF7SYfr8fbifW7G6mlGDZm0XMTZpl2fEskqtIcplMHrpHn5+f6+zsbK6Dr3t7XEtatC7/woxBRYcZ+ftg5nhvR0/qKVsX0hsvDg1wxuNx+OoBM/l/YveR0K5J+VrTAW1XKrMKRefn57q9vVW1WlW/39fd3Z0uLi4i0Mr3kLNa5bzSsZZMwFXE8Xisi4sLSQo7SJLOzs50dnYWRT1ubh4akXrY6SoqEcSHJEKjoNswFwYphWTh4DnclJkUDSQhB0WmGTYstjlr4JkQmv/tIvXc9xDiAjjiiz1iPpceDgq6mrpoXVRw4vt3796FicBFRW31Mls+zypzsS7pgWF3u93oB0j0njRzj3mbOv71M1u2LvIgOC/XQHDXIbXRugAoYTIupcsAO/ad308mE3U6nfAwsG7iU9I99Oc/BQ+Q1pQJSLNwSKTjxsaG2u12FPegTbdLDr7K4s8XzQWYKCm4MUir1xQEtPLL4wdQNPzQ/bOuOaAuux3vgKX/zSKNwz8LA3ACQ7ty+9PfLwWxViWoyeShhyEaS61WC6TevQ3sgY+UEayyLnfv7ezszJU/Aw8i2hFm5/hNmbcjHdAGe8/eoZ26OVmmhZZ5BdLBe4IhkJaNt8PD01PAcZU9LBtr34EIIoXrIjXZYEfkP09rMOZyuxZ3JM93lyEHtcqm87yiudyLIc3XA3DvhhNt0XyL0PR0jkWxDKn29GSCMreaNF+zwaWgr+uznJczbPYR2uC93Y73KrzL1uVMMT0LnulM2v9fUqlNvuo6/bx8Xt9DPufA5grPf25D9jyex9d8PLchex7P43m8P9YKE1gU3rvoM0/RZlb5rKusRX+/LBJr1Uit3y2jLGqxbA/TsW575ar9os9Iq9FD0UgxnUXPSN/li96vtWICZcNtII+EAzR0QKQILPmsc6Xz8awU6Enn+qx2NPN5Kqn7jj/PuormJDjJbWfs9FXBLN4pfbb0fmswz5twgIu5VgXrytaTntkiwOzz4BAesOSYh/TZz6tsD31tzOWfT/GAJ+ADMdaeCXjEm1eOxUcL4JMCMQCFiwJq0uEb7bHg5BJ44g6cOw2xfcpcEJODn8T6+xqk2eVMIxSfupcOftLxaG9vL5BpfOi4RBdFuRWtiXnc7cm6iH13BN/XlOYsrLqHDtYRd7+5uTlXqu0pQqJIC0jXxLq80IzngfhzWd+qIGhKh9CJ90lw5pm6KZ9Ch9KaMwFP4/TkDa/cAvFQSESaqVYcnJetKhp+MTxzjN8xNxclRfVJeuESLTtsn4vYfVxaRL1lWRY1/ty1RkAJBL5sLicoCJaqOC9fvtTLly8jRZpISEJeiTCEyJbNw97R55B9o1gmtRIJssL9RvCTJ2cti3jzdfnlJN7etQHv+MPZQR+LwoYZnkrseQKsl3P0zEdH9PksEZyr0gZnled50Dz5HwgjSXMp8zDuVfYw1rfsA1mW/RlJ/4akszzP/4XH37Uk/QVJ35T0PUl/NM/z7uP//UlJvyjpXtKfyPP8ryx9i4JBbDaFOAkN9RLMeZ5HeC0+fQ7ViSvLsvi5YH2RpESyhqeP0nUGTYBgE3LyPbSWYJJl7booIOkaDUVFj46OVKvVJCl83xyul13nZ/5/0T6SCOXdej7++GP95E/+pF6/fq0sy3R+fq52u612u63z83NJs7oIEFVKwG73Z9msYlK1WtXx8bF2d3eje06r1dL+/r7yPI+Q2tFopH6/HyHLfrFhEmWSmr0jbNjTpplnNBpF7gU+dpeQXuijTNtBY6IWJJWZoEm0NmJXoLFUQ+S8oMWikWXZXMIaAiLP88jMpIGsNKvcxHwERnl05CqMYBVN4L+Q9B9L+rP2u+9I+ut5nv9ylmXfefz5l7Is+2lJPy/p90p6LemvZVn2e/I8X02ftM1AelBumdx0JAy1+Dy+nktK2CbdWODIZRtCEor3z/Oefc1mc64asDSLJut2uxoMBhH+S9YcgR7puryxJNydtdIajKKf9DugkIkX5Ew77xatCy0GVZyciG984xv61re+pW984xtqNptRIk2aqa5k+3kFXy4NwzUvEq9OTk5Uq9V0dHSkZrOpk5OTKIrJOVAm/uLiIjIxib70tmeu3fkg+7DZbMZe0tmIuozsGSm3XiiGNGykp/+cnpfnkXhRWMqckyrs2Y9cdLQpGLf3sCyiDTcH0T6oR0nynNcW4G9geGScYqpAh5+bCeR5/jezLPtm8uufk/Szj9//qqS/IemXHn//a3me30j6Z1mW/Y6kn5H0t5bN45vhudu0mPLKvJKiIg4EwIHe3t7q/PxceZ7HphN5WDSXFxClySlMB8bDheWyeHgsWX8eRVYWHJTiGiRH0euu1Wqp2WxGnfzt7e0oWsGFJ14cFbRoXcwH8AZBcPm8YnK3251joqjJ/H+qShfNgwpL8BYFTA8ODsJ0GQwGc/uUZQ+1B6+urubSbqVZafWigSZYq9V0cnKiw8NDvXz5MpgP0X3X19ehiRDNSI+D8/PzOYFQdl5U+KEhKdWFEQoOPk6n07miLdPpVGdnZ6FhQBuj0ei9tUEbSH6KrJCxyFobjUYIP5KzYKL1ev09rGU4HBbu4Xt7utKn3h8v8jx/I0l5nr/Jsuz08fcfSfrb9rkfPf5upeF2pRfFpMDC/v5+ZIZJiguMOr+xsTHXCMRLLxdxeQeR/HdsOtl9Xj0IhkEabq/Xm4shL7MxYTg8i88guaiezHMwb7xCEJcQrWZRbgSEhqQjhh/p0O12w6yhMk6WZYEzUHWIy+KId9E+snYq4bhJBvNEcsGEJIXJhmTDxCg6M0yparUaX81mU9/85jfVarXizDHHYHqbm5tRNPb6+loHBwcaDAZzsf3pYC7Om3/RTgFPMYeQ3Pv7+6pUKhHjT6KXhzSn+8ffu2rPOikGgwaCMAInqFQqMWej0Zjr+7AqcPxFA4NF7LtQF8my7NuSvj33QbMvuQhs3OXlpbIsizJbXKY8z0OFPDg40GQyiaQfxwjSDfG5+H+qukJAbLSrjDc3N1HGygEfNt8LnSbrlaTIg0C6X19fx/vy73A4jPk4fADItGTWooOGECi3lZb2ph4jc2GPej1Hz3wrUyv5P9KVYZaNRmMu3JW1XF5ehi19fz/rWeCegrI9dDs5z/NoHLu1tRWYBl2r0BKZdzKZxLyOsJcxAYQD+4zWB+MCD5IU9JDneTBc+hHCmIrWBR2mniYamYJTwQCooQGdv379Ovbm8vIyqgx5abxl47MygXdZlr161AJeSTp7/P2PJH3DPvexpE+LHpDn+XclffdxATkLST4T4FetVptLx2SRcENyyLksFO1Y1tYKIoBbo25JigQU7FVURFBu5kA7Wdaui4PmWc790WRIdYUB1Gq1uPxeW8CBrpL9je+5XGg5h4eHMTfMk4vY6/XmvBGLmICfl6f1bm1taTQahVoLhuMl1iuVSgBY7K9nxpUNzot350JKD51/Li4uNB6PA1SGkUsKpg3DcTwlBTz9vGCUo9EoNE/W6pfaexAA1N3f34d26vkmRXOxHi89h/mD6UQKMQVcKBJLK7fBYBAm3qqu3c/KBH5D0i9I+uXHf/+S/f7PZVn2K3oABn9K0t9Z9aFsBIdDxZudnZ257sIerMEhYT9TeBHCSlNX0/l4JhISDQD1VFJ4BABtyFojD9/TZD3bK12XB3JAnJg/VAP2gBC4P5WNvVovjG3RpUnfAWmFbQuQitS7urpSu91+rxPQqgEoaEq4NW9vb8N+p80ZFY3H43GUH4dgnREUEbBfkqurq9h7kPmzszMNBoM5bYtzhEkRN7DIM8C6+QwaDhePGARo0WM+dnd3Q5vx0vScYVmjVb7HpMLcdE0XLXg6nUYFJUDcXq+ns7MzXVxchLds1X4Rq7gI/7weQMDjLMt+JOk/0MPl//Usy35R0g8k/ZHHRfxWlmW/LukfS5pI+mNP9Qw4l765uQmk9OrqKmxj9wsDQKF6OTF55lgZA4AAuPBsvEeE0QcREA+7jEo8MAAPTOE56Xw+uOze5QjsYGtrK9TpXq8XhJUWw1im8jn4xX41m02dnp4GUs3aSdX22IWUeRU9G0AQ1V6aAbetVit6EHoBVS5q6q5b5O2A6WFKAVpSYg4MBaaK54CyXA58pmtIBwzNYzictnATcvkxPXgvXIIwgGXBZB4tCX4CrWOielel09NTNRqNqMTUbrfV6/XeKzW2yljFO/Bvl/zXHyr5/J+W9KdXmr347+cIQppVrsE2Akzz8sxUluGgkJQuWYsGc3hKMtV83ReM2gxDQPpj60nzMedlTIfhICAqN+uQFExhNBrNAWX+DAfSivbR1XWwj0qlEpiGo+JXV1fhDnMkfdEczMOX4x4ePech3l4hCUZ3d3enXq83x4jL5nImQD0/96sTj4AXhIaexHBID/TkMQmL5oJJQlcUT0H40ADHm5LwWTQ3116L1uZn65GCaD7OdGAKrVYrzBQvCQd9ON61bKxlxGBKVKDbXizTA3tAcT2oBZwAW3iV+bD1AAIhlrRXIOYBnN5dZMuAOuf0qMxoLd5j0MNTnTGuOhfz+SWGyCBmD0HFlw3C/ObNm/BmoFIXMYIiogZjARCjvh8MF2YH3oGqDQazyJZlLzAVLy4utLGxoXq9HqYatjIm18HBQQgF8AMA32X752vmQgLUYt7keR5nx34hIJDornWWzcV+wqwcZ8FtTlPc/f39iO7sdDpR0AX6YJ9WGWvJBKQZOgsXRg3iYoOqI1FobuGACmogl65ssPGOOjsgBKoM7uDlv13F9FqIZUAaEggmwOc5RFyjEBmahhfkZK5lnN7ngymyJuxFNC7s3bSJSLovZYzA8yz4G5gLfnnWR0dfpDQBVHT05b3KBhKSop5eoxFwFVW6Xq8H0yPQCvpCQ1m0f3wWwJm9hLZo7Y4ZQyFV1xAxJTwXoGwP3R3p/RTACnCVgxF0u111u93AGlxILNPiGGvJBPxS8jUajdRoNIJAkGq4tCg3RjFI3G3uo/YNcdWTjZNm4Zej0SiirTj8arUaoa7eRAONhGcWhSf7XD6fF76UZjhBtVoNVBkGx3swFxK3bK70iznYP3raEwwDHpCqyylz8zn4F0kI8wWshVHDyOgQhHcE1yhmHu+2rDw3lyJlcFyO7e1tHR0dhWt0OByGeYNwgQmUCYjUZMCDhLsR1R+NCg8A80GHDjCnc0GTDiwSDu0mCc9BEFLvEo2Ds3U6XBQO7WMtmYCXiEKly7JM3W5XeZ5HWO39/X2oklmWqd/v6/7+Pkpqe93AMm6Y2oVZls0hu+7TR1p7hWG39xZtuBOUX0yIlnwBadaJFmLnUvhzfE1F3J53QjpwQZHIt7e3evv27VwIMgAUkpP9WYY7ILHAaAAfkc7+9/4+YDu4Dg8ODgLMXbSP7r1BEr9580Z3d3fhfiTXhOYuae7DxsbGworNThvulYI2er3eXIcgb7HuPSpZr6+/aA89LiEN0+YyE7yGCeABSe6hKHJ7LhprxwQcXHOACQ4JkRJoU6lUwnOAbUaZaGkWT1CE1vtlSgmazby+vg71i7LcfuBsPLbsMqbj83MxJYXGglQhvgEA0qP6kMplZke6l0QduhqJhkHeBEj627dvI1jJoxLLUG2fg2cR4lqr1bS/vz8XF4HNTqyCNN9xmq+ydfnvXAXHW0MQDSYisfswVfbd+zou2jvHIFylx/9PFCJaGR4XtAzceOzlMmwFzQvMxE0y5u31erq4uIjAKPaAO+EeqlXG2jEBP3zAFGLu8zyPlF0OgzRe+s65vc3BlUXW+UYxp6uHEC5qKwyJiCyiutJS0csupZs7rIH3A/xh7fQ7YL1ecXYRo/E1sH8wSC5AtVrV0dGRjo+P1Wq1IvHKiXpV8NGZQKvVih6EJGNJs8Sfo6OjwHbYW69GXMZwfF3QidvL2OneKgwGnecP0YVelXgVSekMF4mdChBppup7UBm5K9DhMvXc8ycQep6HgUngTVUwO1J8aBHjTsfaMQHXBJwoICY4pYfsstHYnl6b3ePfy4Y/kyi9w8PDiN3GH+whrZ6z7T7oZRvvMfSorGRGkrQEcyEtFFdTWkNgUdiwMxtUb7wbk8kkYh5arZYODw81nU51cXGhH/zgB9E52JtbLlsXc6Hek9E3nU5VrVaD6SGlp9NpBFu12+3wILDOZVIzZdoAap71R+bf/f29+v1+aBvEWqxyUXg+6roHjAFqwsg5Fw/UIbgHpl4mjHxtBI3V6/UAAkligwHQdcvb1ada2xcWJ/DjHv7y7ruXZokVHtPNZWHDKU6Byr4scsptMoAsKu6QpFKpVOYuZafTCfegc/ZlDMcJN82H9zxysu46nU50W/YEFEf1y+ZyrYgLSMAKa0WrwsX0/e9/X5988onOzs4CiHTCKhswRzwPaBuYVtjOSHwAyU6no7dv3851JfLzWpVx410g2YYkH5gQdjwMJg0XLjM7HD9A6GDSkJqN3Q94i1sUD4HnGRAzUHZe7uOHxj15DHcqtR+olYArkruDxvrBYgIQuFfQoeqNNItE43DT2HP8x54/XsbtmYsNl2aMh2hFpGG/3w+JhXfAs+R450XRblxid7nBXOg2y3szX6/X02AwiN9z+V19LhpIHrwCZM3d3Nyo0Wio3+9Hht3d3Z263a7evXundrsdEgaGtkhasocwSNbf6/UCE6BxJ2o7tRFA7LHbl0UMMl+q5Tjw5iYWZ+ch3d6CbJmG6G5Nzos9BDiVNNc2jjMkko/AM9/PsvPyrE5wIUA/NFv6EIIHpEzNzeAPlglIMwkvzVQ/mmYSJOQEw/cQPCCaq5Zlg4sI0kyI7nA4VKvVikvifeaQkqDLfC1TLWFceT6rdUDcN2aHNGtnxZzMBUNzjWDRcFsbT8m7d+/CD01MAPvmRUycYFcBOSFckHPPjwfc4iy5oB7ctQrQyVxuKvi+IwWvrq6iIhRuPdKnvdnqsosC06hUKqFhgtMQqQr9wOA4I753elzGtHEtDwYDvX37VuPxWOfn5zo4OAjhBvNEu2DdaKRuFqw61pIJSPOtwabThzTOwWAwB9Jhpzmx8nerqkT8DZ4GCIsgDL+40szbABE5J15l8DzWBaqNzeoBQa5dwOieAvi4usv7sacpGs3nVr2M0rxtzlowO/gde5rGY/h8aR4Ez1zkmgSpn0wmUd+Pn3u9XsQ+sGeEQtPefZkWwMAL4HtGA1Q0A2kWEOSCyZnAKpfSacMFBQl07tL0i+4/r0obPtaqA1GRSyMNrkHdc7WQv3WkfpGtV/IOc4SaZdlcWijzMVAvU8J9wprnYhQAg/wCMJA0q0rmRXOm6/D9kxYj86s8n3+ZK43BcOZTpD09ZW43CySFlsjeui2Nvb6Kmlx0DtCF159EIPH/DO9jWbafi5hCGlMCpgO9+fml5tOStT23IXsez+PLGs5g1+FOlYznNmTP43l8WePzamlf5VgrTGDVCKdVR6r68rsf91gWn+7vWSRNiqId0+etikl8qCMNtfbfS+VnvaqEzrLsSXu46Ly+qFFkvvlYhp2sOtaKCSxasPR+VpxnS7nt5aDTF2HfpvkFDobx81PQ2HQ9bsfylQJ1PndqAz6FeZaty3EU37PPsq50Hj+3dC5+9t8vel5K+KnNzr9uQ6fAI+t6Khbh++xBRGmWZQqsrgKyls3l++cRi+k7O00+da61YgJFxOzRWvxL5BYZb16YA44O4r/MRZgOP1yCNgjkgei86QMegkX18coAT1xnXhvBOyt5HD2MDp/xsrz7snU54eLGg9Gwh060HjC0ykhBLQ/qSRF0n4t9fUryC8+FLnB9UnwDRN1LijHXqm7dsnX5/u3t7c3luaRIfRqctOpcHlruTM49RbxLnucRY+AVrlYZa8UE0uEXgxBNb9hBfLiXlyLJgmos7vdeNHyjQX7xEBDwAhf2rC380FzcVS4nUWd8kfnmKcmswRkOv2dd7iteti4nIoiMS4Nb1C+kS1h3ia6yh944A0bqORgwTdaEVCf+Y5EP398L2nAGwNxZlkWItNeUcO3LoyiX7SF750VfXBghdNI0bP/7ZVGekuYYJkVLeAZRi3meB62xv2gglDf7QmsMflWjUqlE3bb9/f1oBba7u6vDw0PV6/WQLFTIJSiDNGCi8Cg0sSj3nmcjmfkdXXXq9XqYH15F9vLyMkJ/CUQpqvQKoW9ubkYk3e7ublTBgTEgxTzM1O1OIiT7/b4qlcpc8YqydXmhD89uo4sOa/Firi45CeiByMvOi/f3nn3MRXCNF391FRbNB6ZNhF26HmnWWo0Yfr4QDru7uxHUQ1KRn4H78Yn8K6sBwcUn7yLt50iuB5GQBJJ5CDlMlj1MGYEzeWjdOxGxXoq+wHC4+ATXke9BxWeiWpcxgrVkAlmWRbAHyTzE89MdqFqtKsuy6APAhSAphQHhIxGK5kLaQ7hkcNXrdR0fH+v169eq1WpBQESEXV5e6uzsbM5MgTGlLbTwmXuCEkxgf38/iAkpxvvC6e/v7yN5hOAVaT7SLB07Oztx0TE9kFx0Ozo4OAgmwAUkWpGS2hBZikeke0hVYRgBUXswc9blQS/MRds4mHie5++10IIZUkj08PAwahEcHh5Gh2U0JS/zDQ3c3NxoNBpFhSjMrDLaoCOV7yNJX3SOIliJCM/0C5rhQrK+dF07OztqNptB37VaLYQTjMgLvIB73N7eqt1uh4bjRVhX0kwX/u9XMNh4LgOX5PT0NApVePYg+f5wbGxLl66kGxehqB6IBAFxKb2XHnXqMAkODg7mKrxwiBBc0bo4UBpzcDmazWZIGCIGubRecwCNZzqdRhecslZTripDTPR1JEOSlmdeCRdG2m631el0QoOCGRWty9XxRqOh3d1dHR8fRyi0B/Hc39/r6OhI29vb8f70bxyNRpIUBO7nBdODYVer1UjyOj4+jjZhMADKnbt6vrm5qXfv3knSXB4+CThF66LwCem8zWYzshQ9iejm5ibaoBF+3ul0JCm0GjSyMpongcwZDDUfOXf2mvZo3qiWedg772uxaKwdE8CWgjvzL5fby4hDXKiBJGAAmGAHlnkKHNlFSniXYE8cIQvNy1iBP8AYyuL64dA0SHHQEcZGaCvEAkPjIntVoMlkMleFuGgPYTgOpNIhmAw7TCrPSfAqx5hTpDCXSUu3+Zl7f39fzWZT0gyx9uxJmIOkSNZaVlMATYa/xTR8+fKlWq1W1JXgIlYqlShb5ucMmFvkffF1uXkD4Fiv1/XixYu5Woy8K5ec86PWIZe4LJUY+pDmgVKEChc9z/MoqErtBq9fCDP1UOUPGhPg8tNybDgcxu/u7+8jkxBul+d5dH711F+v01/mT2XjuQwQJzaapChsyeWo1WpxsK72FalfXAAG9iLqcaVSmePiHCCmzPHxsSQFwTFPWdEPZ24wT34PAVGmCkzh7u4uQEoIGZV6UVKKo9OeZ5Gi/qwXDWc6nYYp0m63Y38XeT48GYnv0dio/0ihDeryUcKdugLkFiwyA9J1QTMwAtqDk2jmNMlnJpNJXOI0yaxsPkw7ytpx5mRZOkBdqVSi7B2ZtWg2qWdp2VgrJuC+YE+uyfN8rhiFu2kozHFwcDDHBQGg+CobHIrnHNzf34fKjvsHe45DZh7y4JFAZTaz+3ap4Qc+kGXZXGUaDtmr6EoKLQim45mWPlLACECORCxcq17h2Eu3o/l467MiKea4BASM9BuNRnHx3Ib1IicUTwHspBhM2WWBqbgHAo0NYIzUawbgGtoQ/8flLGJu7h1x9+n9/X1oh+AoXteSM0MwsedeLboIFIQBOM1TNLdWq0VilqQ5zRe6ubm5ifZkKS1+cOaAc102HqLCzsO2hQBgAjs7O3rz5s17rZ+8KGh6Of1iQuRcODabfgYwHVQwimKACANsISEWrQsPA5KYv6OFFdoBzM9jEfr9fjAebMGUiB0B52e0G3dljcfjqN9I004uPkizN9JM99CDY3gu2hkAIN9zAZCu29vbkZYN4XJeZRmgbiIiCFDBLy8voyLSeDyWNJOuMFNXj4t8+L4umJozmHq9HvEHALXuqqMXITTgWhsMvEhLZG6YNuBvo9EIWgQ/AiNDm7q4uNDFxUXUnyDNeJX0ZcZaMQFpRsAgnx5lJimAGe86401GUCvTjSgzAzwri4uHSwa0G68Btu5kMlG73Q7CTTvOFs0FUYEjSArClBTlo3AB7e3tqdlshp/Yy6Z5kcwyiYn6zf9jttze3kbdAtx6jrQPBoNQqSHyRUE1nBfajgdRoZIDVG1sbASAh6RkPTCAsvNy7ZB3QltjPuZGO8CVjOeHS+2u0rLzcrceZ4WXBvUbPARvBa5f9t7fexEmwFy4htEsrq6u5sBJaJ/mJzQgJUW63+8HY39KgNdaMgG/mNJ8kRFMAFxOMAv+jmd4nbpl8/lw28wvKBpAlmVqt9tBsBDkspGChoCEvDuqJI1HYDhOeDAcGFVZTgIXk/2CuLA3cXdhYiFhMAO84YnvS9n+ORMgroDCG+4OpST5/v7+nLmCpISJLJrLzxUtCYaIdwKGjeuQGBOXzniOCP4pWxcX2tfla4F5ext0b3nmIDXnVaS58V6cmdv30oNZ02q1wiVJ/4uihriLzqtorB0TYDhBpMg76qI0A3BSIAfbd1WO6MSHCjcej0PjQIL48zioFBxbtCZJIT0khVkDE6CYKhoOnhIv/MnfFLmbfC5X19EkYCTY5GABEC+q79XVlaT5GvhlwKqvjfNBoqPNEQ6NlOYye7su9ncRmOV7TLwGYCcX3gOVYDqAsACXHkRVNF/qVYIeBoNBBHgxD5oj3gQiOUH0oc9VBJJjEQ4qcgb8zvtgcm7uEVtVC5DWlAl40APE7mHCHKQDhG5/wQRATN1GK5vPLzrhrdh9k8kkLmeWZRGJhZRIOX2R687nAMfADqfuvyP6jlNQXhqACJwiTWxK52MgxbDxB4OBbm5uosIxjI0uyx6GLc3MpFXChtk7Z0DgA4TXwpBooME+OhNfdGF4Jt4LgskAcTkHpCjz93q9wC2Yr2wP/RygH6QtHijPWYAh804EJLEv7rouY6apu5Uv8Bw8XsSmuGcHnATwHMbxQWIC0nzwBBWAp9PpnP/cYwVczXMEHNs3z/OIVS+ai4vv0t5BI7rcZFkW6pf7Yj3m39W6orkIRYZop9NpdJYhmAYGxztjO+O14HfLJIz/ngrGmDW4sQCa8BZQzhoTB0YqzerXlc3lNjagZWrKYcs6IAjBEq6N5C0KFuI9QNExn46Pj8NPzjMxHSn6ic3s7sFlsfzSDM+5urrS+fl5vCe0AiPP8zz6RNAIRZppfovMUxiAexfAA8CmAB3ZH0BvtADXbBaFyadj7ZgADMB9rkhNkGdpVnKLLjpcZEfCXQUsGw4SwdVR8zx5p1KpBGjGxeO5/K2khRsPc0JFRGUlsMUP2W1/JLN3RuJCLbqU0kx9hhFSBBTtCs2Gr6L21u5FKZqH57kEB8O4urqaYyQwN5gEDMCZ+yJMgDWjSbAfFBclvuHu7i5yFvDAUHFZmnlJFmWZpuYhFZXxENBPgXdiPS6xGWV+e+bApOBfz4jE1Nnb21Oe5+r3+3NNSIkg5DloqZh0y8ZaMgGkioOAjUZjrnCkF2+8u7tTtVqdwwkA1JYdss8Hooz3gfBk/OwQDhITRuQZYmUjNRf43n3zHhkJ0aFCu10uaU6tLSMsdz2BQbBf19fXajabyvM8TADUZdZKxOAquIozCs4OzcYLkNLKDSLlYm9vb79XtDV126FpgAUMh8NgvqwZjYnPDwaDOY8MzInqwYs0xHQPsce54GAOMFjOzoPU+J1rHem63JxE+qMp0h0KM4tW75h0ksKDdHBwEKbqKhgEY62YgNuDnr3FhqCue9AGrhVUI4AnJGmlMt/mKx2eagu4Qw84bw6CRPHqwA7i8CyvTJyuy+1LLgZBJjACzAmIeTweB6FzCSDGMj9wmcT22APPmoSouRxI9tRFuwwUZIBbcIaupXmikrvCHBAsm4vfO3ALTbh717WSnZ2d6AKEjQw2skr9AqdJxyI8+AoJ7dGjvJdHUC4bjlPgSm02mzo8PJSksP89ASnLssjQdG+JNPM8LRtrxQS4VM4ZUVs9cxB1H64rKWxaegPAET0yrGykWgcHwJwE8aDGenx6yuGL0O1UpUbSU9Mee1GaqakwNVRfCIx1LooT8D100wPbtVqt6uTkRK1WKy4hHhcPEfbnLyJkR6VdmlWr1YhDIOfCGYv3bfBK0cs8BOwT78yX+9V5H2xmcAiPS1hWfMP3EBpxTwchxGmQENoUEZSrrMsZAIKHTE9wAjQBB2C9vLuv6SnFdNaKCTBcLWTjHNGFwyIxQWRx4XgvQqR3mWThAvNcpKMXMUEi93o9vX37Vufn50FUXBak06J4bYgdtw6EK836yvO7fr8fLqY0FtwbWyw6aPbLM++Oj491dHQUDCDLsrB1QbQ9Ndml7zJNINXeALSwnbkcYCt4KrjQXKJlTJu1pepu6mGAjmDYngzldFU2l2ulgHvUKyAGgViO6XQaNAje4fvHPGV7CA25t8ETpsCOoBG0trSvAfkXCI5VxtoxAVeX6enW6XR0f3+vwWAQG4LLxu1zgCjnxMsi+fwCexoojAbCubi40Keffqqzs7NoC+bx4KiKiwgKzQVbFWQb9TzLHkqHYW5g0niMO5LGJUzZuhzwJJMOrYDLf3V1FT0Psddd5faIwbJ1+UXi0vC3MOI8f+i2RBs3GLWnwnqMfdlgLjdT2FfPI/A9cR8774RvvQzI9XUB4MKoWSdAJmAx9ArzZg9cwyoTRq7VsCekIjuA2+l0gga9lwJM2lvjrWIKSCswgSzL/oykf0PSWZ7n/8Lj7/6UpP+TpPPHj/17eZ7/5cf/+5OSflHSvaQ/kef5X1npTWyg+rJxVAnCZwrgxGI5TI8e8y+3n9KNcZCR556fn4dXAmbApruZ4c/3r7KRIrb39/fqdDrhnnTNxtVjiBiihGExdxEABGHxtxQiOTs7i3fJ8zwuI3kQMBl/h2XqOe+UZVnUCLi7e2ib1Wg04h1g0qzRNSM0gGUaB4zQQTjU/V6vF4zVA7LwOFH9h/wCwNVF8zkoy567CYI9jseAPphoiuzjMu0mf/QIwVyI23jz5k2YGry/543wjqlbe1UGIK2mCfwXkv5jSX82+f3/M8/z/4f/Isuyn5b085J+r6TXkv5almW/J8/zJ9fDhkhRhzmINGrPAyIcWFvEedPhmwbQmOd5uLb8AFMTxdW9VdeFtPUUULdfJcU6WSNzu+2+yrqotUh6Ks/vdDpzaiTakwN3i3IG0oGLzP38BB/BnGG0HtcBI1hGvM7APRgGIBONQ3qgA0wgSXGeaFBeAm7Z2lgLLmHoEeHkWX2sk/gH4vhXSenlApP8dHd3p3q9HueH2xFTzZ/pjMBpctWxlAnkef43syz75orP+zlJv5bn+Y2kf5Zl2e9I+hlJf2vVF3LJhgTzqC53s0kz4kAFLdqEMmnpA40AhiNprtBDOp7CZNJnuLvR3Wn+Obez0wvpn1llXe4Sy7KH3AePpvRQU29J/hRCghBdMksPzTU9AMvfN5WQi+ZL98X9/OyhVz6CoUE77g14ykXhc5yBA44pGAqD8zZkT7mQCAaSt/r9vqRZLAvvDlgpzeIPVtnDsvF5MIE/nmXZ/0HSb0r6d/M870r6SNLfts/86PF3K430oPl+VSm7yrOXfcbnWzXiatkoktqolctGkQnz1OF4gqQwDZyRSp+NgJbNVeaH/yzPLRp+RosY4uddGxeU4etK5/2iz+vLHp+1Ddl/Iumfl/T7JL2R9B89/r7oFAp3JMuyb2dZ9ptZlv3mZ3yHr8X4Ii7msuc+VX1c15FiM6vgNF/GvB/a+EyaQJ7n7/g+y7L/TNL/5/HHH0n6hn30Y0mfljzju5K++/iM2LkyqYTkKgPB/O/KpOcXIVXXfawSKVZkTvn/eSRi0bO+CM3sqcNR+afQho9V7HKet0q03ar0lO6vNNtDX1fRZ1dd1yKaX3Zen4kJZFn2Ks/zN48//luS/tHj978h6c9lWfYregAGf0rS3/mMc7z3O2ww/MFuA2LfloF1n+Xy8w7YlW6uFOEOn2WkLifsW1+Lz5l+X/a8RWsBg/CEqSJg6YuSbj43IzX9VpkjvTA+PPITd54/lzWCXXxWM5O52UP2k5HGA6wC1vl60rX5PJ6jwvOKAtVWoRMfq7gI/7ykn5V0nGXZjyT9B5J+Nsuy36cHVf97kv7Pj5P+VpZlvy7pH0uaSPpj+WfwDKS2qkcPkrFHNRwGMe6exPGULiy23vcuJElF7inwr/QwnjIPvnyYGsEoqRvQo/hWzX7zebwSMHEJVK71qj4e5+77+VRmULSPOzs7sVepRyf9fdEokqieAerluJvNZgB1eZ7P0QPBNF7FqAgjSdeTZpvisiYblL2T5pmOx5SU7WGqhXiMB+5OIj6dDjgrB5tX9R7F2tZBPcYcSFV6534U2CBck5BeatgRUguA44S9LGCIuSFWsv1gAIS/UuPP/cspAa9yOdNLj5+ZAhgUQ+n3+3OFNwGLILYi33OaG+/rgQEQ8Ubteo/ic1TbA36csBZdVLQ1cgY89JtEFy9e6lLMXYdFKr9fTl8XWaa4BanAQ4CN+9Xp0EPhFI/HKDMHoAPmImkI1yCeFqoyQWfOSHG74mZ0c8DnQovhyzMLqXAlzWoLwHQ4K4/xKMhb+Ht5nv+B9MzWLmJQmm2MX0aYwObmZrQGo/OQ51QTbUWFFz/wMu6YZVkcKKW2CBZqtVrRLKPT6egHP/hBRPM5g0nDh8suSvYYIcglJEW0Vqvp6Ogo2p2Nx2O12+1gOvi24fQQVlkSkTSrIUiTDOolkh9BXDoBPvjaPVOOKDii/hYxAM+HJxV2Z2dHh4eHevHihWq1mu7u7qIgJkyH9XhR0nQP3T5O4/ap70dDkuPj40jqIaKULEkanHDZ0ApcY0wvJe3GCIOmJgOh2GSREgkJQ/AzgpYJJvJ1+feEXDvT3tra0uHhYXSMImaBsHXC0GEAfl6raMJrxQT8ELwENmYArcFev36tly9fhmrERaDhQ7/fj8qzJK4sUpFQjZvNZjTooKsNNe3v7++jE1G73dbZ2VkQFWGiBKWUxaPDbCDWer0ezTNOT0/VarXCFKAACGHMpI/2+/2QsJLeM0O4KOwhLbNgAo1GI5p1VKvV8KHXarW5XHgi8IhWQ/soYwLU2fP6hVzQFy9e6OXLlzo8PNTt7a0uLi7U7XYjhLjb7Wo4HM4lU6GuF9EGmZ6e5NVsNnV8fBxZd2AdfpmI8UdjdJ9/6o7j//f393V8fKzj4+Ng2pSiR7shxqRarYYmxZoIQSdVmr1M/fqYajAW3ps0+kajoVarFaXSPNT67u4u5qPCc5bNunN/KcDglzXczgMQQa2EwF69eqVXr17p6OgoGkGiBUiai8HHni1r/yTNOgRvbW2p2Wzq6OhI3/rWt3R6ehpgoHNUJDWX0BM4PGuvKAbAbTwSbD766COdnp6qVqtFBBzaC4yQ52LmkGjiQVRFe+j17yj4+dFHH+nk5CSi6SCStJoy9rQXMykDHbm8MALPgIMpeKm4ly9fRn+9SqUSkXeE6LJPqRTDViaGnzVSWxDpT/UgLhufRdJ2u925QKl0D1kT6j+aW6vV0unpaWRFsj8wE7QRCn6S2k5EKOdSRPeefu3aG8leVKNCW6KMOpiDh5S7Br3KWCsmIM0KgrgrhYsKYaGuS/NBN160ExTVAbyiuTzqi/BQUofv7u7U6/WiVJWXl767u4sED5+nzCWTEhufoVqtN7QkMo1DR/XkslFRpgysc5RcmlWtefHihU5PT6OBpksSN7lQ4VFriVwrUys9ivP29va9ugwAVn4+1WpVV1dXuri4iOdgRyPFUgbAOaFtud0rKfYQhuxMwxkLc6VIfrom7HEYMJoF2hN1Crhw3rKMgCzHuYrOizXB2BxLwMwhdd5xGp6DCeaNWPzufCHegR/3YCNYwGQyCWl4eHioo6OjwAJQKSG8V69ehRSbTqdhSy/CAuCW2G8AZKhYo9FIk8kk1DQ226vaggcwFuEBrAkThsq/l5eXUcp8Y2MjauUDQOX5Q5s1mpIuSrl1IuB76tbXarW54ihEvpEA02g0Yn3sgefUp9qAX0ywBPAY7FbP94B5Q7zUTEwz+tJ1+fyeHnx9fa1ut6udnZ3ItWfdmF/8y2WDwXtxkHQuXxchwzc3Nzo/P9f+/n5kIqIx0LXaQ4hhOuBGzLvItcz6+B5shQpTnB05Lq1WS3d3d1Fr0+tcsI5lY+2YAAOi4lDTVtDtdlsXFxeRYcghI41ooAEyXHYx3d0yGAy0ubmp8/Pz6AYLYWVZFl19sclSVyHPW8R94fRkwCGRidm/vb2NWgZe6xC70y//IneTu1V3dnZ0dHQU3Y9ZFzX3vLbi/f299vf3wwzg4iARy+aDMZEcBdDqufCsywuCepy9J8Wk5+XEDG1QRKTRaOju7i6YJcwdkG1nZycAO89YLMM5nNnxWdrheS0LfnbXJA1cpFmpMwRMEbDq2oJ7f/I8n+uwhfaBtwjTC4bT7/eDsUFTq7qR144JoDK5RoBkqtfrAZyBlud5HsCQp3yyGSSOFMVh83wOio2n3ffV1VXUewO5hyP3er05t2SaXbhobUgXwMROpxNE7MVVAZN6vV4Am0gKdxsWSRNpptJSKYnL523GptNpSGrvZ+C17ii0UqTO+nrZBy6pg5beTZhnkWXIxXSpXLSHvn8ew4A2wYXh79lLys156rXXm0iz/JypwcCgk1qtJmm+QzI4CGYHPSqRzC6dOfeidTFYO8/knDF/JEV8gscH5Hkeqe6uDSwba8UEHOF2PyocnU3B3qJjz8nJiU5OTnR5eRkElhapKNoMZwLu76d23f7+frhmjo6OQpXtdDpzLit/3iJpyf8hXQDfsKGlGa4BBiApGqA6QFfGbNzWrVQqAS69evVK1WpVvV5vTr0HkKK02vHxcZgCWZap2Wyq1+vNRWemo8iVx76jDRweHqrVasUlpedAGgeRouYpbaDqA45y8TyADBpAknL5vCmJM+6ifQRk84AjvDUwVlyHXofSMyOhP4+zSJm202ClUglhBWPDNLy9vQ0BiNaxv78fdRtSE/opNQXWigkwkE6SgkA5bFxEVGHlosLd3WePXbfIRcL/oUUALnm1V9xQW1tbkRq7u7urw8PDOXBw0UhdhwCRVBRGbacCkDSzCVnf9fW1Li4u5sKn0+EMArDq9PQ03KlcgLQj0O7ubjC7/f39yIcHhV7kHXCGlGpjlcpD0UzXRjxugwu7aoSbo/0MTBrXNiTN1frf399XvV4Pr4sDwkXr4p1g1nh8rq6uArDFG4AGB/NLn8O5FHkhfF3soWtknBlnQByG1x3kDHnXZXOlY62YQHoYXAw2mYPHheIhvdjLqHkcHK6nRcO5Mapco9GYA/GGw2EQhkeOAQR5zvyywXOZ6+DgYA44Qk0nfmF7ezv8vylDLHq2u6O8aQUqPv5t9sdteMwd9hCAa1WicoDQqzD5mvFGePUf6f0+B2XP57Ne78H3xk0mSXP4BCYC7uVFtMHFdA+B4zGOGzhzco3NG48sAupYF1iOMyj2z5kDdwKh58zqKeclrRkT8E2C+8HxsO0c8ZZmattk8lDrjTp5aAKU7UJCLRs8C40A0AWUudlsxgHf3t7O+eMX2bMMDpcoMzwZXP7BYBCfwdZk3aj3xDVQXz59PsOTW6bTaWACoPLsJb7lPJ/5nN1GT/d80XA3F9FrnU5nDt9hn1PTBcJ11bbo+Q7GeYMOPEIeV0/AEsw63UPmdtqADv0LjZL3BNdxs5C+lZw/AoN3Y91lGhyeBmgtLaeHIIAhgGl4xKPnUazKCNaKCbA5ftAQMQCSAyXYRlza29tbdTqdiN9GRaL45LIB8RGa6xItyzI1Go24HBw2B+XBQWX2GAfN4VQqlbmyW1yc+/v7uKj39/fhKvQkGSRC2eV0/zSg0Xg8nsMm3N/sbjG0KgBTD7pZ5fx4toezEulYr9fDDILxSQppC1NM8RUXDuyBV4NGI+TZVDbi85T/khT7t7u7G/tTtA6YqPc28EpGeDjyPA83NnRB1SgCmHhmWmSliOa5wOydlxvf2NiIgCQYuGNfaAmUJftgXYRsuKvpV1dX6na7oZ4REslCXf30mv3SYrddalvD2XHHQCSoYgRwSDNigiiR7GXzuArvUubm5iZARxgPwSLYgjCbFBwsWxeMhurF7XY7tArWhQaC1sXzCZAi3r7b7S6Nt+C8fA/BBZCYuHNhmA5Qesj1IsJlrz3C0YO77u/vI/GKFujQE2o7e+mRn0VzEmjk32NaATSCA7ipmGWzsHeYO7kRZcMD3JxJA4KD4WCquSCheQv09JRkNmkNmYBfDrfD8vyhe403g0QKkDhBM0iq3WLPu7RbZX44uvuwkVAwFI/O2t7ejjmfgsr6XJ5l5q7ALHuIT+j1evFcGF3ZpXSVlSAkgDEQZhgIaiwXA2nHPtKgtMj08JECYK7F3dzchFYGwXrKKxfM36vIO+ARkFxgLibMlLgQ3Hu8C/vLBeYyFWTazc3FfgJIAzqC03hqt/eOQCJLmkPvfa98LjeFYFZuMpIsxD7xN5Tdp3+Dt0BbdawVE3BbTJoBM56mibSCa9Ks8+LiQj/60Y/muumsGsDDcAbEM7Ism8suJE8d96QHhywDtdJ1eqIHf8tlrNVqOj09jUAX3se1nKJ1QdDY9Ujzer0e62LQSRfTo9frSVKkTF9cXLwXD7HK/qEueyQh6jqXA3V2d3c3VHf+tiimg+GgGSYRlwUGABBI/r3XZoDx+HoWaYl+ST01Gs+HvxNAnQPWrq1Cy0X0wHAA0UE/mI/b+iR5OWbgsRkftIsw5ZTS7EDG4/EcAkxV1rdv385FCDqS60Ei6cY400EikTCCy+no6EhHR0c6OTnR6emprq+v9e7du7A/CeUsu5jpcNOANGJJAWDhFsQ1CLd/9+6dLi4uIhBlUaAQaioA58XFRSDVSHUHHdEuJpNJdFo6OzuLsOwyf7qvR5ol3sA4Sbw5OTmJ5CukG2YJ0tmxgKI99EvLxURdd4zG6yZIiuhIN28IDfdaE0UjLcYCY8EUhClAN5PJJJg2FZ69hXjZXL5uaDvFIarVajBVksx6vV70w8CE9WCyVcZaMQEuqRO3SxPnjNj/3W5XvV5PFxcXsQn+vGW2EQTl7h389YQqn56eRrwABEvHnsFgMBcgUrbx6bqwIVGBIVq3JSEeLiXpot5speyygJlQB5823peXlwGqoTJnWRaNR25vb2NPmWtRfQQfXMp0/1qtVuTiS4pLiHbnTKZsD90d58zdU59xE0oPEpWLPplM1G631el0gk5cbS5ipO65wJPgxVk8rBs6IyoRjwiMx3s5pGtLtV6+l2bJcWg8/D1mL4yAHBDXclZJIWasFRNwLoi04JAuLy+juwzZW/1+X/1+P1RWD83kEngdgUXShcuABCVQ5uDgYC47jfz+H/7whzo7O4sCIxDbIi0AwkWt55nk85Mx5n5pbPrhcKizs7PIs192MVmHNGOGt7e3Ed+AO8svFwwWNJ92a451FK0P15mbAsxHIhEXgaIib968UbvdjqjBsoi69Jw4X1fPcUUiqQHvptNpeI1YD6DhogQihjNa1oPpR1IZGggMlCIszMd5sY9leAd/DxZFXQynYUBqem7yObQ4MCVnbiuZwavaDV/myAqqDWPr7e7uqlaraXNzM9ByQCZvyOjdYVC7nKjKzAFp5goCbATsA0yjqszh4WEwgXa7HRLTCXjZ8Lk8xRWsA7yDSwXDQLWEMMu0gCJACzMAu9Vz+yXFmj04BS2Ar0UZfpybI+isicIsJMGA3pP8xdqWmVKpK415PGzY3ad8jkvERcHkSelDmhcIDOIQYJysCxzFU3dhdoTyOsP2iwxTZj2pOQrehLbBfHk+K47Dc10bQktKtUTb08LyYmvFBFL0mcPlUCFoB1jcVeZAohNViiuUvENcTj7HITshIDmww0C7V1W9HHx0RLiIGNzlAzEvuyxpgIiHGDvhMacj+WleQpnGsQgbcF93nucRpcfZbWxszNnIRTX+Vl2Xg2Sg6Qx377EeN7/Q2pw2WJfPxZq85BdApwOH4AEusQFUF+1h0bqckQEWS5oLgEvX5Zff6cPXpQ+BCSS/i39dbfVQ0fSzXBb//1UYQDovOARc3l15PAeTY9XLXzSPM72U8FJPRZHEKhplUWKpP9wZj68x1Z7K1P9la/M9TLUTnsHlWPVc0p/9vfM8n0t39vWyh6lJU6SWp3PxvQcOSbMKVnzGGRAaatF8jgHw3JSWU3pzmvf3QVOEoaUuSBeQj+PDYgLP43ms80iZko8f151aVbDZ+HCqDT+P57HuYx2E5xf1Dl9bJuCqXJmLKOX2qdpW9nfp5xdJjS9qFJlHDoYuewf/TBmI6v+f/n4ZoFf0nk8Zq+zhZ5CMc8PPi68va12Oz3zZY9m7fVBMwO1oD42V5jGARfZs+ryiy+PPd7BL0py9zPdPAQaL3oH53BZkpOspSq5Z9uzUxnW70/cgtc/TecqYSco00vlYkwOhRWtZdV1la0z30M8nffai8ypiAOmacE96wBLzOK6yagDZsnfxqMUiMPwpdJ+OD4IJpGGb3pPA68QBbHEIq7Z+kt53TXpwCO5Bd8EAbOGeJFbgKUCXI/P8Sygy7+3FUUCaPcBm0dqccCEe1ketBp7r+ff+zFXdn84A3CPhpcr29vYCzCoKbCkC75btoa+HM8ONjO/cgVXQ/GVzFYF1XgOBeag8hauOTFDo4u7u7r2WZ6usy2meIDaPLmUP2Te+PPZhVWaw1kyAS0L2nhfgpNIPwSeky7o7DVR4WWCNHzDRbsxFW6tqtSpJc8Ue2XTq3KeocNlwPzeVabyyEO4h/PPu4qO4pvu8i+ZKNSaPDXDXK9qU169L3W5+aZedlxMuxMyFcZcd6+I9CJNNg2NWoY00go/EHXd3Mq8zKGcGy9bl/nvOiGYutVotojGHw2EUnaEacpbN+mAURSgWrcuzJWEClBSrVCoRkzCZTOYaoGxsbETA0AdZY9BHpVKJYB1Cd+k4Q5eZSqWifr+vTz755L2IMPK5aUxS1q4LYiAmnH/5/vj4WCcnJ9EchLJbxPMPh8O4TBQoXVSxhhhwmmVUq9WI3iMoiRJjFIyUFGui6AjBMSRQ+Xr8e8qzQVRcUApkwkh5Z2cASBVvg7ZoXV75xmPqd3d31Wg0Is4CKSnN3LpeFQofe5k0q1QqUdOP/ASCefDnTyaTiCb1CDr86khuDy4roo0sy6L+IvMxz+HhoU5OTiIcejQahZDgvKCPra2tqD1QluHneRcwThjbwcFBlH7L8zwYDEyTfSWT8vLyMnIYPkhMIMuySNx58eKFXr16pdPTU7169Sri0KmTD4GPx2N98skn2tzc1MXFRai2cFZ8+0VzkTBE8Uhq9J+cnOjFixdRi386nUbnoF6vF3Hqrm4WBWwwYDYwMZKUyFDkovBcDxAajUZ69+7dXM15JKhLFzcD0GQouw2BIcFIWPKKuxRgIayZC0natudm+B4St+95+phSR0dH0cYrVVkpDw8z87TjtNiHnxft4o6OjubK0Xs5836/r1arNVfAxIN4iCJ03CAdFH2lniBFU09PT3V0dBTJRGT60VQFQYE5J81XwSrbQ09Q4vxoj0exW87BBcRoNIqy4zBiEuyWjbVkAh5S22g0dHR0pJ/4iZ+IdFhPmKDaCpcY9QuO76BUEdjjdfa8sQhSmUtBDDxBKZR7JtmH33sYqQ8O2ctjY+PRyMRj7mGE1E+cTh8ad/T7/bhgaZQc80iz4htcRBJ46KVHshK59h56S2KWg3mUUivbQ1RXahfu7++r0WgEI202m9rc3IzLCOO8urqKdFhy4r1WQzoXl7JarUYPx+PjYx0dHYXpQlMQmBJq/2AwiOYt3uugqAKPr4t/YditVkutVivAYg8Xhg6q1epczwqPcCyiD8xBZ6bQNEV16cJNUhPaLncAUxRz4oOtLAThYRNicxOP3el09Pbt26jsQtVfv2DYfpLm7MEi11aWZe+ppC5lSRjhMzAoNtsvD/Z1kdkBEUB42PY06SRZCFszvVTgG6xtUbINTAJiQCX3dF6YkqT4DOYBkoo9QeKU7R/ME8KjZdzp6ak+/vhj1Wq1qPIznU7nwFCaobj3pSw3gvBcbHPUcsqpj8djvXv3LiojYZuT8wHjBi9yE6EMCOSdOCNi+sF/RqORKpVZuq9HSCLJ0Z7KvEjQEPNhmkDbpBBjSlAcBQ/I7u5uZId69+hVwcG1YwLSfImvwWCg7e1tfe9731OlUlG73Y7a+c1mM7q0YoOm6K+jzkXzSLPU2/F4HC3B6vX6XDy2I+RoHkgtadYfflFBDMwFDmw6fahYRGVjzABKUVHWbHt7W/1+f44I0ISK7MvUnw8BoUrzuzS19fb2VtVqNbAE7OayEGn22rURLjnNVuv1eqjkdHG+v78PyYpUYw8XAauuuUkKrQ2mRhEUNAuv19doNHR//9BZejgcznkmfM98XWiUZPixH47IO/2wb5g9MIdlwKoDv+6lccZMrUKvfM1c1N70RKlVQUFpTZkAm3p7e6t2ux0cDamB6o691Gg0NJ1O1W635zIIXaKlww8dW40502qtZLl58Qh+7wdcxnnd7wwBYS+6+wdmJs2aTuAJIHecbEKXCIsGhIU9jKmB1gMBsV6kEu415kXCFO1h6rPGXKL34d3dXfSNvLq6CgmNqo2NOx6Pl+bds48ec0AhFLI7aRCSeiq8p4PTWpEmUPSZ6XQ6V84MRs2Fp4Oxg6K8X1n9h6I95GzRqmB0g8EgAFO0PeZBKJBevIrXg7G2TIDLQg+4arWq0WikjY2NqPADaJdlmYbDYeSng5qmX0XzONf3Ah+uMlOXz1NVx+NxqOVoHs6AiubxdXGYdJcB3Nrf3w9GgzvIC1TQYxHG5DUU0/0DNByPx/FciAs8hXfd2NgIswpkudPpRK0Gt3mL5vKLsrOzMwfSDQYDvX37NjS4g4ODACVhpNPpdA60Sy8M++emAgj51dWVzs/P9e7duzBd0uAlN/fSoKEiFT2dm8+g+cGwKXLKpaQfBiYHOE8ZI0iDfPgsz0PlR6ug8jUeLFzTnlLsMQqrBLGtHRNgI/xS5nmu0WgUNf5ev36t169fB6CGBEkj5LgIRRLaVWX+xebEp015r62trdAQPM13PB4HmAOBlmkDDlRCeA7u4QqtVqtzQUP4l72YqtcZLGM4zHV7eztX9Zb1wNQ2NzfD9YoJgK3r5dqKpBg/c8HYd+82nGVZMBswkFarFa3OIF4vasL3KTDotjnzwUgozU1/CvaP2AsYNozcAboUL+J7zgZTyvsyAkKDPbh7EkYK+OuVlIsuJefo7+OuQQehaRxDc1wC1Xg+GsEHW15MmleLuDAQJa3B6vV6lOimqgy9+qrVaoB50vspu0Xz8TlXi72OPL/z8GEYBbgA3oyyuXxdzOeHj/qPNOai8oU96Ny9zAvhmoCrzbhUUcdB7IlbQMNB40DbWLaH7oVxBJxKOfv7+zo5OVGWZeF52dnZ0XA4nLv80nz9gyKm4xL9/v5+rqrTxsaGGo3G3GXBQ4IWhCT3uImitbmGg63PJU8LmnjEJ1okwimNaizbRxhEGi3o3gtiTBwr8L/zs/Kvzx0nkGXZNyT9WUkvJU0lfTfP8/9XlmUtSX9B0jclfU/SH83zvPv4N39S0i9Kupf0J/I8/yvL5vHhFwaNwDkc5ZexJyeTiba2tlSv16MiMY0o/MKUbQYH5f5VLp1LJS4UsQkcUMoEyuaCoHgWn4O4JcVl8LBnr0oMwfn+lO2hNPO2QCwQF/5oQCcq10wmk6j6g7trmavJJSlr4pIyF/gGjBwmhQ3rc6U1IXy4dnd5ealutxvSlsIvBNt4YBTPQk13N1oZTfA3eFfYe9ytCA43K1nnYDAIld5bxy3bQxgp5y0p9hGNBnORz0I3vM+yPUzHKprARNK/m+f5/5BlWU3S38uy7K9K+j9K+ut5nv9ylmXfkfQdSb+UZdlPS/p5Sb9X0mtJfy3Lst+T5/lqKIXmkyawqdwH/ObNm7kLV6vV1Gq15sJHUaGWuUkgCIJovLa814aTFO/ijSB4hkuDsgvj/mLPTUB6Yu9BLEhTZ0T8rTRzW7pJAKPh75mH9+cdcWe6W4rS7dTGA+lf5N/2wTMBIWEGBDc50wOrACz0kOVlzBQGiXmE9OWieU4AwgB8CVdeWhqs7LyQ6gR24e4E72DPr66ugqGivSEkHKBcxAg8ZDg9O0lhejgjpOYgNMrfs0erjKVMIM/zN5LePH4/zLLstyV9JOnnJP3s48d+VdLfkPRLj7//tTzPbyT9syzLfkfSz0j6Wyu9keaztPgetxLMAJBlf38/gBAu8MHBwVwUXJHE5GdH5+HaHiQDweKPvb6+DjuNd0wvdhkBY2a4OolkwQzg8nDYqORE0vF+HvKagmD860SFOQBhoKrzLoCB3W73vcuCJCrbQ7dlCdd9+/ZteAg4A4KfiD0AzPXekVyYRZcTBH08Hs/lfMDQAF13d3eDWRBFKCl6EXjlqHRdSGVPSCJwjDP3IqrT6UPHqLu7u6ATtDr+dpnm4WsHB6M7VZbN8g/oMI05RMQgTB0zAXPic5sDyYt+U9K/JOm/l/TikUEoz/M3WZadPn7sI0l/2/7sR4+/W3WOOQaAKoYt5N1mJIWdC1JLhJxLIUJEfbjqxeWF2+/s7Oj29jbALd5LUtjTGxsbYdMuO2D+3hNpUFuxxflb1FUvUAmhImmcUMouC4TqgBQXjwKg/N6r27oEw0xZZKO77Xl//9AAY2NjQ2dnZxFUA34znU7jbIgHwJvj9ROLYhJ8XTA03I1gQI1GI6ISWQfoPbgDIClBUUUgJOuCCXjUHxIWyQuGQkYr+42XwwWQm30pbXi8BdorIdVoI4CfMD72yDMUHdT8woHBLMuqkv4rSf9OnueDBZy66D/eY0VZln1b0rdL5goiRrKnLhHcKHx2b29PjUYjQELiCRZlpPlBI5XT4Ay3iR1wkhQureFwGLHcaQFLnwutA0ZCIA3hoLFZ+ay9d57n0R0ZrwEEmHo4fC7OB7QfxgWxEyoMIyN2H+ItwiaWSWdJoZGB3SCNCUJCesKQuEScFedVxHTSy0SEJefPhXH8hBBl9ty1AmilbA/97DGXYI6o4e45wWxKQUsSilKtrWxtrM9NK/42y2YxHpIix8N7LHh+wheFCSjLsi09MID/Ms/z//rx1++yLHv1qAW8knT2+PsfSfqG/fnHkj5Nn5nn+Xclfffx+UVMIqQ0rkFXwT2l+MWLF3OoN5l20qwzzTKgjgvvTUDcVQMOQIimu7dc8pQxHB+o9bVaLcpxA4BmWTbHxT2uH2njKn5RFJ9/z7PQfPz5EBkqJaotQVnu8ixibOnguYRFD4fDyJR0rWQyeWgGcnZ2Fs9M8+3L5vJncEFA4pGQjinAeJCgDiYvik70ywhTxE8PPXA2MNjp9KEXhnel8joTjuQv2kMHxjFrHTDEVKMJCRc+rZGwCgOQVvMOZJL+c0m/nef5r9h//YakX5D0y4///iX7/Z/LsuxX9AAM/pSkv7PS28zmDMJHbT4+Po40SrffDw8P9eLFC+3v70fjzMFgoG63G/EDi3K42WyI1G3l+/v7sGP5bJZlkbF1cXGh8/Pz6Ay0yD/L37oNS4AQ7bq9MzHAnEsR0mwhjLL0aN9HJygAUN4BgmKP6APgJcE9HmEV9ZKLB7OGadVqtWBi9NDjgrgGwLuWnZczbWdyuFQlhSuPFOOtra3QdIhC5fIsmsufD+Pxvb+/v4+GOGgH7CV4R7/fn+s/UBZv4UzLgXFMX3Il0BjRZLrdbuA50Im/8ypjFU3gD0r630v6h1mW/f3H3/17erj8v55l2S9K+oGkP/K4oN/KsuzXJf1jPXgW/thTPAOSYqMcSb27uwswDXcJOAHx1N1uV59++qm+//3vR9ceV9F9cHAQBtybVt7SDDSUZhfz8vIyAmm63W4cctoEpWi4ve2E7IFImAI83+sXAEAhYfg5XZc039iSC5kCkkg579XHJXXPA5JwmZcFaQWDpoMT6a/sNQyU/XLzz989HS7d/LLwf2iH7pZDegOeeRuyZZobEZd8XV1dqd/vBw7EZ3hvGCf4CnvqEXxlOA7n6CYuNAIuBiOGRvv9fphUHknJmX1hTCDP8/+viu18SfpDJX/zpyX96ZXe4P2/jQWhqqJqDQaDyOve3d0NG5B+b2/evNHZ2ZnOz8+DKy6SzNK81AV17vV6c4UqAOo4XBgGDAGCWlTODJuX2H8INcuyubRe7PPz83P1er05yezpr8s0HJfebq+jGsO06KTkRSjczPEEIt83XxeaFAzHC4vARLGdr6+v1W63Y9/cRenEu2hdrrnxTMLLuUB8Frcr6jkNSWnftei82GdH7cFXwHYoJMNeQQNcVLQdaKTsYrLn4A9gCp5fsbGxMUeHCAcwMABW94ytMtYuYlCaVbVhY+jIC7qO/Q+gh4pMmKvbs8viBHyu6+trdbvdOZcOh8ABotJ5Ag5zLcMDnOHc3T2kRn/yySexLhhFeqhIYnd5lqnnXATmwLVE5hxgHS4uQE3m5T2L5uXZRYwAMA+Cdy2LugwQNxGJYAdc0EVM1M+LwBikPBGlvV4vzDfAXRgC50seBkJi0VysgXOhPgBMDnewNNPAYJYIMMcTFklmzotnVSqVcNli3rhZAhMHQIbmPZlt1bGWTECamQS+Oc7pcfNgu/M3EO8y25LhSCxMp+hv3IXDRXDbK3XRlA13I5EqjEqZZn65FPd5Fl0UVzVZjwfx9Hq90DhSCe9rcGa3bF0O1kG8t7e3Iak84AuGyrsB7qWg1qKBlPazQWPq9/tBGwB2rBdEnwzJZfTh9MeeuDnCZ2AMbp5wTp60tGxdRUFfrEXSHEDooG2avPYUBiBp/TsQpbaf/wtDANkv8pcuem7Rz45DpL54n9NVuzJEOyUYHx4fnuezlmc8k7kB11y9K1Nf/e/SNXmIaRqW6utzzcbnKdMC0j10nzcEjIcmtXXTyrjLnl30O48pYX3u3uP/HFBdhDmwX+lwW90vaBGo51GcMJJ0+DkXzeUYidNGeh+cNsr20H733IZs3UdKEKtcvC9qLp/zQ51rkevty5iv7B3WeA+f25Ct+1jCxb/0ub6s8eOaax0E2od4XmvHBNzWStXxslGmdvvG+XPL5kq/X3U8Zf5Fvy967qrv+FVdgM+6b6t+Pt3bRZI2pZen7onPVUSHRXOU/X3R3/nzyly7n2Us28tl+7B2TMBtrHSk2IBv8io4QNnwudLnS5qzz9J5UgByEQ5QNJ/P5basNPOXL4ra+yxMy+dz+zed4yl7uui8/Kvs2aviOOlnivAakHupvDXYU+nF1+cAcZpd6ZebORZFdabPLpo3XVv6bD+3z3IH1o4JFIFxnq3ngBpAFoecElyRe8vnkd6/tFxCLyTigScg9H5RcXWVpS6XSUtfDyHSVIyRFO429/26++6pROx7x7qoAoxnhb0C2V7ktiu7+L4mD1TKsiy8Dp41yFgU1+Fn5XOzHvZvZ2cn+lVsbGzEuZCjkLaNW3Rx0vk89oH1kb2YelNI8MnzPM6wLHmIuYpow9O/6U/BfDzTvStezn3VsXZMQCo/YC/+yQCp903jM1yYonDNVOPwtFHKlnn0G7kEuJd4Tw4ZgltUcTjVLPyScCmJgfDElTzPw83mwSvLwoaZ0y89REvuwsHBQayLCETcYtTvL7ucRYTLnpGenXomYDa4LvGOENbsxWOWrQu68OpB1WpVJycnOjo6isy7Xq8nSVFdiJRiGMIyJufrIk7F6ZKAKPaJtHfmoFisRw2WzcV5pTQPXVK0BEZGyLQHNjHPsj1krBUTSAmKjL20+AYbhJvJ87a5PBAx9efS3mzpXIeHh/F1fHwc5aRo3EFm3GAwCM5OGDEJSxw2QSJlayS+wbk8BEynnizL4mLmeR4MjbUwD/UGyuZiHbu7u6rX68Hg6GhDDny/34/4+n6/Hxl6XEzm9bmKzotcj2q1Olc7AYbgBUdggATWeHi05+OnA2ns5cO4nEdHR9GpCibAexFIxt9QRdkLrqbryrIs/t6zTMnDgGY8noVBYNRgMNDZ2VlUayrT4qANL2HmSXT0PSTQq1arzcXGQOuscxEd+lgrJuADSUXrJ1RX4qgJAPGEH6TN9fV1EDKJFmx+OrIsi6ajR0dHUQSTDWd+zAvKmw+HwyieAaEh9TyOW5qXmKiQXpp6d3dXzWZTL1680MuXL4PheNw6ueVE+HlOQ1kFGYgWE6PRaOjly5eRwtxoNLSxsaHxeKxqtTpXqafdbkdBCzQJ8haKzJ2trS3VarVo5cblgBlQ4QemxRnCdLrdbjANr2VQNBd7SBkxZ6AfffSRXrx4oVqtFmHDfJa0bxcWBC2luA5aIvTmVac4L5K/vLGKx0FAe5RTY01FZoGkoAXKpZFAd3BwoJcvX6rVaml/f1+S5tR+IiZ9Dz2l+YMDBiXNJYJwKU9PT+dKQrGZpHLSWefu7qHGPX0Jt7e340B8cNCuVdCNmMN1yYX9SrMTuC/Zi0hdEoR8ON4AkVPcYnd3V8fHx3r58qVev36tZrMZEXBe9IIuPXB+pFlZIRMHkUi5pgciRMmejEajeH/21InZMZKiwXo2NzejajJdgSjywYCZc17ee5DLQXj1onW5qbi7u6tWqxUXBcbF5b67u4ukM7Ia/e/L1uUhwtAG6d/Y555GTKo5+Adpx1xUcIlFc8Hg0DROTk7UbDZ1fHwcFaFvb2+jToM0qxJF7gd0v6x8GmPtmAAXBTW2Wq2qVquFik7oJ+DL3t5etLxyqej/lqHKEDtSF3v/7u5Og8FgrrLL4eHhXAUjDtfjvRflcnPIRJzx/rVaTS9evIiuy5Smcjuc+bkw0izhpsgUcMANAiTufTqdqtvtxt+SIwEegWZ0fn4e+7YoB8Ptemd2xPAPBgMNh8MoNoI2x7+bm5saDodhllC4o2hN6bpguNjL2OqoxuQV8O4Aeq5pFGEdzJPWbAC4hXmQb7GzszP3PpVKJaoc8ft2ux1nX7Q2zyIFU6DsHKXoCTHH/pcUgoCcEDo8LUvE8rF2TIBDYvPu7x9KepMNNhgMIoEEgiBO/fT0VKPRKDgiwA9EnLqoGGR9jUajQMq95Ddqp5eqcrWf90yruvhwFJi/xU4/PT0Njk9GHKW+Njc31Ww2Q2vALClDm32gvpON1ul0lOd5MEhUadxpWfZQtPXNmzchpd0rsYioHLe4v78Pc6zb7QZghbYFmEofxoODA11cXMxhHunanMl4Ig2VjMFvSMSC+dBsBdPH07Xx5qTSMnVj4teHcW5tPXRoQmJDa5PJRAcHB/r444+Dhjz5bBFOxBwIFkyCer2uer0eAgiTkOfDPEkwIh/jg84idJ8uNt3FxYWur6/VaDQi5x0i3djYiBbRbCTlliiaCSbgw/3WbF6n0wnCPzw8lKS5xp70PMBMABgEzHJNJNU+UqYjPajpx8fH+sY3vhEgT7vdVqfTCfUfoI1npIVFFrnTWBu9GQC4JpNJqKysq9lsBrPFVpcU6PkyouLdKLVNIQwwBMdAUKthGJwRVY6L2qul8QCsmwv+0UcfqVqtSlKUTMe7wfth0/vFLPLjc3Z8keHojBe6wFRDY0PbAlBlDwGTy+I6nMHxTggJ3IJ02KJ/gnuR0GC9HNmqbsK1ZAKSotgFAAfSU5oluoABSApkvtfr6d27d3r37p36/X7k5BcBWvwMlwYlphJNvV7X0dGRTk5OAihEXadoCUAdqicqbdGF4XccHG2nAZb6/b46nY663a4kqdlsRkFQgEAu6DJ/MISMHxnX0Wg0ii5AIOxU/alUKjo7O4v6DKT4enWhsoEEGw6HIV0haCQ0ZhTFWvAGXFxcxFmhyaWutDR2BFPu4OBAJycn0drM6z1Mp9Oo4EQNCt4BbWCRhuPzsXbOFyzJeyd6EVi0U86UzMoiE45L72e2sfHQ9NZLycFk0aiazWaYyDBe/1pVG1grJsBmcLEB5FC/cNd4xVgwAz4PA/j000/V6/XmMtWK5vI03jzPw+e6ubkZpcsoXwbIyIFQuYh87kW53Gl0FxV/0WAqlUowIW+5jnsPlRrAzgOhyuYqCkRB+2i1WqrVamGfVyoV9fv9OVOMi1KUVchw5kC8BtKTuIRqtRoqLZ4DAlt6vV5cFC5wGXNz6QyQeXR0FBWbsc3RNjY3H7orgapzybrd7lzTEJ6XmoqYffzO6xeCaUA7kgIs3NnZ0c3NzRxTBxcpYqR+XpwToCOMCzc09P/ixQs1m83QCNFC3CT7IDUB54RO7B64gipJ8UoAk7u7O11cXIQ6jSRIo9J8Lul9Lsx87vbiYCWF+o/GwN94amiZKeBMwHvXcfF2dnbUarXUarXmmIAzKFT4NFw1HUVaD/tKBWfAKw8wAZ2G4aX7VTRc8kszt+Xd3V3EWRwdHQVqDaPHT0+RkUXptX5WSFvWAHMBJMSORv3nDDlbMIS0BkDRutgDGBqaDGuG0VQqFdVqNe3t7c0VS+l0OkFPy+aCTmFo0IZ7QJrNZpgJYA7ehxOTC9xslbFWTICR2mnYOtRZcw8CB4C/udPpBAbAhhCiWiY1fbNc+iHRBoNBoPLYWg6ocVBFXgFpnuEgUVBLsSshalRAvAm4hPBc4LJDFX3KnvLF3yO1HeXe398PTQuVd5kp4Ot0FRrG5f5/rzAEfkPPPvZw0VycF5ebdwa8xWTzegJUNuJsPL/AY/HTeVgHc7k5A0PxCElvDENVINdmoaGydfFuXH72i3gPAoUwp1IvhzQLmCtzexaNtWICqd0HAXmUID3zXH26v7+P/vS9Xm8ugAgVqQgBdrcTRIEkBODx56UFLHjuzs7OHOEuitJiLdiNSAD/PdISBjEcDuM9wBvcNCgb7upCA4CQkcRIbWxa6QG4dF8z60lNAj8viBcmQnNVJC6MlYsDok4fQhgq+8f+F60JiU/EYLVajSAa9pBYDvYQ88MZGs8q0t48WKher0eMBSq6o/loVh4xen5+HvUxveZi2eVkPujcA8k85gN6RjtMW9XDPJhvFea9VkzAGYCrpXA8D6Rwfy/Re6DLeZ5HpyI4dhpV58SLpOIAKE0F0IM9TmciCNQJn1BOj9QqWx/Sdzwe6927dxFWC/LPOiFk7EsAOy7fIiYAgbs6iTmFdPeQWSQOJg7rxc4ucn36eXEZKdBKDAT9IpBYfiZ4YgDB8FqgPhetyQUCv/PmHKDjzEWbOoBIQq3BndgjX5uva29vTy9evIhwblB7DxAiuI0isqwLV2dKt2VnBk0j2AhR5wzQBD1gDpcybkPWtGqgkLRmTIDhrhYOHUJETecQx+NxgC/eCZbNBEsoU9M9QQgphlqO+gXXxRXEJQI8pCEJ3Los2g1uj81I6W0ATrfvarVaHKakYHTuHlyE/romhLoKgAqB0AcQbMUj5GBMjmiXEZUXgCU3wSUYmgchulx8Lu7BwUGg25xJkXRmD2H+YEXD4TAYMYDt3d1dgK4w1F6vp4uLiznAeFG8hYftEsnpICJ0Vq1Wled5SGM8TeBIvueLzot1wUDG47Ha7XaAxXhNoBXpQTsDmPbw51UDhaQ1YwKu5kqzum4QJCgwn6GkMzXsYQzY0p6EUkbAqGs8H78s7heYiQOGksK/TnQXmkbZxkPUqKPexmowGMz5vb1pJ6h9p9OJgBqk3SL3IHvna0OV5fKQMMR6UNn5W6TdIu+Am1RZlgUjYD5MgclkEkAg+APgquMBvhdFDMAlKZIXAI41uJSHlkajkdrtdqjpnlSWzgUdehSfpIgWlGYmC3EHaflvtE9ow8+raF0pUA2wilcAbAtMhUjWwWAQnpU05XzVsVZMgMEmeVAN6C9Ek+d5+JjxZ8OVHdSDM5fZs0g/kkKI3COTC/DN1SuY0P7+/lzUmduJRd4BvveL3Ol05kBC1EYG0gtgMG3euWjwTm5DQ2AQCeYPDA3PR2orFzGBFFdhDWQrEpyENkGcAkx1Y2Mj1HUHZBe5CKGL6+vrUPGRlh49h8cgyzKdnZ1FqXECsRbVf/D50ARhWN5ZGVpACyCj1BkEJoFjEkVr4ntwE86i1+sFBkEiG/ei1+up3W6Hqca+uRdqlbGWTACicsCOwB2AJg4QlRhVWtIc0ZURsGsGbtvXajW1Wq1obw4Qmed5uB3dBYQ6ilSB8SxS/fz39/f34c1oNBpzodDgHO12e65WvpctX6QNwAC4EPjMWXu9XtdkMom1O1iInYkEK8vo89+5mwvXIDEXfuEAsPAKUDOfC7MsEpL34W9Go1EwbMBM1jKdTnVxcaHhcKhOp6NerxfntSj/gnlQ7ckIJLCK9QIeX1xc6N27d4HZgE05KJl6vVI69N/5XtJ0B7rCXOh0Omq326FdQR+L1lU01o4JpJfWASpAJ1cJkS6eb89mOSiYBoQw2FBAJdccsIkBZbyWPh1mAILwd8MofLiqx8/O5FinR6CxrouLi+jWwzOQPmXcHoni6if7waVM0eazszPd3t6q2+0G0xkMBnP5A2VMzQNUYFKkIcOg2XvsV0BP7+rr1X/K5nIGQLYhrmPMndvb20i2wdwiKMnDd9OU76J1ca69Xi/okJDy6XQamsibN2/U7XbnGBoaHc9ZZML5WUIvXoUJDRLTgmhVzonzcW30g2QCLJ6FQ8iemMOl7Pf7evfuXYRkwoH5GwiSQym7LGwqTTmkB/uRVlMQKyGgXqeAaEEn/iIbk+FpuhwSTAhGA5HiEUDT4JlcZFTURXPhhhuNRup0OhHzQIAV+wQ+wLqYdxXJLCnmwTcOkxqPxzHPYDCIYC5/NmfD2YLtFDE4V5elGQo+nU5VrVYDSWfOu7tZhyLOyrv1eDxIER2CY7jLEeYGkxkMBjo/P9fZ2ZkGg8F75iFrA9AtY9y8D7QBbY7H4zn3NAKHcHXXDtFGHRNYxSRYKybA4FJtbm4GJ97aemg8ur+/H8RGQgUXB2knaW4zFm2E28G47CAk3FCuUXhcthOSNB8RWDQgCCRilj3knO/u7kZBCMA4GATSwyvFeEmsMg0nxUSurq7CDYqN6RLHM+H8Iq5iX4JQ8/3V1ZU6nc4cQAuTSG1x/nVmwO/K1uW5DLhsvcQYajT2M8/mAjkTLRMOSFT23126gNWo4LhueaYzADcJluEPDmJXKg/1Abx4CvvrXhb3DkCPTvOLzFLG2jEBDgAu7ujsxcVF2JLEYjsuwN87uJKqWUUb4viCN0CFiJCCzqWlmU1YdFnK5uJZjh0MBoMAPLGX0UpcKnBZnXgX+YJ9b1wyuMvUvQBOtP7zKtIEace7YqJ5SDLrda3C1df0vIqGg4POVLl47HvqK0+xhEVz+Z46toRg4v0RDkXmH89w1XzZPnJefC/Ngst4F352mvP3WCb0isbadiBiEwnm2N3djZ+R+GwKaLbbrqk7psguT/8PrIFLws/p3zBnESEten66Pp7PReTvHXGXNMfQFqHmC/Z37oKkTMDfz23JVZ5btIcp1lH03sv2sOi80rnT9/e/cTezr2sZluLvnM7j5+Wma/o5X6+v29fF759KG74mvwerrEu/W9qQOTGn48teC/OuomJ9nufzPWMdzuizjvQy++8/5HVJxWv4smkjZRpPnOt3RxuyVdXTL2tu//fLev6XOcePeyyygT/08eMURF8m7a0LE7iQNH7890Max3p+5x/H+NDeeV3f958r+uVamAOSlGXZbxapKus8nt/5xzM+tHf+0N539aTj5/E8nsfvyvHMBJ7H8/iaj3ViAt/9ql/gM4znd/7xjA/tnT+o910bTOB5PI/n8dWMddIEnsfzeB5fwfjKmUCWZf9almX/JMuy38my7Dtf9fuUjSzLvpdl2T/MsuzvZ1n2m4+/a2VZ9lezLPufH/9tfsXv+GeyLDvLsuwf2e9K3zHLsj/5uO//JMuy/+0avfOfyrLsk8e9/vtZlv3hNXvnb2RZ9t9lWfbbWZb9VpZl/5fH36/1XpcODzf8cX9J2pD0v0j6SUnbkv5HST/9Vb7Tgnf9nqTj5Hf/d0nfefz+O5L+b1/xO/7Lkn6/pH+07B0l/fTjfu9I+tbjOWysyTv/KUn/14LPrss7v5L0+x+/r0n6nx7fba33uuzrq9YEfkbS7+R5/k/zPL+V9GuSfu4rfqenjJ+T9KuP3/+qpH/zq3sVKc/zvympk/y67B1/TtKv5Xl+k+f5P5P0O3o4jx/rKHnnsrEu7/wmz/P/4fH7oaTflvSR1nyvy8ZXzQQ+kvRD+/lHj79bx5FL+m+zLPt7WZZ9+/F3L/I8fyM9EIak06/s7cpH2Tuu+97/8SzL/sGjuYBavXbvnGXZNyX9S5L+e32ge/1VM4GiPNh1dVf8wTzPf7+kf13SH8uy7F/+ql/oc4513vv/RNI/L+n3SXoj6T96/P1avXOWZVVJ/5WkfyfP88Gijxb8bl32+itnAj+S9A37+WNJn35F77Jw5Hn+6eO/Z5L+oh7UuXdZlr2SpMd/z766NywdZe+4tnuf5/m7PM/v8zyfSvrPNFOd1+adsyzb0gMD+C/zPP+vH3/9we219NUzgb8r6aeyLPtWlmXbkn5e0m98xe/03siy7CDLshrfS/pXJf0jPbzrLzx+7Bck/aWv5g0XjrJ3/A1JP59l2U6WZd+S9FOS/s5X8H7vDS7S4/i39LDX0pq8c/aQz/ufS/rtPM9/xf7rg9trSV+td+AROf3DekBX/xdJ//5X/T4l7/iTekB3/0dJv8V7SjqS9Ncl/c+P/7a+4vf883pQn+/0IH1+cdE7Svr3H/f9n0j619fonf/fkv6hpH+ghwv0as3e+X+tB3X+H0j6+49ff3jd97rs6zli8Hk8j6/5+KrNgefxPJ7HVzyemcDzeB5f8/HMBJ7H8/iaj2cm8Dyex9d8PDOB5/E8vubjmQk8j+fxNR/PTOB5PI+v+XhmAs/jeXzNx/8fbIrQbcGZXsMAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 2 Train loss: 148.8094\n", + "Test loss: 136.5518\n", + "Epoch: 2\n", + "Reconstruction\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "generate from prior z:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 3 Train loss: 128.4078\n", + "Test loss: 124.8055\n", + "Epoch: 3\n", + "Reconstruction\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "generate from prior z:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# z_sample for generate imgs from prior\n", + "z_sample = 0.5 * torch.randn(64, z_dim).to(device)\n", + "\n", + "# fixed _x for watching reconstruction improvement\n", + "_x, _ = iter(test_loader).next()\n", + "_x = _x.to(device)\n", + "\n", + "for epoch in range(1, epochs + 1):\n", + " train_loss = train(epoch)\n", + " test_loss = test(epoch)\n", + " \n", + " recon = plot_reconstrunction(_x[:8])\n", + " sample = plot_image_from_latent(z_sample)\n", + " \n", + " print('Epoch: {}'.format(epoch))\n", + " print('Reconstruction')\n", + " imshow(torchvision.utils.make_grid(recon))\n", + " print('generate from prior z:')\n", + " imshow(torchvision.utils.make_grid(sample))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/tutorial/Japanese/01-DistributionAPITutorial.ipynb b/tutorial/Japanese/01-DistributionAPITutorial.ipynb new file mode 100644 index 00000000..8d4c79f3 --- /dev/null +++ b/tutorial/Japanese/01-DistributionAPITutorial.ipynb @@ -0,0 +1,720 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Pixyzの確率分布の記述方法\n", + "\n", + "ここではまず，Pixyzにおける確率モデルの実装方法について説明します. \n", + "Distribution API document: https://docs.pixyz.io/en/latest/distributions.html" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from __future__ import print_function\n", + "import torch\n", + "from torch import nn\n", + "from torch.nn import functional as F\n", + "import numpy as np\n", + "\n", + "torch.manual_seed(1)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from pixyz.utils import print_latex" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. 深層ニューラルネットワークを用いない確率分布の定義" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.1 シンプルな確率分布の定義" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "ガウス分布を作るためには，`Normal`をインポートして，平均（loc）と標準偏差（scale）を定義します．" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "from pixyz.distributions import Normal\n", + "\n", + "x_dim = 50\n", + "p1_nor_x = Normal(loc=torch.tensor(0.), scale=torch.tensor(1.), var=['x'], features_shape=[x_dim], name='p_{1}')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "なお``var``には，変数の名前を設定します．ここでは`\"x\"`を設定しています．\n", + "\n", + "また，features_shapeでは次元数を指定します．ここではfeatures_shapeが50となっていますから，50次元のサンプルを生成する形になります．\n", + "\n", + "上記で定義したp1の情報は次のようにみることができます．" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Normal\n", + "p_{1}(x)\n" + ] + } + ], + "source": [ + "print(p1_nor_x.distribution_name) \n", + "print(p1_nor_x.prob_text)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "distribution_nameでは，確率分布の名前を確認できます．\n", + "\n", + "prob_textでは，確率分布の形をテキストで出力できます．ここでテキストに書かれている確率変数は，上記のvarで指定したものです.\n", + "\n", + "また，p1を丸ごとprintすると，以下のように表示されます．" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Distribution:\n", + " p_{1}(x)\n", + "Network architecture:\n", + " Normal(\n", + " name=p_{1}, distribution_name=Normal,\n", + " var=['x'], cond_var=[], input_var=[], features_shape=torch.Size([50])\n", + " (loc): torch.Size([1, 50])\n", + " (scale): torch.Size([1, 50])\n", + " )\n" + ] + } + ], + "source": [ + "print(p1_nor_x)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "print_latexを利用するとLaTex表記で定義した確率分布が表示されます \n", + "注: 数式のtex形式への出力に外部ライブラリのsympy使用しており，sympyの影響で数式の結果に支障を与えないが，数式の順序が入れ替わることがある \n", + "print_latex(A +B)の出力が \n", + "B+Aになることがあったりする" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle p_{1}(x)$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print_latex(p1_nor_x)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "次に，定義した分布からサンプリングしてみましょう． サンプリングは，`sample()`によって実行します．" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'x': tensor([[-1.5256, -0.7502, -0.6540, -1.6095, -0.1002, -0.6092, -0.9798, -1.6091,\n", + " -0.7121, 0.3037, -0.7773, -0.2515, -0.2223, 1.6871, 0.2284, 0.4676,\n", + " -0.6970, -1.1608, 0.6995, 0.1991, 0.8657, 0.2444, -0.6629, 0.8073,\n", + " 1.1017, -0.1759, -2.2456, -1.4465, 0.0612, -0.6177, -0.7981, -0.1316,\n", + " 1.8793, -0.0721, 0.0663, -0.4370, 0.7626, 0.4415, 1.1651, 2.0154,\n", + " 0.2152, -0.5242, -0.1860, -0.6446, 1.5392, -0.8696, -3.3312, -0.7479,\n", + " 1.1173, 0.2981]])}\n", + "--------------------------------------------------------------------------\n", + "tensor([[-1.5256, -0.7502, -0.6540, -1.6095, -0.1002, -0.6092, -0.9798, -1.6091,\n", + " -0.7121, 0.3037, -0.7773, -0.2515, -0.2223, 1.6871, 0.2284, 0.4676,\n", + " -0.6970, -1.1608, 0.6995, 0.1991, 0.8657, 0.2444, -0.6629, 0.8073,\n", + " 1.1017, -0.1759, -2.2456, -1.4465, 0.0612, -0.6177, -0.7981, -0.1316,\n", + " 1.8793, -0.0721, 0.0663, -0.4370, 0.7626, 0.4415, 1.1651, 2.0154,\n", + " 0.2152, -0.5242, -0.1860, -0.6446, 1.5392, -0.8696, -3.3312, -0.7479,\n", + " 1.1173, 0.2981]])\n" + ] + } + ], + "source": [ + "p1_nor_x_samples = p1_nor_x.sample()\n", + "print(p1_nor_x_samples)\n", + "print('--------------------------------------------------------------------------')\n", + "print(p1_nor_x_samples[\"x\"])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "出力はdict形式になっています．\n", + "\n", + "サンプリング結果を確認したい変数について指定することで，中身を確認できます（ただし，この例では変数は\"x\"のみです）．\n", + "\n", + "なお，サンプリング結果は，PyTorchのtensor形式になっています．" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.2 条件付確率分布の定義" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "次に条件付確率分布の定義の仕方を正規分布の例で見ていきます\n", + "\n", + "正規分布ではパラメータは平均$\\mu$と分散$\\sigma^2$がありますが，今回は平均が条件付けられた正規分布を取り上げたいと思います" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "$p(x|\\mu_{var}) = \\cal N(x; \\mu=\\mu_{var}, \\sigma^2=1)$\n", + "\n", + "分布の条件付き変数の設定はcond_varで行います \n", + "ここではmu_varという変数を正規分布の平均に設定したいため \n", + "cond_var=['mu_var'] \n", + "loc='mu_var' \n", + "とします" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "x_dim = 50\n", + "p1_nor_x__mu = Normal(loc='mu_var', scale=torch.tensor(1.), var=['x'], cond_var=['mu_var'], features_shape=[x_dim])" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Distribution:\n", + " p(x|\\mu_{var})\n", + "Network architecture:\n", + " Normal(\n", + " name=p, distribution_name=Normal,\n", + " var=['x'], cond_var=['mu_var'], input_var=['mu_var'], features_shape=torch.Size([50])\n", + " (scale): torch.Size([1, 50])\n", + " )\n" + ] + }, + { + "data": { + "text/latex": [ + "$\\displaystyle p(x|\\mu_{var})$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(p1_nor_x__mu)\n", + "print_latex(p1_nor_x__mu)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "これで平均が$\\mu_{var}$で条件付けされる正規分布が定義できました \n", + "試しに$\\mu_{var}=0$としてxをサンプリングしてみます \n", + "sampleメソッドにdict形式で変数を指定します" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'mu_var': 0,\n", + " 'x': tensor([[-0.5962, -1.0055, -0.2106, -0.0075, 1.6734, 0.0103, 0.9837, 0.8793,\n", + " -0.9962, -0.8313, -0.4610, -0.5601, 0.3956, -0.9823, 1.3264, 0.8547,\n", + " -0.6540, 0.7317, -1.4344, -0.5008, 0.1716, -0.1600, -0.5047, -1.4746,\n", + " -1.0412, 0.7323, -1.0483, -0.4709, 0.2911, 1.9907, -0.9247, -0.9301,\n", + " 0.8165, -0.9135, 0.2053, 0.3051, 0.5357, -0.4312, 0.1573, 1.2540,\n", + " 1.3275, -0.4954, -1.9804, 1.7986, 0.1018, 0.3400, -0.6447, -0.2870,\n", + " 3.3212, -0.4021]])}" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "p1_nor_x__mu.sample({\"mu_var\": 0})" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "次に$\\mu_{var}$自体も何らかの確率分布に従う変数とし，その確率分布を定めます \n", + "ここでは仮にベルヌーイ分布とします \n", + "$p(\\mu_{var}) = \\cal B(\\mu_{var};p=0.3)$" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "from pixyz.distributions import Bernoulli\n", + "p2_ber_mu = Bernoulli(probs=torch.tensor(0.3), var=['mu_var'], features_shape=[x_dim])" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Distribution:\n", + " p(\\mu_{var})\n", + "Network architecture:\n", + " Bernoulli(\n", + " name=p, distribution_name=Bernoulli,\n", + " var=['mu_var'], cond_var=[], input_var=[], features_shape=torch.Size([50])\n", + " (probs): torch.Size([1, 50])\n", + " )\n", + "{'mu_var': tensor([[0., 0., 0., 0., 0., 0., 1., 1., 1., 0., 1., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 1., 1., 1., 1., 0., 0., 1., 0., 0., 0., 1., 0., 0., 0.,\n", + " 1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0.]])}\n" + ] + }, + { + "data": { + "text/latex": [ + "$\\displaystyle p(\\mu_{var})$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(p2_ber_mu)\n", + "print(p2_ber_mu.sample())\n", + "print_latex(p2_ber_mu)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Pixyzでは分布の積は，掛け算で表すことができます \n", + "定義した$p(\\mu_{var})$と$p(x|\\mu_{var})$を掛け合わせて同時分布$p(x, \\mu_{var})$を定義します \n", + "$p(x, \\mu_{var}) = p(x|\\mu_{var}) p(\\mu_{var})$\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Distribution:\n", + " p(x,\\mu_{var}) = p(x|\\mu_{var})p(\\mu_{var})\n", + "Network architecture:\n", + " Bernoulli(\n", + " name=p, distribution_name=Bernoulli,\n", + " var=['mu_var'], cond_var=[], input_var=[], features_shape=torch.Size([50])\n", + " (probs): torch.Size([1, 50])\n", + " )\n", + " Normal(\n", + " name=p, distribution_name=Normal,\n", + " var=['x'], cond_var=['mu_var'], input_var=['mu_var'], features_shape=torch.Size([50])\n", + " (scale): torch.Size([1, 50])\n", + " )\n" + ] + }, + { + "data": { + "text/latex": [ + "$\\displaystyle p(x,\\mu_{var}) = p(x|\\mu_{var})p(\\mu_{var})$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "p_joint_mu_x = p1_nor_x__mu * p2_ber_mu\n", + "print(p_joint_mu_x) \n", + "print_latex(p_joint_mu_x)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "同時分布でも今までと同様にsampleメソッドでサンプリングを行うことができます \n", + "全ての変数とその値がdict形式で出力されます" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'mu_var': tensor([[1., 0., 1., 0., 1., 1., 0., 1., 0., 0., 1., 0., 0., 1., 0., 0., 0., 1.,\n", + " 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 1.,\n", + " 0., 0., 1., 0., 1., 1., 0., 1., 0., 0., 0., 0., 0., 1.]]),\n", + " 'x': tensor([[ 3.6415, -0.9624, 0.7924, -1.3889, 1.0127, -0.8734, 1.7997, 1.2824,\n", + " 1.6604, 0.2717, 0.1913, 0.1267, 0.5707, 0.8652, 0.3437, 0.3718,\n", + " 0.1444, 1.7772, -2.3381, 0.1709, 1.1661, 1.4787, 0.2676, 0.7561,\n", + " -0.5873, -2.0619, 0.4305, 0.3377, -0.3438, -0.6172, 2.2530, -0.0514,\n", + " -1.0257, 0.5213, -2.3065, 1.6037, 0.1794, 0.1447, 0.6411, 0.4793,\n", + " 0.7617, -0.3542, -0.2693, 2.3120, -0.8920, -0.7529, -0.0573, 2.2000,\n", + " 0.9912, 0.9414]])}" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "p_joint_mu_x.sample()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. 深層ニューラルネットワークと組み合わせた確率分布の設定" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "次に， 確率分布のパラメータを深層ニューラルネットワークで定義します．\n", + "\n", + "例えば，ガウス分布の平均$\\mu$と分散$\\sigma^2$は， パラメータ$\\theta$を持つ深層ニューラルネットワークによって，$\\mu=f(x;\\theta)$および$\\sigma^2=g(x;\\theta)$と定義できます．\n", + "\n", + "したがって，ガウス分布は${\\cal N}(\\mu=f(x;\\theta),\\sigma^2=g(x;\\theta))$となります．\n", + "\n", + "$p(a) = {\\cal N}(a; \\mu=f(x;\\theta),\\sigma^2=g(x;\\theta))$を定義してみましょう\n", + "\n", + "Pixyzでは，次のようなクラスを記述することで，これを実現できます．" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "a_dim = 20\n", + "\n", + "class ProbNorAgivX(Normal):\n", + " \"\"\"\n", + " Probability distrituion Normal A given X\n", + " p(a) = {\\cal N}(a; \\mu=f(x;\\theta),\\sigma^2=g(x;\\theta)\n", + " loc and scale are parameterized by theta given x\n", + " \"\"\"\n", + " def __init__(self):\n", + " super(ProbNorAgivX, self).__init__(var=['a'], cond_var=['x'])\n", + " \n", + " self.fc1 = nn.Linear(x_dim, 10)\n", + " self.fc_loc = nn.Linear(10, a_dim)\n", + " self.fc_scale = nn.Linear(10, a_dim)\n", + " \n", + " def forward(self, x):\n", + " h1 = F.relu(self.fc1(x))\n", + " return {'loc': self.fc_loc(h1), 'scale': F.softplus(self.fc_scale(h1))}\n", + "p_nor_a__x = ProbNorAgivX()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "まず， ガウス分布クラスを継承することで，ガウス分布のパラメータを深層ニューラルネットワークで定義することを明示します．\n", + "\n", + "次に，コンストラクタで，利用するニューラルネットワークを記述します．これは，通常のPyTorchと同じです．\n", + "\n", + "唯一異なる点は，superの引数にvarとcond_varの名前を指定している点です．\n", + "\n", + "varは先程見たように，出力する変数の名前を指定します．一方，cond_varではニューラルネットワークの入力変数の名前を指定します．これは，ここで定義する分布において，条件付けられる変数とみなすことができます．\n", + "\n", + "forwardについても，通常のPyTorchと同じです．ただし，注意点が2つあります．\n", + "\n", + "* 引数の名前と数は，cond_varで設定したものと同じにしてください． 例えば，cond_var=[\"x\", \"y\"]とした場合は，forward(self, x, y)としてください．\n", + "* 戻り値は，それぞれの確率分布のパラメータになります．上記の例ではガウス分布なので，平均と分散を指定しています．\n", + "\n", + "そして最後に，定義した確率分布クラスのインスタンスを作成します．\n", + "\n", + "次に，先程の例と同様，確率分布の情報を見てみましょう." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Distribution:\n", + " p(a|x)\n", + "Network architecture:\n", + " ProbNorAgivX(\n", + " name=p, distribution_name=Normal,\n", + " var=['a'], cond_var=['x'], input_var=['x'], features_shape=torch.Size([])\n", + " (fc1): Linear(in_features=50, out_features=10, bias=True)\n", + " (fc_loc): Linear(in_features=10, out_features=20, bias=True)\n", + " (fc_scale): Linear(in_features=10, out_features=20, bias=True)\n", + " )\n" + ] + }, + { + "data": { + "text/latex": [ + "$\\displaystyle p(a|x)$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(p_nor_a__x)\n", + "print_latex(p_nor_a__x)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "p2の分布は，xで条件付けた形になっています．これらの表記は，superの引数で設定したとおりになっています．" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "次に，先程の例のように，サンプリングしてみましょう．\n", + "\n", + "注意しなければならないのは，先ほどと異なり，条件づけた変数xがあるということです．\n", + "\n", + "x_samplesをxとしてサンプリングしましょう．" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "x_samples = torch.Tensor([[-0.3030, -1.7618, 0.6348, -0.8044, -1.0371, -1.0669, -0.2085,\n", + " -0.2155, 2.2952, 0.6749, 1.7133, -1.7943, -1.5208, 0.9196,\n", + " -0.5484, -0.3472, 0.4730, -0.4286, 0.5514, -1.5474, 0.7575,\n", + " -0.4068, -0.1277, 0.2804, 1.7460, 1.8550, -0.7064, 2.5571,\n", + " 0.7705, -1.0739, -0.2015, -0.5603, -0.6240, -0.9773, -0.1637,\n", + " -0.3582, -0.0594, -2.4919, 0.2423, 0.2883, -0.1095, 0.3126,\n", + " -0.3417, 0.9473, 0.6223, -0.4481, -0.2856, 0.3880, -1.1435,\n", + " -0.6512]])" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'x': tensor([[-0.3030, -1.7618, 0.6348, -0.8044, -1.0371, -1.0669, -0.2085, -0.2155,\n", + " 2.2952, 0.6749, 1.7133, -1.7943, -1.5208, 0.9196, -0.5484, -0.3472,\n", + " 0.4730, -0.4286, 0.5514, -1.5474, 0.7575, -0.4068, -0.1277, 0.2804,\n", + " 1.7460, 1.8550, -0.7064, 2.5571, 0.7705, -1.0739, -0.2015, -0.5603,\n", + " -0.6240, -0.9773, -0.1637, -0.3582, -0.0594, -2.4919, 0.2423, 0.2883,\n", + " -0.1095, 0.3126, -0.3417, 0.9473, 0.6223, -0.4481, -0.2856, 0.3880,\n", + " -1.1435, -0.6512]]), 'a': tensor([[-1.7231e-01, -5.0856e-01, 1.3573e+00, -7.1246e-01, 3.8644e-01,\n", + " 1.1225e+00, 1.4864e-01, 6.8819e-02, -5.6884e-01, -2.4427e+00,\n", + " 1.2279e-03, -9.0337e-01, 5.3217e-02, 6.0509e-01, -3.8033e-01,\n", + " 6.5706e-02, -2.3049e-01, 3.4607e-01, 2.6745e-02, -3.9659e-01]])}\n", + "tensor([[-1.7231e-01, -5.0856e-01, 1.3573e+00, -7.1246e-01, 3.8644e-01,\n", + " 1.1225e+00, 1.4864e-01, 6.8819e-02, -5.6884e-01, -2.4427e+00,\n", + " 1.2279e-03, -9.0337e-01, 5.3217e-02, 6.0509e-01, -3.8033e-01,\n", + " 6.5706e-02, -2.3049e-01, 3.4607e-01, 2.6745e-02, -3.9659e-01]])\n", + "tensor([[-0.3030, -1.7618, 0.6348, -0.8044, -1.0371, -1.0669, -0.2085, -0.2155,\n", + " 2.2952, 0.6749, 1.7133, -1.7943, -1.5208, 0.9196, -0.5484, -0.3472,\n", + " 0.4730, -0.4286, 0.5514, -1.5474, 0.7575, -0.4068, -0.1277, 0.2804,\n", + " 1.7460, 1.8550, -0.7064, 2.5571, 0.7705, -1.0739, -0.2015, -0.5603,\n", + " -0.6240, -0.9773, -0.1637, -0.3582, -0.0594, -2.4919, 0.2423, 0.2883,\n", + " -0.1095, 0.3126, -0.3417, 0.9473, 0.6223, -0.4481, -0.2856, 0.3880,\n", + " -1.1435, -0.6512]])\n" + ] + } + ], + "source": [ + "p_nor_a__x_samples = p_nor_a__x.sample({'x': x_samples})\n", + "print(p_nor_a__x_samples)\n", + "print(p_nor_a__x_samples['a'])\n", + "print(p_nor_a__x_samples['x'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "出力には，aとxの２つのサンプルがあります．\n", + "\n", + "aが今回計算したサンプルで，xについては，引数として与えたサンプルがそのまま入っています．" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Next Tutorial\n", + "02-LossAPITutorial.ipynb" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/tutorial/Japanese/02-LossAPITutorial.ipynb b/tutorial/Japanese/02-LossAPITutorial.ipynb new file mode 100644 index 00000000..9cb30597 --- /dev/null +++ b/tutorial/Japanese/02-LossAPITutorial.ipynb @@ -0,0 +1,1107 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 深層生成モデルではモデルの設計=目的関数の定義\n", + "- 深層生成モデルでは，いずれのモデルも最適化するための目的関数を明示的に設定する\n", + " - 自己回帰モデル・フローベースモデル: Kullback-Leiblerダイバージェンス(対数尤度)\n", + " - VAE: 周辺対数尤度の下界\n", + " - GAN: Jensen-Shannonダイバージェンス(ただし目的関数自身の更新も必要(=敵対的学習))\n", + "- 推論，確率変数の表現の正則化なども，全て目的関数として追加する\n", + "\n", + " \n", + " - 深層生成モデルではモデルの設計=目的関数の定義\n", + " - 従来の生成モデルとは異なり，サンプリングによる推論等は行わない\n", + "- 確率分布を受け取って目的関数を定義できる枠組みが必要\n", + " - LossAPI \n", + "" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 確率分布を受け取って目的関数を定義する\n", + "- Loss API document: https://pixyz.readthedocs.io/en/latest/losses.html#\n", + "\n", + "ここではDistribution APIで定義した確率分布を受け取り目的関数を定義するまでの流れを確認する \n", + "目的関数を定義する際には以下の項目が必要となる\n", + "1. 尤度計算をする\n", + "1. 確率分布の距離を計算する\n", + "1. 期待値を計算する\n", + "1. データ分布を考慮した計算(mean, sum) \n", + "\n", + "VAEのLossではそれぞれの項目は以下のように対応\n", + "" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Lossの計算\n", + "Loss API はlossの計算を行う際入力に確率変数を必要とします(`input_var`).\n", + "確率変数が与えられて初めてLossのあたいは計算されます. \n", + "\n", + "```python\n", + "p = DistributionAPI()\n", + "# define the objective function receiving distribution\n", + "loss = LossAPI(p)\n", + "# the value of loss is calculated when input_var is feeded\n", + "loss_value = loss.eval({'input_var': input_data})\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from __future__ import print_function\n", + "import torch\n", + "from torch import nn\n", + "from torch.nn import functional as F\n", + "import numpy as np\n", + "\n", + "torch.manual_seed(1)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Pixyz module\n", + "from pixyz.distributions import Normal\n", + "from pixyz.utils import print_latex" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 尤度計算を行う\n", + "ある観測値$x_1$, ...., $x_N$が得られた際，xが従うと仮定した確率分布pの尤もらしさを計算します \n", + "ここではxは平均0, 分散1の正規分布に従うのではないかと仮定します \n", + "$p(x) = \\cal N(\\mu=0, \\sigma^2=1)$" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Distribution:\n", + " p(x)\n", + "Network architecture:\n", + " Normal(\n", + " name=p, distribution_name=Normal,\n", + " var=['x'], cond_var=[], input_var=[], features_shape=torch.Size([5])\n", + " (loc): torch.Size([1, 5])\n", + " (scale): torch.Size([1, 5])\n", + " )\n" + ] + }, + { + "data": { + "text/latex": [ + "$\\displaystyle p(x)$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# 確率分布pを定義\n", + "x_dim = 5\n", + "p_nor_x = Normal(var=['x'], loc=torch.tensor(0.), scale=torch.tensor(1.), features_shape=[x_dim])\n", + "print(p_nor_x)\n", + "print_latex(p_nor_x)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([100, 5])\n" + ] + } + ], + "source": [ + "# xを観測\n", + "observed_x_num = 100\n", + "observed_x = torch.randn(observed_x_num, x_dim)\n", + "print(observed_x.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "対数尤度は以下のように計算されます \n", + "$L=\\sum_{i=1}^{100} \\log p\\left(x_{i}\\right)$ \n", + "PixyzではLogProbを使用することで簡単に計算できます \n", + "LogProbの引数にPixyz Distributionで定義した確率分布を格納し \n", + "観測値をLogProb.eval()で渡すことで計算が行われます \n", + "Pixyz document: https://docs.pixyz.io/en/latest/losses.html#probability-density-function" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle \\log p(x)$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from pixyz.losses import LogProb\n", + "# LogProbの引数にPixyz Distributionで定義した確率分布を格納\n", + "log_likelihood_x = LogProb(p_nor_x)\n", + "print_latex(log_likelihood_x)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor([ -7.5539, -6.8545, -6.4024, -5.8851, -6.1517, -8.3702, -6.7028,\n", + " -5.0395, -7.4346, -7.1497, -5.7594, -7.3006, -11.9857, -5.8238,\n", + " -6.7561, -5.7640, -6.2382, -4.9060, -6.1076, -8.2535, -7.8250,\n", + " -7.1956, -7.6949, -5.2324, -11.5860, -8.1068, -7.1763, -8.3332,\n", + " -11.4631, -6.6297, -6.1200, -12.2358, -5.3402, -7.1465, -7.5106,\n", + " -7.0829, -6.6300, -6.1832, -7.2049, -10.8676, -6.8674, -5.8339,\n", + " -9.1939, -7.5965, -8.7743, -7.3492, -5.2578, -10.3097, -6.5646,\n", + " -4.8807, -5.9738, -6.2394, -10.3945, -9.1760, -9.2957, -5.5627,\n", + " -7.1047, -6.4066, -6.8100, -6.0878, -6.8835, -7.9132, -5.0738,\n", + " -8.8378, -6.2286, -5.8401, -5.9691, -5.6857, -7.6903, -6.4982,\n", + " -7.1259, -8.7953, -10.5572, -5.9161, -7.0649, -6.1292, -6.0871,\n", + " -7.2513, -7.2517, -7.1378, -6.4228, -5.5728, -5.6155, -5.1962,\n", + " -8.3940, -7.8178, -9.8129, -6.1119, -5.0492, -8.9898, -6.9675,\n", + " -8.0218, -13.9816, -6.8575, -5.1304, -5.5069, -5.0561, -5.1264,\n", + " -4.8489, -5.4876])\n", + "observed_x_num: 100\n" + ] + } + ], + "source": [ + "# 観測値それぞれに対しての尤度が計算される\n", + "print(log_likelihood_x.eval({'x': observed_x}))\n", + "# observed_x_num = 100\n", + "print('observed_x_num: ', len(log_likelihood_x.eval({'x': observed_x})))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "log_likelihood_x.eval({'x': observed_x})には \n", + "$\\log p(x_{1})$, $\\log p(x_{2})$, ...., $\\log p(x_{100})$ \n", + "の計算結果が格納されている \n", + "log_likelihood_x.eval({'x': observed_x})[i] = $\\log p(x_{i})$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "次に各要素を合計し\n", + "$L=\\sum_{i=1}^{100} \\log p\\left(x_{i}\\right)$を計算する " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "対数尤度の計算結果: tensor(-715.5875)\n" + ] + } + ], + "source": [ + "# 値を合計し対数尤度を計算する\n", + "print('対数尤度の計算結果:', log_likelihood_x.eval({'x': observed_x}).sum())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "以上のようにpixyz.lossesのLogProbを用いることで対数尤度が簡単に計算できることを確認しました \n", + "また，定義した確率分布からp.log_prob().eval()でも同様に計算が行えます" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "LogProb()\n", + "tensor(-715.5875)\n", + ".log_prob()\n", + "tensor(-715.5875)\n" + ] + } + ], + "source": [ + "print('LogProb()')\n", + "print(LogProb(p_nor_x).eval({'x': observed_x}).sum())\n", + "print('.log_prob()')\n", + "print(p_nor_x.log_prob().eval({'x': observed_x}).sum())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For more Loss API related to probability density function: \n", + "https://docs.pixyz.io/en/latest/losses.html#probability-density-function" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 確率分布の距離を計算する\n", + "生成モデルの学習では真の分布(データ分布)$p_{data}(x)$と近いモデル分布(生成モデル)$p_{\\theta}(x)$を考え，適切な$\\theta$を求めるために分布間の距離を測ることがある \n", + "\n", + "VAE系ではKullback-Leiblerダイバージェンス, GAN系ではJensen-Shannonダイバージェンスといったように，確率分布間の距離を計算する \n", + "分布間距離の計算もPixyz Loss APIを用いれば簡単に行うことができる \n", + "Pixyz document: \n", + "https://docs.pixyz.io/en/latest/losses.html#statistical-distance \n", + "https://pixyz.readthedocs.io/en/latest/losses.html#adversarial-statistical-distance\n", + "\n", + "ここでは例として平均0, 分散1の正規分布pと平均5, 分散0.1の正規分布qとのKullback-Leiblerダイバージェンスを計算する \n", + "$p(x) = \\cal N(\\mu=0, \\sigma^2=1)$ \n", + "$q(x) = \\cal N(\\mu=5, \\sigma^2=0.1)$ \n", + "$KL(q(x) || p(x))$" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle p(x)$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# 確率分布の定義\n", + "x_dim = 10\n", + "# p \n", + "p_nor_x = Normal(var=['x'], loc=torch.tensor(0.), scale=torch.tensor(1.), features_shape=[x_dim])\n", + "print_latex(p_nor_x)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle q(x)$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# q\n", + "q_nor_x = Normal(var=['x'], loc=torch.tensor(5.), scale=torch.tensor(0.1), features_shape=[x_dim], name='q')\n", + "print_latex(q_nor_x)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Kullback-Leiblerダイバージェンスを計算はpixyz.lossesのKullbackLeiblerを用いる \n", + "KullbackLeibler()の引数に距離を測りたい分布を格納し \n", + ".eval()で計算が行われる \n", + "Pixyz document: https://docs.pixyz.io/en/latest/losses.html#kullbackleibler " + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle D_{KL} \\left[q(x)||p(x) \\right]$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from pixyz.losses import KullbackLeibler\n", + "\n", + "kl_q_p = KullbackLeibler(q_nor_x, p_nor_x)\n", + "print_latex(kl_q_p)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([143.0759])" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# .eval で計算を行う\n", + "kl_q_p.eval()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For more Loss API related to statistical distance: \n", + "https://docs.pixyz.io/en/latest/losses.html#statistical-distance \n", + "https://docs.pixyz.io/en/latest/losses.html#adversarial-statistical-distance " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 期待値を計算する\n", + "何らかの関数について確率分布で重み付けして積分を行うのが期待値計算であるが\n", + "Pixyzでは潜在変数のように, input_varとして与えられない変数がある場合その変数が従う確率分布で潰\n", + "期待値の計算もLoss APIを用いれば簡単に計算できる \n", + "Pixyz document: \n", + "https://docs.pixyz.io/en/latest/losses.html#expected-value" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "ここでは例として \n", + "$q(z|x) = \\cal N(\\mu=x, \\sigma^2=1)$ \n", + "$p(x|z) = \\cal N(\\mu=z, \\sigma^2=1)$ \n", + "といった二つの確率分布q(z|x), p(x|z)を考え \n", + "$\\mathbb{E}_{q(z|x)} \\left[\\log p(x|z) \\right]$を計算する" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "# 確率分布の定義\n", + "from pixyz.distributions import Normal\n", + "\n", + "q_nor_z__x = Normal(loc=\"x\", scale=torch.tensor(1.), var=[\"z\"], cond_var=[\"x\"],\n", + " features_shape=[10], name='q') # q(z|x)\n", + "p_nor_x__z = Normal(loc=\"z\", scale=torch.tensor(1.), var=[\"x\"], cond_var=[\"z\"],\n", + " features_shape=[10]) # p(x|z)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle \\log p(x|z)$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# p(x|z)の対数尤度をとる\n", + "from pixyz.losses import LogProb\n", + "\n", + "p_log_likelihood = LogProb(p_nor_x__z)\n", + "print_latex(p_log_likelihood)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "期待値の計算はpixyz.lossesのExpectationを用いる \n", + "Expectation()の引数にはp, fがあり \n", + "期待値をとる対象の関数がfで, その関数の確率変数が従う確率分布のpで重み付けを行う \n", + ".eval()で計算が行われる \n", + "Pixyz document: https://docs.pixyz.io/en/latest/losses.html#expected-value" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle \\mathbb{E}_{q(z|x)} \\left[\\log p(x|z) \\right]$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from pixyz.losses import Expectation as E\n", + "\n", + "E_q_logprob_p = E(q_nor_z__x, LogProb(p_nor_x__z))\n", + "print_latex(E_q_logprob_p)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([-10.7006, -11.9861])" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sample_x = torch.randn(2, 10)\n", + "E_q_logprob_p.eval({'x': sample_x})" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For more details about Expectatoin API: \n", + "https://docs.pixyz.io/en/latest/losses.html#expected-value" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### データ分布を考慮した計算(mean, sum)\n", + "本来ならxについて期待値をとる必要があるが，データ分布は実際に与えられないためbatch方向について平均や合計といった計算を行う \n", + "合計や平均といった計算もLoss APIでは簡単に行うことができる \n", + "ここではobserved_xを訓練データとして尤度計算を行いそのmeanを計算する\n", + "\n", + "$p(x) = \\cal N(\\mu=0, \\sigma^2=1)$ \n", + "$\\frac{1}{N} \\sum_{i=1}^N\\left[\\log p\\left(x^{(i)}\\right)\\right]$" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([100, 5])\n" + ] + } + ], + "source": [ + "# xを観測\n", + "observed_x_num = 100\n", + "x_dim = 5\n", + "observed_x = torch.randn(observed_x_num, x_dim)\n", + "print(observed_x.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Distribution:\n", + " p(x)\n", + "Network architecture:\n", + " Normal(\n", + " name=p, distribution_name=Normal,\n", + " var=['x'], cond_var=[], input_var=[], features_shape=torch.Size([5])\n", + " (loc): torch.Size([1, 5])\n", + " (scale): torch.Size([1, 5])\n", + " )\n" + ] + }, + { + "data": { + "text/latex": [ + "$\\displaystyle p(x)$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# 確率分布pを定義\n", + "p_nor_x = Normal(var=['x'], loc=torch.tensor(0.), scale=torch.tensor(1.), features_shape=[x_dim])\n", + "print(p_nor_x)\n", + "print_latex(p_nor_x)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "合計や平均といった計算はLoss.mean()やLoss.sum()とすることで容易に行える" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle mean \\left(\\log p(x) \\right)$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from pixyz.losses import LogProb\n", + "# meanを計算する\n", + "mean_log_likelihood_x = LogProb(p_nor_x).mean() # .mean()\n", + "print_latex(mean_log_likelihood_x)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor(-7.1973)" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mean_log_likelihood_x.eval({'x': observed_x})" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Lossの組み合わせ\n", + "PixyzではLoss同士の四則演算ができる \n", + "例として以下のLossをLoss同士の組み合わせで表現する \n", + "$\\frac{1}{N} \\sum_{i=1}^{N}\\left[\\mathbb{E}_{q\\left(z | x^{(i)}\\right)}\\left[\\log p\\left(x^{(i)} | z\\right)\\right]-K L\\left(q\\left(z | x^{(i)}\\right) \\| p(z)\\right)\\right]$" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "# 確率分布の定義\n", + "from pixyz.distributions import Normal\n", + "\n", + "# p(x|z)\n", + "p_nor_x__z = Normal(loc=\"z\", scale=torch.tensor(1.), var=[\"x\"], cond_var=[\"z\"],\n", + " features_shape=[10])\n", + "\n", + "# p(z)\n", + "p_nor_z = Normal(loc=torch.tensor(0.), scale=torch.tensor(1.), var=[\"z\"],\n", + " features_shape=[10])\n", + "\n", + "# q(z|x)\n", + "q_nor_z__x = Normal(loc=\"x\", scale=torch.tensor(1.), var=[\"z\"], cond_var=[\"x\"],\n", + " features_shape=[10], name='q')" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle mean \\left(- D_{KL} \\left[q(z|x)||p(z) \\right] + \\mathbb{E}_{q(z|x)} \\left[\\log p(x|z) \\right] \\right)$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Lossの定義\n", + "from pixyz.losses import LogProb\n", + "from pixyz.losses import Expectation as E\n", + "from pixyz.losses import KullbackLeibler\n", + "\n", + "# 対数尤度\n", + "logprob_p_x__z = LogProb(p_nor_x__z)# input_var: x, z\n", + "\n", + "# 期待値E\n", + "E_q_z__x_logprob_p__z = E(q_nor_z__x, logprob_p_x__z)# input_car: x(z is not needed because of Expectation)\n", + "\n", + "# KLダイバージェンス\n", + "KL_q_z__x_p_z = KullbackLeibler(q_nor_z__x, p_nor_z)\n", + "\n", + "# Lossの引き算\n", + "total_loss = E_q_z__x_logprob_p__z - KL_q_z__x_p_z# input_var: x(E_q_z__x_logprob_p__z needs x as input_var)\n", + "\n", + "# Lossのmean\n", + "total_loss = total_loss.mean()\n", + "\n", + "# Lossの確認\n", + "print_latex(total_loss)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor(-18.9965)" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Lossの計算\n", + "# xを観測\n", + "observed_x_num = 100\n", + "x_dim = 10\n", + "observed_x = torch.randn(observed_x_num, x_dim)\n", + "\n", + "# 観測したxのLossを計算\n", + "total_loss.eval({'x': observed_x})" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "以上のようにPixyz Loss API同士の四則演算で柔軟にLossが定義でき，数式から実装までが直感的に行えることが確認できた" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 時系列のロス\n", + "\n", + "時系列のロスはIterativeLossで扱われる．\n", + "例として以下のナイーブな変分下界を表現する．\n", + "\n", + "$\\frac{1}{N} \\sum_{i=1}^{N}\\sum_{t=1}^7 \\left(D_{KL}\\left[q(h|x,h_{prev})||p(h|h_{prev})\\right]+\\mathbb{E}_{q(h|x,h_{prev})}\\left[\\log p(x|h)\\right]\\right)$" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle p(x,h|h_{prev}) = p(x|h)p(h|h_{prev})$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# 各時刻の確率分布を定義\n", + "x_dim = 28\n", + "h_dim = x_dim\n", + "\n", + "decoder = Normal(var=[\"x\"], cond_var=[\"h\"], loc=\"h\", scale=torch.ones(1, x_dim))\n", + "prior = Normal(var=[\"h\"], cond_var=[\"h_prev\"], loc=\"h_prev\", scale=torch.ones(1, h_dim))\n", + "\n", + "print_latex(decoder * prior)" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle q(h|x,h_{prev})$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# 損失の期待値を取る確率分布を定義\n", + "encoder = Normal(name='q', var=[\"h\"], cond_var=[\"x\", \"h_prev\"], loc=\"x\", scale=\"h_prev\")\n", + "\n", + "print_latex(encoder)" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle D_{KL} \\left[q(h|x,h_{prev})||p(h|h_{prev}) \\right] + \\mathbb{E}_{q(h|x,h_{prev})} \\left[\\log p(x|h) \\right]$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# 時刻ごとの変分下界\n", + "step_loss = KullbackLeibler(encoder, prior) + decoder.log_prob().expectation(encoder)\n", + "print_latex(step_loss)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "時刻ごとのLossを使用して，時系列のLossをIterativeLossで定義する．\n", + "\n", + "IterativeLossには\n", + "- max_iter: 時系列の長さ\n", + "- series_var: 時系列の観測変数\n", + "- update_value: 次の時刻に引き継がれる変数と引き継ぎ先\n", + "を指定する．" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle \\sum_{t=1}^{7} \\left(D_{KL} \\left[q(h|x,h_{prev})||p(h|h_{prev}) \\right] + \\mathbb{E}_{q(h|x,h_{prev})} \\left[\\log p(x|h) \\right]\\right)$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# IterativeLossで時系列での変分下界を表現する\n", + "from pixyz.losses import IterativeLoss\n", + "t_max = 7\n", + "\n", + "_loss = IterativeLoss(step_loss, max_iter=t_max, \n", + " series_var=[\"x\"], update_value={\"h\": \"h_prev\"})\n", + "print_latex(_loss)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "観測と初期値を与えてLossを評価できる．時系列の観測変数のshapeは(時系列長，batch_size,...)であることに注意．" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor(29149.8828)" + ] + }, + "execution_count": 49, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Lossの計算\n", + "# xとhの初期値を観測\n", + "observed_x_num = 100\n", + "observed_x = torch.randn(t_max, observed_x_num, x_dim)\n", + "initial_h = torch.randn(observed_x_num, h_dim)\n", + "\n", + "# 観測したxのLossを計算\n", + "loss = _loss.mean()\n", + "loss.eval({'x': observed_x, 'h_prev': initial_h})" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Stepごとに異なる損失を用いたい場合は，slice_stepオプションとtimestep_varオプションを使用する．" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle \\sum_{t=1}^{7} \\mathbb{E}_{p(x|t,x_{all})} \\left[D_{KL} \\left[q(h|x,h_{prev})||p(h|h_{prev}) \\right] + \\mathbb{E}_{q(h|x,h_{prev})} \\left[\\log p(x|h) \\right] + t \\right]$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 50, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from pixyz.losses import Parameter\n", + "from pixyz.distributions import Deterministic\n", + "\n", + "class SliceStep(Deterministic):\n", + " def __init__(self):\n", + " super().__init__(var=['x'], cond_var=['t','x_all'])\n", + " def forward(self, x_all, t):\n", + " return {'x': x_all[t]}\n", + "\n", + "_loss2 = IterativeLoss(step_loss + Parameter('t'), max_iter=t_max, \n", + " series_var=['x_all'], update_value={'h': 'h_prev'}, timestep_var='t',\n", + " slice_step=SliceStep())\n", + "print_latex(_loss2)" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor(27127.0879)" + ] + }, + "execution_count": 51, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Lossの計算\n", + "# xとhの初期値を観測\n", + "observed_x_num = 100\n", + "observed_x = torch.randn(t_max, observed_x_num, x_dim)\n", + "initial_h = torch.randn(observed_x_num, h_dim)\n", + "\n", + "# 観測したxのLossを計算\n", + "loss = _loss2.mean()\n", + "loss.eval({'x_all': observed_x, 'h_prev': initial_h})" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Loss API(ELBO)\n", + "Pixyz Loss APIでは以下のようなLossについても実装がある\n", + "\n", + "周辺尤度下界 ELBO: https://docs.pixyz.io/en/latest/losses.html#lower-bound" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Next Tutorial\n", + "ModelAPITutorial.ipynb" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/tutorial/Japanese/03-ModelAPITutorial.ipynb b/tutorial/Japanese/03-ModelAPITutorial.ipynb new file mode 100644 index 00000000..7a68ea93 --- /dev/null +++ b/tutorial/Japanese/03-ModelAPITutorial.ipynb @@ -0,0 +1,543 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 深層生成モデルの学習方法は目的関数を定義して勾配降下法で学習\n", + "- 深層生成モデルでは，既存のようなサンプリング等によっての学習は行わない\n", + "\n", + "\n", + "" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 目的関数と最適化アルゴリズムが独立に設定できる枠組み(Model API)\n", + "- Model API document: https://docs.pixyz.io/en/v0.0.4/models.html \n", + "\n", + "ここでは定義した確率分布と目的関数を受け取り，モデルの学習を行う流れを確認する" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import torch\n", + "import torch.utils.data\n", + "from torch import nn, optim\n", + "from torch.nn import functional as F\n", + "import torchvision\n", + "from torchvision import datasets, transforms\n", + "\n", + "if torch.cuda.is_available():\n", + " device = \"cuda\"\n", + "else:\n", + " device = \"cpu\"\n", + "\n", + "batch_size = 256\n", + "seed = 1\n", + "torch.manual_seed(seed)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# MNIST datasetの準備\n", + "root = '../data'\n", + "transform = transforms.Compose([transforms.ToTensor(),\n", + " transforms.Lambda(lambd=lambda x: x.view(-1))])\n", + "kwargs = {'batch_size': batch_size, 'num_workers': 1, 'pin_memory': True}\n", + "\n", + "train_loader = torch.utils.data.DataLoader(\n", + " datasets.MNIST(root=root, train=True, transform=transform, download=True),\n", + " shuffle=True, **kwargs)\n", + "test_loader = torch.utils.data.DataLoader(\n", + " datasets.MNIST(root=root, train=False, transform=transform),\n", + " shuffle=False, **kwargs)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 確率分布の定義" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "from pixyz.distributions import Normal, Bernoulli\n", + "\n", + "x_dim = 784\n", + "z_dim = 64\n", + "\n", + "# inference model q(z|x)\n", + "class Inference(Normal):\n", + " def __init__(self):\n", + " super(Inference, self).__init__(var=[\"z\"], cond_var=[\"x\"], name=\"q\")\n", + "\n", + " self.fc1 = nn.Linear(x_dim, 512)\n", + " self.fc2 = nn.Linear(512, 512)\n", + " self.fc31 = nn.Linear(512, z_dim)\n", + " self.fc32 = nn.Linear(512, z_dim)\n", + "\n", + " def forward(self, x):\n", + " h = F.relu(self.fc1(x))\n", + " h = F.relu(self.fc2(h))\n", + " return {\"loc\": self.fc31(h), \"scale\": F.softplus(self.fc32(h))}\n", + "\n", + " \n", + "# generative model p(x|z) \n", + "class Generator(Bernoulli):\n", + " def __init__(self):\n", + " super(Generator, self).__init__(var=[\"x\"], cond_var=[\"z\"], name=\"p\")\n", + "\n", + " self.fc1 = nn.Linear(z_dim, 512)\n", + " self.fc2 = nn.Linear(512, 512)\n", + " self.fc3 = nn.Linear(512, x_dim)\n", + "\n", + " def forward(self, z):\n", + " h = F.relu(self.fc1(z))\n", + " h = F.relu(self.fc2(h))\n", + " return {\"probs\": torch.sigmoid(self.fc3(h))}\n", + " \n", + "gen_ber_x__z = Generator().to(device)\n", + "infer_nor_z__x = Inference().to(device)\n", + "\n", + "prior_nor_z = Normal(loc=torch.tensor(0.), scale=torch.tensor(1.),\n", + " var=[\"z\"], features_shape=[z_dim], name=\"p_{prior}\").to(device)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Lossの定義" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle mean \\left(D_{KL} \\left[q(z|x)||p_{prior}(z) \\right] - \\mathbb{E}_{q(z|x)} \\left[\\log p(x|z) \\right] \\right)$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Lossの定義\n", + "from pixyz.losses import LogProb\n", + "from pixyz.losses import Expectation as E\n", + "from pixyz.losses import KullbackLeibler\n", + "from pixyz.utils import print_latex\n", + "\n", + "# 対数尤度\n", + "logprob_gen_x__z = LogProb(gen_ber_x__z)\n", + "\n", + "# 期待値E\n", + "E_infer_z__x_logprob_gen_x__z = E(infer_nor_z__x, logprob_gen_x__z)\n", + "\n", + "# KLダイバージェンス\n", + "KL_infer_nor_z__x_prior_nor_z = KullbackLeibler(infer_nor_z__x, prior_nor_z)\n", + "\n", + "# Lossの引き算\n", + "total_loss = KL_infer_nor_z__x_prior_nor_z - E_infer_z__x_logprob_gen_x__z\n", + "\n", + "# Lossのmean\n", + "total_loss = total_loss.mean()\n", + "\n", + "\n", + "# Lossの確認\n", + "print_latex(total_loss)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### ModelAPIに確率分布とLossを渡し，最適化アルゴリズムを設定する" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "pixyz.modelsのModelを呼び出して使用\n", + "主な引数はloss, distributions, optimizer, optimzer_paramsで，それぞれには以下のように格納します\n", + "- loss: pixyz.lossesを使用して定義した目的関数のLossを格納\n", + "- distributions: pixyz.distributionを使用して定義した，学習を行う確率分布を格納\n", + "- optimizer, optimizer_params: 最適化アルゴリズム，そのパラメータを格納 \n", + "\n", + "For more details about Model: https://docs.pixyz.io/en/v0.0.4/_modules/pixyz/models/model.html#Model" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "from pixyz.models import Model\n", + "from torch import optim\n", + "\n", + "optimizer = optim.Adam\n", + "optimizer_params = {'lr': 1e-3}\n", + "\n", + "vae_model = Model(loss=total_loss, \n", + " distributions=[gen_ber_x__z, infer_nor_z__x],\n", + " optimizer=optimizer,\n", + " optimizer_params=optimizer_params\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "以上でModelの定義が完了した \n", + "目的関数の設定と，最適化アルゴリズムの設定が独立に行えたことを確認できた \n", + "次に実際にtrainメソッドについて確認し実際に学習を行う \n", + "Model Classのtrainメソッドでは以下の処理を行なっている \n", + "source code: https://docs.pixyz.io/en/v0.0.4/_modules/pixyz/models/model.html#Model.train\n", + "1. 観測データであるxを受け取り(.train({\"x\": x}))\n", + "2. Lossを計算し\n", + "3. 1stepパラメーターの更新を行い\n", + "4. Lossを出力 " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "```python\n", + "def train(self, train_x={}, **kwargs):\n", + " self.distributions.train()\n", + "\n", + " self.optimizer.zero_grad()\n", + " loss = self.loss_cls.estimate(train_x, **kwargs)\n", + "\n", + " # backprop\n", + " loss.backward()\n", + "\n", + " # update params\n", + " self.optimizer.step()\n", + "\n", + " return loss\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 学習を行う" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 0, Loss 199.86109924316406 \n", + "Epoch 1, Loss 147.0438690185547 \n", + "Epoch 2, Loss 126.67538452148438 \n" + ] + } + ], + "source": [ + "epoch_loss = []\n", + "for epoch in range(3):\n", + " train_loss = 0\n", + " for x, _ in train_loader:\n", + " x = x.to(device)\n", + " loss = vae_model.train({\"x\": x})\n", + " train_loss += loss\n", + " train_loss = train_loss * train_loader.batch_size / len(train_loader.dataset)\n", + " print('Epoch {}, Loss {} '.format(epoch, train_loss))\n", + " epoch_loss.append(train_loss)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "以上で学習を行えることを確認した \n", + "Pixyzでは高度なModelAPIとしてVAE, GAN Modelを用意しており，ただ入力データの変更やDNNのネットワークアーキテクチャーを変更したいだけの場合は高度なModel APIを使用することで簡単に実装することができる" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 高度なModel APIの使用\n", + "高度なModel APIを使用すると，簡単にモデルを定義することができる\n", + "必要となる実装は \n", + "- 確率分布の定義\n", + "- (追加的な目的関数の設定)\n", + "- 最適化アルゴリズムの選択 \n", + "\n", + "である, ここではVAEモデルを例に高度なModel APIを使用して実装する流れを確認する" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "from pixyz.distributions import Normal, Bernoulli\n", + "from pixyz.losses import KullbackLeibler\n", + "# 高度なModel API VAE\n", + "from pixyz.models import VAE" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 確率分布の定義" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "x_dim = 784\n", + "z_dim = 64\n", + "\n", + "\n", + "# inference model q(z|x)\n", + "class Inference(Normal):\n", + " def __init__(self):\n", + " super(Inference, self).__init__(var=[\"z\"], cond_var=[\"x\"], name=\"q\")\n", + "\n", + " self.fc1 = nn.Linear(x_dim, 512)\n", + " self.fc2 = nn.Linear(512, 512)\n", + " self.fc31 = nn.Linear(512, z_dim)\n", + " self.fc32 = nn.Linear(512, z_dim)\n", + "\n", + " def forward(self, x):\n", + " h = F.relu(self.fc1(x))\n", + " h = F.relu(self.fc2(h))\n", + " return {\"loc\": self.fc31(h), \"scale\": F.softplus(self.fc32(h))}\n", + "\n", + " \n", + "# generative model p(x|z) \n", + "class Generator(Bernoulli):\n", + " def __init__(self):\n", + " super(Generator, self).__init__(var=[\"x\"], cond_var=[\"z\"], name=\"p\")\n", + "\n", + " self.fc1 = nn.Linear(z_dim, 512)\n", + " self.fc2 = nn.Linear(512, 512)\n", + " self.fc3 = nn.Linear(512, x_dim)\n", + "\n", + " def forward(self, z):\n", + " h = F.relu(self.fc1(z))\n", + " h = F.relu(self.fc2(h))\n", + " return {\"probs\": torch.sigmoid(self.fc3(h))}\n", + " \n", + "p = Generator().to(device)\n", + "q = Inference().to(device)\n", + "\n", + "prior = Normal(loc=torch.tensor(0.), scale=torch.tensor(1.),\n", + " var=[\"z\"], features_shape=[z_dim], name=\"p_{prior}\").to(device)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 目的関数の正則化項の設定" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle D_{KL} \\left[q(z|x)||p_{prior}(z) \\right]$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "kl = KullbackLeibler(q, prior)\n", + "print_latex(kl)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### VAE modelの使用・最適化アルゴリズムの設定" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$\\displaystyle mean \\left(D_{KL} \\left[q(z|x)||p_{prior}(z) \\right] - \\mathbb{E}_{q(z|x)} \\left[\\log p(x|z) \\right] \\right)$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model = VAE(encoder=q, decoder=p, regularizer=kl, \n", + " optimizer=optim.Adam, optimizer_params={\"lr\":1e-3})\n", + "print_latex(model)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 学習" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "def train(epoch):\n", + " train_loss = 0\n", + " for x, _ in train_loader:\n", + " x = x.to(device)\n", + " loss = model.train({\"x\": x})\n", + " train_loss += loss\n", + " \n", + " train_loss = train_loss * train_loader.batch_size / len(train_loader.dataset)\n", + " print('Epoch: {} Train loss: {:.4f}'.format(epoch, train_loss))\n", + " return train_loss" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 1 Train loss: 200.3801\n", + "Epoch: 2 Train loss: 147.1353\n", + "Epoch: 3 Train loss: 127.9876\n" + ] + } + ], + "source": [ + "epochs = 3\n", + "train_losses = []\n", + "for epoch in range(1, epochs + 1):\n", + " train_loss = train(epoch)\n", + " train_losses.append(train_loss)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For more higher model API\n", + "- Pre-implementation models: https://docs.pixyz.io/en/v0.0.4/models.html#pre-implementation-models" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Pixyzの実用例\n", + "さらに複雑なモデルの実装例は以下のリンクにある\n", + "- Pixyz examples: https://github.com/masa-su/pixyz/tree/master/examples\n", + "- Pixyzoo: https://github.com/masa-su/pixyzoo\n", + "\n", + "\n", + "1. Distribution APIで柔軟にニューラルネットワークを用いた確率分布を定義\n", + "1. Loss APIではDistribution APIで定義した確率分布をもとに, Lossの設計を行う\n", + "1. Model APIではLoss APIで定義した目的関数と, 学習する確率分布を受け取り，最適化アルゴリズムを設定\n", + "1. Model APIで定義したモデルで学習を行う\n", + "\n", + "という基本的な実装の流れはどのモデルでも変わらない" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/tutorial/tutorial_figs/pixyz_API.png b/tutorial/tutorial_figs/pixyz_API.png new file mode 100644 index 00000000..2f038a70 Binary files /dev/null and b/tutorial/tutorial_figs/pixyz_API.png differ diff --git a/tutorial/tutorial_figs/vae_graphicalmodel.png b/tutorial/tutorial_figs/vae_graphicalmodel.png new file mode 100644 index 00000000..3e8900a1 Binary files /dev/null and b/tutorial/tutorial_figs/vae_graphicalmodel.png differ diff --git a/tutorial/tutorial_figs/vae_loss_API.png b/tutorial/tutorial_figs/vae_loss_API.png new file mode 100644 index 00000000..f915999f Binary files /dev/null and b/tutorial/tutorial_figs/vae_loss_API.png differ diff --git a/tutorial/tutorial_figs/vae_loss_EN.png b/tutorial/tutorial_figs/vae_loss_EN.png new file mode 100644 index 00000000..25eda419 Binary files /dev/null and b/tutorial/tutorial_figs/vae_loss_EN.png differ