cycle-gan-using-pytorch.ipynb

{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.7.12","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"\n## makin a gan","metadata":{}},{"cell_type":"markdown","source":"The followig is an architecture of a cycle gan, here am using a data set of handwritten images 28x28 and trying to generate A's from B's and the other way around,the scope of these are far more than this but as i was starting it out i thought i'd approach it slowly ,also took inspirations from lotta other kaggle notebooks too, and i'll be trying to dig deep and do more better stuff from this sort of an architecture.\nso, feel free to discuss anything related ,and if you got any ideas or advices please share.\nenjoy..","metadata":{}},{"cell_type":"code","source":"import torch\nimport torchvision\nimport torchvision.transforms as transforms\nimport torch.nn as nn\nimport torch.nn.functional as F\nimport torch.optim as optim\nfrom torch.autograd import Variable\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport math\nfrom torch.utils.data import DataLoader ","metadata":{"execution":{"iopub.status.busy":"2023-10-17T12:20:05.041442Z","iopub.execute_input":"2023-10-17T12:20:05.041625Z","iopub.status.idle":"2023-10-17T12:20:05.055040Z","shell.execute_reply.started":"2023-10-17T12:20:05.041603Z","shell.execute_reply":"2023-10-17T12:20:05.054517Z"},"trusted":true},"execution_count":9,"outputs":[]},{"cell_type":"code","source":"import warnings\nwarnings.simplefilter('ignore')\n%config Complete.use_jedi=False","metadata":{"execution":{"iopub.status.busy":"2023-10-17T12:20:05.055644Z","iopub.execute_input":"2023-10-17T12:20:05.055884Z","iopub.status.idle":"2023-10-17T12:20:05.072066Z","shell.execute_reply.started":"2023-10-17T12:20:05.055846Z","shell.execute_reply":"2023-10-17T12:20:05.071465Z"},"trusted":true},"execution_count":10,"outputs":[]},{"cell_type":"code","source":"device=torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")","metadata":{"execution":{"iopub.status.busy":"2023-10-17T12:20:05.072837Z","iopub.execute_input":"2023-10-17T12:20:05.073000Z","iopub.status.idle":"2023-10-17T12:20:05.082724Z","shell.execute_reply.started":"2023-10-17T12:20:05.072981Z","shell.execute_reply":"2023-10-17T12:20:05.082109Z"},"trusted":true},"execution_count":11,"outputs":[]},{"cell_type":"code","source":"\n#loader function\nclass data_load:\n    def __init__(self,url,mode='train',trans=None):\n        data=np.loadtxt(url,delimiter=',',skiprows=1,dtype=np.float32)\n        A=data[:,1:][data[:,0]==0]\n        B=data[:,1:][data[:,0]==1]\n        A=A.reshape(A.shape[0],28,28)/255\n        B=B.reshape(B.shape[0],28,28)/255\n        \n        if A.shape > B.shape:\n            limit= B.shape[0]\n        else:\n            limit=A.shape[0]\n        index=int(math.floor(limit*(4/5)))\n        if mode=='train': \n            self.A=A[:index,:]\n            self.B=B[:index,:]\n        elif mode=='test':\n            self.A=A[index:limit,:]\n            self.B=B[index:limit,:]\n        \n        \n        self.len=self.A.shape[0]    \n        self.trans=trans\n        \n    def __len__(self):\n        return self.len\n    \n    def __getitem__(self,index):\n        A=self.A[index]\n        B=self.B[index]\n        if self.trans is not None:\n            A=self.trans(A)\n            B=self.trans(B)\n        return A,B","metadata":{"execution":{"iopub.status.busy":"2023-10-17T12:20:05.083507Z","iopub.execute_input":"2023-10-17T12:20:05.083672Z","iopub.status.idle":"2023-10-17T12:20:05.094463Z","shell.execute_reply.started":"2023-10-17T12:20:05.083652Z","shell.execute_reply":"2023-10-17T12:20:05.093863Z"},"trusted":true},"execution_count":12,"outputs":[]},{"cell_type":"code","source":"##loading the data and apropriately transforming\n\ntransformations=transforms.Compose([transforms.ToTensor(),\n                                    transforms.Normalize(0.5,0.5)\n                                   ])\ntrain_data=DataLoader(\ndata_load(\"../input/az-handwritten-alphabets-in-csv-format/A_Z Handwritten Data.csv\",\nmode='train',\ntrans=transformations),\nbatch_size=20,\nshuffle=True)\n\ntest_data=DataLoader(\ndata_load(\"../input/az-handwritten-alphabets-in-csv-format/A_Z Handwritten Data.csv\",\nmode='test',\ntrans=transformations),\nbatch_size=20,\nshuffle=False)","metadata":{"execution":{"iopub.status.busy":"2023-10-17T12:20:05.095253Z","iopub.execute_input":"2023-10-17T12:20:05.095489Z","iopub.status.idle":"2023-10-17T12:24:32.398394Z","shell.execute_reply.started":"2023-10-17T12:20:05.095466Z","shell.execute_reply":"2023-10-17T12:24:32.397647Z"},"trusted":true},"execution_count":13,"outputs":[]},{"cell_type":"code","source":"# discriminator\nclass Discriminator(nn.Module):\n    def __init__(self,in_channels):\n        super().__init__()\n        self.main=nn.Sequential(\n            *self.block(in_channels,64,norm=False), #28-14\n            *self.block(64,128,norm=True),             #141-7\n            nn.ZeroPad2d((1,0,1,0)),                  #7-8\n            nn.Conv2d(128,1,4,1,1))             #8-7  fianl shape (batch_size x1x7x7)\n                                                                 \n                \n    @staticmethod    \n    def block(in_channels,out_channels,norm=False):\n        block=[nn.Conv2d(in_channels,out_channels,4,2,1)]\n        if norm:\n            block.append(nn.InstanceNorm2d(out_channels))\n        block.append(nn.LeakyReLU(0.2,inplace=True))\n        return block\n        \n    def forward(self,x):\n        return self.main(x)","metadata":{"execution":{"iopub.status.busy":"2023-10-17T12:24:32.399436Z","iopub.execute_input":"2023-10-17T12:24:32.399648Z","iopub.status.idle":"2023-10-17T12:24:32.406488Z","shell.execute_reply.started":"2023-10-17T12:24:32.399616Z","shell.execute_reply":"2023-10-17T12:24:32.405925Z"},"trusted":true},"execution_count":14,"outputs":[]},{"cell_type":"code","source":"class ResidualBlock(nn.Module):\n    def __init__(self, in_channels):\n        super(ResidualBlock, self).__init__()\n        self.block = nn.Sequential(\n            nn.ReflectionPad2d(1), # padding, keep the image size constant after next conv2d\n            nn.Conv2d(in_channels, in_channels, 3),\n            nn.InstanceNorm2d(in_channels),\n            nn.ReLU(inplace=True),\n            nn.ReflectionPad2d(1),\n            nn.Conv2d(in_channels, in_channels, 3),\n            nn.InstanceNorm2d(in_channels)\n        )\n    \n    def forward(self, x):\n        return x + self.block(x)","metadata":{"execution":{"iopub.status.busy":"2023-10-17T12:24:32.408072Z","iopub.execute_input":"2023-10-17T12:24:32.408288Z","iopub.status.idle":"2023-10-17T12:24:32.424610Z","shell.execute_reply.started":"2023-10-17T12:24:32.408257Z","shell.execute_reply":"2023-10-17T12:24:32.424106Z"},"trusted":true},"execution_count":15,"outputs":[]},{"cell_type":"code","source":"#generator\n\nclass Generator(nn.Module):\n\n    def __init__(self,in_channels):\n        super().__init__()\n        #initial convolution\n        self.conv=nn.Sequential(nn.ReflectionPad2d(in_channels),\n                               nn.Conv2d(in_channels,64,(2*in_channels)+1),\n                               nn.InstanceNorm2d(64),\n                               nn.ReLU(inplace=True) #final image of same size,channel_size=64\n        )\n        \n        #downsample to 7x7, chanel_size to increase by doble evry time \n        self.down=nn.Sequential(*self.downer(64,128),\n                                *self.downer(128,256)\n                                \n        )\n        #does't change the size of the image at all\n        self.trans = [ResidualBlock(256) for _ in range(5)]\n        self.trans = nn.Sequential(*self.trans)\n        \n        #upsampling to original image size\n        self.up = nn.Sequential(*self.upper(256,128),\n                                *self.upper(128,64)\n                               \n                               )\n        \n        self.out = nn.Sequential(\n            nn.ReflectionPad2d(1),\n            nn.Conv2d(64,1, 2*in_channels+1),\n            nn.Tanh()\n        )\n    \n   \n    \n    @staticmethod\n    def downer(in_channels,out_channels):\n        block=[nn.Conv2d(in_channels,out_channels,3,2,1),\n               nn.InstanceNorm2d(out_channels),\n               nn.ReLU(inplace=True)]\n        return block\n    \n    @staticmethod    \n    def upper(in_channels,out_channels):\n        block=[nn.Upsample(scale_factor=2),\n               nn.Conv2d(in_channels, out_channels, 3, stride=1, padding=1),\n               nn.InstanceNorm2d(out_channels),\n               nn.ReLU(inplace=True)\n              ]\n        return block\n    \n    def forward(self, x):\n        x = self.conv(x)\n        x = self.down(x)\n        x = self.trans(x)\n        x = self.up(x)\n        x = self.out(x)\n        return x\n        ","metadata":{"execution":{"iopub.status.busy":"2023-10-17T12:24:32.425373Z","iopub.execute_input":"2023-10-17T12:24:32.425536Z","iopub.status.idle":"2023-10-17T12:24:32.436186Z","shell.execute_reply.started":"2023-10-17T12:24:32.425517Z","shell.execute_reply":"2023-10-17T12:24:32.435680Z"},"trusted":true},"execution_count":16,"outputs":[]},{"cell_type":"code","source":"from torchvision.utils import make_grid\n\ndef plot(real_a,real_b):\n    \"\"\"plots the generated images\n\n    Args:\n        real_a (tensor): real image a\n        real_b (tensor): real image b\n    \"\"\"\n    real_a=real_a.to(device)\n    real_b=real_b.to(device)\n    G_ab.eval()\n    G_ba.eval()\n    with torch.no_grad():\n        fake_a=G_ba(real_b[:5]).detach()\n        fake_b=G_ab(real_a[:5]).detach()\n\n        f_a=make_grid(fake_a)\n        f_b=make_grid(fake_b)\n        grid=torch.cat((f_a,f_b),1).to('cpu')\n        grid=transforms.functional.to_pil_image(grid)\n#         grid=grid\n        plt.figure(figsize=(8,8))\n        plt.matshow(grid)\n        plt.axis('off')\n        plt.show()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# criterions\ncriterion_gan=nn.MSELoss()\ncriterion_cycle=nn.L1Loss()\ncriterion_identity=nn.L1Loss()\n\n#changing to device\ncriterion_gan.to(device)\ncriterion_cycle.to(device)\ncriterion_identity.to(device)\n\n#model\nG_ab=Generator(1)\nG_ba=Generator(1)\nD_a=Discriminator(1)\nD_b=Discriminator(1)\n\n#changing them to device\nG_ab=G_ab.to(device)\nG_ba=G_ba.to(device)\nD_a=D_a.to(device)\nD_b=D_b.to(device)\n\n\n#optimizer\nimport itertools\nlr = 0.0005\nb1 = 0.5\nb2 = 0.996\n\noptim_G=optim.Adam(itertools.chain(G_ab.parameters(),G_ba.parameters()),lr=lr,betas=(b1,b2))\noptim_Da=optim.Adam(D_a.parameters(),lr=lr,betas=(b1,b2))\noptim_Db=optim.Adam(D_b.parameters(),lr=lr,betas=(b1,b2))\n\n\n#lr scheduler\nepochs = 30\ndecay_epoch = 20\nlambda_func = lambda epoch: 1 - max(0, epoch-decay_epoch)/(epochs-decay_epoch)\nlr_scheduler_G = torch.optim.lr_scheduler.LambdaLR(optim_G, lr_lambda=lambda_func)\nlr_scheduler_D_A = torch.optim.lr_scheduler.LambdaLR(optim_Da, lr_lambda=lambda_func)\nlr_scheduler_D_B = torch.optim.lr_scheduler.LambdaLR(optim_Db, lr_lambda=lambda_func)\n\n\nfor epoch in range(epochs):\n    for i,(a,b) in enumerate(train_data):\n        a,b=a.to(device),b.to(device)\n        shape=[int(a.size(0)),1,int(a.size(2)/4),int(a.size(3)/4)]\n        real_label=torch.ones(shape,device=device)\n        fake_label=torch.zeros(shape,device=device)\n        \n        G_ab.train()\n        G_ba.train()\n        \n        fake_b=G_ab(a)\n        fake_a=G_ba(b)\n        \n        #loss beetween in _im and out_im\n        id_1=criterion_identity(fake_b,a)\n        id_2=criterion_identity(fake_a,b)\n        main_id=(id_1+id_2)/2\n        \n        #missguiding \n        gan_1=criterion_gan(D_a(fake_a),real_label)\n        gan_2=criterion_gan(D_b(fake_b),real_label)\n        main_gan=(gan_1+gan_2)/2\n        \n        \n        cy_1=criterion_cycle(G_ba(fake_b),a)\n        cy_2=criterion_cycle(G_ab(fake_a),b)\n        main_cy=(cy_1+cy_2)/2\n        \n        gan_loss=5*main_id + main_gan +10*main_cy\n        optim_G.zero_grad()\n        gan_loss.backward()\n        optim_G.step()\n        \n        #trainnig_D_a\n        optim_Da.zero_grad()\n        da_1=criterion_gan(D_a(fake_a.detach()),fake_label)\n        da_2=criterion_gan(D_a(a),real_label)\n        loss_da=(da_1+da_2)/2\n        loss_da.backward()\n        optim_Da.step()\n        #training D_b\n        optim_Db.zero_grad()\n        db_1=criterion_gan(D_b(fake_b.detach()),fake_label)\n        db_2=criterion_gan(D_b(b),real_label)\n        loss_db=(db_1+db_2)/2\n        loss_db.backward()\n        optim_Db.step()\n        \n    lr_scheduler_G.step()\n    lr_scheduler_D_A.step()\n    lr_scheduler_D_B.step()\n    \n    with torch.no_grad():\n        \n        if (epoch+1)%10==0:\n\n            loss_d=(loss_da+loss_db)/2\n            print(f'''\n            epoch = {epoch+1}/{epochs}\n            gan_loss = {gan_loss.item()}\n            subsidiaries:\n            id={main_id.item()} , gan={main_gan.item()} , cy={main_cy.item()}\n \n            total_d_loss = {loss_d.item()}\n            subsidiaries:\n            da={loss_da.item()} , db={loss_db.item()}\n            ''')\n\n            a,b=next(iter(train_data))\n            plot(a,b)","metadata":{"execution":{"iopub.status.busy":"2023-10-17T12:24:32.452146Z","iopub.execute_input":"2023-10-17T12:24:32.452327Z"},"trusted":true},"execution_count":null,"outputs":[{"name":"stdout","text":"\n            epoch = 10/60\n            gan_loss = 1.4407706260681152\n            subsidiaries:\n            id=0.12034732848405838 , gan=0.498893678188324 , cy=0.03401403874158859\n \n            total_d_loss = 0.2111167311668396\n            subsidiaries:\n            da=0.1988537758588791 , db=0.2233797013759613\n            \n","output_type":"stream"},{"output_type":"display_data","data":{"text/plain":"<Figure size 576x576 with 0 Axes>"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<Figure size 684x288 with 1 Axes>","image/png":"iVBORw0KGgoAAAANSUhEUgAAAiAAAADtCAYAAACGYM5fAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8/fFQqAAAACXBIWXMAAAsTAAALEwEAmpwYAAAv8ElEQVR4nO2dedhN5frHb6eRkCJDppMhojIkKoomrtKhQakkiZCiq4HoVGiS5lSkQTmlkkinXFFCKI0qpJRkaNAgRDS/v79+z/ned+9+rL3s9ey1376fv767+91rrb0mT/dYqqioSAghhBBCQvKPfB8AIYQQQv5+cAFCCCGEkOBwAUIIIYSQ4HABQgghhJDgcAFCCCGEkOBwAUIIIYSQ4OzsM5YqVYo1uoQQQgiJTVFRUani/js9IIQQQggJDhcghBBCCAkOFyCEEEIICQ4XIIQQQggJDhcghBBCCAmOtwrGR6lSpYrVIiJRB9zZ7/koCUPzfL837u/zfe8f//j7ri+TuF+yuV+RP//8M6Pt73qNQj/PvmuXpusT4rzEvY/zie8a2d+Dn7M5n2k9L3HviVz9Ht/+cR++a5SJv+fbjxBCCCF5hQsQQgghhAQndggGScJtWBJCLpaS+JtKGml1wxJSqER14ccl9DNbEsI6PkL+O0UPCCGEEEKCwwUIIYQQQoLDBQghhBBCgpOTHJC42FhTIcbLSDrIVdwy6Xj135l85kDlqsw9aolnmu8VPO4Qx5n0PkLcV0m0lkgrIX8DPSCEEEIICQ4XIIQQQggJTl5DMJakXWlxXUssn80faepo+ndyw0alpD8bSdwrvm3mqqt01O+FDoMXStg9TeG1uB20C+Fc0wNCCCGEkOBwAUIIIYSQ4HABQgghhJDgpCoHJC4Y29pjjz2UbfLkyU6//PLLyta1a9dityEisuuuuzrdrFkzZSvpce9cELddca7OLW6zQoUKyrZo0SKnf/rpJ2U7/PDDnd6yZUusfafp/kjTsUQlbj5DaHJ1nBs2bHB6xIgRynbXXXc5vcsuuyjb0Ucf7fRbb72lbBs3box1XLmYvBp3f2m67rnKl8BpytlM9O3Vq5fTffv2Vbavv/7a6U6dOmXcpj1/acpr+X/oASGEEEJIcLgAIYQQQkhwCiYE43MRlS1b1umVK1dm/F779u0j7+/11193+qCDDlK2JUuWOJ1W93A25KpcK1fdJqPiO84zzjjD6UqVKilbtWrVnLZu7e7duzs9duzYWMeVBIVQUieSm+OqUqWK+rxt2zanf//994w2n4s7LnE7oWbDqFGjnB43bpyy7bvvvk4PGTJE2bp06eK0Dd089NBDTttzlgRpeg8m/WzY7e+0005O2/OAtl9//TXjNu33dt75f/80N27cOOP36tSpoz7bf//SDj0ghBBCCAkOFyCEEEIICQ4XIIQQQggJTqntlOZkNOazHW3p0qWVbdasWU7XqFFD2apXrx5rf7/99pvTEyZMULZ+/fo5ne/Yp2//WAIWet9JYO85/IzliiI67t2yZUtla9KkidP2XsJ8ol9++UXZkshxSfoaWXJ9zbJ5D+y+++5O23wGvA4DBw5Utj/++MNpWzZ9/vnnOz19+nRli9uOHPFdn1zlLj344INOb9q0SdlOO+00p2vWrJlxm3iORHR55owZM2IdZ5oI/QzZa+TbB+Yexb0nMFdERP+bVrFiRWXDvKDbb79d2UaOHBnrWKI+x76cKF8OVlFRUbE7oAeEEEIIIcHhAoQQQgghwUltGa51CWGHSuuGrV27ttNVq1aNvA9fFz4sz7Tut/3339/pTz75JOM2C4VsSjzzGXaxbsqPP/7Y6S+//FLZXnrpJadt+dugQYOcvvHGG5Vt6NChTg8fPjz7A/4b4Ls/sIT2zTffVLZJkyY53bt3b2XD8Ix9vsuUKeP0XnvtpWwXXnih0zYEkwuSKH/GMJ+IDrOUL18+8nbef/99p5s2bapsWIZrQzeF+I4KAb7n7X32888/O42l3yK5OZ8TJ05Un9etW+e0TQEYPXq00/ZewndkiPLrHYUeEEIIIYQEhwsQQgghhASHCxBCCCGEBCfxHJC4MVNsRSuiY8RYoiQisttuu0Xa5vr169Xn1atXO42lmSI6lnbeeecpG7Zmx9yUQsIXt0w6RpzNPYHXAdvji4j8+OOPTuOESBGRt99+2+nXXntN2Tp37uz0/Pnzle2GG25wOt8TfXNBEtOFMT9q5syZ6u8wfwPLBUVELr30UqfXrl2rbDjZFXMiRHSJqS07vPbaa7d77GnDtgqwpeCZwOndIvo+tjkg999/f8bthL5Xo+aUxZ2Gm6tyU7TZXBy8r3PV8h8nrtvjwhYAAwYMULaPPvrIaTspF99ntvw66js/5FRiekAIIYQQEhwuQAghhBASnOBluA0bNnQa3a4iuozusMMOU7YWLVo47Qu5WHfR+PHjnf7ss8+UDafa7rPPPhm/Z8twV6xY4fQBBxygbOge296x5ZNclBPGdX3a89m6dWunW7VqpWwYNkOXpYgutV24cKGyzZkzx2nrpmzXrp3Tp59+urLlonQtpAszKexvwHOPped77723+jssmbW/Gye92pDZ1q1bnV68eHHG71n3d7du3ZxetGiRpBU8n5dffrmyYbjZnrNzzjnHaRu6+c9//uP02WefrWz4nrXPG57DfE9VjhoSydUz5As1YKjP3p9YhpsrypUr57T9twnD/r169VK2r776yuk33nhD2T7//POM+4t6PkO+r+gBIYQQQkhwuAAhhBBCSHC4ACGEEEJIcILngDzyyCNON2/eXNmwrfKyZcuUzZbmZWLEiBHq8+bNm53GWLKILr095JBDlM0XKzz++OOdrlWrlrJ16NDB6STihiWBBx54QH3G2La9DliGe8kllygbTiz2teF+9tln1eczzjijWC2ip0mWhFyObPC1vf/mm2+K/Q7mfIjoODqeSxGRpUuXOj1lyhRlwzyF6667Ttnw/njnnXeUbcyYMU4XyvWxv6Fnz55Ov/LKK8qGeQI2/+WOO+7IuA9se49tA0R0DsrcuXOVDXOgMNdNROf+bNiwQdnw3OeqTDUJoua8ZPPuxnboNj/xhx9+cNq2lujfv7/TtlUA5jbZY7n33nudtiMoML/N5pXgtc0m94dluIQQQggpUXABQgghhJDgBA/BvPzyy07bEEy9evWctuWtPpcRuvw+/fRTZTv44IOdtmGcPffc0+lrrrkm8v4qVark9PPPP69sOKG1cePGymanfCKF4j6Oim+6MHYbFdGuXewAKCJyzDHHOG0nVH7wwQdOW/fmSSed5PRFF12kbO+++67T9vpFJd/li7nA/gYMg9jSTezWiefali1jWbN1D/vKZDHUgFNeRXQJPoY4RfzPVD6x5xY7OduySt+zj/f41KlTlQ0nD1sefPBBp7FjsIh+xmxpOx4ntikQ0aEGeyyPP/640xhmFxF56623nPb9Vhu+sO+CTOT7WcR3G5Y/i+jrZ99f+Bw9+eSTyoaTpCtUqKBss2fPLnbfIiKnnnqq07YTMb537XPruy5Jnl96QAghhBASHC5ACCGEEBIcLkAIIYQQEpxS24n9ZDRGjQvZv8N4P+ZgiIhUrFgx0jYtWOpkp3Niq2jbyrhBgwZO27JDJOo0RxFdGnrFFVcoG+a4PPbYY8r23nvvZdymD9/f2jh+rrH79p2nu+66y2nbZh9LbzE/Q0S3ol6wYIGyYU7Bo48+qmwY77S5B0cccYTTtWvXVra4EyN9+MoSc3GN4rbEt1NYt23b5vSvv/6qbJmO0+ZVbdy40WmM/dtt2twDzMXB6yOi49VPPfWUsvXp08fpbOLY+LfZfC9qO2v7vVGjRjmNU4FFdK6Fr2R806ZNyuabxI3nzMb7sX33tGnTlA1z6LA9vohI/fr1na5bt66yYa4d5sGJ6KmstswY8bWMT/oZ2hEwlwP/TRER2WOPPZy2uWhjx451evTo0cqG/zZiabuIzgGx770nnnjCafv84YTkyZMnKxvmXGLriuL2nwnfNSoqKir2hUkPCCGEEEKCwwUIIYQQQoITvAx3wIABTtsppVg66XOr2c5wGNoYPHiwsqFra/jw4cqGpX92Gi6CpWkW64ZF1/Ktt96qbDjFEF1zIn89F4WALwzRuXNn9Rld81hWKaLP4X777adsWJJpy/Ks+xFZvny509bNjFNE45Y/56tsLVvssZQvX97p6tWrKxuWDPqev3vuucdpfPbs/mw5Jnb8xG7CItp1bcMzeO/Y0FBo4l73Tp06Zfy722+/3Wn7jsLQrA2lYLhy2LBhyobdMm3nVZz0iiFjEe1GtyEfDKXYd/Bll13mdM2aNZUNw+K2bLRQOqj6wOtizxmmB9h7HrudWvC82Pcehqznz5+vbPi3NryMnVHtO3H//fd32oZukoQeEEIIIYQEhwsQQgghhASHCxBCCCGEBCd4DsisWbOcPuGEE5QNY5qHHnpoxm3Ydus4EbN3797KhjFjW46JZWV22ifmaNgS3XXr1jlduXJlZcN2wjbeib/vu+++k5IGxiax/FlE5KqrrnLaxtFvvPFGpzFHSERk4sSJTh911FHKhlM+bWnj+PHjnV6/fr2yrVy5svgfkCPy3VbfN9UW4+y25bkv7wOfI/x9NocAnz/bQhpzAWzrfB+Ye2DzSpBscm+iltPm6ns44RdzkCz33Xef+oyl/AMHDlQ2nB5uJ95ivo3NHUmC2267zemOHTsqG5Z756rFQFqxU4Ix58qWIFerVs3p5557TtnwebPP0Yknnui0Ld/Flvh2FALeI3jv5BN6QAghhBASHC5ACCGEEBKc4CEYDEvYSZYHHnhgpG1YdxW6GH1letglTkSXQdnJta+++qrTOJlQRJfK1alTR9kwHGSnUGIZFrrK8k02HU0Re72OO+44p205IW5z6NChyoZlgXaCI3ZYtF0GMZSCnVZFdFm1vUa+boxpJW75p713sWzW1/3Xdj/E56p///4Zt+ErH0SXsC3VxPDPa6+9pmy4D99EXUvczrVRt+nDTnb997//nfFvsSulLYHE8tYuXbooG4a71q5dG+s4cwW+C2zbAiwJthRimMWHDUkuW7bMaezqLKLDZDi9WOSvZc7InXfe6TSGve3+zj//fGWzIRkk6nXIdYsBekAIIYQQEhwuQAghhBASHC5ACCGEEBKcxHNAbGwJ48K2FS1Oym3SpEnGbdqWvdhC2tqw3A9bSIuIzJkzx2lbFjt37lynbTwXS0qxlEpE53189NFHyoa5DvZ7oYk79RXj8djaV0RkyJAhTtsSZDvFFMFSWwu2ke7Ro4eyYRm1LcPFfB87+TFuy+eoU5F9k1ezIe73sHTTlomXLVs24/ewFP2UU05RNmzbfu655zptSzzx2WjatKmyYZ5C9+7dle2CCy5w+qyzzlK2b7/91umo9+32bEm3y7dlxrZlPbJq1SqnsVxXROfJYe6NiH7XhMilwNYE9tpiSbedkIyt9efNm6dsUa9DEr8v7jZ9x9ymTRv1GfOZbCt2vH6+nA8LPnO2/BpzQDB/TkS3hf/www8j7y9J6AEhhBBCSHC4ACGEEEJIcIKX4aLbq3379sr28MMPR9qGDd2ga2vJkiXKVqNGDaexg5yIdheffPLJyjZlyhSnbYdIdOHbqbZYvmgnI2KIye7PlmEhcbsvJgGWBbZt21bZcLqwLUe78sornbad/Xzgubelm7gda8NQXzYTVJMo3UwCPDY7QRjL/WxZM7Jlyxb1+eOPP3Yaw5oiuvwVJ7Ta+xHDLLZj8Z577ul0w4YNlQ2vV9euXZUNyw7zff9HxRfms/cVdvjFcJOIvka5+u24fxsqwmtkw3UYynz55ZeV7e6773bahv0wvJYmfKHSuGFU28kZJ9Lac4YpANmAZc4jR45UNgzlNGrUSNnS2H2bHhBCCCGEBIcLEEIIIYQEhwsQQgghhAQneA4IYnMkMG/Axtw2btzo9LZt25QNY/zTp09Xtrp16zqdzQTOuGApI07/FBE54ogjnM4mLpqLMs64k0Jr1aqlbFgC1qFDB2XD/JdTTz1V2bAMEdvcbw+MpdsWz2+88YbTNp8B4632fkHynVMQd/+YG2MnQPtGGuAzVqZMGWU79thjI+0by0azoVmzZk5XrVpV2V566SWnx40bF2v7+QavpS3dx/i7LcHH99LmzZsTOrr/gWWxtt0Btu+2k4fx/WXbimMe3oQJE5Rt9uzZ8Q82T2TzXO61115OY66biM5rPPvss5XNTrKNCuZ5TJ06VdnwubL5ibZEOA3QA0IIIYSQ4HABQgghhJDg5DUEg+EKEe2+stNU0e00aNAgZcMytmHDhimbb+JnLnj77bfV5/HjxzttJ1TOmjXLaTvVE8vfkiCuq9+WilnXOTJw4ECnbRdYn9s+avmb7bqJNjvpET/bya5JhF2SLtm120f3+Jlnnpnxe7YcGkM3Sd9zFuzMiF0ZRfQzvXXrVmXLd5gsDvbc9urVy+mnn35a2ZYuXeq07SAcFV/HYltOi51Kbfk/hjJtt9MqVao4bd8DLVu2dDput9oQZe9J3EsYysQuwSIi999/v9PYXXtHjgXD0rZzLr53bffp119/Pdb+koQeEEIIIYQEhwsQQgghhASHCxBCCCGEBCevrdhtzA/zKTp27JhxG7bEbdKkSU7bUkIsw23QoIGylS9fPuOx+NiwYYPTthQVJxz6sDHiNMW5MWa8YMECZcNSMltm/OKLLzq9Zs0aZYv6+3xTS21uAJa/2TbDmLtiY9lRW9v7jiX0dFULltraPCdsa25LnnEcAP5dCLA1uy21xfbdK1euDHZMuQTvAfuuueSSS5zGkmMR3a47iWPBd6CIyIoVK5yeP3++smGJri2lxzJq2wIcSdO7LARfffWV0y1atFC2xYsXO51EiTVOWBfR403wWoroHJRcTeje0fcePSCEEEIICQ4XIIQQQggJTvAQjM9lE9Ut5HMdr169Wn2+7777nH7hhRciHwuWbtrjQtekDbmUBPfj0KFDnW7durWyffHFF07bsIctO0ZyEaKwHSRbtWrltD3vvm6rUa9Rmqfh4vRfLFEXEenfv7/TPXr0ULZRo0Y5nc3E1lzc1zNmzHDaho2wxDruvtJ0vewEZrxGdir3tdde6zR2DBbRLnb73sN3lK8M194DzzzzjNN2MvUhhxzitC17t+5+JBf3R77DmlHx/VabOlC/fn2n7cTuzz77zGn7DEfFXqOFCxdGOs4knu840ANCCCGEkOBwAUIIIYSQ4HABQgghhJDglNpOnCijMW58LmoJZNxt2uPCcszGjRsrG5Zx2nbdWH5qY+Xz5s1z+vrrr1e20PHrbOL4Uf+uZ8+eTmPJsYhut96tWzdl88WI41K6dGmnp02bpmxYjo2lcCI6FwhzWiy5ipP6znUS1wjLVitWrKhsGFu2uQiFQOhcgFxcH/u32F5d5K9luQhOde7Tp4+yYdm0fUdFxbYtwPMb9/4IkTOA59N3jXC8wPZI+rjt/dKpUyenbbn1mDFjnI47LiKJZyObcxT1GhUVFRV7oPSAEEIIISQ4XIAQQgghJDglIgSTafsiuqvn8uXLlQ070x100EHK1rZtW6fXrVunbMuWLXPaup1KQggGP1v3Zlw3cNTjsjbs5temTRtlw/BQuXLllO3777932rrD45KmEExU0loWnqYSyyRCMDfddJOyYSjRlmPivdqvX7/I+/N1lY5Lmu6XqO593/vLEjoEg6G3CRMmKNuRRx7ptJ1anc9SdIZgCCGEEFKi4QKEEEIIIcHhAoQQQgghwQmeAxKapI8z3zHTuHkJcf4uV/srVHI1QRKJWkKY7/ss14S4V6LmSOQqByQX37Mk8byFyL3L9f6yOQ+5yDPMVavyqNco9DXxkcR7jjkghBBCCEkNXIAQQgghJDjBp+H6SKJEN26pWklweYd2/0V1k8btdJnm8E8+S//ySb7Pe1oJMYk06W6ZJf3aFurvy3f301xCDwghhBBCgsMFCCGEEEKCwwUIIYQQQoKTqhyQkhwrF0m+Db3Fl/8S+lxvp0Qr4JHEJ3TMOHQ75rTk2CSRPxF6wq6P0JNks7HFJYm28KHfl/mkJLbSjwI9IIQQQggJDhcghBBCCAlOqkIwJaGUMW730TR1wkuCpEuC0+RiJztG3Am0JZ00/9Z8HluIcFOhhIOS7n6a63+j6QEhhBBCSHC4ACGEEEJIcLgAIYQQQkhwYk/DJYQQQgjZHpyGSwghhJDUwAUIIYQQQoLDBQghhBBCgsMFCCGEEEKCwwUIIYQQQoLDBQghhBBCgsMFCCGEEEKCwwUIIYQQQoLDBQghhBBCgsMFCCGEEEKCwwUIIYQQQoLDBQghhBBCgsMFCCGEEEKCs3PcL5YqVexwu5zh275vgm+u9hGXXB0b4jvOP//8M9b3kiDq/pI4Rz5CnwdLmq4R+SvbmQge8EjSRYh3cFR8+/vHP6L/f3QujjubeyL0econcX4rPSCEEEIICQ4XIIQQQggJTuwQTCESwp2K+8iV+w23k2+XcL73TwgJQ0kIH5SE31CSoQeEEEIIIcHhAoQQQgghweEChBBCCCHBSVUOSNL5BTYeGHd/+Ywrpjmm6ctVSes5y6bUkPkvhBAfaX4/pxF6QAghhBASHC5ACCGEEBKcVIVgQrvw6S7LnqjnLHRH2Lj7C/29vzOF0nm4UMjF+SwJ5y9NXVlzRSGmB8SBHhBCCCGEBIcLEEIIIYQEhwsQQgghhAQnVTkgSKHFsoqDUxN3nLSWvqapzDgucX8Dfs9uo1u3bk5fffXVyrZ+/XqnW7ZsmXH7v/76q/p87733Or127dqMtkK5Btnc0zjptUKFCso2evRop2+77baM22jTpo36/MADDzhtzzVSKOfTEnqKb9z94fd23ln/U3zWWWc5fd999ynb448/7vQtt9yibKtWrYq071yxo6NH6AEhhBBCSHC4ACGEEEJIcEptx0WU0ZhW13gIfL+9fPnyTs+ZM0fZqlWr5vRbb72lbCeffLLTvg6c1ha3y2do4h5LjRo1nD7uuOOUrW/fvk4fddRRyvbbb7/F2l8S/PnnnxltSV8j3/bjhmDKlCmT0TZ37lyn69Wrp2z4bPiwx/H77787feWVVyobhiGSKKnO1fXB7VSsWFHZxo8f73T16tWVrXbt2k63atVK2TDE1a5dO2X76quvnL700kuV7dhjj3V67NixyrZp06Zij18kvd2MMUy1I9uJS9x7BL/Xtm1bZZs5c6bT9pj/+OMPpzEcIyJy8cUXO23fgUn/dt97rqioqNiTRA8IIYQQQoLDBQghhBBCgsMFCCGEEEKCwxyQDPh+H5Yafvnll8o2adKkjN/bZZddnMY4nojIPvvsE+m4CiUHxO4bf3vZsmWVDUsr582bp2yVK1d2+t1331U2/O1Lly5Vtqefftrp2bNnK9sxxxzj9Lffflv8D8ghacoBGTZsmNPPP/+8sp144olO29yA+vXrO71161anFyxYoP7Olx/iI+p9vHnzZmXr3Lmz06+++mqi+84G3/3fvHlzZZsyZYrTVatWzbhN331kbbj/n3/+Wdn69evn9F133aVsmIu2cOFCZWMOSPHguT766KOVDd9LWIYuInLzzTc73adPH2XDa/T6668r2zPPPOP03nvvrWzbtm1z+qCDDlI25oAQQgghhAgXIIQQQgjJA6nthBqCqCWKtpzpxx9/zLiNGTNmOG1LbbFs7ptvvsnuYAsAPBe2C+bgwYOdfvHFF5UN/xZDLiIiEydOdLpmzZrKtueeezptwwm//PKL07vuuquyffTRR04fccQRyrZ8+XIpdPA64HkX0S5+WyaOoSos1RQRadCggdMDBw502hdy8ZXTfv3118pWunRpp23HTwxflCtXTtlWr17tdJq702LYceXKlcpmf28mPvnkE/W5SZMmTtvwJJY816pVS9kmTJjg9Oeff65s77zzjtO2jHrFihVOp+nchsbeZyNHjnT6nHPOUbbrr7/e6Q0bNihbw4YNnbbdTidPnuy0Dde3bt3aaVuGi+8ve93xWUkL9IAQQgghJDhcgBBCCCEkOFyAEEIIISQ4BZMDsqNT9+w2LDb3YK+99nLalmqOGzfO6S1btijb3Xff7TTmKIiIXHjhhU7/8MMPEY64cLGlY1OnTnV6wIAByob5GjbeifF/O7nz7bffdtrG0XHi55lnnqlsWF64ePFiZdttt92kJLFu3Tr1+YYbbnDali927NjRaSxVFtH5G/a+RvDZxHwoEZHjjz/e6SFDhigbTvW0zxQ+ixYcb5DGGPf/g/dur169lO3yyy93Gqf7iugS2ueee07Z/vnPfzrdpUsXZVuzZk2xWkS3gq9bt66yYX7Wfvvtp2yNGjVyGp9ZkdzkhISeYhuXnXbaSX0++OCDncb7UURPp7XjIh599FGnn332WWXz/V7MSbTPKV7bAw44QNlOP/30SNvPhh3dDj0ghBBCCAkOFyCEEEIICU7BhGCQuN0Jrcu5e/fuTrdo0ULZsDwTy25FREaNGuW07TKILFmyRH3GrnUYqrGkyd2YDXjctvuo/ZwJe23R/W5Le3Hipw3B4LH861//yrgPDAvkitDXz54zLFXdd999lc3XNRLDXzYUhWWy+PtsGSe6oPE5ERE5++yzi92eiMjOO//vVeSbZIyhIBGRN998s9jjyjf2mvTv399p64rHbsr2e3he7H2M978ta8ay9N69eyvbI4884rR9bo488kinsYRURE9avf322+XvBF4Xez4xDGI79eI7f9CgQcp24IEHOh23w7V9r5500klO23BQEuxoagQ9IIQQQggJDhcghBBCCAkOFyCEEEIICU5B5oBkA06ZtdMBb731VqdtvHrmzJlOv/DCC5H3hyV2NpaNE0bHjBmjbGmKX4cG8xKaNm2qbFi+a1vbb9y40Wl7/RCbz4D7q1GjRsbvFeo1Oe+885zu0aNHxr+zvw/LC22uCE66xHJXmwOFOQW2pBqx1wRbWNvnDfe9aNEiZTvjjDOcfuqppzLuLzR9+/ZVn/Hds/vuuysbXi8ftWvXVp/xGs2aNUvZ8DNODBbR+W22VLpKlSpO2zb7Nhcu1xTK82bHNWCrAAu2xLf3J7a292HzgvAzjqoQETn11FOdfuihh5QNn5W0QA8IIYQQQoLDBQghhBBCglMiQjBHH32003aq4Pvvv+90+/btlQ1dUvPnz1c2XykgYicO4oTDefPmKdsTTzzhdKG4G5PAut8//PDDYrWIyLZt25y2LmA7yRbBcIItscZz36pVK2WzLs1CZNiwYU5nM602aonutGnTnLYTWn1hF7wmGP4UETnkkEOctvcHdhG1bmzbQTIttGvXTn3Ge9V2drWdNREsO8ZyXRGRSZMmOe0Ljzz22GPqM4aA7NRjDHF17dpV2Ro3bpxxH2kliffszTffnNFmwzHdunVzGruUikQvtbUhGAytnHDCCcqGZfFDhw6NvL98QQ8IIYQQQoLDBQghhBBCgsMFCCGEEEKCU5A5IE2aNFGf77nnHqfr16+vbDi5c+nSpcr2zjvvOG1zPjBe5muP3KZNG2XDCZUvvfSSsuH01jTG45IEr8Nll12mbBjzx8mSInqqrS/2asE21dgOWUTkoosucvrBBx9UtkK8Lvb+xFgz5tBYfDkf9nnAHAOcymqnHvuOC3NxbPknTuq0pb0DBw502pZA2gnJacFOvMXfMHz4cGXzjZbAnAJbMh53cjOe38mTJysbTrm1zw2+61577TVlw/usEJ+hbDjllFPU57Vr12b8W2wPYPMMEZs7gvmJ9t80HB+xbNkyZcNpxp999lnG/cUl7hiUTNADQgghhJDgcAFCCCGEkOCkNgTj6/5mO/vtv//+TlvXMYZd7DRJn/vW52qqVKmS09athq7/V199NfL2S4LbEn+T7fY4ePBgp23JYOXKlZ2eO3eust12223Fbl9Eu6Dr1aunbCNGjHC6Y8eOyoZliYV63vFcHH744cqGn30lnhbsOGrDIBg2wLCLLXvHTpodOnRQNgx52vJnPE57TXr27Om0DSnZfaSFn376SX3GLr4LFy5UNhvGRTDca99X+BzZqbbYJdiCzw0+JyK6Q7N9hjEkY0uJfaG+kkajRo0i/y2Wibds2VLZXnnlFadtegCWpe+6667KNn36dKffffddZUt6SrF9Nnc0JEMPCCGEEEKCwwUIIYQQQoLDBQghhBBCglNqO+1gMxpzXY6zvW1iCaaN6WN81bYW3rRpk9M44VZE5JhjjnHatq3F+JwtV8S/tbZ7773XaRuz3bJli9Nxcw/s96K2800CX56OLUFet26d01hyKaLjx5dccomyzZkzx+lVq1YpG05+bNCggbItWbLEaTthd+TIkZKJJHJCkrhG+D0b/8fcozp16igbxpO//fZbZcPrYCevYo4G5or4jitX9x+ev9mzZysbtrr+7rvvdnj7llz9BtyOHdFw2GGHOe0rjbZgDghO/RYROeqoo5y2JbOYV2InhGOJtS0NxetuW83/8MMPTn/99dfKlotnyrcNe86SeIbx+tn8HsypwTJmEf3OsmWxmLtYt27dyMeCzynmHIro0Qv2GcbzkqtzhOfF914oKioq9kGiB4QQQgghweEChBBCCCHByWsZrs+Fj25JEe2ustMd7777bqdtGdKKFSucvuaaa5StdOnSxW5DRKRfv35Oo6tfRE8j3Lp1q7Jhl03r5sJyu/POO0/ZMESRjUs4aXejD+v6xK6l5cqVU7ZmzZo5fdVVVylb69atM27zgw8+cPq///2vsj355JMZv4dliLgNEX394rrt8w26WrETsIjIAQcc4LTPPb3HHnsoG3ZQjTqh1d7/uE27DTwW665FtzJuX0T/VtsF+cYbb3S6T58+GY85TWBpuYh+HuzkZh9YJmtLe/HZwCncIjoUYMMJhx56qNNvvvmmsmHprQ3r9O7d22kMiYuIrFmzxulCLXtHcAqxiMi5557r9IABA5Rt8+bNTuN5ENHPLb7/RXR5rX2OrrjiCqcx1Cyiz68txcZu1HFhJ1RCCCGEFDxcgBBCCCEkOFyAEEIIISQ4wctwfd/D9rPVq1dXNozv2lbsf/zxR6xjwZi3bdP+ySefOG3LHDE+980338Tat22vG3WqZxJluL6/szaM42PsU0TnHvTv31/ZsBU7tuQW0eXJgwYNUjZs9W1/64cffljsNkR0C2R7v6xevTqjzU6XjEOIUmlsPW9zH7CU2caPcX+23Trek75yUDzXGzZsUDZs1405VnbfmLshIjJlyhSnr7vuOmU78cQTnba/B4/FPqdR8w1Cl7JjGayIyHHHHee0zXPy5eKccMIJTl944YXKhseNU7hFRK6++mqn7T2A57Nq1arK5rsn8P1l81jwnliwYIGy5eIahSjDxfwJm/+CJbTdu3dXtqlTp+b8uDDPqn379sqGeYb2+cN3ctxj8T0PLMMlhBBCSEHABQghhBBCgpN4Ga7PZVOrVq2Mf3vppZcqG5Yz+UIu2bhT169f77TtUoeuMyzlFflrF8Co+0eihlySwndd0MWH7lMR7dazrs+TTz7ZaXQPi+iwi29y5gUXXKA+169f32lfZ8ayZcsqG5YTHnzwwcqGLlNbtj127FinbRli3HBbEtx6661ON2/eXNnwvPjc5osXL1afsaTvwAMPVDY8T2eddZbTtowTJ/HaMAuWan766afKhl1Za9asqWz4vNuQxMcffyyFhn1/YcdK20EYnyP7PQxV2RAyvtvsc/Poo486Xb58eWXDLtN2Qit2o7b3B+7DtjvA9zyW3KcZ+34cNmyY0/b+xGcRQ78iuek+ao8F/+2wE3bxXA8ZMiTW/nzkOrxFDwghhBBCgsMFCCGEEEKCwwUIIYQQQoKTSBmuz4atam3exdNPP+20bS+NcTacvLgjdOjQodjti+jW73hcIn8tP0WixsiyKe/zbTNqzks21wtj9zjdV0RPkj3ttNOUDeORdiKmLdcMyZlnnqk+33TTTU5XqVJF2TC+imXaIjq3wp53PIchSqUHDhzo9B133BFpG/ZYjjzySGWrXLmy0zhRV0RPlfaBpbw9evRQtp49ezpt20JjzoKNsWPZ6rRp05QNc39w+yLpLcO128R8N5sjgXlVFjxP9jfY1t5xsLkjWMa57777KluvXr0yHgvmBdl8ujSV4fquNeaR2VbzmEtlczKSOC4cDTJ69Ghl840l8b2/csF2/p1iGS4hhBBC0gEXIIQQQggJTvBpuDgx1U7rQ1cadkUVEfnxxx9j7Q+3ec455yhb3759na5Ro4ayYcjAupJzgc+Fb/G59334tolubev2nTNnjtMrV67M+D07tRRL1Wx55osvvui0LVXD8sIkXIO4bxFdSty2bVtlw3tk7dq1yma78yKhp3w2atQo1vfwnsCOmCIiEydOdNp2yMyEdX/XqVPH6VtuuUXZcHqr7Qbqu1ex/BmPUUR3JS7USas44Rcnzm4P7BpsOytjN9y4naJ/++039Rnd/dj1WERfFzutHENMOC08V4SYCH7llVdm3F8uSsF997+9tk2bNnXaTrRu0KCB07YzaRqfD3pACCGEEBIcLkAIIYQQEhwuQAghhBASnOBluOXKlXMa2y+LiPzyyy9OY9tmEZGZM2c6bfMLEBunx33gFFQRXQpoy0T322+/Yo9rR8BznavyPt8EQozPY5xZRGTMmDFO23wCLG30Hacto8a20XaqJx5nt27dlA1LBkeMGKFsOA3XXiOc3GlzCsqUKeM0tmUXEbn88sudtuWgGDu3Uy/xPsgmnppEGS6WSuO0WBGRSpUqOW1/H+btdOrUSdnwPNnyPswjwJi0vV447bRhw4bKNmrUKIkDPvv2WcSSxLgx7nyX4eJoALx2Ivp82u/hM2XLkzGPa/z48cqWi/eZLdF95JFHnLbHuWjRIqdtaWiaSqVxO/vss4+yvffee07bvCcs5bcTaOOO3MDzi2NIRHR+1tChQ5Xt/vvvdzqbdgBR4TRcQgghhBQ8XIAQQgghJDiJhGB8f4cuYQzHiGhXnXVl4YRF24UPy2SXL1+ubNiZDrstiujyvhYtWiibz52UJqKGYHzYvxs+fLjTNtyFk2zRPSyip6liyaWI7qBqrzuee5zUKSLSr18/p5ctW6ZsOKl38ODByoYdJNesWaNsGPJ55plnlC1u11kfSbiP8Zo99NBDylavXj2ncXKtiMiqVaucttcozj2Prn4RXRZYrVo1ZbOfozJu3Din7fONoaI0XZ9sQHf7G2+8oWxYCmtbE+Cx2WuH3TqbNWumbFh2b9sb4LThxo0bKxuWotpJyr5WBXgP2lBRWkMwrVq1Urbp06c7/eSTTyobhlnsBGgMc86YMUPZMMzTtWtXZcP3ku1KjM8AhiBFRL744guns+nWnItzyBAMIYQQQgoCLkAIIYQQEhwuQAghhBASnMRzQLL5Hk7Kve666zJ+D+OUIjoG9/333yvbDTfc4LSdYoixtNBtakOU4SZxjZBctYWPii39w5JrnFYpoicd2/JPmxOChJ4SmYvzkk0bZyyn9bXojjtlGdtS2wm6zZs3z7hNxJYuYhnpxRdfHPk4o5LvHBDcB+bviOgySztpFXOpLrvsMmXDlgM2BwTzdOxE5Hbt2jmN5fgify11z8S1116rPmNJPuaJZUPoHBDMOxIR6dy5s9O2HQDmhNhW81u3bnXa/puG76yOHTsqW4UKFZyeP3++smELhVdeeUXZkpgEHBXmgBBCCCGkIOAChBBCCCHBSVUIBl3stgQMy43ef/99ZcNypocffljZ7MRWJI3TAbeHrxvi9v620Eni94S4B/Lp4vdtP4nOiBgevfPOO5WtV69eTlt3Ppab1qxZU9msyxspCSGY0PvD92ybNm2UDUM5xx57rLJh6bcNr5UvX95pDB+IxO8gjIQOwdjQFE5Ox/tYRHddti0GsIuvnVyLTJo0SX3GdIQuXboo2wsvvOB0rt5fDMEQQggh5G8DFyCEEEIICQ4XIIQQQggJTqpyQHJBrsqQ0pof8nfOAbGk9V7KZjsl/RohSZR354I0Xx9f++yk9xeXQixlz2abSbQxTxNxzzVzQAghhBBSEHABQgghhJDgRGtttx1CuKCScOv5jjvp8kUfaXLppelYQpOr357WcF5oeB6yJ03hqLSSxLs6m+8VahdtJF/XnR4QQgghhASHCxBCCCGEBIcLEEIIIYQEJyc5IIVCmvMZ0nRsaTqWQiGfsfPQ1ytNeQL5zNUqFLK5P0Ln2kXFd1xpKk/O9z0Xt2w7X+98ekAIIYQQEhwuQAghhBASnJyEYHLl6sm3+4qQQoFhMhKVfL9X89m2IN/TrpPeX6F08M4EPSCEEEIICQ4XIIQQQggJDhcghBBCCAlO7Gm4hBBCCCHbg9NwCSGEEJIauAAhhBBCSHC4ACGEEEJIcLgAIYQQQkhwuAAhhBBCSHC4ACGEEEJIcLxluIQQQgghSUAPCCGEEEKCwwUIIYQQQoLDBQghhBBCgsMFCCGEEEKCwwUIIYQQQoLDBQghhBBCgvN/97cI9Q3/UZYAAAAASUVORK5CYII=\n"},"metadata":{"needs_background":"light"}},{"name":"stdout","text":"\n            epoch = 20/60\n            gan_loss = 1.5046230554580688\n            subsidiaries:\n            id=0.14152118563652039 , gan=0.49965938925743103 , cy=0.02973577007651329\n \n            total_d_loss = 0.1390264630317688\n            subsidiaries:\n            da=0.15543538331985474 , db=0.12261754274368286\n            \n","output_type":"stream"},{"output_type":"display_data","data":{"text/plain":"<Figure size 576x576 with 0 Axes>"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<Figure size 684x288 with 1 Axes>","image/png":"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\n"},"metadata":{"needs_background":"light"}},{"name":"stdout","text":"\n            epoch = 30/60\n            gan_loss = 1.4594873189926147\n            subsidiaries:\n            id=0.13217005133628845 , gan=0.5372283458709717 , cy=0.026140864938497543\n \n            total_d_loss = 0.16843968629837036\n            subsidiaries:\n            da=0.17409077286720276 , db=0.16278859972953796\n            \n","output_type":"stream"},{"output_type":"display_data","data":{"text/plain":"<Figure size 576x576 with 0 Axes>"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<Figure size 684x288 with 1 Axes>","image/png":"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\n"},"metadata":{"needs_background":"light"}}]},{"cell_type":"code","source":"","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"","metadata":{},"execution_count":null,"outputs":[]}]}