diff --git a/notebooks/L96_offline_NN.ipynb b/notebooks/L96_offline_NN.ipynb index 7da9e71a..b2b06e1a 100644 --- a/notebooks/L96_offline_NN.ipynb +++ b/notebooks/L96_offline_NN.ipynb @@ -145,7 +145,9 @@ "val_size = 4000\n", "\n", "# Training Data\n", - "X_true_train = X_true[:-val_size, :] # Flatten because we first use single input as a sample\n", + "X_true_train = X_true[\n", + " :-val_size, :\n", + "] # Flatten because we first use single input as a sample\n", "subgrid_tend_train = xy_true[:-val_size, :]\n", "\n", "# Test Data\n", @@ -183,7 +185,7 @@ "outputs": [], "source": [ "# Number of sample in each batch\n", - "BATCH_SIZE = 2000 \n", + "BATCH_SIZE = 2000\n", "# this batch size would result in 2 test batches and 8 training batches." ] }, @@ -262,7 +264,7 @@ "plt.figure(dpi=150)\n", "plt.plot(X_iter, subgrid_tend_iter, \".\")\n", "plt.xlabel(\"State - X\", fontsize=20)\n", - "plt.ylabel(\"Subgrid tendency - U\", fontsize=20);\n", + "plt.ylabel(\"Subgrid tendency - U\", fontsize=20)\n", "plt.xlim([-12, 16])" ] }, @@ -419,7 +421,9 @@ "net_input = torch.randn(1, 1)\n", "out_linear = linear_network(net_input)\n", "out_fcnn = fcnn_network(net_input)\n", - "print(f\"The output of the random input from the linear network is: {out_linear.item():.4f}\")\n", + "print(\n", + " f\"The output of the random input from the linear network is: {out_linear.item():.4f}\"\n", + ")\n", "print(f\"The output of the random input from the fcnn is: {out_fcnn.item():.4f}\")" ] }, @@ -458,7 +462,7 @@ "\n", "# Predict the output\n", "y_tmp_linear = linear_network(torch.unsqueeze(X_tmp[0], 1))\n", - "y_tmp_fcnn = fcnn_network(torch.unsqueeze(X_tmp[0], 1))\n", + "y_tmp_fcnn = fcnn_network(torch.unsqueeze(X_tmp[0], 1))\n", "\n", "# Calculate the MSE loss\n", "loss_linear = loss_fn(y_tmp_linear, torch.unsqueeze(X_tmp[1], 1))\n", @@ -532,7 +536,7 @@ "outputs": [], "source": [ "# switch the commenting out below to try a different optimizer.\n", - "#optimizer_linear = optim.SGD(linear_network.parameters(), lr=learning_rate, momentum=momentum)\n", + "# optimizer_linear = optim.SGD(linear_network.parameters(), lr=learning_rate, momentum=momentum)\n", "optimizer_linear = optim.Adam(linear_network.parameters(), lr=learning_rate)\n", "print(\"Before backward pass: \\n\", list(linear_network.parameters())[0].data.numpy())\n", "\n", @@ -549,7 +553,7 @@ "metadata": {}, "outputs": [], "source": [ - "#optimizer_fcnn = optim.SGD(fcnn_network.parameters(), lr=learning_rate, momentum=momentum)\n", + "# optimizer_fcnn = optim.SGD(fcnn_network.parameters(), lr=learning_rate, momentum=momentum)\n", "optimizer_fcnn = optim.Adam(fcnn_network.parameters(), lr=learning_rate)" ] }, @@ -695,7 +699,7 @@ "metadata": {}, "outputs": [], "source": [ - "#Epochs refer to the number of times we iterate over the entire training data during training.\n", + "# Epochs refer to the number of times we iterate over the entire training data during training.\n", "n_epochs = 15" ] }, @@ -732,16 +736,16 @@ "source": [ "plt.figure(dpi=150)\n", "\n", - "plt.plot(train_loss_linear, label='Linear train loss')\n", - "plt.plot(test_loss_linear, linestyle='--', label='Linear test loss')\n", + "plt.plot(train_loss_linear, label=\"Linear train loss\")\n", + "plt.plot(test_loss_linear, linestyle=\"--\", label=\"Linear test loss\")\n", "\n", - "plt.plot(train_loss_fcnn, label='FCNN train loss')\n", - "plt.plot(test_loss_fcnn, linestyle='--', label='FCNN test loss')\n", + "plt.plot(train_loss_fcnn, label=\"FCNN train loss\")\n", + "plt.plot(test_loss_fcnn, linestyle=\"--\", label=\"FCNN test loss\")\n", "\n", "plt.legend()\n", "plt.xlabel(\"Iteration\")\n", "plt.ylabel(\"Loss\")\n", - "plt.yscale('log')\n", + "plt.yscale(\"log\")\n", "plt.title(\"Loss vs Iteration\")\n", "plt.show();" ] @@ -770,9 +774,11 @@ "\n", "\n", "plt.figure(dpi=150)\n", - "plt.plot(predictions_linear.detach().numpy()[0:1000], label=\"Predicted from linear model\")\n", + "plt.plot(\n", + " predictions_linear.detach().numpy()[0:1000], label=\"Predicted from linear model\"\n", + ")\n", "plt.plot(predictions_fcnn.detach().numpy()[0:1000], label=\"Predicted from FCNN model\")\n", - "plt.plot(subgrid_tend_test[:1000, 1], label=\"True Values\", color='k', linestyle='--')\n", + "plt.plot(subgrid_tend_test[:1000, 1], label=\"True Values\", color=\"k\", linestyle=\"--\")\n", "plt.legend(fontsize=7);" ] }, @@ -791,10 +797,10 @@ "\n", "\n", "plt.figure(dpi=150)\n", - "plt.hist2d(np.reshape(X_true, -1), np.reshape(xy_true, -1), bins=91, cmap='Reds')\n", + "plt.hist2d(np.reshape(X_true, -1), np.reshape(xy_true, -1), bins=91, cmap=\"Reds\")\n", "\n", - "plt.plot(X_points, linear_pred, \"-\", label='Linear predictions')\n", - "plt.plot(X_points, fcnn_pred, \"-\", label='FCNN predictions', color='g')\n", + "plt.plot(X_points, linear_pred, \"-\", label=\"Linear predictions\")\n", + "plt.plot(X_points, fcnn_pred, \"-\", label=\"FCNN predictions\", color=\"g\")\n", "\n", "plt.legend()\n", "plt.xlim([-12, 16])\n", @@ -837,22 +843,32 @@ "plt.figure(figsize=(12, 4), dpi=150)\n", "\n", "plt.subplot(131)\n", - "plt.hist2d(np.reshape(np.roll(X_true, -1, axis=1), -1), np.reshape(xy_true, -1), bins=91, cmap='Reds');\n", + "plt.hist2d(\n", + " np.reshape(np.roll(X_true, -1, axis=1), -1),\n", + " np.reshape(xy_true, -1),\n", + " bins=91,\n", + " cmap=\"Reds\",\n", + ")\n", "plt.xlim([-12, 16])\n", "plt.xlabel(\"State - $X_{k-1}$\", fontsize=20)\n", - "plt.ylabel(\"Subgrid tendency - $U_{k}$\", fontsize=20);\n", + "plt.ylabel(\"Subgrid tendency - $U_{k}$\", fontsize=20)\n", "\n", "plt.subplot(132)\n", - "plt.hist2d(np.reshape(X_true, -1), np.reshape(xy_true, -1), bins=91, cmap='Reds');\n", + "plt.hist2d(np.reshape(X_true, -1), np.reshape(xy_true, -1), bins=91, cmap=\"Reds\")\n", "plt.xlim([-12, 16])\n", "plt.xlabel(\"State - $X_{k}$\", fontsize=20)\n", - "plt.ylabel(\"Subgrid tendency - $U_{k}$\", fontsize=20);\n", + "plt.ylabel(\"Subgrid tendency - $U_{k}$\", fontsize=20)\n", "\n", "plt.subplot(133)\n", - "plt.hist2d(np.reshape(np.roll(X_true, 1, axis=1), -1), np.reshape(xy_true, -1), bins=91, cmap='Reds');\n", + "plt.hist2d(\n", + " np.reshape(np.roll(X_true, 1, axis=1), -1),\n", + " np.reshape(xy_true, -1),\n", + " bins=91,\n", + " cmap=\"Reds\",\n", + ")\n", "plt.xlim([-12, 16])\n", "plt.xlabel(\"State - $X_{k+1}$\", fontsize=20)\n", - "plt.ylabel(\"Subgrid tendency - $U_{k}$\", fontsize=20);\n", + "plt.ylabel(\"Subgrid tendency - $U_{k}$\", fontsize=20)\n", "\n", "plt.tight_layout()" ] @@ -897,7 +913,8 @@ " torch.from_numpy(X_true_test), torch.from_numpy(subgrid_tend_test)\n", ")\n", "nlocal_loader_test = Data.DataLoader(\n", - " dataset=nlocal_data_test, batch_size=BATCH_SIZE, shuffle=True)" + " dataset=nlocal_data_test, batch_size=BATCH_SIZE, shuffle=True\n", + ")" ] }, { @@ -940,9 +957,11 @@ "metadata": {}, "outputs": [], "source": [ - "#optimizer_nonlocal_fcnn = optim.SGD(nonlocal_fcnn_network.parameters(),\n", + "# optimizer_nonlocal_fcnn = optim.SGD(nonlocal_fcnn_network.parameters(),\n", "# lr=learning_rate, momentum=momentum)\n", - "optimizer_nonlocal_fcnn = optim.Adam(nonlocal_fcnn_network.parameters(), lr=learning_rate)" + "optimizer_nonlocal_fcnn = optim.Adam(\n", + " nonlocal_fcnn_network.parameters(), lr=learning_rate\n", + ")" ] }, { @@ -954,8 +973,12 @@ "source": [ "n_epochs = 120\n", "train_loss_nonlocal, test_loss_nonlocal = fit_model(\n", - " nonlocal_fcnn_network, loss_fn, optimizer_nonlocal_fcnn, \n", - " nlocal_loader_train, nlocal_loader_test, n_epochs\n", + " nonlocal_fcnn_network,\n", + " loss_fn,\n", + " optimizer_nonlocal_fcnn,\n", + " nlocal_loader_train,\n", + " nlocal_loader_test,\n", + " n_epochs,\n", ")" ] }, @@ -968,16 +991,16 @@ "source": [ "plt.figure(dpi=150)\n", "\n", - "plt.plot(train_loss_nonlocal, label='Non-local model train loss')\n", - "plt.plot(test_loss_nonlocal, linestyle='--', label='Non-local model test loss')\n", + "plt.plot(train_loss_nonlocal, label=\"Non-local model train loss\")\n", + "plt.plot(test_loss_nonlocal, linestyle=\"--\", label=\"Non-local model test loss\")\n", "\n", - "plt.plot(train_loss_fcnn, label='local FCNN train loss')\n", - "plt.plot(test_loss_fcnn, linestyle='--', label='local FCNN test loss')\n", + "plt.plot(train_loss_fcnn, label=\"local FCNN train loss\")\n", + "plt.plot(test_loss_fcnn, linestyle=\"--\", label=\"local FCNN test loss\")\n", "\n", "plt.legend()\n", "plt.xlabel(\"Epochs\")\n", "plt.ylabel(\"Loss\")\n", - "plt.yscale('log')\n", + "plt.yscale(\"log\")\n", "plt.title(\"Loss vs Epochs\")\n", "plt.grid()\n", "plt.show();" @@ -1002,10 +1025,17 @@ "\n", "\n", "plt.figure(dpi=150)\n", - "plt.plot(predictions_linear.detach().numpy()[0:1000], label=\"Predicted from linear model\")\n", - "plt.plot(predictions_fcnn.detach().numpy()[0:1000], label=\"Predicted from local FCNN model\")\n", - "plt.plot(predictions_nonlocal_fcnn.detach().numpy()[0:1000,k_loc], label=\"Predicted from non-local FCNN model\")\n", - "plt.plot(subgrid_tend_test[:1000, 1], label=\"True Values\", color='k', linestyle='--')\n", + "plt.plot(\n", + " predictions_linear.detach().numpy()[0:1000], label=\"Predicted from linear model\"\n", + ")\n", + "plt.plot(\n", + " predictions_fcnn.detach().numpy()[0:1000], label=\"Predicted from local FCNN model\"\n", + ")\n", + "plt.plot(\n", + " predictions_nonlocal_fcnn.detach().numpy()[0:1000, k_loc],\n", + " label=\"Predicted from non-local FCNN model\",\n", + ")\n", + "plt.plot(subgrid_tend_test[:1000, 1], label=\"True Values\", color=\"k\", linestyle=\"--\")\n", "plt.legend(fontsize=7);" ] }, diff --git a/notebooks/L96_online_implement_NN.ipynb b/notebooks/L96_online_implement_NN.ipynb index 2a1c69e2..0e2f58da 100644 --- a/notebooks/L96_online_implement_NN.ipynb +++ b/notebooks/L96_online_implement_NN.ipynb @@ -84,6 +84,7 @@ "# The model architectures\n", "# ---------------------------\n", "\n", + "\n", "class LinearRegression(nn.Module):\n", " def __init__(self):\n", " super().__init__()\n", @@ -94,7 +95,8 @@ " # we call a object of this class\n", " x = self.linear1(x)\n", " return x\n", - " \n", + "\n", + "\n", "class FCNN(nn.Module):\n", " def __init__(self):\n", " super().__init__()\n", @@ -108,7 +110,8 @@ " x = self.relu(self.linear1(x))\n", " x = self.relu(self.linear2(x))\n", " x = self.linear3(x)\n", - " return x \n", + " return x\n", + "\n", "\n", "class NonLocal_FCNN(nn.Module):\n", " def __init__(self):\n", @@ -192,8 +195,8 @@ "forcing = 18\n", "dt = 0.01\n", "\n", - "k=8\n", - "j=32 \n", + "k = 8\n", + "j = 32\n", "\n", "W = L96(k, j, F=forcing)\n", "\n", @@ -361,7 +364,9 @@ "\n", "# Evaluate with nonlocal FCNN\n", "gcm_nonlocal_net = GCM_network(forcing, nonlocal_fcnn_network)\n", - "Xnn_nonlocal, t = gcm_nonlocal_net(init_conditions, dt, int(T_test / dt), nonlocal_fcnn_network)" + "Xnn_nonlocal, t = gcm_nonlocal_net(\n", + " init_conditions, dt, int(T_test / dt), nonlocal_fcnn_network\n", + ")" ] }, { @@ -384,11 +389,11 @@ "time_i = 200\n", "plt.figure(dpi=150)\n", "plt.plot(t[:time_i], X_full[:time_i, 4], label=\"Full L96\")\n", - "plt.plot(t[:time_i], X_no_param[:time_i, 4], '--', label=\"No parameterization\")\n", + "plt.plot(t[:time_i], X_no_param[:time_i, 4], \"--\", label=\"No parameterization\")\n", "\n", "plt.plot(t[:time_i], Xnn_linear[:time_i, 4], label=\"linear parameterization\")\n", "\n", - "plt.plot(t[:time_i], Xnn_local[:time_i, 4], label=\"local NN\")\n", + "plt.plot(t[:time_i], Xnn_local[:time_i, 4], label=\"local NN\")\n", "plt.plot(t[:time_i], Xnn_nonlocal[:time_i, 4], label=\"nonlocal NN\")\n", "plt.legend(loc=\"upper left\", fontsize=7);" ] @@ -417,37 +422,42 @@ "\n", " # Evaluate with linear network\n", " gcm_linear_net = GCM_network(forcing, linear_network)\n", - " Xnn_linear, t = gcm_linear_net(init_conditions_i, dt, int(T_test / dt), linear_network)\n", + " Xnn_linear, t = gcm_linear_net(\n", + " init_conditions_i, dt, int(T_test / dt), linear_network\n", + " )\n", "\n", " # Evaluate with local FCNN\n", " gcm_local_net = GCM_network(forcing, local_fcnn_network)\n", - " Xnn_local, t = gcm_local_net(init_conditions_i, dt, int(T_test / dt), local_fcnn_network)\n", + " Xnn_local, t = gcm_local_net(\n", + " init_conditions_i, dt, int(T_test / dt), local_fcnn_network\n", + " )\n", "\n", " # Evaluate with nonlocal FCNN\n", " gcm_nonlocal_net = GCM_network(forcing, nonlocal_fcnn_network)\n", - " Xnn_nonlocal, t = gcm_nonlocal_net(init_conditions_i, dt, int(T_test / dt), nonlocal_fcnn_network)\n", + " Xnn_nonlocal, t = gcm_nonlocal_net(\n", + " init_conditions_i, dt, int(T_test / dt), nonlocal_fcnn_network\n", + " )\n", "\n", " # GCM parameterized by the global 3-layer network\n", - " #gcm_net_3layers = GCM_network(forcing, nn_3l)\n", - " #Xnn_3layer_i, t = gcm_net_3layers(init_conditions_i, dt, int(T_test / dt), nn_3l)\n", + " # gcm_net_3layers = GCM_network(forcing, nn_3l)\n", + " # Xnn_3layer_i, t = gcm_net_3layers(init_conditions_i, dt, int(T_test / dt), nn_3l)\n", "\n", " # GCM parameterized by the linear network\n", - " #gcm_net_1layers = GCM_network(forcing, linear_network)\n", - " #Xnn_1layer_i, t = gcm_net_1layers(init_conditions_i, dt, int(T_test / dt), linear_network)\n", + " # gcm_net_1layers = GCM_network(forcing, linear_network)\n", + " # Xnn_1layer_i, t = gcm_net_1layers(init_conditions_i, dt, int(T_test / dt), linear_network)\n", "\n", " err_linear.append(\n", " np.sum(np.abs(X_full[i * 10 : i * 10 + T_test * 100 + 1] - Xnn_linear))\n", " )\n", - " \n", + "\n", " err_local.append(\n", " np.sum(np.abs(X_full[i * 10 : i * 10 + T_test * 100 + 1] - Xnn_local))\n", " )\n", - " \n", + "\n", " err_nonlocal.append(\n", " np.sum(np.abs(X_full[i * 10 : i * 10 + T_test * 100 + 1] - Xnn_nonlocal))\n", " )\n", - " \n", - " \n", + "\n", "\n", "print(f\"Sum of errors for linear: {sum(err_linear):.2f}\")\n", "print(f\"Sum of errors for local neural network: {sum(err_local):.2f}\")\n", diff --git a/notebooks/intro_ML_and_NNs.ipynb b/notebooks/intro_ML_and_NNs.ipynb index 1da35cd4..de43c1d5 100644 --- a/notebooks/intro_ML_and_NNs.ipynb +++ b/notebooks/intro_ML_and_NNs.ipynb @@ -200,7 +200,7 @@ "metadata": {}, "outputs": [], "source": [ - "# We create 100 data points. \n", + "# We create 100 data points.\n", "n = 100\n", "x = torch.ones(n, 2)\n", "\n", @@ -287,7 +287,7 @@ "metadata": {}, "outputs": [], "source": [ - "# Initialize parameters with some randomly guessed values. \n", + "# Initialize parameters with some randomly guessed values.\n", "w_real = torch.as_tensor([-3.0, -5])\n", "y_hat = x @ w_real\n", "# Initial mean-squared error\n", @@ -311,7 +311,7 @@ "plt.scatter(x[:, 1], y, label=\"y\")\n", "plt.scatter(x[:, 1], y_hat, label=\"$\\\\tilde{y}$\")\n", "plt.xlabel(\"$x$\")\n", - "plt.title('Prediction of model using non-optimized model')\n", + "plt.title(\"Prediction of model using non-optimized model\")\n", "plt.legend(fontsize=7);" ] }, @@ -451,7 +451,7 @@ "plt.plot(np.array(losses))\n", "plt.xlabel(\"Iteration\")\n", "plt.ylabel(\"Loss\")\n", - "plt.yscale('log')\n", + "plt.yscale(\"log\")\n", "plt.title(\"Loss vs Iteration\")\n", "plt.show();" ] @@ -547,13 +547,13 @@ "source": [ "# We create many data points, as neural networks need lot of data to train from scratch.\n", "n = 10000\n", - "x = torch.ones(n,1)\n", + "x = torch.ones(n, 1)\n", "\n", "# uniformly sample x points between -1 and 1.\n", "# Underscore functions in pytorch means replace the value (update)\n", "x = x.uniform_(-1.0, 1)\n", "\n", - "y = torch.sin(x* 2*torch.pi) + 0.1*torch.rand(n, 1) " + "y = torch.sin(x * 2 * torch.pi) + 0.1 * torch.rand(n, 1)" ] }, { @@ -569,7 +569,7 @@ "metadata": {}, "outputs": [], "source": [ - "plt.plot(x[:,0], y, '.', markersize=0.5)" + "plt.plot(x[:, 0], y, \".\", markersize=0.5)" ] }, { @@ -600,12 +600,12 @@ "class Simple_Neural_Net(nn.Module):\n", " def __init__(self):\n", " super().__init__()\n", - " self.Dense1 = nn.Linear(1, 30) \n", - " self.Dense2 = nn.Linear(30,30)\n", - " self.Dense3 = nn.Linear(30,1)\n", - " \n", + " self.Dense1 = nn.Linear(1, 30)\n", + " self.Dense2 = nn.Linear(30, 30)\n", + " self.Dense3 = nn.Linear(30, 1)\n", + "\n", " self.relu = nn.ReLU()\n", - " \n", + "\n", " def forward(self, x):\n", " # This method is automatically executed when\n", " # we call a object of this class\n", @@ -635,7 +635,9 @@ "source": [ "net_input = torch.randn(1, 1)\n", "out = neural_net(net_input)\n", - "print(f\"The output of the random input {net_input.item():.4f} from untrained network is: {out.item():.4f}\")" + "print(\n", + " f\"The output of the random input {net_input.item():.4f} from untrained network is: {out.item():.4f}\"\n", + ")" ] }, { @@ -697,7 +699,6 @@ "outputs": [], "source": [ "def train_step(model, loss_fn, optimizer):\n", - " \n", " # Set the model to training mode - important for batch normalization and dropout layers\n", " # Unnecessary in this situation but added for best practices\n", "\n", @@ -733,8 +734,7 @@ "for t in range(epochs):\n", " Loss[t] = train_step(neural_net, loss_fn, optimizer)\n", " if np.mod(t, 200) == 0:\n", - " print(f\"Loss at Epoch {t+1} is \", Loss[t])\n", - " " + " print(f\"Loss at Epoch {t+1} is \", Loss[t])" ] }, { @@ -747,7 +747,7 @@ "plt.plot(Loss)\n", "plt.xlabel(\"Iteration\")\n", "plt.ylabel(\"Loss\")\n", - "plt.yscale('log')\n", + "plt.yscale(\"log\")\n", "plt.title(\"Loss vs Iteration\")\n", "plt.show();" ] @@ -769,8 +769,8 @@ "source": [ "# Generate some points where the predictions of the model will be tested.\n", "# Here we pick the testing domain to be larger than the training domain to check if the model\n", - "# has any skill at extrapolation. \n", - "x_test = torch.linspace(-1.5, 1.5, 501).reshape(501,1)\n", + "# has any skill at extrapolation.\n", + "x_test = torch.linspace(-1.5, 1.5, 501).reshape(501, 1)\n", "\n", "# Generate the predictions from the trained model.\n", "pred = neural_net(x_test).detach().numpy()" @@ -784,8 +784,8 @@ "source": [ "plt.figure(dpi=150)\n", "\n", - "plt.plot(x, y, '.', markersize=0.5, label='Data')\n", - "plt.plot(x_test, pred, markersize=0.5, label='Predicted fit')\n", + "plt.plot(x, y, \".\", markersize=0.5, label=\"Data\")\n", + "plt.plot(x_test, pred, markersize=0.5, label=\"Predicted fit\")\n", "\n", "plt.legend()" ] diff --git a/notebooks/old_notebooks/gradient_decent-old.ipynb b/notebooks/old_notebooks/gradient_decent-old.ipynb index 94c3ce82..cbed645a 100644 --- a/notebooks/old_notebooks/gradient_decent-old.ipynb +++ b/notebooks/old_notebooks/gradient_decent-old.ipynb @@ -116,7 +116,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -144,7 +144,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -160,20 +160,9 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "tensor([3., 2.])" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "w = torch.as_tensor([3.0, 2])\n", "w" @@ -200,24 +189,9 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "tensor([[ 1.0000, 0.2203],\n", - " [ 1.0000, -0.1899],\n", - " [ 1.0000, 0.7698],\n", - " [ 1.0000, 0.3822],\n", - " [ 1.0000, -0.2894]])" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "n = 100\n", "x = torch.ones(n, 2)\n", @@ -229,7 +203,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -238,20 +212,9 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAz4AAAKHCAYAAABAeZ3RAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAABcSAAAXEgFnn9JSAABoBklEQVR4nO3dfXxU5Z3///cwDImaKAawgiQaQGiJaG0gQa0KtXy1uvGGxri0tVRst1Vr7fJbW+2ujel2C1tvVm3rt92utNStLGlE3WjXG9C2KCV3+q0aCqQkmqTeMEmkJODEYTi/P9ihhGSSOWfOmTnnzOv5ePh4yGSuc645HofzznVdnytgGIYhAAAAAPCxcZnuAAAAAAA4jeADAAAAwPcIPgAAAAB8j+ADAAAAwPcIPgAAAAB8j+ADAAAAwPcIPgAAAAB8j+ADAAAAwPcIPgAAAAB8j+ADAAAAwPcIPgAAAAB8j+ADAAAAwPcIPgAAAAB8b3ymO+BWJ598svbt26eioqJMdwUAAADIep2dnTruuOP0zjvvWGrPiE8C+/btUzQazXQ3AAAAAEiKRqPat2+f5faM+CQQH+lpbW3NcE8AAAAAlJSUpNSeER8AAAAAvkfwAQAAAOB7BB8AAAAAvkfwAQAAAOB7BB8AAAAAvkfwAQAAAOB7BB8AAAAAvkfwAQAAAOB7BB8AAAAAvkfwAQAAAOB7BB8AAAAAvkfwAQAAAOB7BB8AAAAAvkfwAQAAAOB7BB8AAAAAvkfwAQAAAOB74zPdAQAAACDbhfsHtb6pUw0dfRoYPKC8nPFaOGOSquYXakp+Tqa75wsEHwAAACBDItGYaupbVdfSrWjMGPKzzW09um/jTlWWFqq6Yq5yQ8EM9dIfCD4AAABABkSiMS1f06iGjr6E74nGDK1r7FR7eEBrV5QRflLAGh8AAAAgA2rqW0cNPUdq6OhTTf02h3vkbwQfAAAAIM1290dU19Jtqk1dS5fC/YMO9cj/CD4AAABAmtU2dQ1b0zOWaMzQytr/R/ixiOADAAAApFmyU9yOtrmtR+eu3qTbN7ymSDRmc6/8jeADAAAApNnA4AHLbeMFD5avaST8mEDwAQAAANIsLyf14soUPDCH4AMAAACkWXlxgS3HoeBB8gg+AAAAQJpVLShUKBhI+TjRmKHa5i4beuR/BB8AAAAgzU7Kz1Vl6XRbjrW1vdeW4/gdwQcAAADIgOqKElumvKVSKCGbEHwAAACADMgNBbV2RZmWlRWlNO3NjkIJ2YDgAwAAAGRIbiioVUvnacttF+njsyZbOsbCGZNs7pU/EXwAAACADJuSn6N7rznL9MhPKBhQ1fxCh3rlLwQfAAAAwAWsFDyoLC3UlPwch3rkLwQfAAAAwCXMFDwoLy5QdcVch3vkHwQfAAAAwCWSKXgQCga0rKxIa1eUKTcUTHMPvYsSEAAAAICLxAserFwyW7XNXdra3quBwQPKyxmvhTMmqWo+09usIPgAAAAALjQlP0c3LZ6lmxbPynRXfIGpbgAAAAB8j+ADAAAAwPcIPgAAAAB8j+ADAAAAwPcIPgAAAAB8j6puAAAAQBYL9w9qfVOnGjr6fF02m+ADAAAAZKFINKaa+lbVtXQrGjOG/GxzW4/u27hTlaWFqq6Y64uNUgk+AAAAQJaJRGNavqZRDR19Cd8TjRla19ip9vCA1q4o83z4YY0PAAAAkGVq6ltHDT1HaujoU039Nod75DyCDwAAAJBFdvdHVNfSbapNXUuXwv2DDvUoPQg+AAAAQBapbeoatqZnLNGYodrmLod6lB4EHwAAACCLJDvF7Whb23tt7kl6EXwAAACALDIweCCt7dyC4AMAAABkkbwca4WdrbZzC4IPAAAAkEXKiwsstVs4Y5LNPUkvgg8AAACQRaoWFCoUDJhqE5D0u51h/eiFP3m2uhvBBwAAAMgiJ+XnqrJ0uqk2hg4VRbjrmR06d/Um3b7hNUWiMWc66BCCDwAAAJBlqitKLE95i8YMrWvs1PI1jZ4KPwQfAAAAIMvkhoJau6JMy8qKTE97i2vo6FNN/Tabe+Ycgg8AAACQhXJDQa1aOk9bbrtIt148R+XFBTIbgepaujyz5ofgAwAAAGSxKfk5umnxLJ1/+mQZJttGY4Zqm7sc6ZfdCD4AAAAA1NDRZ6nd1vZem3viDIIPAAAAAA0MHkhru3Qj+AAAAABQXs74tLZLN4IPAAAAAMvlrRfOmGRzT5xB8AEAAACgqgWFpktbh4IBVc0vdKhH9iL4AAAAANBJ+bmqLJ1uqk1laaGm5Oc41CN7EXwAAAAASJKqK0qSnvJWXlyg6oq5DvfIPgQfAAAAAJIObWq6dkWZlpUVJZz2FgoGtKysSGtXlCk3FExzD63zRgkGAAAAwEPC/YNa39Spho4+DQweUF7OeC2cMUlV890/NSw3FNSqpfO0csls1TZ3aWt7r+c+w0gChmGY3aA1K5SUlEiSWltbM9wTAAAAeEUkGlNNfavqWroVjQ1/zA4FA6osLVR1xVxPjZa4QarP54z4AAAAADaIRGNavqZRDR19Cd8TjRla19ip9vCA56aKeR1rfAAAAAAb1NS3jhp6jtTQ0aea+m0O9whHIvgAAAAAKdrdH1FdS7epNnUtXQr3DzrUIxyN4AMAAACkqLapa8Q1PaOJxgzVNnc51CMcjTU+AAAAyCpOVFxLdorb0ba29+qmxbMstYU5BB8AAABkhdEqrm1u69F9G3darrg2MHjAUp+stoN5BB8AAAD4npmKa/V/+LPOnD5R582anPQo0DEWq7Pl5fA4ni6s8QEAAIDvmam4NjAY05ZdvbrrmR06d/Um3b7hNUWisdHbRKyN3CycMclSO5hH8AEAAICvWam4FhcfBVq+pjFh+NndH9G2t/eaPvb4cVLV/EJL/YJ5BB8AAAD4mpWKa0cbbd+d2qYuHTho/vhzp51guZgCzGNSIQAAABzhRPU0K6xWXDtaXUuXVi6ZPazvVo/P+p704moDAADAVk5WT7PCrspp8X13ji4/bfX474+xbgj2YqobAAAAbBOvnrauMfH0smTWzdjJzpGVre29th2fEZ/0IvgAAADANmaqp422bsZO5cUFth1rpNEdq8enolt6EXwAAABgCyvV0+pauhTuH3SoR4dULShUKBiw5VgjjdJYOX4oGKCiW5oRfAAAAGALK9XT4utmnHRSfq4qS6fbcqyRRmmsHL+yNL0FHkDwAQAAgE2sVjcbad2M3aorSlKe8jbaKI2Z459wzHidfHyO4yNdGIoVVQAAALCF1epmqVRdS7Zkdm4oqLUrylRTv011Ldb29RltlMbM8f/y/gH928Y2/fCFP9la3c4t5cPdKmAYRmq7OflUSUmJJKm1tTXDPQEAAPCGax9q0Oa2HtPtzj99sh6+vtxUm9FKZkuHRmcShYpw/6Bqm7v00p969Gr3Hg0Mjl1Zrry4QGtXlCUVUML9g/plw5ta82KH9kbGDnVmjj2SVK6Fl6T6fM6IDwAAgEe57Tf85cUFloKP2epm8ZLZo02ti5fMbg8PDAsVU/JzdNPiWbpp8az/DQ2JR2mshIYp+Tl6d28kqdAj/bW63aql85J6/5FSvRbZhBGfBBjxAQAAbuXW3/Dv7o/ovNXPm5pGFgoGtOW2i0wFtds3vKp1jckXRFhWVjRmqIiPAm1t7005RKbrOkjmr0XV/On6fuVZps7hFqk+n1PcAAAAwEPcuEFoXDqqmzlVMjs+CvTw9eV67Mbz9PD15bpp8SxLI2fpqm5n5Vr8qrlb3e/tN9XGLwg+AAAAHuLGDUKPZKa6WXlxgaor5po6vltLZh8pXdXtrFwLQ9KNv3zZVBu/IPgAAAB4hFs3CD1SvLrZsrKihJt6hoIBLSsrsrTexM0ls+PSVd3O6rV4rfsvWVlK27PBZ9GiRQoEAgn/efrppzPdRQAAAFt5YbRDOhR+Vi2dpy23XaRbL56j80+frLOLJur80yfr1ovnaMttF2nV0nmW1h9lomS2WXk51uqHmW1n9TMZUtrvCTfwfFW3T3/608rLyxv2+imnnJKB3gAAADgnldGOmxbPsrk3Yzuyeppd0hUqUpGu6napfKZM3ROZ5Pngc/fdd+u0007LdDcAAAAc54XRDqelK1SkompBoe7f1Ga6qlvV/EJT57F6LSR/3RPJ8uxUNwAAgGzjhdEOp1UtKEy4digRK6EiFemobicduhbmrsRf+emeSBbBBwAAwCOSrZZ2tHSOdjgtXaEiVU5Xt5MOXYt5p5xgup3kr3siWZ4PPg899JBuvPFGffWrX9UDDzygzs7OTHcJAADAEV4Y7UiHdISKVDld3S7uh5892/Sojx/viWR4fozru9/97pA//8M//IPuuOMO3XHHHRnqEQAAgDPiox3rGpOvyJWJ0Q6nxUNFTf021bWMXOkuFAyosrRQ1RVzLYeKVMWr261cMlu1zV3a2t6rgcEDyssZr4UzJqlqfur/bYoKjlPl/FP0q+Y/J93Gj/dEMgKGYZiriegS3/72tzV79myde+65mjp1qrq6ulRXV6fvfve7ev/993XffffplltuGfM4JSUlI76+a9cuzZw5U62trXZ3HQAAwLJINKblaxqTqvBWXlyQ0miCF4T7Bx0LFV6xZ/8HOv/7L6g/MnbBgvzc8XrxG4t1wrET0tAze8Wf260+n3s2+CTy7LPP6uKLL9YJJ5ygt99+W8ccc8yo7yf4AAAAr4lEY64f7XBauH9Q65s61dDRl7WBJ+72Da+aGgVcVlakVUvnOdgjZxB8RrBgwQI1Nzfr+eef1+LFiy0dI9ULCwAA4LRsHO04FPpaVdfSnbWh70i7+yM6b/Xzpktnb7ntIs/dI6k+n3t+jc9ITj/9dDU3N+vtt9/OdFcAAAAcY8cGoV4aOUlmml80ZmhdY6fawwO+n+YnSbVNI4/6jSYaM1Tb3MUGpn7w3nvvSZLy8vIy3BMAAAB3Gm3kZHNbj+7buNN1Iyc19a1JrW2SpIaOPtXUb/PklC4zkr0eR9va3pt1wcfz5ayPFg6HtXnzZknSxz72sQz3BgAAwH3iIyfrGhOPFsRHTpavaVQkGktzD4fb3R9RXUu3qTZ1LV0K9w861CN3GBgcu6CBne28zJPBZ+vWrXrhhRd09PKkN954Q1dddZX27dunyy+/XNOnm9vcCgAAIBtYGTnJtFSmdPlZXo61CVxW23mZJ4PP9u3b9YlPfEKnnHKKFi1apL/927/Vxz/+cX3kIx/RSy+9pJKSEv30pz/NdDcBAABcx6sjJ6lM6fKzZDdyPdrCGZNs7on7eTL4lJeX64YbbtDUqVO1bds2Pfroo3r99df10Y9+VPfcc4+ampp00kknZbqbAAAAruPVkROmdI2sakGhQsGAqTahYEBV8wsd6pF7eXKM6yMf+YgefPDBTHcDAADAc7y6GJ4pXSM7KT9XlaXTTe3jU1nqvop96eDJER8AAABY49WRE6Z0JVZdUZL09SkvLlB1xVyHe+ROBB8AAIAs4tWRE6Z0JZYbCmrtijItKytKeI1CwYCWlRVlxd5Gifh77A8AAMBF3LBZaHlxgTa39Zhul+mRE6Z0jS43FNSqpfO0csls1TZ3aWt7r+s3pE23gHF0TWhIkkpKSiRJra2tGe4JAADwutE2C5UO/TY+XZuF7u6P6LzVz5sqcBAKBrTltosy/uAc338omXVK5cUFWT264UepPp8z1Q0AAMBBbtssND5yYoZbRk6Y0oVUMOKTACM+AADADrdveNXU9KxlZUVatXSegz3yx8hJuH+QKV1ZJtXnc4JPAgQfAACQKjdPKzs0/W6b6lpGHolK5/Q7IBmpPp9T3AAAAMAhqWwW6vSeOV5ZDO+GghDwB4IPAACAQ7ywWeiU/BzdtHhWRjcnHcloBSE2t/Xovo07GZGCKQQfAAAAh3h1s9BMS2YNUrwgRHt4IOEaJEaLcCSCDwAAgEO8ulloptXUtyY9WtbQ0aea+m1DCkIwWoSRUM4aAADAIeXFBZbaZXqz0Eza3R9RXUu3qTZ1LV0K9w9Kcl/5cLgHwQcAAMAhVQsKE+43k0goGFDV/EKHeuR+qRSEkKyNFiE7EHwAAAAc4uXNQjMllYIQqY4Wwd8IPgAAAA6qrihJespbeXGBqivmOtwjd0ulIESqo0XwN4IPAACAg3JDQa1dUaZlZUUJp72FggEtKytKWJ0sm6RSECKV0SL4X3aXDAEAAFkvHSWPvbJZqBuUFxdoc1uP6XYLZ0zSxj++a+mc2V4+PFsQfAAAQFbKRMljt24W6iZVCwp1/6Y2U1PW4gUhrI7cZHv58GzBVDcAAJB1KHnsXqkUhLBaPrz01BMttYO3EHwAAEDWoeSxOeH+Qf3w+TZd+1CDrnrwJV37UIN+9MKfHKuGZrUghJXy4ZL0u51hwm0WIPgAAICsQsnj5EWiMd2+4VWdu3qT7n52pza39eiVzj3a3Naju57ZoXNXb9LtG16zPTRYLQhhZbRIkl7u3JP14TYbMKERAABklVRKHmfT2pz4dMDRRsbi0wHbwwO2V6SzWhCiuqJEO97p18ude0ydr66lSyuXzKbIhI8RfAAAQFZJpeRxNgUfK9MBVy2dZ3s/zBaEyA0Fdf7pk00Hn2wMt9mGqW4AACCrpLJBZrbw+nRAs6Enjv18/I3gAwAAskoqG2Rmi1SmA7oB4RYjIfgAAICsYrXk8cIZk2zuiXulMh3QDQi3GAn/dQEAQFZJZYNMrwv3D2p9U6caOvpGLRTg9RGT8uICbW7rMd0um8JtNiL4AACArBIvebyuMflpWfENMr0qEo2ppr5VdS3dwwLf5rYe3bdxpypLC1VdMVe5oaDnR0yyOdwiMaa6AQCArGN1g0wvipelXteYeN1OvCz18jWNikRjnp8OeFJ+rq48+xRTbQqOm6DaZvcUaID9CD4AACDrWN0g04uslKWuWlCY8Lok4r4RE3PFGd7dO+jopqzIPHeMRwIAAKSZ1Q0yvcRqWeqVS2Z7ejrg7v6IHn/lLUttndyUFZlF8AEAAFnN7AaZbjVS4QLDMCyXpa6uKFF7eF9So0Vumw5opRz30ZzclBWZQfABAADwsNEKF1i1tb1XNy2epbUrylRTv011LSMHiVAwMKQogltYLcd9tPjol1tGspAagg8AAIBHxQsX2PWgHxcvS+3V6YB2ldWOj355fTQQhxB8AAAAPMpM4QIzji5L7bXpgHaW1Y6PfsH7qOoGAADgQVYKFyTLLWWprbJajnskbtmUFakj+AAAAHiQHQv4R+K+stTmWSnHnYhbNmVF6vgvCQAA4EFOTHGTpL85c9qw6nBuXs8zkpPyc02X407E66Nf+CuCDwAAgAc5MQXrpPwc1f/hzzpwcOjrm9t6dN/Gna6s4JaImXLcifhh9At/xVQ3AAAAD7JzCtb4cQGdlJ+j3f2Dw0JPXHxjz+VrGhWJxmw7t1NyQ0GtXVGmZWVFlqe9uWlTVqSOER8AAIAMG2nz0bGml5UXF2hzW4/pc51/+mRJGnKett39evyVt5Jqf+TGnlb6nU5Hl+N+6U89erV7jwYGxw5ubtuUFakLGIZh/6o4HygpKZEktba2ZrgnAADAr8bafHS0DUJ390d03urnTRU4CAUD2nLbRUNCiZXjjB8n/c2Zp+ip197y1MamUvyae29TVqT+fM6IDwAAQAYks/lofHpZe3hAa1eUDXkQt7KAf6SpW1aqwx04KD3+//5sqd+Z5tVNWZE6RnwSYMQHAAA46fYNr5oKLcvKirRq6bwhryUTnuLKiwtGDCHXPtRgacpcskbqN2BFqs/nFDcAAABIMyubj9a1dCncPzjktWQW8IeCAS0rK0o48uL0Bp0j9RvIBKa6AQAApJmV6WXRmKHa5i7dtHjWkNdTnbrl9AadifoNpBvBBwAAIM2s7i2ztb03YYCYkp+jmxbPMh0wrFaHM2O0fgPpwlQ3AACANLM6vcyJaWlVCwot73OTLKen0wHJYMQHAAAgzaxOL3NiWpqV6nBmJdNvt+8JBO8j+AAAAKSZ1ellC2dMcqA3UnVFidrD+yxPwRvLaP0ebS+jzW09um/jTvbVgS2Y6gYAAJBmVqaXhYIBVc0vdKQ/yVaHu/Kjp2j8OPv6HS/Hva4xcbGH+J5Ay9c0KhKNmTo3cCRGfAAAANLMrs1H7ZRsdbhjJoyzrd819a1JjzI1dPSppn4bewLBMjYwTYANTAEAgJPs2Hw0E+zq9+7+iM5b/bypst6hYEBbbruINT9Zig1MAQAAPMiOzUczwa5+p7KXEWAFIz4JMOIDAADSJdw/aGnz0UxLpd/XPtRgqcDD+adP1sPXl1vtMjws1edz1vgAAABkmNXNRzMtlX67aS8jZAeCDwAAyCrsF+MObtrLCNmBOwcAAGQF9otxF7ftZQT/o7gBAADwPfaLcR+37WUE/yP4AAAA37OyXwycFd/LyAyn9zKCvxF8AACAr+3uj6iupdtUm7qWLoX7Bx3qEeKqK0pUXlyQ1HvLiwtUXTHX4R7Bzwg+AADA19gvxr28upcRvIniBgAAwNeSneJ2tK3tvY6Xl6bC3KHws2rpPK1cMtuTexnBOwg+AADA19y4XwwV5obz6l5G8A6CDwAA8DW37RcTrzA32khUvMJce3iAKV6ATQg+AAAgaV6cmpWJ/WJGu073PrfDdIW5VUvnWe4LgEMChmGYW+2XJUpKSiRJra2tGe4JAACZN9rULOnQAnS3Ts3a3R/ReaufN1XgIBQMaMttF5kOc2Ndp/HjpIPGoX+c7gvgN6k+n1PVDQAAjMrrm3+ma7+YZK7TgYPmQo9EhTnALgQfAAAwKq9v/hmJxnTg4EGNXCx5OKv7xZi5TmZtbe915LhANiH4AACAhLy++Wd8FOZXzX/WWAMtAUlV86dbKiZg5TqZ4WSFOSBbEHwAAEBCXt/808wojCEpOG6cpTVKVq6TGU5VmAOyCcEHAAAklMrmn5mWztEqp6a4xaVSYQ7AIQQfAACQkBs3/0xWOkernPy8oWBAVfMLHTs+kC0IPgAAICG3bf5pRjpHq5z8vFYqzAEYjuADAAASKi8usNTODVOz0jlaZfU6jeVjRRMtVZgDMBzBBwAAJFS1oFChYLKFoA9xy9SsdI5WWblOybhw9hTXbQgLeBXBBwAAJJSuzT+dkM7RKivXKRnNb75n+zGBbJX5CbgAAGBM4f5BrW/qVENHnwYGDygvZ7wWzpikqvnOh4zqihK1h/cltWbG6uafTqhaUKj7N7WZKnCQymiVmeuULDcUiQD8ghEfAABcLBKN6fYNr+rc1Zt097M7tbmtR6907tHmth7d9cwOnbt6k27f8Joi0ZhjfcgNBbV2RZmWlRUlnM4VCga0rKzI0uafTkn3aFUy18ksNxSJAPwiYBiGc7tteVhJSYkkqbW1NcM9AQBkq0g0puVrGpMeaUlH6Aj3D6q2uUtb23sdH3myY5QrU9fw6OvUt+8Dvdm73/Rxbr14jm5aPCvl/gB+kOrzOcEnAYIPACDTbt/wqtY1Jr+nzLKyIq1aOs/BHqVHJBpTTX2r6lq6R5ymFgoGVFlaqOqKuUmFlEPH26a6lpH39TF7PCt290d03urnTU+723LbRa5YLwW4QarP54yfAgDgQrv7I6pr6TbVpq6lSyuXzPb0g3IyIzTRmKF1jZ1qDw8kNUKTGwpq1dJ5WrlkdtpGq44Wn3ZnJsi6pUgE4BcEHwAAXKi2aeTRidFEY4Zqm7s8PTWqpr416eIADR19qqnflvQo15T8HN20eFbGro9Xi0QAfkFxAwAAXMhqZbCt7b029yR9rI5yhfsHHeqRvbxaJALwC0Z8AABwIatljL1c/jgbRrncMO0OyFYEHwAAXMhqGWMvlz9OZZTLK8EnLtPT7oBsxFQ3AABcqLy4wFK7hTMm2dyT9MnGUS4A6UPwAQDAhaoWFJreBDMUDKhqfqFDPXJeNo5yAUgfgg8AAC4UL39shtfLH2fjKBeA9OFXJAAAuJRXyx+H+we1vqlTDR19phbuVy0o1P2b2kxv8unlUS4A6UPwAQDApeLlj2vqt6muZeSKZ6FgQJWlhaqumJvx8seRaEw19a2qa+ke1tfNbT26b+POUfvKJp8AnBQwDMNc3cgsUVJSIklqbW3NcE8AADg0iuLm8seRaEzL1zQmPTqVaJ8aK8fpjxywNMIEwFtSfT4n+CRA8AEAIPlpa7dveNXUSM2ysiKtWjpvxJ8dGjkae5TrtkvmaPXT20ccYTryfW4YDQOQOoKPQwg+AIBsNtq0NWloqNgbieq81c+bXpuz5baLRh2RGW2UKz93vC0jTAC8I9Xnc1+s8enr69OHP/xhhcNhzZkzR9u3b890lwAASMjq4v90SWa6WTRmaF1jp9rDA1o4o8BU6Im3r23uGnUDz9E2+bx9w6tJb3ja0NGnmvptCUeYAGQHXwSflStXqqenJ9PdAABgVKku/k+XmvpWU6Hizd79ls6ztb131OCTyO7+iOpauk21qWvp0sols10RLAFkhuf38dm0aZPWrl2rL33pS5nuCgAACcVHUdY1jrxuRfrrKMryNY2KRGNp7V+4f1A/fL5N1/zk9/ovE2t1JOndvRFL5xwYPGCpXW1T4muYSHyECUD28vSIz/vvv6+vfOUrmjt3rv7hH/5B//7v/57pLgEAMCKzoyjpmpo11lqeZFhdLJyXY+0xJNnreDSrI0xOcPt0R8CPPB18ampqtGvXLv3mN79RKBTKdHcAABiRW6dmmSkd7YSFMyZZamd1pMhqOzt5Zboj4EeeDT6vvvqq7rnnHl133XW64IIL9MYbb2S6SwAAjCiVqVlmRyjMjCSYGYUaS0DmRn5CwYCq5hdaOpfVkSKr7exitmgElegAe3ky+Bw8eFBf+tKXNHHiRH3/+99P6VjxsnhH27Vrl2bOnJnSsQEAkNIzNcvsSIKVUajRHJcz3tSISmWp9Sld5cUF2txmvqiR1REmu7h1uiOQLTxZ3OAHP/iBGhsbddddd2nSpMx+iQEAMBanp2ZZKZxgZRTKjr5Kh4JLdcVcy+eqWlCoUDBgqk0qI0x2sDrdMdw/6FCPgOzjuRGfrq4u/dM//ZMuvPBCfeELX0j5eIk2QEo0EgQAgFlOT82yMpLQ/Z61EtSpOHLT01SmcJ2Un6vK0ulaZ6L6XCojTHZI53RHACPz3IjPjTfeqA8++ED/9//+30x3BQCApJQXF1hql8zULKsjCXv2Ry31yaozp5+gLbddpFVL59mybqW6oiTp65rqCJMdUpnuCMAenhvxefLJJzVx4kTdcMMNQ16PRA7tIdDZ2alFixYdfm9eXl66uwgAwBBVCwp1/6Y2U7/xT3ZqltWRhL2R9AafP76919bj5YaCWruiTDX121TXMvI1sGuEyQ5erkQH+IXngo8k7dmzR7/97W9H/Nn7779/+GcHDvBlAQDIPCenZmWqFLVZTkzbyg0FtWrpPK1cMlu1zV3a2t7r2j1xvFqJDvATz/3fZBgj/1brjTfeUHFxsebMmaPt27enuVcAAIyuuqJE7eF9SQUVM1OzrI4I5OeON12COi43NE6R6EHT7ZzaQHRKfo5uWjzL1WthvFqJDvATz63xAQDAi+JTs5aVFSWsSBYKBrSsrMjU/i1WRwROPHaC5p1yguW2VqR72la4f1A/fL5N1z7UoKsefEnXPtSgH73wp4xUSvNiJTrAbzw34gMAgFc5MTUrlZGEirOm6sLv/8b0xqNFBcfq7b9ETJ8zXdO2zO5plA5erEQH+A3BBwCANLNzalYqhROm5Oeocv4p+lXzn5NuW1laqFMm5lpaW5SOaVvxPY1G6198T6P28ICp0bVUOTXdEUByfDPV7bTTTpNhGKzvAQBklfhIghlHjiT88xXzTJeFdvO0LSt7GqWLU9MdASSHER8AADwulZEEK2Whc0NBV07bsrqn0cols9M2pcxLlegAvwkYicqkZbmSkhJJUmtra4Z7AgDA2A6ta0ltT5tw/2DSD+PJTCmLKy8uSMsIxg+fb9Pdz+403e7Wi+e4uiIcgENSfT4n+CRA8AEAeJGZ8JIqO8KWna59qMFSoYfzT5+sh68vd6BHAOyU6vM5U90AAPCRdO5p47ZpW1bLZae7zDaAzCD4AACAlLhlA1Gr5bLTVWYbQGb5pqobAADIbslWpztaOspsA8g8gg8AAPAFN5fZBpB5BB8AAOALqe5pBMDfCD4AAMA3qitKTG/ICiA7EHwAAIBvxDdkXVZWlHDaWygY0LKyorTsLQTAPShjAgAAfMVtZbYBuAPBBwAA+JJbymwDcAemugEAAADwPUZ8AADIUuH+Qa1v6lRDRx9TwQD4HsEHAIAsE4nGVFPfqrqWbkVjxpCfbW7r0X0bd6qytFDVFXNZ/A/ANwg+AABkkUg0puVrGtXQ0ZfwPdGYoXWNnWoPD1D5DIBvsMYHAIAsUlPfOmroOVJDR59q6rc53CMASA+CDwAAWWJ3f0R1Ld2m2tS1dCncP+hQjwAgfZjqBgCAi9lZgKC2qWvYmp6xRGOGapu7KAkNwPMIPgAAuJATBQiSneJ2tK3tvQQfAJ5H8AEAZBxllYdyqgDBwOABS/2x2g4A3ITgAwDIGMoqj8xKAYJVS+eN+d68HGt/7VttBwBuQnEDAEBGxEc11jUmXncSH9VYvqZRkWgszT3MDCcLEJQXF1jq08IZkyy1AwA3IfgAADKCssojS6UAwViqFhQqFAyYOnYoGFDV/EJTbQDAjQg+AIC0o6xyYqkUIBjLSfm5qiydbuq4laXZuc4KgP8QfAAAaefkqIbXOV2AoLqiJOkpb+XFBaqumGupPwDgNqxWBAA4JlG1ts1tPZaOlw1llZ0uQJAbCmrtijLV1G9TXcvIATQUDGRlUQkA/kbwAQDYbqxqbeZWmfxVNpRVLi8usBQMzRQgyA0FtWrpPK1cMlu1zV3a2t5LGXEAvkfwAQDYKpk9aMxNcvurY5IYffD6nkBVCwp1/6Y2U1MBrRYgmJKfo5sWz/L9KBoASAQfAIDNzFRrM2u0ER+/7AkUL0CwrjH59UwUIACAsVHcAABgGyvV2szY9tbeESu7+W1PIAoQAID9CD4AANtYqdZmxoGDI1d289ueQPECBMvKihLuuxMKBrSsrEhrV5S5egQLANyCqW4AANs4NcXtSEdXdrO6J9DKJbNdPT2MAgQAYC+CDwDANumounb0OVLZE8gLi/opQAAA9mCqGwDANlb3oEnlHFZHmba299rRHQCARxB8AAC2SXZBfiqO3q/G6ihTNuwJBAD4K4IPAMA2VQsKEy7Gt8NI+9VYHWVKx+gUAMA9CD4AANvE96Bxykj71VgdZTp65AgA4G8EHwCArczsQSNJyY4PJdqvxsoo00gjRwAAfyP4AABsdeQeNOOT+FsmXo8tUXQZa78aK6NMI40cAQD8jQnOAADbxfegef+DmB7/f39Oqo0h6czpJ+iEY0Km96uprihRe3hfUhXeEo0cAQD8jeADAHDE7v6InnrtLVNt/vj2Xm257SLTozHxUaaa+m2qaxl5X59QMKDK0kJVV8wdceQIAOBvBB8AgCPSvbFofJRp5ZLZqm3u0tb2XtMjRwAA/yL4AAAckcrGolaCT9yU/BzdtHhWSscAAPgPxQ0AAI5gY1EAgJsQfAAAjmBjUQCAmxB8AACOYGNRAICbEHwAAI5gY1EAgJsQfAAAjmBjUQCAmxB8AACOqa4oSXrKGxuLAgCcZGvw+d73vqe3337bzkMCADwsvrHosrKihNPeQsGAlpUVae2KMjYWBQA4JmAYhrnd5UYxbtw4jR8/Xpdddpm+9KUv6VOf+pQCAXPzu92ipKREktTa2prhngCAP4T7B9lYFABgWarP57YGn5qaGv385z/Xm2++qUAgoGnTpun666/XihUrVFRUZNdp0oLgAwAAALhHqs/ntk51q66uVnt7u37961/rqquu0u7du/Wd73xHM2bM0KWXXqrHHntMsVjMzlMCAAAAwJhsL24QCAR0ySWXqK6uTt3d3Vq9erVmzpypp59+WpWVlTrllFN0++23609/+pPdpwYAAACAETla1W3KlCn6xje+oR07dug3v/mNqqqqtHv3bn3/+9/XnDlzdNFFF+mxxx5zsgsAAAAAkJ5y1h0dHXr22We1efNmSZJhGJo6dapeeOEFVVZWqry8XN3d3enoCgAAAIAs5FjwiUajqq2t1ZIlS3T66afre9/7nt5//33dcsst2rZtm7q7u/Xiiy/qU5/6lJqamnTzzTc71RUAAAAAWW683Qf84x//qP/4j//Qww8/rN7eXhmGoYULF+orX/mKqqqqlJube/i95557rp588kktXLhQL7zwgt1dAQAAAABJNgef888/X1u2bJFhGDr++OP1la98RV/5ylc0b968UduVlJSoqanJzq4AAAAAwGG2Bp+XXnpJpaWl+vKXv6zPfOYzOvbYY5Nq98UvflEXXHCBnV0BAAAAgMNsDT6NjY2aP3++6XbnnHOOzjnnHDu7AgAAAACH2VrcwEroAQAAAACnpaWcNQAAAABkEsEHAAAAgO/ZXs4aAGBduH9Q65s61dDRp4HBA8rLGa+FMyapan6hpuTnZLp7AAB4FsEHAFwgEo2ppr5VdS3disaMIT/b3Naj+zbuVGVpoaor5io3FMxQLwEA8C6CDwBkWCQa0/I1jWro6Ev4nmjM0LrGTrWHB7R2RRnhBwAAk1jjAwAZVlPfOmroOVJDR59q6rc53CMAAPyH4AMAGbS7P6K6lm5TbepauhTuH3SoRwAA+BPBBwAyqLapa9ianrFEY4Zqm7sc6hEAAP5E8AGADEp2itvRtrb32twTAAD8jeADABk0MHggre0AAMhWBB8AyKC8HGvFNa22AwAgWxF8ACCDyosLLLVbOGOSzT0BAMDfCD4AkEFVCwoVCgZMtQkFA6qaX+hQjwAA8CfmSgBABp2Un6vK0ula15h8lbbK0kJNyc8Z8lq4f1DrmzrV0NGngcEDyssZr4UzJqlq/vD3AgCQjQg+AJBh1RUlag/vS6rCW3lxgaor5h7+cyQaU019q+pauoeVxd7c1qP7Nu5UZWmhqivmKjcUtL3vAAB4BVPdACDDckNBrV1RpmVlRQmnvYWCAS0rK9LaFWWHA0wkGtPyNY1a15h4L6BozNC6xk4tX9OoSDTm2GcAAMDtAoZhmNs5L0uUlJRIklpbWzPcEwBuF59mtrmtR519+/V+NKZjQkEVFRyrC2ZPMTXdLNw/qNrmLm1t7x1zytrtG141NUVuWVmRVi2dZ+qzAQDgFqk+nxN8EiD4ABhLfJrZr5q7dOBg4veNHxfQ1fPtnW62uz+i81Y/n3CkZyShYEBbbruINT8AAE9K9fmcqW4AYMGR08xGCz2SdOCg/dPNapsST29LJBozVNuc/AgRAAB+QvABAAtq6luTKkZwpIaOPtXUb7Pl/GbPHbe1vdeW8wMA4DUEHwAwaXd/RHUt3Zba1rV0Kdw/mHIfBgYPpLUdAABeR/ABAJOsTDOLs2u6WV6Otd0IrLYDAMDrCD4AYJLVaWZxdkw3Ky8usNRu4YxJKZ8bAAAvIvgAgEmpThezY7pZ1YJCjR838p4/iYwLSFd8dFrK5wYAwIsIPgBgUqrTxVJtH4nG9G/P7VTM5G4EBw3p/6v9AxuZAgCyEsEHAEyyOs0sLpXpZkeW0bayC5udleUAAPASVrkC8IRw/6DWN3WqoaNPA4MHlJczXgtnTFLV/MK0b8hZtaBQ929qs1TgIBQMqGp+oeVzWymjfbS6li6tXDKbjUwBAFmF4APA1SLRmGrqW1XX0j0saGxu69F9G3eqsrRQ1RVzlRsKpqVPJ+XnqrJ0utY1mq/OVllqPailUkb7SPHKcjctnpXysQAA8AqmugFwrSOndSUaXYnGDK1r7NTyNY1pXbtSXVFiespbeXGBqivmWj5nKmW0j8ZGpgCAbEPwAeBaZqZ1pXvtSm4oqLUryrSsrEjjx/gmHT8uoGVlRVq7oiylUalUp7gdiY1MAQDZxrNT3e699169+OKLeu2117R7925FIhGdfPLJWrRokb7xjW+opKQk010EkAIr07rSvXYlNxTUqqXztHLJbNU2d+l3O8Pq7Nuv96MxHRMKqqjgWF0we4pt65DsDCsTguP0w+fbXLFmCgCAdAgYhpW6QJk3efJk7du3T2eeeaZOOeUUSVJra6t27typCRMm6PHHH9enPvUpy8ePB6fW1lZb+gvAnB8+36a7n91put2tF8/x7dqVax9q0Oa2HluONS5wqLz10ULBQNrXTAEAkIxUn889O9XtiSee0HvvvaeGhgZt2LBBGzZs0I4dO/Tggw/qgw8+0Be/+EXFYuxVAXiV1Wldfl67kmoZ7SONFHqkzK2ZAgDAaZ4NPuedd55yc3OHvX7DDTdo1qxZeuutt7Rjx44M9AyAHaxO6/Lz2pWqBYUKBQNpORf7/QAA/MazwWc0weCh6RkTJkzIcE8AWJWXY20JotV2XhAvo50udS1dCvcPpu18AAA4yXfB5xe/+IV27Nih2bNna8aMGZnuDgCLrE7rWjhjks09cRcrZbStiu/3AwCAH3g++Nx11136whe+oKuvvlpnnHGGli9frmnTpumRRx7RuHGe/3hA1rIyrSsUDKhqfqFDPXKHI8top2Pam5/XTAEAsovn54Q888wz2rRp0+E/FxYW6uGHH1ZpaWlS7ROVvd61a5dmzpxpSx8BmBef1rWuMfkRh8rS7CjFfHQZ7drmLr3Zu9+Rc/l5zRQAILt4fkhk48aNMgxD7733nn73u99pzpw5WrRokf7lX/4l010DkCIz07rKiwtUXTHX4R65y5T8HN20eJaKCo517Bx+XjMFAMgunt3HJ5FoNKpzzjlHL7/8shoaGrRgwQJLx2EfH8AdItGYauq3qa6lS9HY8K8rN+w7E+4f1PqmzoxtBnrVgy/plc49jhzbz/siAQC8JdXnc9/9Ki8UCumaa65RS0uL6uvrLQcfAO5w9LSure292rM/qr2RqCQpP3e8ut/br4de7Ehb0Ig7FMpaVdfSPSyUbW7r0X0bd6YllDk1KpMNa6YAANnDd8FHkiZPnixJCofDGe4JALtMyc/R9R8vVvd7+7W1vTejQUM6FHqWr2kcdaPV+Gag7eEBrV1R5lifyosLtLmtx/bjZsuaKQBAdvD8Gp+R/Pa3v5UkihMAPhIPGusaR57yJv01aCxf06hINOZof2rqW0cNPUdq6OhT1U9+79ieOE5sbBqQdNNivkMBAP7hyeCzefNmrV+/XgcODK02FI1G9YMf/EAPP/ywjjnmGF1zzTUZ6iEAu5kNGjX12xzry+7+iOpauk21ebX7Lzpn1SbdvuE120OZExubGpKe+H9v2XpMAAAyyZNT3Xbt2qXrrrtOkydPVmlpqSZNmqSenh699tprevvtt5Wbm6uf//znKixkbjrgB1aCRl1Ll1Yume3IVK3apsSjTqM5cNC5qW/VFSVqD+9LOhwmY2t7L4UNAAC+4ckRnwsvvFDf+ta3NGfOHL366qv61a9+pZdeekkFBQW6+eab9dprr6mqqirT3QRgEytBIxozVNuc/B5AZqQaLpwYkXJiY1P28AEA+IknR3yKi4vZpwfIIlaDhlMjFnYEAidGpEaqgDcweEAdPfu0Z3/U9PHYwwcA4CeeHPEBkF2sBg2nRizsCAROjkjFNzZ9+PpyPXbjefrix4stHWfhjEk29wwAgMwh+ABwPatBw6kRi/LiAluOs7W915bjjMVK1Tf28AEA+A3BB4DrWQ0aTo1Y2FU+Ol1raKxUfWMPHwCA3xB8ALie20Ys7Cofnc41NNUVJUkHyPLiAlVXzHW4RwAApBfBB4CrhfsHVdvUpUnHTTDVzukRCzNBIpF0rqFJpupbKBjQsrIi20ttAwDgBgHDMMxvRpEFSkpKJEmtra0Z7gmQWeH+Qa1v6lRDR58GBg8oL2e8Fs6YpKr5zgaLSDSmmvpW1bV0my5lXV5ckJaH90N93Kb/auyU2S/SUDCgLbddlJHpZOH+wSFV39L13xQAgFSk+nxO8EmA4INsN1bwCAUDqiwtVHXFXNsDRiQa0/I1jabLWDvZp0R290d07qrndeCgua/SK88+Rfdd81FnOgUAgA+l+nzOJg0AhkkmeERjhtY1dqo9PGD76EpNfaup0HPy8bm69pxTMzJiUdvUZTr0SNJpk451oDcAACAR1vgAGMZM8Gjo6FNN/Tbbzr27P6K6lm5TbXr3DWZsmpbVzVVb3nzP5p4AAIDREHwADGEleNS1dCncP2jL+Wubukyv6XFyM9CxuG1zVQAAMDKCD4AhMh08rI6gpGsz0KO5bXNVAAAwMv7mBTBEKsHjpsWzUj6/10ZQyosLtLmtx3Q7O0tZZ6ryHgAAXkLwATBEpoOH10ZQqhYU6v5NbaZGyezaXHW0ynub23p038adaa9yBwCAWzHVDcAQmQ4eVjcFTedmoEc6KT9XlaXTTbWxY3PVeOW9dY2JpybGK+8tX9OoSDSW0vkAAPA6gg+AITIdPKoWFCoUDJhqY9cIilXVFSVJX7fy4gJVV8xN+ZyZrLwHAIAXEXwADJHp4JGpEZRU5IaCWruiTMvKihJeu1AwoGVlRbbseZTpynsAAHgRa3wADBEPHusak6/SZnfwqK4oUXt4X1IjGnaNoKQqNxTUqqXztHLJbNU2d2lre69jhQZSqbxnRwEKAAC8iOADYJhMB4/4CEpN/TbVtYz8kB8KBly5cH9Kfo5uWjzL0YCR6cp7AAB4EcEHwDBuCB7pHEHxmkxX3gMAwIsIPgBG5JbgkY4RFK/JdOU9AAC8iL8FAYzKruDBJpv2ccOmqQAAeA3BB4Cj2GTTfpncNBUAAK+inDUAx7DJpjO8WPIbAIBMI/gAcAybbDonE5umAgDgZQQfAI5gk01npXvTVAAAvI41PgAcwSabznNL5T0AALyA4APAEWyymT6U/AYAYGxMdQPgCDbZBAAAbkLwAeAINtkEAABuQvAB4IhkK44djU02AQCAEwg+ABxRtaAwYbWxRNhkEwAAOIXgA8ARbLIJAADchOADwDFssgkAANyCVcSABeH+Qa1v6lRDRx/7powivslmTf021bWMvK9PKBhQZWmhqivmsskmAABwDMEHMCESjammvlV1Ld3DHuI3t/Xovo07eYj/X0eHw48VnagJ48fpgwMH9UHsIGERAACkFcEHSFIkGtPyNY2jbswZjRla19ip9vCA1q4oc1X4Sdco1WjhUMqeER5GBQEAcJeAYRjDn0ygkpISSVJra2uGewK3uH3Dq1rX2JX0+5eVFWnV0nkO9ig56QwiyYTDuPLiAteFQzsQ/AAAcEaqz+cUNwCSsLs/orqWblNt6lq6FO4fdKhHyYkHkXWNI6+vkf46SrV8TaMi0VhK56upb00q9EhSQ0efauq3pXQ+t0n39QYAAMkj+CDrhfsH9cPn23TtQw266sGXdO1DDfrRC38aElpqmxI/yCYSjRmqbU5+hMgJ6QwiXg2Hdsr24AcAgJsRfJC1ItGYbt/wqs5dvUl3P7tTm9t69ErnHm1u69Fdz+zQuas36fYNrykSjSX9MHu0re29Nvc6eekOIl4Nh3Yh+AEA4G4EH2Qls1OS9r4ftXSegcEDqXQzJekOIl4Mh3bK9uAHAIDbEXyQlcxOSXp3r7XfyuflZK5wYrqDiNWQl8lwaKdsD34AALgdwQdZx8qUpN39EUvnWjhjkqV2dkh3ELEa8jIZDu2U7cEPAAC3I/gg61iZknTQkMYFzJ0nFAyoan6huUY2SncQKS8usNQuk+HQTtke/AAAcDuCD7KO1SlJJ5ncdLKyNLMbVaY7iFQtKFQoaC4dZjoc2inbgx8AAG5H8EHWsTq16EMn5Cb9cFteXKDqirmWzmOXdAeRk/JzVVk63VSbTIdDO2V78AMAwO0IPsg6VqcWHZ8b0toVZVpWVpTwATcUDGhZWZHWrihTbiiYSjdTlokgUl1R4qlwaKdsD34AALgdk8uRdcqLC7S5rcd0u4UzJik3FNSqpfO0csls1TZ3aWt7rwYGDygvZ7wWzpikqvnuepCtrihRe3hfUtP77AgiuaGg1q4oU039NtW1jLyWKhQMqLK0UNUVczMeDu2W7usNAACSFzAMw9wq7yxRUlIiSWptbc1wT2C33f0Rnbf6eVMFDkLBgLbcdpGrQk2yItFYRoJIuH/QE+HQbpm63gAA+F2qz+cEnwQIPv52+4ZXta4x+Y0jl5UVadXSeQ72yHnZGkQyhesNAIC9CD4OIfj4WyQa0/I1jUlPSXLDmh0AAIBslurzOcUNkJXia1G8UqgAAAAAqaG4AbKW1woVAAAAwDqCD7LelPwc3bR4lm5aPCvTXQEAAIBDmOoGAAAAwPcIPgAAAAB8j6lucL1w/6DWN3WqoaOPNTgAAACwhOAD1zq0EWSr6lq6h20EubmtR/dt3MlGkAAAAEgKwQeulMw+O9GYoXWNnWoPD1ByGgAAAKMi+MCVaupbk9pcVJIaOvpUU79Nq5bOc7hXmce0PwAAAGsIPnCd3f0R1bV0m2pT19KllUtm+/bhn2l/AAAAqaGqG1yntqlr2MP9WKIxQ7XNXQ71KLPi0/7WNSa+LvFpf8vXNCoSjaW5hwAAAO7HiA9cJ9kpbkfb2t7ry01IMzXtj2l1AADATwg+cJ2BwQNpbedmmZj2x7Q6AADgR0x1g+vk5VjL41bbuVm6p/0xrQ4AAPgVwQeuU15cYKndwhmTbO5J5qUy7c8KK9PqAAAAvIDgA9epWlCoUDBgqk0oGFDV/EKHepQ56Zz2Z3VaXbh/0PS5AAAA0o3gA9c5KT9XlaXTTbWpLPXngvt0Tvujmh4AAPAzgg9cqbqiJOkpb+XFBaqumOtwjzIjndP+0j2tDgAAIJ0IPnCl3FBQa1eUaVlZUcJpb6FgQMvKirR2RZlvq4ulc9of1fQAAICf+a8MFnwjNxTUqqXztHLJbNU2d2lre2/W7ScTn/a3rjH56WRWp/1RTQ8AAPgZTyxwvSn5Obpp8Sxfbk6ajOqKErWH9yU1FS2VaX/lxQXa3NZjup0fq+kBAAD/Yaob4HLpmvZHNT0AAOBnjPgAHpCOaX/pnFYHAACQbgQfwEOcnvZXXVGiP+0eUNMb74353gWnnejbanoAAMB/mOoGYKhkt/Ixt+UPAABARhF8ABxWU9+qpjfHHu2RpKY331NN/TaHewQAAGAPproBCYT7B7W+qVMNHX1ZUUZ7d39EdS3dptrUtXRp5ZLZpq5Htl1XAADgDgQf+IKdD9ORaEw19a2qa+lWNDZ0Ptfmth7dt3GnKksLVV0x11cbp9Y2dQ37vGOJxgzVNnclteYoW68rAABwB4IPPM3uh+lINKblaxpH3TMnGjO0rrFT7eGBlMpHu00y+wSNZGt775jBJ5uvKwAAcAfW+MCz4g/T6xoTj1TEH6aXr2lUJBob85g19a1JB4CGjj5frXEZGDzgWLtsvq4AAMAdCD7wLLsfpq2ucQn3D5pq41Z5OdYGgMdql+3XFQAAuAPBB57kxMN0Kmtc/KC8uMBSu4UzJo3682y/rgAAwB0IPvAkJx6mU1nj4gdVCwoVCgZMtQkFA6qaXzjqe7L9ugIAAHcg+MCTnHiYdnKNixeclJ+rytLpptpUlo5dNS/brysAAHAHgg88yYmHaafWuHhJdUVJ0lPeyosLVF0xd8z3cV0BAIAb8GQBT3LiYbq8uECb23pMH3OsNS5ekhsKau2KMtXUb1Ndy8jTCUPBwJAS4WPtocR1BQAAbkDwgSc58TBdtaBQ929qM7V2KJk1Ll6TGwpq1dJ5Wrlktmqbu7S1vXfEQBOJxnT7hlfH3EPpxkUzua4AACDjCD7wJCdCSnyNy7rG5KuJJbPGxaum5OfopsWzRtyc1OyGpFeefYp+1Zx8FT4/X1cAAJAZrPGBJzm1EN+JNS5+ZHYPJSn5ctnZfF0BAIBzCD7wLCdCSnyNy7KyooSlnUPBgJaVFWntijLlhoKm+uwHVvZQevyVP+vuq8/iugIAgIwJGIZhbjOULFFSUiJJam1tzXBPMJpINGZqIb4Z4f7BUde4ZKsfPt+mu5/dabrdrRfP0U2LZ3FdAQCAJak+nxN8EiD4eAsP0+lz7UMNlgpLnH/6ZD18fbkDPQIAANkg1edzTxY32L9/v5599lnV19erqalJb7zxhmKxmGbNmqVPf/rTWrlypfLy8jLdTaTRaAvxYS82JAUAAF7kyTU+jzzyiK666iqtWbNGBw8e1CWXXKLzzz9fHR0dqq6u1oIFC7R79+5MdxPwJTYkBQAAXuTJ4DNhwgTdcMMN2rlzp15//XXV1tbq6aef1o4dO3T22Wdr+/bt+vrXv57pbgK+lGxBiaOxISkAAMgk363x+f3vf69zzz1XOTk52rt3ryZMmGDpOKzxsSbcP6j1TZ1q6OhjrY1P7e6P6LzVz5veQ2nLbRdxDwAAAMuyco3PaM466yxJ0uDgoHp7ezV16tQM9yg7HKqu1qq6lu5hD8Sb23p038adlqurwV3Y6BUAAHiRJ6e6jaa9vV2SFAqFVFBgbUoOzIlEY1q+plHrGkcuKS1J0ZihdY2dWr6mUZFoLM09hN3Y6BUAAHiN74LP/fffL0m65JJLlJPDb5jToaa+VQ0dfUm9t6GjTzX12xzuEZzGRq8AAMBrfLXG59e//rX+5m/+RuPHj1dTU9PhaW+jic8VPNquXbs0c+ZM1viMIRPrPVhH5C7soQQAANKBNT7/649//KM+97nPyTAM3XXXXUmFHqSutinx9LZEojFDtc1dpvfcYR2RdU6GRfZQAgAAXuCL4NPd3a1LLrlE7733nlauXKlbbrkl6baJEmOikSAMlewUt6Ntbe819aAcX0c02vni64jawwNMr/pfhEUAAIBDPL/Gp6enR0uWLFFnZ6euu+463X333ZnuUlYZGDyQlnasIzKPohMAAAB/5eng09/fr0996lPavn27li5dqp/+9KcKBEZeaA1n5OVYGzQ00253f0R1Ld2mjl/X0qVw/6DZbvkKYREAAOCvPBt8BgcHdcUVV6i5uVkXX3yx1q1bp2CQqTrplmxJ46MtnDEp6femso4oWxEWAQAAhvJk8InFYlq2bJleeOEFnX/++dqwYYMmTJiQ6W5lpaoFhQnLGScSCgZUNb8w6fenso4oWxEWAQAAhvJkcYMf/vCHeuyxxyRJkydP1o033jji++6++25Nnjw5nV3LOifl56qydLrWNSb/wFxZaq6SWLrWEflJuopOAAAAeIUng8977713+N/jAWgkd955J8EnDaorStQe3pfUw3Z5cYGqK+aaOn461hH5DWERAABgKE9OdbvzzjtlGMaY/5x22mmZ7mpWyA0FtXZFmZaVFSWc9hYKBrSsrMhSmel0rCPyG8IiAADAUDzlwBa5oaBWLZ2nlUtmq7a5S1vbe23bKLNqQaHu39Rmas2K2XVEflNeXKDNbT2m22VzWAQAAP5G8IGtpuTn6KbFs2xdJ5KOdUR+Q1gEAAAYypNT3ZB9qitKkp7yZmUdkd/Ew6IZ2R4WAQCAvxF84AlOryPyI8IiAADAXwUMwzC32UeWKCkpkSS1trZmuCc4Wrh/0PZ1RH4VicZUU79NdS0j7+sTCgZUWVqo6oq5hEUAAOBqqT6fE3wSIPjATwiLAADA61J9Pqe4AWCjcP+g1jd1qqGjz1UBw4miEwAAAF5C8AFscGhKWavqWrqHTSnb3Naj+zbuZEoZAABABhF8gBRFojEtX9Ooho6+hO+Jxgyta+xUe3iA4gsAAAAZQFU3IEU19a2jhp4jNXT0qaZ+m8M9AgAAwNEIPkAKdvdHVNfSbapNXUuXwv2DDvUIAAAAIyH4ACmobRq5TPRoojFDtc1dDvUIAAAAI2GND1zLrRXSjpTsFLejbW3vpcIaAABAGhF84DpeqpA2MHggre0AAABgDcEHruK1Cml5Odb+F7LaDgAAANawxgeu4rUKaeXFBZbaLZwxyeaeAAAAYDQEH7iGFyukVS0oVCgYMNUmFAyoan6hQz0CAADASAg+cA0vVkg7KT9XlaXTTbWpLHVPcQYAAIBsQfCBa6RSIS2TqitKkp7yVl5coOqKuQ73CAAAAEcj+MA1vFohLTcU1NoVZVpWVpRw2lsoGNCysqKMF2MAAADIVpSWgmt4uUJabiioVUvnaeWS2apt7tLW9l7X7j0EAACQjTL/xAj8r/LiAm1u6zHdzk0V0qbk5+imxbPYnBQAAMBlCD5wjaoFhbp/U5upAgdWKqSF+we1vqlTDR19jMoAAABkCYIPXCNeIW1dY/JV2sxUSItEY6qpb1VdS/ewcLW5rUf3bdypytJCVVfMZR0OAACAz1DcAK7iVIW0SDSm5Wsata4xccnsaMzQusZOLV/TqEg0lnSfAQAA4H4EH7iKUxXSaupbky6X3dDRp5r6bUn3GQAAAO7HVDe4jt0V0nb3R1TX0m2qD3UtXVq5ZDZrfgAAAHyC4APXsqtCWm1T4ultiURjhmqbu6jOBgAA4BNMdYPvJTvF7Whb23tt7gkAAAAyhREfZEQ6S0oPDB5IazsAAAC4D8EHtkkmzGSipHRejrXb3Go7AAAAuA9PdkhZsmHmm5fM0Zcfbhl16lm8pHR7eMBU1bbRlBcXaHNbj+l2C2dMSvncAAAAcAfW+CAlZvbHWfJvv8tISemqBYUJS2MnEgoGVDW/0JbzAwAAIPMIPkiJmf1xwv2Dpo5d19Jlus1ITsrPVWXpdFNtKkvtX2sEAACAzGGqGyyzsj+OGWZLSo+2xqi6okTt4X1JhbTy4gJVV8xNtfsAAABwEYIPLLOyP45ZW9t7xww+ya4x+vdrS7X66R2qaxm536FgwPbCCgAAAHAHgg8ss7o/jhljlZSOrzEyUzBh5ZLZqm3u0tb2XsdLaQMAAMAdCD6wLB373IxVUtrMGqN4wYRVS+fppsWzkp5CBwAAAO+juAEsS8c+N6OVlLayxsiuggkAAADwFoIPLCsvLnD0+GOVlLayxiheMAEAAADZheADy6zsj2PGWCWlra4x2trea7VLAAAA8CiCDyyzsj/OSUkWD0impLTVNUbpWJsEAAAAdyH4ICXVFSVJT3krLy7Qs39/gZaVFSUcKQoFA1pWVqS1K8rGLCltdY1ROtYmAQAAwF14AkRKckNBrV1Rppr6bUnvj7Nq6TxbSkqXFxdoc1uP6T6PVjABAAAA/hQwDMPZHSg9qqSkRJLU2tqa4Z54R7h/MK374+zuj+i81c+bKnAQCga05baL2K8HAADAY1J9PmfEB7aZkp+T1v1x4muM1jUmX6VtrIIJAAAA8CeCjw+F+we1vqlTDR19aRl5yaTqihK1h/clVeEtmYIJAAAA8CemuiXgxalukWhMNfWtqmvpTmqtjV8c+tzJrzECAACA96T6fE7wScBrwScSjWn5msakRz6SqZrmNeleYwQAAID0Ifg4xGvB5/YNr5pa67KsrEirls5zsEcAAACAfVJ9PmcfHx/Y3R9RXUu3qTZ1LV0K9w861CMAAADAXQg+PlDbNPLaltFEY4Zqm5MfIQIAAAC8jODjA8ms6xnJ1vZem3sCAAAAuBPBxwcGBg+ktR0AAADgNezj41Jm9uLJy7H2n9FqOwAAAMBrePJ1mdH24tnc1qP7Nu4ctidNeXGBNrf1mD7XwhmTbOkzAAAA4HZMdXOR+F486xoTFyuIxgyta+zU8jWNikRjkqSqBYUKBQOmzhUKBlQ1vzDlPgMAAABeQPBxkZr61qQLFTR09Kmmfpsk6aT8XFWWTjd1rspSNvUEAABA9iD4uESqe/FUV5SovLggqXblxQWqrphruo8AAACAVxF8XCLVvXhyQ0GtXVGmZWVFCae9hYIBLSsr0toVZYfXBwEAAADZgOIGLpHKXjw3LZ4l6VD4WbV0nlYuma3a5i5tbe8dsyIcAAAAkA0IPi5h5148U/JzdNPiWYcDEQAAAJDtmOrmEuzFAwAAADiH4OMSyRYmOBp78QAAAABjI/i4BHvxAAAAAM4h+LgEe/EAAAAAziH4uAh78QAAAADOIPi4CHvxAAAAAM6gJJjLsBcPAAAAYD+Cj0uxFw8AAABgH4KPy4X7B7W+qVMNHX2M/AAAAAAWEXxcKhKNqaa+VXUt3YrGjCE/29zWo/s27lRlaaGqK+ay1gcAAAAYA8HHhSLRmJavaVRDR1/C90RjhtY1dqo9PEChAwAAAGAMVHVzoZr61lFDz5EaOvpUU7/N4R4BAAAA3kbwcZnd/RHVtXSbalPX0qVw/6BDPQIAAAC8j+DjMrVNXcPW9IwlGjNU29zlUI8AAAAA7yP4uEyyU9yOtrW91+aeAAAAAP5B8HGZgcEDaW0HAAAAZAOCj8vk5VgrtGe1HQAAAJANCD4uU15cYKndwhmTbO4JAAAA4B8EH5epWlCoUDBgqk0oGFDV/EKHegQAAAB4H8HHZU7Kz1Vl6XRTbYoKjlN+LlPdAAAAgEQIPi5UXVFiasrbrvCAlq9pVCQac7BXAAAAgHcRfFwoNxTU2hVlmjnluKTbNHT0qaZ+m4O9AgAAALyL4ONSeyNRdfbtN9WmrqVL4f5Bh3oEAAAAeBfBx6Vqm7oUjRmm2kRjhmqbuxzqEQAAAOBdBB+Xaujos9Rua3uvzT0BAAAAvI/g41IDgwfS2g4AAADwM4KPS+XlWCtPbbUdAAAA4GcEH5cyU876SAtnTLK5JwAAAID3EXxcqmpBoULBgKk2oWBAVfMLHeoRAAAA4F0EH5c6KT9XlaXTTbWpLC3UlPwch3oEAAAAeBfBx8WqK0qSnvJWXlyg6oq5DvcIAAAA8CaCj4vlhoJau6JMy8qKEk57CwUDWlZWpLUrypQbCqa5hwAAAIA3eLYEWEtLi5577jk1NjaqoaFBb731lnJychSJRDLdNVvlhoJatXSeVi6ZrdrmLm1t79XA4AHl5YzXwhmTVDWf6W0AAADAWAKGYRiZ7oQVV155pZ544okhr9kZfEpKSiRJra2tthwPAAAAgHWpPp97dsTnnHPO0VlnnaUFCxZowYIFOvnkkzPdJQAAAAAu5dng881vfjPTXQAAAADgERQ3AAAAAOB7BB8AAAAAvufZqW52iS+SOtquXbs0c+bMNPcGAAAAgBMY8QEAAADge1k/4pOoHF6ikSAAAAAA3sOIDwAAAADfI/gAAAAA8D2CDwAAAADfI/gAAAAA8D2CDwAAAADf82xVt6eeekr//M//POS1Dz74QAsXLjz85zvuuEOXXXZZursGAAAAwGU8G3zC4bAaGhqGvGYYxpDXwuFwursFAAAAwIUChmEYme6EG8X38Um0zw8AAACA9En1+Zzgk0B+fr6i0ahmzpyZ6a4AAAAAWW/Xrl0KhULq7++31J7iBgkcd9xxCoVCth93165d2rVrl+3HBdfWaVxf53BtncX1dQ7X1jlcW2dxfZ3j5LUNhUI67rjjLLdnxCfNmELnHK6ts7i+zuHaOovr6xyurXO4ts7i+jrHzdeWER8AAAAAvkfwAQAAAOB7BB8AAAAAvkfwAQAAAOB7BB8AAAAAvkdVNwAAAAC+x4gPAAAAAN8j+AAAAADwPYIPAAAAAN8j+AAAAADwPYIPAAAAAN8j+AAAAADwPYIPAAAAAN8j+KRg3759evjhh3XzzTerrKxMOTk5CgQCWr16dUrHffLJJ3XhhRfqhBNO0PHHH68LL7xQTz755Kht/vjHP+rqq6/WlClTdMwxx2jevHn6t3/7Nx08eDClvrjBli1bdOmll6qgoEB5eXkqKyvT2rVrTR/ntNNOUyAQGPWfGTNmDGnzxhtvjPr+k08+2a6PmRF2Xduf//zno16nv/3bv03Y1q/3rl3XtqWlRXfeeafOP/98TZs2TTk5OSosLNTnPvc5vfrqqyO28cN9G4lEVF1drdmzZys3N1fTpk3TihUr1N3dbfpYe/bs0de//nWdeuqpysnJ0amnnqpbbrlFe/bsSdjm4MGDuu+++zRv3jwdc8wxmjJliq6++mpt27YthU/lDnZc2z179uiRRx7RZz7zGc2dO1fHHXec8vPzVV5ervvvv1/RaHTEdl/4whdGvTd//OMf2/UxM8aue3esv7O2b98+Yjvu3dGN9fdV/J9f/OIXQ9r5+d5taWnR6tWrtXTpUp1yyikKBALKzc21fDw3f+eOt/VoWaatrU2f//znbT3mAw88oFtuuUXjx4/XJz/5SeXk5OjZZ59VRUWF7r//fn3ta18b1mbr1q266KKLtH//fpWVlem0007T7373O61cuVIvvfSSfvWrXykQCNjaz3R57LHHdPXVV+vgwYO64IILNHnyZG3atElf+MIX9Ic//EH33ntv0seqrKxUT0/PiD/77W9/qzfeeEPnn3/+iD//0Ic+pEsuuWTY6yeccELS53cbO69t3FlnnaWPfvSjw14vLy8f8f1+vXfturYHDhzQ/PnzJUmTJ09WWVmZjj32WL3yyiv65S9/qdraWj3yyCOqrKwcsb1X79tIJKKLLrpIW7Zs0dSpU3XFFVfojTfe0M9+9jM9+eST+v3vf6+ZM2cmdaze3l6dc845amtr04wZM3TllVeqtbVVDzzwgH79619r69atmjRp0pA2hmHommuuUV1dnSZOnKjLLrtMPT09evTRR/XUU0/phRdeSHhPu51d1/buu+/Wv/zLv2jcuHE6++yzVVFRoXA4rJdeekmNjY2qq6vTM888o2OPPXbE9hdffPGIAXzOnDkpf8ZMsvPejVu+fPmIr4/0/zH37tjXdtasWQmv6V/+8hc9/vjjkqSPf/zjI77Hj/fuP//zP+uJJ56w5Viu/841YNmf/vQn4/rrrzd+8pOfGC+//LLxj//4j4YkY9WqVZaOt2PHDmP8+PFGTk6OsWXLliGvT5o0yRg/fryxc+fOIW2i0agxc+ZMQ5Jx7733Hn69v7/fOOeccwxJxpo1a6x9wAzr6+szTjjhBEOS8eijjx5+/Z133jFmzZplSDKef/75lM8Ti8WMadOmGZKM5557bsjPOjo6DEnGhRdemPJ53MTua/uzn/3MkGRUV1cn3cav966d1zYajRrl5eXGk08+acRiscOvx2Kxw983+fn5RjgcHtLO6/ftHXfcYUgyzjnnHKO/v//w6/fcc48hybjggguSPta1115rSDKWLl1qRKPRw6/ffPPNhiTj85///LA2Dz30kCHJOP3004133nnn8Ot1dXWGJGPmzJlDjuUldl3bVatWGd/61reM7u7uIa/v3LnTKCoqMiQZt99++7B2y5cvNyQZL7zwQkqfw63svHdPPfVUw+xjGvduah588EFDknHeeecN+5mf793Vq1cb3/72t436+nrjnXfeMSQZOTk5lo7l9u9cgo+NqqurUwo+N954oyHJuOWWW4b97N577zUkGV/96leHvF5bW2tIMs4666xhbV5++WVDknHGGWdY6k+mff/73zckGVdcccWwn23YsMGQZPzN3/xNyud59tlnDUnGtGnThjxcGob3HyATsfvaWgk+fr1303XfHjx40Pjwhz9sSDJ+/vOfD/mZl+/bDz74wJg4caIhyXj55ZeH/fzMM880JBnNzc1jHuvtt982xo0bZ4RCoSF/mRqGYUQiEWPKlClGMBgc9rO5c+cakozHHnts2DEvv/xyQ5JRV1dn7oO5gJ3XdjSPPPKIIck47bTThv3Mzw+Pdl9fK8GHeze1e/fcc881JBk//vGPh/3Mz/fu0awGHy9857LGx0Xi63hGmrZy9dVXS5Lq6+uTbnP22WdrxowZev311/XGG2/Y3FvnjfbZLrvsMuXm5mrjxo2KRCIpnec///M/JUmf/exnNW5cdvwvka5ra7UPXr5303VtA4GA5s2bJ0l66623UjqWm7z44ovas2ePZs6cqbPPPnvYz+PX9ejvwpH8z//8z+Hphh/60IeG/CwnJ0cVFRWKxWL6n//5n8Ovd3R0aNu2bTrmmGN02WWXpXR+t7Hz2o7mrLPOkuSv+zIZ6bq+iXDvpvbZOjo6tGXLFk2YMEFVVVWWj5PNvPCdyxofl9izZ486OzslacT/qadPn67JkyfrzTff1F/+8pfDc3v/8Ic/SJI+9rGPjXjcj33sY2pvb9cf/vAHnXbaac503iHxhdsjfbYJEybojDPOUHNzs3bs2HH4L1qz3n//fT322GOSpM997nMJ3/fuu++qurpab7/9tk444QSVl5fr8ssv14QJEyydN9OcurYtLS269dZbtXfvXp188sn6xCc+oQsvvHDE9/r13k3HfRvX3t4uSQmLFXjxvk3mvjjyfakea82aNUOOFf/3M844Q6FQKKXzu42d13Y0Y92XkrRhwwY9+uijisViKi4uVkVFhT784Q+ndN5Mc+r63nXXXdq1a5dycnJUUlKiq666SlOmTEl4fu5da+K/BL3ssst04oknJnyfH+9du3jhO5fg4xLx0HPiiSfquOOOG/E906dPV09Pjzo7Ow//pjfebvr06QnbHPk+r9i7d+/h6h+jfbbm5mZ1dnZafoB8/PHH1d/frzPPPFNnnnlmwvdt375d3/nOd4a8VlRUpNraWs8tFHXy2j755JNDKhB+5zvf0YUXXqj169cP++2PH+/ddN230qHfgLa0tGjChAkjFjCQvHnf2nlfWDmWH+/LuHR9tvvvv1+SdMUVVyR8zw9+8IMhf/7mN7+pG264Qffff7/Gj/fmo4lT1/cb3/jGkD///d//vR544AFdf/31aTm/G6Tjs/3yl7+UJF177bWjvs+P965dvPCdmx3zejxgYGBAkhJWwJF0OBDF35tMu5HaeMGR/XXysz388MOSEn/R5eTk6IYbbtBvfvMbvfvuu/rLX/6i3//+97r00kvV2dmpSy65xHNTsZy4tlOnTtWdd96pV155RX/5y1/0zjvv6L//+7/14Q9/WL/97W912WWXKRaLjdgPP9276bpv9+7dqxUrVkg69BA0derUIT/38n1r531h5Vh+vC/j0vHZfvzjH2vjxo2aOHGibrvttmE/P/vss/XjH/9YO3fu1P79+9Xe3q4f/ehHmjhxoh588EHdeuutls+daXZf38svv1wbNmzQm2++qf379+v111/XypUrNTg4qC9+8YuHq485dX43cfqzNTY2aseOHTrxxBNHnG4l+fvetYsXvnOzOppWVlbq9ddfN9XmF7/4hcrKymzvi2EYkjRq6d74e0aSqN1obZyWyvVNpt+pfrZwOKznnntO48aN02c+85kR3zN16lQ9+OCDQ15buHChnnrqKX32s5/VI488ou9973v693//95T6Ypbbru3FF1+siy+++PCfjz/+eFVUVGjx4sUqLS1VS0uL1q9fP+J1dtu967Zre7RYLKbPfOYzamtrU1lZ2bARHcm9920yxvouNHP9rBwrme9ir7Lz2o7kt7/9rW655RYFAgGtWbNG06ZNG/aeW265Zcifi4uLdeONN+qCCy5QaWmpfvCDH2jlypUqLCxMqS+ZYPf1feCBB4b8uaSkRPfcc4/mzJmjL3/5y/rmN7+pK6+8Munze5nT9258mts111yTcCqwn+9du3jhOzerg88bb7yhHTt2mGqzf/9+R/qSn58v6dCmqGOdOy8v7/BreXl5eu+99xK2G6lNuqRyfePXI/7a8ccfn/C9Vj/bunXrdODAAS1ZsmTEv6DH8q1vfUuPPPKInnnmGUvnT4Xbr21cXl6evva1r+mrX/2qnnnmmSHBx633rtuv7d/93d/pqaee0pw5c/TUU0+ZXq+Tyfs2GWN9F5q5flaONVab+OuZ+E5NlZ3X9mivvvqqrrzySn3wwQd64IEHdNVVV5lqf8YZZ+jyyy9XXV2dNm7cqOuuu850HzLNyet7pC9+8Yu64447tHPnTnV0dKi4uDip83PvjuzAgQNav369pLGnuY3ED/euXbzwnZvVU92am5tlHCrpnfQ/ixYtcqQvRUVFkjTqg2B8Z+L4e4/890S7Fo/UJl1Sub7HH3/84QIOTn22+G94RitqMJrTTz9dkvT2229bap8Kt1/bIyW6Tm69d918bW+99VatWbNGhYWFeu655zR58mTTx8jkfZsMO+8LK8dy631pB6c+265du3TxxRdrz549uvPOO3XzzTdb6p/b782xpOveGTdu3OGNOo+8Vty71j7bs88+q927d2vGjBk699xzLfXP6/euXbzwnZvVwcdNJk6cePg/6iuvvDLs593d3erp6VFRUdGQ3Zrji6NffvnlEY8bf320hftuNdpni0ajev3115WTk2Npt+SdO3eqqalJxx57rJYuXWqpf++9954kb/72zMlre7RE18mv965T13bVqlW6++67ddJJJ+m5556zPJ3C7fetnfeFlWPF27z++uuKRqMpnd9tnPh/7q233tKSJUv0zjvv6JZbblF1dbXl/rn93hxLOr/TRrpW3LvWPluqvwSVvH/v2sUT37mWdwDCMKluYHrDDTeMuYHpjTfeOOT19evXj7kJ5Ny5cy31J9P+9V//dcyNIC+99FJLx47vAP3Zz37Wcv9+9KMfGZKMT37yk5aPkSlOXtujXX311YYk47vf/e6Q1/167zpxbX/yk58YkoyJEycar7zySkr9c/t9Ozg4aJxwwgljblTY2Ng45rHeeustY9y4ccaECROMd999d8jP4pvpjRs3znj77beH/OwjH/nImJvp1dbWmvtgLmDntTUMw+jr6zPOOOMMQ5Jx3XXXGQcPHrTct0gkYhQWFhqSjBdffNHycTLJ7uubyOuvv24EAgHj2GOPNQYHB4f8jHvX3LXt7+83jj32WEOSsXPnTkt988O9ezRZ3MDUC9+5BB8bJRt85syZY8yZM8fo7u4e8vr27duNYDBo5OTkGL///e8Pv75z505j0qRJRjAYNLZv3z6kzQcffGAUFxcbkox777338OsDAwPGOeecY0gy/uM//sOGT5d+vb29xvHHH29IMh599NHDr7/77rvGrFmzDEnGxo0bh7VLdH2PNGPGDEOS8fTTT4/ah7Vr1xpdXV3DXn/00UeN/Px8Q5KxYcMGE5/KHey+tvfff7/R398/5LUPPvjAuPPOOw1JxjHHHDOsjV/vXbuv7a9+9Stj3LhxRl5enrFly5ak+uD1+/Yf//EfDUnGueeeawwMDBx+/Z577jEkGR//+MeHvP8HP/iBMWfOHOO2224bdqzPfvazhiTj05/+tBGNRg+//rWvfc2QZHzuc58b1uanP/2pIck4/fTTh/zl/eijjxqSjOLiYuODDz6w46OmnV3Xdt++fcbChQsNSUZVVZVx4MCBMc+9fft24/HHHx/23t27dxtXXnnl4V+EpBKgMs2u6/v0008bzc3Nw47/hz/84fBD4te+9rVhP+fe/avRvhfi1q5da0gyFi5cOOq5s+HePdJYwcfL37kEnxRdeeWVRnl5uVFeXm6ccsophiSjsLDw8GtXXnnlsDaSDElGR0fHsJ/FR3bGjx9vfOpTnzKuuOIK45hjjhn2cHikl1566fB7ysvLjaqqKmPq1KmGJOPKK680YrGY3R87berq6oxx48YZgUDAWLRokVFZWWlMnDgx4Ze+YYx+fQ3j0PWSZJx88slj/mV94YUXGuPGjTPmzp1rXHrppcbSpUuND3/4w4fPceutt6b6ETPGzmsbDzelpaXG0qVLjUsvvdSYNm2aIcnIzc0dEgCO5Nd7165r++677xoTJkwwJBnz5s0zli9fPuI/R/+WzOv37fvvv2+Ul5cbkoypU6caVVVVh/88adIko62tbcj74790Wr58+bBjhcNhY+bMmYYkY+bMmcY111xzeJRi5syZRjgcHtYmFosZV111lSHJOPHEE43Kykpj0aJFRiAQMHJzc42XXnrJqY/uOLuu7de//nVDkhEMBo3PfOYzCe/NI73wwguHz3PeeecZVVVVxqJFiw6H8enTpxs7duxw+Ao4y67rG3/91FNPNT7xiU8Y11xzjVFWVmaMHz/ekGRceOGFxr59+4adn3v3r0b7XohbsmSJIcn40Y9+NOq5/X7vPvnkk4efW+PXNBAIDHntySefPPx+L3/nEnxSdOqppx5+mBjpn1NPPXVYm7EezP/7v//bOP/88428vDwjLy/P+PjHP2488cQTo/bj9ddfNz796U8bkyZNMnJycoy5c+cad999d1K/hXO7F1980bjkkkuMiRMnGscee6xRWlpqrFmzJuH7x7q+8SmFf//3fz/muf/zP//TqKysNGbNmmUcf/zxRigUMqZNm2YsXbrUeO6556x+JNew69p++9vfNpYsWWIUFhYaxxxzjJGbm2vMmjXL+PKXvzxslPJofr137bi2HR0do36/xP+prq4eciw/3Lf79+837rjjDmPmzJnGhAkTjA996EPG8uXLjc7OzmHvHesBp6+vz7j55puNwsJCY8KECUZhYaHx1a9+1ejt7U14/gMHDhj33HOPUVJSYuTm5hqTJk0yli5darz++ut2fcSMsePaLl++PKl780h//vOfja9//evGwoULjZNPPtkIhUJGXl6e8bGPfcyorq42+vr6nPzYaWPH9d2yZYuxYsUKY968ecakSZOM8ePHGwUFBcaiRYuMn/70p6N+P3LvHjLW98Jbb71lBINBIxQKGT09PaOe1+/37s9+9rMx/1/+2c9+dvj9Xv7ODRhGBjd6AQAAAIA0oKobAAAAAN8j+AAAAADwPYIPAAAAAN8j+AAAAADwPYIPAAAAAN8j+AAAAADwPYIPAAAAAN8j+AAAAADwPYIPAAAAAN8j+AAAAADwPYIPAAAAAN8j+AAAAADwPYIPAAAAAN8j+AAAAADwPYIPAAAAAN8j+AAAfOeaa65RIBDQN7/5zWE/2759u4499lgdf/zxam9vz0DvAACZEDAMw8h0JwAAsNN7772nM888U2+99ZY2bdqkRYsWSZKi0ajKy8v1yiuv6Gc/+5m+8IUvZLSfAID0YcQHAOA7J554on7xi19Ikj7/+c9rz549kqR/+qd/0iuvvKLKykpCDwBkGUZ8AAC+9Y1vfEN33XWXli1bpr/7u7/TRRddpJNPPlmvvfaaCgoKMt09AEAaEXwAAL71wQcfaOHChXrllVd0/PHHq7+/X88++6w++clPZrprAIA0Y6obAMC3JkyYoJ///OeSpL179+qrX/0qoQcAshTBBwDga+vXrz/876+88ooOHjyYwd4AADKF4AMA8K3Nmzdr9erVmjZtmj7xiU/oxRdf1OrVqzPdLQBABrDGBwDgS3v37tWZZ56pzs5OPf3005o3b57mzZunvXv3asuWLZo/f36muwgASCNGfAAAvnTjjTfqzTff1M0336z/83/+j6ZOnaqf/vSnikaj+uxnP6v9+/dnuosAgDQi+AAAfOe//uu/9Mtf/lIlJSX613/918OvX3XVVbruuuu0c+dOrVy5MoM9BACkG1PdAAC+0tXVpTPPPFP79+9XQ0ODPvrRjw75+cDAgM466yy1t7friSee0OWXX56ZjgIA0orgAwAAAMD3mOoGAAAAwPcIPgAAAAB8j+ADAAAAwPcIPgAAAAB8j+ADAAAAwPcIPgAAAAB8j+ADAAAAwPcIPgAAAAB8j+ADAAAAwPcIPgAAAAB8j+ADAAAAwPcIPgAAAAB8j+ADAAAAwPcIPgAAAAB8j+ADAAAAwPcIPgAAAAB8j+ADAAAAwPcIPgAAAAB87/8HjmslpoubTaYAAAAASUVORK5CYII=\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plt.figure(dpi=150)\n", "plt.scatter(x[:, 1], y)\n", @@ -262,7 +225,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -289,7 +252,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -310,20 +273,9 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "tensor(63.0779)" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "y_hat = x @ w_real\n", "# Initial mean-squared error\n", @@ -332,20 +284,9 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plt.figure(dpi=150)\n", "plt.scatter(x[:, 1], y, label=\"y\")\n", @@ -356,21 +297,9 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Parameter containing:\n", - "tensor([-3., -5.], requires_grad=True)" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "w = nn.Parameter(w_real)\n", "w" @@ -385,22 +314,9 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Load the image file\n", "with open(\"figs/Gradient_descent2.png\", \"rb\") as f:\n", @@ -442,7 +358,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -475,7 +391,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -489,7 +405,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -511,7 +427,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -556,1345 +472,9 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "display(HTML(f'
{animation.to_html5_video()}
'))" ] @@ -1908,20 +488,9 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plt.figure(dpi=150)\n", "plt.plot(np.array(losses))\n",