diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..17212a5 --- /dev/null +++ b/.gitignore @@ -0,0 +1,4 @@ +# Jupyter Notebook +.ipynb_checkpoints + +logs diff --git a/form.yml.erb b/form.yml.erb index ac4b119..ad931e4 100644 --- a/form.yml.erb +++ b/form.yml.erb @@ -9,6 +9,9 @@ attributes: options: - ["test"] - ["Alphafold3"] + - ["Pytorch"] + - ["Tensorflow"] + - ["Tensorboard"] num_hours: widget: 'number_field' label: "Number of hours (max 4)" diff --git a/submit.yml.erb b/submit.yml.erb index e585864..cb69277 100644 --- a/submit.yml.erb +++ b/submit.yml.erb @@ -1,3 +1,20 @@ +<%- + case tutorial + when "Pytorch" + slurm_args = [ + "--nodes", "1", + "-c", "14", + "--gres=gpu:1", + "--partition", "ondemand-p100" + ] + else + slurm_args = [ + "--nodes", "1", + "-c", "4", + "--partition", "ondemand" + ] + end +%> --- batch_connect: template: "basic" @@ -5,10 +22,8 @@ batch_connect: - usertutorial script: native: - - "--nodes=1" - - "--ntasks=1" - - "--cpus-per-task=4" - - "--mem=5G" - - "--partition=ondemand" + <%- slurm_args.each do |arg| %> + - "<%= arg %>" + <%- end %> - "--time=<%= num_hours.to_i %>:00:00" - - "-J=Tutorial" + - "-J Tutorial" diff --git a/template/alphafold3.ipynb b/template/alphafold3.ipynb index 05eeff0..c304644 100644 --- a/template/alphafold3.ipynb +++ b/template/alphafold3.ipynb @@ -25,7 +25,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "Python 3", "language": "python", "name": "python3" }, @@ -39,7 +39,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.10" + "version": "3.6.8" } }, "nbformat": 4, diff --git a/template/ml_tutorials/deep_ensemble.ipynb b/template/ml_tutorials/deep_ensemble.ipynb new file mode 100644 index 0000000..67c52f0 --- /dev/null +++ b/template/ml_tutorials/deep_ensemble.ipynb @@ -0,0 +1,251 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "156e10f2-b47b-4bda-bc44-9984f7fbd704", + "metadata": {}, + "source": [ + "## Deep Ensemble Code\n", + "\n", + "The code in this notebook is a step‐by‐step PyTorch tutorial demonstrating how to implement deep ensemble as an ensemble method. In a deep ensemble, several independent models are trained on the same task with different random initializations. At inference time, predictions from each model are aggregated (e.g., by averaging) to obtain a final prediction and to quantify uncertainty.\n", + "\n", + "### Setup and Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "f85e1642-23f9-423a-ac12-2b7052ccc02b", + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import numpy as np\n", + "import torch.nn as nn\n", + "import torch.optim as optim\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "id": "c2249f70-83b9-43a9-8446-c6679754f1aa", + "metadata": {}, + "source": [ + "### Define Model Architecture: a Simple Neural Network\n", + "\n", + "We define a simple feed-forward network for a regression task. Each model in the ensemble will have the same architecture but will be independently initialized and trained." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "63232548-efea-441f-9804-af1015a6ffe1", + "metadata": {}, + "outputs": [], + "source": [ + "class SimpleNet(nn.Module):\n", + " def __init__(self, input_dim, hidden_dim, output_dim):\n", + " super(SimpleNet, self).__init__()\n", + " self.fc1 = nn.Linear(input_dim, hidden_dim)\n", + " self.fc2 = nn.Linear(hidden_dim, hidden_dim)\n", + " self.fc3 = nn.Linear(hidden_dim, output_dim)\n", + " \n", + " def forward(self, x):\n", + " x = torch.relu(self.fc1(x))\n", + " x = torch.relu(self.fc2(x))\n", + " x = self.fc3(x)\n", + " return x\n" + ] + }, + { + "cell_type": "markdown", + "id": "e2cebc71-996e-4156-a111-ed9efb68e495", + "metadata": {}, + "source": [ + "### Load the Data" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "2d11a164-f5d9-4fa4-bb1d-e49d15586cf3", + "metadata": {}, + "outputs": [], + "source": [ + "# Create synthetic data: y = sin(2*pi*x) with added noise\n", + "np.random.seed(0)\n", + "x = np.linspace(0, 1, 100)[:, None]\n", + "y = np.sin(2 * np.pi * x) + 0.1 * np.random.randn(*x.shape)\n", + "\n", + "# Convert numpy arrays to PyTorch tensors\n", + "x_tensor = torch.from_numpy(x).float()\n", + "y_tensor = torch.from_numpy(y).float()\n" + ] + }, + { + "cell_type": "markdown", + "id": "182dcf7b-0b32-46f4-a6f9-ce1278b8c8b1", + "metadata": {}, + "source": [ + "### Train an Ensemble of Models\n", + "Here we create and train several independent models. Each model is trained on the same data, but with different initial weights." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "5d000d94-db64-4190-bfc5-c6720b7845e6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training model 1/5...\n", + "Training model 2/5...\n", + "Training model 3/5...\n", + "Training model 4/5...\n", + "Training model 5/5...\n" + ] + } + ], + "source": [ + "def train_model(model, x, y, num_epochs=500, learning_rate=0.01):\n", + " criterion = nn.MSELoss()\n", + " optimizer = optim.Adam(model.parameters(), lr=learning_rate)\n", + " model.train()\n", + " \n", + " for epoch in range(num_epochs):\n", + " optimizer.zero_grad()\n", + " predictions = model(x)\n", + " loss = criterion(predictions, y)\n", + " loss.backward()\n", + " optimizer.step()\n", + " return model\n", + "\n", + "# Ensemble hyperparameters\n", + "ensemble_size = 5\n", + "input_dim = 1\n", + "hidden_dim = 64\n", + "output_dim = 1\n", + "num_epochs = 500\n", + "learning_rate = 0.01\n", + "\n", + "# Train ensemble of models\n", + "ensemble_models = []\n", + "for i in range(ensemble_size):\n", + " model = SimpleNet(input_dim, hidden_dim, output_dim)\n", + " print(f\"Training model {i+1}/{ensemble_size}...\")\n", + " model = train_model(model, x_tensor, y_tensor, num_epochs, learning_rate)\n", + " ensemble_models.append(model)" + ] + }, + { + "cell_type": "markdown", + "id": "537c683a-5657-4698-ae70-25eaaa667815", + "metadata": {}, + "source": [ + "### Inference with Deep Ensembles\n", + "\n", + "During inference, each model in the ensemble produces its own prediction. The final prediction is obtained by averaging the predictions, and the variability across predictions provides a measure of uncertainty." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "8c161150-ad51-40ce-8fc6-d05932230405", + "metadata": {}, + "outputs": [], + "source": [ + "def ensemble_predict(models, x):\n", + " preds = []\n", + " for model in models:\n", + " model.eval() # Set each model to evaluation mode\n", + " with torch.no_grad():\n", + " pred = model(x)\n", + " preds.append(pred.cpu().numpy())\n", + " preds = np.array(preds) # Shape: (ensemble_size, batch_size, output_dim)\n", + " return preds\n", + "\n", + "# Get ensemble predictions\n", + "ensemble_preds = ensemble_predict(ensemble_models, x_tensor)\n", + "\n", + "# Compute mean and standard deviation across the ensemble\n", + "pred_mean = ensemble_preds.mean(axis=0).squeeze() # (batch_size,)\n", + "pred_std = ensemble_preds.std(axis=0).squeeze()\n" + ] + }, + { + "cell_type": "markdown", + "id": "6ac1f535-c3a8-4c6b-b165-bef962201299", + "metadata": {}, + "source": [ + "### Visualize the Results\n", + "Finally, we plot the ensemble’s mean prediction along with uncertainty bands (e.g., ±1 standard deviation).\n", + "\n", + "Uncertainty Estimation: Here we use the mean and standard deviation of the predictions as an estimate of the prediction and its uncertainty, respectively." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "134509f6-5065-442c-bf24-8858b0df5497", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,6))\n", + "plt.scatter(x, y, color='black', label='Data')\n", + "plt.plot(x, pred_mean, color='blue', label='Ensemble Mean')\n", + "plt.fill_between(x.squeeze(), \n", + " pred_mean - pred_std, \n", + " pred_mean + pred_std, \n", + " color='blue', alpha=0.2, label='Uncertainty (±1 std)')\n", + "plt.xlabel('x')\n", + "plt.ylabel('y')\n", + "plt.legend()\n", + "plt.title('Deep Ensembles for Regression with Uncertainty Estimation')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "138254f0-d6b2-4018-94f4-d1742c810f68", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "ml_tutorial", + "language": "python", + "name": "ml_tutorial" + }, + "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.9.15" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/template/ml_tutorials/ml_benchmarking.ipynb b/template/ml_tutorials/ml_benchmarking.ipynb new file mode 100644 index 0000000..02cdd8a --- /dev/null +++ b/template/ml_tutorials/ml_benchmarking.ipynb @@ -0,0 +1,667 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "2a46ebd1-761c-42e0-8e5d-5b5aad90a79f", + "metadata": {}, + "source": [ + "## Benchmarking Machine Learning Code\n", + "\n", + "In this tutorial, we are going to tackle a common problem that most people often face while running their code on Borah or any other super computer out there. However, you don't have to worry, super computers are built to solve this kind of problem. We will perform a benchmarking test on some machine learning problem to demonstrate how we can take full advantage of the resources on Borah. \n", + "\n", + "### Problem Statement\n", + "\n", + "- Let's assume you have a code that takes long hours to run. \n", + "- In this case, let's say the code runs for at least 12 hours. \n", + "- This kind of code might require more computing power than what is on your local computer. \n", + "- So you decided to use Borah.\n", + "- You always love to write and run or test your code in a Jupyter Notebook.\n", + "- However, you only have 4 hours maximum when you Borah OnDemand and the code takes at least 12 hours to run.\n", + "- What should you do?\n", + "\n", + "First of all Jupyter Notebooks are not ideal for running codes that run for several hours. As long as the code is still running, you will have to leave the notebook opened, the computer must always be on and/or always connected to the internet if the code requires an internet connection to run, etc. This means you have to basically babysit your code until it's done running. Jupyter Notebooks are good for writing and running/testing codes that do not require a lot of time to run. Let's say each cell in the notebook only takes a few seconds or minutes to run and in total it does not take several hours to run the entire notebook.\n", + "\n", + "In our example above, does that mean Borah cannot help? No. Borah can definitely help because it was built for tasks like this. This is why the people at the Research Computing Department are ther to help you. They are working hard every day just to make your experiecne on Borah easier and fun. This is also why this tutorial is made available to help you. Beyond this tutorial, you can still reach out to the Research Computing department for help on Borah and/or high performance computing related matters.\n", + "\n", + "### How to Solve the Problem\n", + "\n", + "Let's start by considering the sample code below.\n", + "\n", + "I have created a very large and deep PyTorch tutorial that:\n", + "- Uses 10 million synthetic samples with 200 features.\n", + "- Builds a 40-layer deep fully connected neural network with large hidden dimensions.\n", + "- Trains for 50 epochs, which should take 12+ hours on a personal computer, especially without a high-end GPU.\n", + "- Logs training loss and validation accuracy.\n", + "\n", + "\n", + "Now, let's break down the complex PyTorch tutorial you just created. This code is designed to train a massive deep neural network on synthetic data, with the goal of maximizing training time and computational load for experimentation or benchmarking.\n", + "\n", + "---\n", + "- **1. The code block:**\n", + "```python\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", + "```\n", + " - Chooses GPU if available, otherwise defaults to CPU.\n", + " \n", + "---\n", + "- **2. The code block:**\n", + "```python\n", + "X, y = make_classification(n_samples=10_000_000, n_features=200, ...)\n", + "```\n", + " - Generates 10 million samples with 200 features.\n", + " - 150 of the features are informative (helpful for classification). These are features that actually help in distinguishing between the classes (i.e. they influence the target `y`). \n", + " - 30 are redundant (correlated). This means they are linear combinations of the informative features — they’re correlated with the informative ones.\n", + " - The remaining 20 features are `noise features`. They're completely random and do not contribute to classification — they serve to make the problem more realistic by introducing irrelevant or noisy data. They help to test model robustness, simulate real-world data, which usually contains irrelevant or uninformative features, and prevent the model from overfitting to only clean, synthetic features.\n", + " \n", + "---\n", + "- **3. The code block:**\n", + "```python\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.1)\n", + "```\n", + " - Splits the dataset into 90\\% training and 10\\% testing.\n", + "\n", + "---\n", + "- **4. The code block:**\n", + "```python\n", + "class LargeDataset(Dataset):\n", + " ...\n", + "```\n", + " - Is a custom data set class that wraps the NumPy arrays in a PyTorch data set for use with DataLoader.\n", + " \n", + "---\n", + "- **5. The code block:**\n", + "```python\n", + "train_loader = DataLoader(..., batch_size=2048, num_workers=4)\n", + "```\n", + " - Creates Data Loaders and loads data in batches of 2048.\n", + " - `num_workers=4` means parallel data loading with 4 processes (if supported). Thus, it will take a longer time to load if not supported.\n", + " \n", + "---\n", + "- **6. The code block:**\n", + "```python\n", + "class DeepNN(nn.Module):\n", + " ...\n", + "```\n", + " - Defines a massive deep neural network.\n", + " - This model is:\n", + " - 40 layers deep, each with:\n", + " - A Linear layer (fully connected)\n", + " - BatchNorm1d for training stability\n", + " - ReLU activation\n", + " - Dropout to prevent overfitting\n", + " - Final output: 2 classes (binary classification)\n", + " - This is what makes the model computationally expensive.\n", + " \n", + "---\n", + "- **7. The code block:**\n", + "```python\n", + "criterion = nn.CrossEntropyLoss()\n", + "optimizer = optim.AdamW(model.parameters(), lr=1e-4, weight_decay=1e-4)\n", + "```\n", + " - Defines loss and optimizer\n", + " - `CrossEntropyLoss` is suitable for classification tasks.\n", + " - `AdamW` is a variant of Adam that decouples weight decay (helps with regularization).\n", + " \n", + "---\n", + "- **8. The code block:**\n", + "```python\n", + "for epoch in range(start_epoch, num_epochs):\n", + " ...\n", + "```\n", + " - Is the training loop\n", + " - Each epoch:\n", + " - Loops over batches\n", + " - Sends inputs/labels to device\n", + " - Computes outputs --> loss --> gradients --> weight updates\n", + " - Tracks average loss per epoch\n", + " - Also includes validation at each epoch:\n", + " - Runs the model on the test set (no gradient tracking)\n", + " - Calculates and stores accuracy\n", + " \n", + "---\n", + "- **9. The code block:**\n", + "```python\n", + "start_time = time.time()\n", + "...\n", + "end_time = time.time()\n", + "```\n", + " - Measures and prints how long training takes in hours.\n", + " \n", + "---\n", + "- **10. The code block:**\n", + "```python\n", + "plt.plot(train_losses, ...)\n", + "```\n", + " - Saves line plots of:\n", + " - Training Loss vs. Epochs\n", + " - Validation Accuracy vs. Epochs \n", + "\n", + "### Summary\n", + "\n", + "| Part | Description |\n", + "|------|-------------|\n", + "| Data | 10M samples, 200 features, binary classification |\n", + "| Model | 40 hidden layers, each 2048 neurons deep |\n", + "| Training | 50 epochs, large batches (2048), uses AdamW |\n", + "| Runtime | Estimated 12+ hours on a personal CPU |\n", + "| Output | Loss & accuracy plots + final test accuracy |\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9c567499-1ac2-473f-ba77-64f932208d89", + "metadata": {}, + "outputs": [], + "source": [ + "# Load packages\n", + "import time\n", + "import torch\n", + "import numpy as np\n", + "import torch.nn as nn\n", + "import torch.optim as optim\n", + "import matplotlib.pyplot as plt\n", + "from torch.utils.data import DataLoader, Dataset\n", + "from sklearn.datasets import make_classification\n", + "from sklearn.model_selection import train_test_split\n", + "\n", + "# Check device\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", + "\n", + "# Generate a massive synthetic dataset (10 million samples, 200 features)\n", + "X, y = make_classification(n_samples=10e6, n_features=200, n_informative=150,\n", + " n_redundant=30, n_classes=2, random_state=42)\n", + "\n", + "# Split the data\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.1, random_state=42)\n", + "\n", + "# Custom dataset class\n", + "class LargeDataset(Dataset):\n", + " def __init__(self, X, y):\n", + " self.X = torch.tensor(X, dtype=torch.float32)\n", + " self.y = torch.tensor(y, dtype=torch.long)\n", + "\n", + " def __len__(self):\n", + " return len(self.X)\n", + "\n", + " def __getitem__(self, idx):\n", + " return self.X[idx], self.y[idx]\n", + "\n", + "train_dataset = LargeDataset(X_train, y_train)\n", + "test_dataset = LargeDataset(X_test, y_test)\n", + "\n", + "train_loader = DataLoader(train_dataset, batch_size=2048, shuffle=True, num_workers=4)\n", + "test_loader = DataLoader(test_dataset, batch_size=2048, shuffle=False, num_workers=4)\n", + "\n", + "# Very deep and wide neural network model\n", + "class DeepNN(nn.Module):\n", + " def __init__(self):\n", + " super(DeepNN, self).__init__()\n", + " self.net = nn.Sequential(\n", + " nn.Linear(200, 2048),\n", + " nn.BatchNorm1d(2048),\n", + " nn.ReLU(),\n", + " *[layer for _ in range(40) for layer in [\n", + " nn.Linear(2048, 2048),\n", + " nn.BatchNorm1d(2048),\n", + " nn.ReLU(),\n", + " nn.Dropout(0.2)\n", + " ]],\n", + " nn.Linear(2048, 2)\n", + " )\n", + "\n", + " def forward(self, x):\n", + " return self.net(x)\n", + "\n", + "model = DeepNN().to(device)\n", + "criterion = nn.CrossEntropyLoss()\n", + "optimizer = optim.AdamW(model.parameters(), lr=1e-4, weight_decay=1e-4)\n", + "\n", + "# Training loop\n", + "num_epochs = 50\n", + "train_losses = []\n", + "val_accuracies = []\n", + "\n", + "start_time = time.time()\n", + "for epoch in range(num_epochs):\n", + " model.train()\n", + " running_loss = 0.0\n", + " for i, (inputs, labels) in enumerate(train_loader):\n", + " inputs, labels = inputs.to(device), labels.to(device)\n", + "\n", + " optimizer.zero_grad()\n", + " outputs = model(inputs)\n", + " loss = criterion(outputs, labels)\n", + " loss.backward()\n", + " optimizer.step()\n", + "\n", + " running_loss += loss.item()\n", + "\n", + " avg_loss = running_loss / len(train_loader)\n", + " train_losses.append(avg_loss)\n", + "\n", + " # Evaluation\n", + " model.eval()\n", + " correct = 0\n", + " total = 0\n", + " with torch.no_grad():\n", + " for inputs, labels in test_loader:\n", + " inputs, labels = inputs.to(device), labels.to(device)\n", + " outputs = model(inputs)\n", + " _, predicted = torch.max(outputs.data, 1)\n", + " total += labels.size(0)\n", + " correct += (predicted == labels).sum().item()\n", + "\n", + " accuracy = correct / total\n", + " val_accuracies.append(accuracy)\n", + "\n", + " print(f\"Epoch [{epoch+1}/{num_epochs}], Loss: {avg_loss:.4f}, Val Accuracy: {accuracy:.4f}\")\n", + "\n", + "end_time = time.time()\n", + "print(f\"Training completed in {(end_time - start_time) / 3600:.2f} hours\")\n", + "\n", + "# Plot results\n", + "plt.figure()\n", + "plt.plot(train_losses, label='Train Loss')\n", + "plt.xlabel('Epoch')\n", + "plt.ylabel('Loss')\n", + "plt.title('Training Loss Over Epochs')\n", + "plt.legend()\n", + "plt.savefig('loss_plot.png')\n", + "\n", + "plt.figure()\n", + "plt.plot(val_accuracies, label='Validation Accuracy')\n", + "plt.xlabel('Epoch')\n", + "plt.ylabel('Accuracy')\n", + "plt.title('Validation Accuracy Over Epochs')\n", + "plt.legend()\n", + "plt.savefig('accuracy_plot.png')" + ] + }, + { + "cell_type": "markdown", + "id": "0c3ee819-5ca4-4a7b-8644-7b572b08f42c", + "metadata": {}, + "source": [ + "### How to Improve the Code\n", + "\n", + "The following improvement can be made to the code.\n", + "- Add TensorBoard logging.\n", + "- Parallelize or optimize the data pipeline.\n", + "- Turn this into a distributed training script \n", + "- Save checkpoints for resuming later.\n", + "\n", + "Now, let's navigate through a step-by-step breakdown of how we improve the code using the suggested improvements above.\n", + "\n", + "---\n", + "#### Add TensorBoard Logging.\n", + "TensorBoard logging was added in the code. It appears inside the `train()` function and is scoped to `rank == 0`, so only one process (usually GPU 0) writes to TensorBoard to avoid duplication.\n", + "\n", + "---\n", + "- **1. The code block:**\n", + "```python\n", + "log_dir = f\"runs/ddp_rank{rank}_\" + datetime.datetime.now().strftime(\"%Y%m%d-%H%M%S\")\n", + "writer = SummaryWriter(log_dir=log_dir) if rank == 0 else None\n", + "```\n", + " - Is the TensorBoard Setup (inside `train()`).\n", + " \n", + "- **2. The code block:**\n", + "```python\n", + "if rank == 0:\n", + " writer.add_scalar(\"Loss/train\", avg_loss, epoch)\n", + " writer.add_scalar(\"Accuracy/val\", accuracy, epoch)\n", + " print(f\"Epoch [{epoch+1}/{num_epochs}], Loss: {avg_loss:.4f}, Val Accuracy: {accuracy:.4f}\")\n", + "```\n", + " - Logging metrics after each epoch:\n", + " \n", + "- **3. The code block:**\n", + "```python\n", + "if rank == 0:\n", + " writer.close()\n", + "```\n", + " - Closes the writer after training\n", + " - What It Logs:\n", + " - `Loss/train`: The average training loss per epoch.\n", + " - `Accuracy/val`: The validation accuracy per epoch.\n", + " - You can visualize it by running the code below in terminal and then open your browser to [http://localhost:6006](http://localhost:6006).\n", + " ```bash\n", + " tensorboard --logdir=runs\n", + " ```\n", + "\n", + "#### Parallelize or Optimize the Data Pipeline.\n", + "The data pipeline is now optimized for performance! Here's what was added:\n", + "- Parallelization and performance enhancements:\n", + " - `num_workers=8`: Enables multi-process data loading.\n", + " - `pin_memory=True`: Speeds up data transfer to GPU.\n", + " - `prefetch_factor=4`: Loads data in advance to reduce I/O wait.\n", + " - `non_blocking=True`: Ensures faster GPU data transfers.\n", + " - `torch.set_num_threads(os.cpu_count())`: Fully utilizes available CPU cores.\n", + " - `PYTORCH_CUDA_ALLOC_CONF` set for better memory handling on CUDA.\n", + "\n", + "These changes should significantly improve data loading throughput and reduce GPU idle time.\n", + "\n", + "#### Turn this into a Distributed Training Script \n", + "The script has now been fully converted for Distributed Data Parallel (DDP) training using PyTorch's `torch.distributed` module.\n", + "- Key Features Added:\n", + " - Uses `torch.multiprocessing.spawn` to launch multiple processes across available GPUs.\n", + " - Leverages `DistributedSampler` to partition the dataset across processes.\n", + " - Wraps the model with `DistributedDataParallel` (DDP) for synchronized training.\n", + " - Logs metrics to TensorBoard only from rank 0 to avoid duplication.\n", + " - Ensures each epoch sees the full dataset using `train_sampler.set_epoch(epoch)`.\n", + "\n", + "#### Save Checkpoints for Resuming Later.\n", + "- Checkpointing is now built into the distributed training script.\n", + "- What was added:\n", + " - `save_checkpoint()`: Saves model, optimizer, and epoch state to a .pth file.\n", + " - `load_checkpoint()`: Loads from checkpoint if it exists, and resumes training.\n", + " - Per-rank checkpointing: Each process saves its own checkpoint (e.g., `checkpoint_rank0.pth`).\n", + "- Usage:\n", + " - If you stop training, just re-run the script—it will pick up from the last saved epoch.\n", + " \n", + "**Note:** Make sure you save the code below as a `.py` file. Also note that we eliminate the `matplotlib` plotting functions from this final code. This is because `matplotlib` will not work in a `.py` file. However, we can save the output to file so that we can plot them separately later." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "61336e98-6525-45a6-b309-6ff29191cd8a", + "metadata": {}, + "outputs": [], + "source": [ + "# Load packages\n", + "import os\n", + "import time\n", + "import torch\n", + "import datetime\n", + "import numpy as np\n", + "import torch.nn as nn\n", + "import torch.optim as optim\n", + "import matplotlib.pyplot as plt\n", + "import torch.distributed as dist\n", + "import torch.multiprocessing as mp\n", + "from sklearn.datasets import make_classification\n", + "from torch.utils.tensorboard import SummaryWriter\n", + "from sklearn.model_selection import train_test_split\n", + "from torch.nn.parallel import DistributedDataParallel as DDP\n", + "from torch.utils.data import DataLoader, Dataset, DistributedSampler\n", + "\n", + "os.environ[\"PYTORCH_CUDA_ALLOC_CONF\"] = \"expandable_segments:True\"\n", + "torch.set_num_threads(os.cpu_count())\n", + "\n", + "def setup(rank, world_size):\n", + " dist.init_process_group(\"nccl\", rank=rank, world_size=world_size)\n", + " torch.cuda.set_device(rank)\n", + "\n", + "def cleanup():\n", + " dist.destroy_process_group()\n", + "\n", + "# Wrap the NumPy arrays in a PyTorch data set for use with DataLoader.\n", + "class LargeDataset(Dataset): \n", + " def __init__(self, X, y):\n", + " self.X = torch.tensor(X, dtype=torch.float32)\n", + " self.y = torch.tensor(y, dtype=torch.long)\n", + "\n", + " def __len__(self):\n", + " return len(self.X)\n", + "\n", + " def __getitem__(self, idx):\n", + " return self.X[idx], self.y[idx]\n", + "\n", + "# Define a massive deep neural network.\n", + "class DeepNN(nn.Module):\n", + " def __init__(self):\n", + " super(DeepNN, self).__init__()\n", + " self.net = nn.Sequential(\n", + " nn.Linear(200, 2048),\n", + " nn.BatchNorm1d(2048),\n", + " nn.ReLU(),\n", + " *[layer for _ in range(40) for layer in [\n", + " nn.Linear(2048, 2048),\n", + " nn.BatchNorm1d(2048),\n", + " nn.ReLU(),\n", + " nn.Dropout(0.2)\n", + " ]],\n", + " nn.Linear(2048, 2)\n", + " )\n", + "\n", + " def forward(self, x):\n", + " return self.net(x)\n", + "\n", + "def save_checkpoint(state, filename=\"checkpoint.pth\"):\n", + " torch.save(state, filename)\n", + "\n", + "def load_checkpoint(model, optimizer, filename=\"checkpoint.pth\"):\n", + " if os.path.isfile(filename):\n", + " checkpoint = torch.load(filename, map_location=\"cpu\")\n", + " model.load_state_dict(checkpoint['model_state_dict'])\n", + " optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\n", + " start_epoch = checkpoint['epoch'] + 1\n", + " print(f\"Loaded checkpoint from '{filename}' at epoch {start_epoch}\")\n", + " return start_epoch\n", + " else:\n", + " print(f\"No checkpoint found at '{filename}', starting from scratch.\")\n", + " return 0\n", + "\n", + "def train(rank, world_size):\n", + " setup(rank, world_size)\n", + "\n", + " device = torch.device(f\"cuda:{rank}\")\n", + "\n", + " # Create 10 million synthetic dataset with 200 feature in total: 150 informative features and 30 redundant/correlated features. The remain. \n", + " X, y = make_classification(n_samples=10e6, n_features=200, n_informative=150,\n", + " n_redundant=30, n_classes=2, random_state=42)\n", + " # Split the dataset into 90% training and 10% testing.\n", + " X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.1, random_state=42)\n", + "\n", + " train_dataset = LargeDataset(X_train, y_train)\n", + " test_dataset = LargeDataset(X_test, y_test)\n", + "\n", + " train_sampler = DistributedSampler(train_dataset, num_replicas=world_size, rank=rank)\n", + " test_sampler = DistributedSampler(test_dataset, num_replicas=world_size, rank=rank, shuffle=False)\n", + "\n", + " # Load data in batches of 2048. num_workers=4 means parallel data loading with 4 processes (if supported).\n", + " train_loader = DataLoader(train_dataset, batch_size=2048, sampler=train_sampler,\n", + " num_workers=8, pin_memory=True, prefetch_factor=4)\n", + " test_loader = DataLoader(test_dataset, batch_size=2048, sampler=test_sampler,\n", + " num_workers=8, pin_memory=True, prefetch_factor=4)\n", + "\n", + " model = DeepNN().to(device)\n", + " model = DDP(model, device_ids=[rank])\n", + "\n", + " # Define loss and optimizer\n", + " criterion = nn.CrossEntropyLoss()\n", + " optimizer = optim.AdamW(model.parameters(), lr=1e-4, weight_decay=1e-4)\n", + "\n", + " # Setup TensorBoard logging\n", + " log_dir = f\"runs/ddp_rank{rank}_\" + datetime.datetime.now().strftime(\"%Y%m%d-%H%M%S\")\n", + " writer = SummaryWriter(log_dir=log_dir) if rank == 0 else None\n", + "\n", + " num_epochs = 50\n", + " checkpoint_file = f\"checkpoint_rank{rank}.pth\"\n", + " start_epoch = load_checkpoint(model, optimizer, checkpoint_file)\n", + "\n", + " # Time measurement\n", + " start_time = time.time()\n", + "\n", + " # Training loop\n", + " for epoch in range(start_epoch, num_epochs):\n", + " model.train()\n", + " train_sampler.set_epoch(epoch)\n", + " running_loss = 0.0\n", + " correct = 0\n", + " total = 0\n", + "\n", + " for i, (inputs, labels) in enumerate(train_loader):\n", + " inputs, labels = inputs.to(device, non_blocking=True), labels.to(device, non_blocking=True)\n", + " optimizer.zero_grad()\n", + " outputs = model(inputs)\n", + " loss = criterion(outputs, labels)\n", + " loss.backward()\n", + " optimizer.step()\n", + "\n", + " running_loss += loss.item()\n", + "\n", + " avg_loss = running_loss / len(train_loader)\n", + "\n", + " # Validation\n", + " model.eval()\n", + " correct = 0\n", + " total = 0\n", + " with torch.no_grad():\n", + " for inputs, labels in test_loader:\n", + " inputs, labels = inputs.to(device, non_blocking=True), labels.to(device, non_blocking=True)\n", + " outputs = model(inputs)\n", + " _, predicted = torch.max(outputs.data, 1)\n", + " total += labels.size(0)\n", + " correct += (predicted == labels).sum().item()\n", + "\n", + " accuracy = correct / total\n", + "\n", + " # TensorBoard logging step\n", + " if rank == 0:\n", + " writer.add_scalar(\"Loss/train\", avg_loss, epoch)\n", + " writer.add_scalar(\"Accuracy/val\", accuracy, epoch)\n", + " print(f\"Epoch [{epoch+1}/{num_epochs}], Loss: {avg_loss:.4f}, Val Accuracy: {accuracy:.4f}\")\n", + "\n", + " # Save checkpoint\n", + " save_checkpoint({\n", + " 'epoch': epoch,\n", + " 'model_state_dict': model.module.state_dict(),\n", + " 'optimizer_state_dict': optimizer.state_dict()\n", + " }, filename=checkpoint_file)\n", + "\n", + " if rank == 0:\n", + " writer.close()\n", + " end_time = time.time()\n", + " print(f\"Training completed in {(end_time - start_time) / 3600:.2f} hours\")\n", + "\n", + " cleanup()\n", + "\n", + "if __name__ == \"__main__\":\n", + " world_size = torch.cuda.device_count()\n", + " mp.spawn(train, args=(world_size,), nprocs=world_size, join=True)" + ] + }, + { + "cell_type": "markdown", + "id": "6601d6ac-a085-4d4d-af6a-8bf9945a5f51", + "metadata": {}, + "source": [ + "### Submitting Jobs on Borah\n", + "\n", + "Since the code cannot run on our local machines or OnDemand, we will have to run it by submitting a job on Borah. Below is a sample script for submitting jobs on Borah. The codes below must be saved into a `.sh` file. \n", + "\n", + "```bash\n", + "#!/bin/bash\n", + "#Account and Email Information\n", + "#SBATCH -A tnde ## User ID\n", + "#SBATCH --mail-type=end\n", + "#SBATCH --mail-user=titusnyarkonde@u.boisestate.edu\n", + "# Specify parition (queue)\n", + "#SBATCH --partition=bsudfq\n", + "# Join output and errors into output.\n", + "#SBATCH -o test_borah.o%j\n", + "#SBATCH -e test_borah.e%j\n", + "# Specify job not to be rerunable.\n", + "#SBATCH --no-requeue\n", + "# Job Name.\n", + "#SBATCH --job-name=\"test_borah_login2\"\n", + "# Specify walltime.\n", + "#SBATCH -t 06-23:59:59 \n", + "# ###SBATCH --time=48:00:00\n", + "# Specify number of requested nodes.\n", + "#SBATCH -N 1\n", + "# Specify the total number of requested procs:\n", + "#SBATCH -n 48\n", + "# number of cpus per task\n", + "#SBATCH --cpus-per-task=1 \n", + "# Number of GPUs per node.\n", + "# #SBATCH --gres=gpu:1\n", + "# load all necessary modules and ctivate the conda environment\n", + "module load slurm\n", + "module load gcc/7.5.0\n", + "module load gsl/gcc8/2.6\n", + "module load openmpi/gcc/64/1.10.7\n", + "module load cuda11.0/toolkit/11.0.3 \n", + "source /bsuhome/tnde/miniconda3/etc/profile.d/conda.sh\n", + "conda activate /bsuhome/tnde/miniconda3/envs/ml_tutorial\n", + "# Echo commands to stdout (standard output).\n", + "# set -x\n", + "# Copy your code & data to your R2 Home directory using\n", + "# the SFTP (secure file transfer protocol).\n", + "# Go to the directory where the actual BATCH file is present.\n", + "cd /bsuhome/tnde/ondemand/dev/ood_tutorials/template\n", + " # The �python� command runs your python code.\n", + "# All output is dumped into test_borah.o%j with �%j� replaced by the Job ID.\n", + "## The file Multiprocessing.py must also \n", + "## be in $/home/tnde/P1_Density_Calibration/Density3D\n", + "mpirun -np 8 python3 ml_benchmarking.py >>log.out\n", + "# python3 demo_analytic.py >>log.out\n", + "```\n", + "\n", + "Now, we will run the code under different scenarios and report the time it took to finish running. Remember that this tutorial is about benchmarking the time the code takes to run. This means we are not interested in the model's performance and accuracy. We are only interested in the time it takes to finish running the code. Hence, we will not be showing training and validation accuracy/loss curves here." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "11d53c2f-07b1-4d23-8e62-fd2b2613ad5c", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bd954d1f-a2ed-49bc-8d4e-f5610a3633b3", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "109de7bd-84bd-442c-82c9-edbcce8624cc", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3c31b237-f113-4522-befd-5d5d0881b730", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b37c4769-3211-4da8-bd36-92e140db1880", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "ml_tutorial", + "language": "python", + "name": "ml_tutorial" + }, + "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.9.15" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/template/ml_tutorials/ml_benchmarking.py b/template/ml_tutorials/ml_benchmarking.py new file mode 100644 index 0000000..10f1400 --- /dev/null +++ b/template/ml_tutorials/ml_benchmarking.py @@ -0,0 +1,172 @@ +# Load packages +import os +import time +import torch +import datetime +import numpy as np +import torch.nn as nn +import torch.optim as optim +import matplotlib.pyplot as plt +import torch.distributed as dist +import torch.multiprocessing as mp +from sklearn.datasets import make_classification +from torch.utils.tensorboard import SummaryWriter +from sklearn.model_selection import train_test_split +from torch.nn.parallel import DistributedDataParallel as DDP +from torch.utils.data import DataLoader, Dataset, DistributedSampler + +os.environ["PYTORCH_CUDA_ALLOC_CONF"] = "expandable_segments:True" +torch.set_num_threads(os.cpu_count()) + +def setup(rank, world_size): + dist.init_process_group("nccl", rank=rank, world_size=world_size) + torch.cuda.set_device(rank) + +def cleanup(): + dist.destroy_process_group() + +# Wrap the NumPy arrays in a PyTorch data set for use with DataLoader. +class LargeDataset(Dataset): + def __init__(self, X, y): + self.X = torch.tensor(X, dtype=torch.float32) + self.y = torch.tensor(y, dtype=torch.long) + + def __len__(self): + return len(self.X) + + def __getitem__(self, idx): + return self.X[idx], self.y[idx] + +# Define a massive deep neural network. +class DeepNN(nn.Module): + def __init__(self): + super(DeepNN, self).__init__() + self.net = nn.Sequential( + nn.Linear(200, 2048), + nn.BatchNorm1d(2048), + nn.ReLU(), + *[layer for _ in range(40) for layer in [ + nn.Linear(2048, 2048), + nn.BatchNorm1d(2048), + nn.ReLU(), + nn.Dropout(0.2) + ]], + nn.Linear(2048, 2) + ) + + def forward(self, x): + return self.net(x) + +def save_checkpoint(state, filename="checkpoint.pth"): + torch.save(state, filename) + +def load_checkpoint(model, optimizer, filename="checkpoint.pth"): + if os.path.isfile(filename): + checkpoint = torch.load(filename, map_location="cpu") + model.load_state_dict(checkpoint['model_state_dict']) + optimizer.load_state_dict(checkpoint['optimizer_state_dict']) + start_epoch = checkpoint['epoch'] + 1 + print(f"Loaded checkpoint from '{filename}' at epoch {start_epoch}") + return start_epoch + else: + print(f"No checkpoint found at '{filename}', starting from scratch.") + return 0 + +def train(rank, world_size): + setup(rank, world_size) + + device = torch.device(f"cuda:{rank}") + + # Create 10 million synthetic dataset with 200 feature in total: 150 informative features and 30 redundant/correlated features. The remain. + X, y = make_classification(n_samples=10e6, n_features=200, n_informative=150, + n_redundant=30, n_classes=2, random_state=42) + # Split the dataset into 90% training and 10% testing. + X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.1, random_state=42) + + train_dataset = LargeDataset(X_train, y_train) + test_dataset = LargeDataset(X_test, y_test) + + train_sampler = DistributedSampler(train_dataset, num_replicas=world_size, rank=rank) + test_sampler = DistributedSampler(test_dataset, num_replicas=world_size, rank=rank, shuffle=False) + + # Load data in batches of 2048. num_workers=4 means parallel data loading with 4 processes (if supported). + train_loader = DataLoader(train_dataset, batch_size=2048, sampler=train_sampler, + num_workers=8, pin_memory=True, prefetch_factor=4) + test_loader = DataLoader(test_dataset, batch_size=2048, sampler=test_sampler, + num_workers=8, pin_memory=True, prefetch_factor=4) + + model = DeepNN().to(device) + model = DDP(model, device_ids=[rank]) + + # Define loss and optimizer + criterion = nn.CrossEntropyLoss() + optimizer = optim.AdamW(model.parameters(), lr=1e-4, weight_decay=1e-4) + + # Setup TensorBoard logging + log_dir = f"runs/ddp_rank{rank}_" + datetime.datetime.now().strftime("%Y%m%d-%H%M%S") + writer = SummaryWriter(log_dir=log_dir) if rank == 0 else None + + num_epochs = 50 + checkpoint_file = f"checkpoint_rank{rank}.pth" + start_epoch = load_checkpoint(model, optimizer, checkpoint_file) + + # Time measurement + start_time = time.time() + + # Training loop + for epoch in range(start_epoch, num_epochs): + model.train() + train_sampler.set_epoch(epoch) + running_loss = 0.0 + correct = 0 + total = 0 + + for i, (inputs, labels) in enumerate(train_loader): + inputs, labels = inputs.to(device, non_blocking=True), labels.to(device, non_blocking=True) + optimizer.zero_grad() + outputs = model(inputs) + loss = criterion(outputs, labels) + loss.backward() + optimizer.step() + + running_loss += loss.item() + + avg_loss = running_loss / len(train_loader) + + # Validation + model.eval() + correct = 0 + total = 0 + with torch.no_grad(): + for inputs, labels in test_loader: + inputs, labels = inputs.to(device, non_blocking=True), labels.to(device, non_blocking=True) + outputs = model(inputs) + _, predicted = torch.max(outputs.data, 1) + total += labels.size(0) + correct += (predicted == labels).sum().item() + + accuracy = correct / total + + # TensorBoard logging step + if rank == 0: + writer.add_scalar("Loss/train", avg_loss, epoch) + writer.add_scalar("Accuracy/val", accuracy, epoch) + print(f"Epoch [{epoch+1}/{num_epochs}], Loss: {avg_loss:.4f}, Val Accuracy: {accuracy:.4f}") + + # Save checkpoint + save_checkpoint({ + 'epoch': epoch, + 'model_state_dict': model.module.state_dict(), + 'optimizer_state_dict': optimizer.state_dict() + }, filename=checkpoint_file) + + if rank == 0: + writer.close() + end_time = time.time() + print(f"Training completed in {(end_time - start_time) / 3600:.2f} hours") + + cleanup() + +if __name__ == "__main__": + world_size = torch.cuda.device_count() + mp.spawn(train, args=(world_size,), nprocs=world_size, join=True) \ No newline at end of file diff --git a/template/ml_tutorials/monte_carlo_dropout.ipynb b/template/ml_tutorials/monte_carlo_dropout.ipynb new file mode 100644 index 0000000..43794b2 --- /dev/null +++ b/template/ml_tutorials/monte_carlo_dropout.ipynb @@ -0,0 +1,262 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "cf707841-47f8-41c8-9a45-af9737c701ac", + "metadata": {}, + "source": [ + "## Monte Carlo Dropout Code\n", + "\n", + "The code in this notebook is a step‐by‐step PyTorch tutorial demonstrating how to implement Monte Carlo (MC) dropout as an ensemble method.\n", + "\n", + "### Setup and Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "269c2d00-4cc8-41de-8986-31bf3e83e86a", + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import numpy as np\n", + "import torch.nn as nn\n", + "import torch.optim as optim\n", + "import torch.nn.functional as F\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "id": "943e9b5c-8e4b-4588-b2e7-dd7a36bfb7a6", + "metadata": {}, + "source": [ + "### Define Model Architecture: a Neural Network with Dropout\n", + "We include dropout layers that will be active during both training and MC inference. During training, **dropout** is a **regularization technique**. During inference, dropout is an ensemble technique." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "633f3b4c-dfcd-4d74-ab88-60d0cc67e89f", + "metadata": {}, + "outputs": [], + "source": [ + "class MCDropoutNet(nn.Module):\n", + " def __init__(self, input_dim, hidden_dim, output_dim, dropout_rate=0.5):\n", + " super(MCDropoutNet, self).__init__()\n", + " self.fc1 = nn.Linear(input_dim, hidden_dim)\n", + " self.dropout = nn.Dropout(dropout_rate)\n", + " self.fc2 = nn.Linear(hidden_dim, hidden_dim)\n", + " self.fc3 = nn.Linear(hidden_dim, output_dim)\n", + " \n", + " def forward(self, x):\n", + " x = F.relu(self.fc1(x))\n", + " x = self.dropout(x) # Dropout layer\n", + " x = F.relu(self.fc2(x))\n", + " x = self.dropout(x) # Dropout layer\n", + " output = self.fc3(x)\n", + " return output" + ] + }, + { + "cell_type": "markdown", + "id": "f1438694-5631-4a0e-b89e-63d12844fdcd", + "metadata": {}, + "source": [ + "### 3. Load the Data" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "1a0a48eb-7481-4ca9-8c9b-673d10b8d29e", + "metadata": {}, + "outputs": [], + "source": [ + "# Generate synthetic data: y = sin(2*pi*x) with noise\n", + "np.random.seed(0)\n", + "x = np.linspace(0, 1, 100)[:, None]\n", + "y = np.sin(2 * np.pi * x) + 0.1 * np.random.randn(*x.shape)\n", + "\n", + "# Convert to PyTorch tensors\n", + "x_tensor = torch.from_numpy(x).float()\n", + "y_tensor = torch.from_numpy(y).float()" + ] + }, + { + "cell_type": "markdown", + "id": "bd7c571e-7b5d-467c-9175-a0a4bf647967", + "metadata": {}, + "source": [ + "### Train the Model\n", + "Here, we will train the model using mean squared error loss and the Adam optimizer." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "ff1cf674-c6d9-4d4c-b6fd-8c7e8f6f1929", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch [100/500], Loss: 0.0799\n", + "Epoch [200/500], Loss: 0.0405\n", + "Epoch [300/500], Loss: 0.0440\n", + "Epoch [400/500], Loss: 0.0289\n", + "Epoch [500/500], Loss: 0.0306\n", + "Training is complete\n" + ] + } + ], + "source": [ + "# Model hyperparameters\n", + "input_dim = 1\n", + "hidden_dim = 64\n", + "output_dim = 1\n", + "dropout_rate = 0.2\n", + "num_epochs = 500\n", + "learning_rate = 0.01\n", + "\n", + "# Initialize model, loss, and optimizer\n", + "model = MCDropoutNet(input_dim, hidden_dim, output_dim, dropout_rate)\n", + "criterion = nn.MSELoss()\n", + "optimizer = optim.Adam(model.parameters(), lr=learning_rate)\n", + "\n", + "# Training loop\n", + "model.train() # Ensure dropout is active during training\n", + "for epoch in range(num_epochs):\n", + " optimizer.zero_grad()\n", + " predictions = model(x_tensor)\n", + " loss = criterion(predictions, y_tensor)\n", + " loss.backward()\n", + " optimizer.step()\n", + " \n", + " if (epoch + 1) % 100 == 0:\n", + " print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')\n", + " \n", + "print(\"Training is complete\")" + ] + }, + { + "cell_type": "markdown", + "id": "0c8b1704-b0c9-4289-ac05-a965f742b7b0", + "metadata": {}, + "source": [ + "### Monte Carlo Dropout Inference\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "75e5cc64-3aa9-4b97-bc20-d97750e8c394", + "metadata": {}, + "outputs": [], + "source": [ + "def mc_dropout_predict(model, x, n_samples=100):\n", + " model.train() # Activate dropout during inference\n", + " predictions = []\n", + " with torch.no_grad():\n", + " for _ in range(n_samples):\n", + " preds = model(x)\n", + " predictions.append(preds.cpu().numpy())\n", + " predictions = np.array(predictions) # Shape: (n_samples, batch_size, output_dim)\n", + " return predictions\n", + "\n", + "# Generate predictions with MC dropout\n", + "n_samples = 100\n", + "mc_predictions = mc_dropout_predict(model, x_tensor, n_samples)\n", + "\n", + "# Compute mean and standard deviation\n", + "pred_mean = mc_predictions.mean(axis=0).squeeze() # shape: (batch_size,)\n", + "pred_std = mc_predictions.std(axis=0).squeeze()" + ] + }, + { + "cell_type": "markdown", + "id": "7f0d8f55-532a-4ce2-a8d3-e33ed3ee9f71", + "metadata": {}, + "source": [ + "### Visualize the Ensemble Predictions and Uncertainty\n", + "\n", + "We plot the mean prediction along with the uncertainty bands (e.g., ±1 standard deviation).\n", + "\n", + "Uncertainty Estimation: Here we use the mean and standard deviation of the predictions as an estimate of the prediction and its uncertainty, respectively." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "90310eb7-e6b4-4ed6-9041-e222e69a1fa7", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,6))\n", + "plt.scatter(x, y, color='black', label='Data')\n", + "plt.plot(x, pred_mean, color='blue', label='MC Dropout Mean')\n", + "plt.fill_between(x.squeeze(), \n", + " pred_mean - pred_std, \n", + " pred_mean + pred_std, \n", + " color='blue', alpha=0.2, label='Uncertainty (±1 std)')\n", + "plt.xlabel('x')\n", + "plt.ylabel('y')\n", + "plt.legend()\n", + "plt.title('Monte Carlo Dropout for Uncertainty Estimation')\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a642601b-d9fa-47d2-a1d2-34677988fe36", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "65498de7-fdde-4edf-9361-621a16f0b785", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "ml_tutorial", + "language": "python", + "name": "ml_tutorial" + }, + "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.9.15" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/template/ml_tutorials/pytorch_tutorial.ipynb b/template/ml_tutorials/pytorch_tutorial.ipynb new file mode 100644 index 0000000..1feff11 --- /dev/null +++ b/template/ml_tutorials/pytorch_tutorial.ipynb @@ -0,0 +1,1324 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "0a14f733-6ecd-426c-9a31-a535e7f11f9d", + "metadata": {}, + "source": [ + "# **Machine Learning Tutorial - PyTorch**\n", + "\n", + "This Jupyter Notebook files is a simple tutorial for Python users on the BSU Borah cluster. We will focus on PyTorch in this tutorial.\n", + "\n", + "## **Scenario 1: Starting a new project.**\n", + "\n", + "If you are starting a new project, it is better to create a new Python environment and install all the packages needed in it. Follow the steps in the link below to create a new Python environment on Borah.\n", + "\n", + "[Click here](https://bsu-docs.readthedocs.io/en/latest/software/conda/)\n", + " \n", + "For simplicity I will show the steps here, assuming that you will not need to use GPUs and already have conda/mamba installed. Ideally, if you know all the packages you will be using in your project, then it is better to install all of them at the point of creating your Python environment. This helps to prevent conflicts between package versions and dependencies. Here, we will create a new Python environment calle `ml_tutorial` that has some of the most popular and widely used Machine Learning (ML) Python packages installed in it. In this environment we need the following packages:\n", + "- pandas\n", + "- numpy\n", + "- matplotlib\n", + "- ipykernel\n", + "- pytorch (Note: Torch (built on Lua, a scripting language) and and PyTorch (built on Python) differ in origin. Also, the community and support for torch is diminishing, so it recommended to install PyTorch instead of torch. However, in Python, torch is the main package name for PyTorch. When you install PyTorch, you import it using `import torch`, not `import pytorch`.\n", + "- torchvision\n", + "- tensorflow\n", + "- tensorflow-gpu (for those who have need for GPUs)\n", + "- tensorboard\n", + "- scikit-learn\n", + "\n", + "Notice, how there are no white spaces in my environment name. This is very important. You can change the environment.\n", + "\n", + "Also note, per the new tensorflow update, once you install tensorflow you don't necessary have to install tensorbaord separately. However, for the purpose of this tutorial, I will just go ahead to install the two of them separately.\n", + " \n", + "Run the following commands:\n", + "\n", + "### **Step 1: Create a Python environment**\n", + "\n", + "``` ruby\n", + "mamba create -n ml_tutorial -c conda-forge matplotlib numpy pandas ipykernel pytorch torchvision tensorflow tensorflow-gpu tensorboard scikit-learn\n", + "```\n", + "\n", + "By extension, if you have up to `n` packages, then the code will be:\n", + "\n", + "```ruby\n", + "mamba create -n ml_tutorial -c conda-forge package1 package2 package3 ... packagen\n", + "```\n", + "\n", + "### **Step 2: Add your environment to Borah `OnDemand`**\n", + "\n", + "``` ruby\n", + "python -m ipykernel install --user --name ml_tutorial --display-name \"ml_tutorial\"\n", + "```\n", + "\n", + "## **Scenario 2: Installing in an already existing Python environment**\n", + "If you already have and existing Python environment for your project, but wants to install additional Python libraries for your ML applications, then just simply skip creating a new Python environment. Just be aware that sometimes, you might have conflicts with some package versions and dependencies, this is normal and can be fixed. Though, sometimes the conflicts are not so easily fixed.\n", + "\n", + "```ruby\n", + "mamba install -c conda-forge package1 package2 package3 ... packagen\n", + "```\n", + "\n", + "Thus, by extension, if we only want to install the ML libraries in our existing Python environment, we will use the following command.\n", + "\n", + "```ruby\n", + "mamba install -c conda-forge pytorch torchvision tensorflow tensorflow-gpu tensorboard scikit-learn\n", + "```\n", + "\n", + "Great!!! \n", + "Now the rest of this notebook demonstrates how to do a simple analysis using PyTorch.\n", + "\n", + "## **ML Tutorial**\n", + "Here we will rely on some in-built datasets in Python to build very simple ML models. Note that the idea here is to demonstrate simply how to install and use this libraries on Borah. We don't care so much about the model's accuracy or performance.\n", + "\n", + "### **The MNIST Problem: Handwritten Digit Classification** \n", + "\n", + "### **Overview** \n", + "The **MNIST (Modified National Institute of Standards and Technology) dataset** is a classic **machine learning problem** where the goal is to classify **handwritten digits (0-9)**. The dataset consists of **70,000 grayscale images** of digits, each **28×28 pixels** in size. \n", + "\n", + "#### **Why is MNIST Important?** \n", + "- It serves as the **\"Hello World\"** of deep learning and computer vision.\n", + "- It helps in testing **image classification algorithms**.\n", + "- It is small and easy to use but still challenging enough to evaluate different models.\n", + "\n", + "---\n", + "\n", + "### **Problem Definition**\n", + "The task is to train a **machine learning model** that can **automatically recognize handwritten digits** from images.\n", + "\n", + "1. **Input:** A **grayscale image (28×28 pixels)** of a handwritten digit.\n", + "2. **Output:** A **single label (0-9)** representing the digit in the image.\n", + "3. **Model Type:** This is a **supervised classification** problem.\n", + "\n", + "---\n", + "\n", + "### **Dataset Breakdown**\n", + "- **Training Set:** 60,000 images.\n", + "- **Test Set:** 10,000 images.\n", + "- **Classes:** 10 (digits 0-9).\n", + "- **Image Properties:**\n", + " - 28×28 pixels.\n", + " - Each pixel has a value between **0 (black) and 255 (white)**.\n", + " - No color channels (grayscale).\n", + " - Images vary in style due to different handwriting.\n", + "\n", + "---\n", + "\n", + "### **Challenges of the MNIST Problem**\n", + "1. **Variability in Handwriting:** Different people write digits differently.\n", + "2. **Noise in Data:** Some images might be blurry or poorly written.\n", + "3. **Generalization:** The model should work on unseen handwritten digits.\n", + "\n", + "---\n", + "\n", + "### **Approaches to Solve MNIST**\n", + "There are several ways to tackle the problem:\n", + "\n", + "| Approach | Method |\n", + "|----------|--------|\n", + "| **Basic Approach** | Logistic Regression, k-Nearest Neighbors (KNN) |\n", + "| **Deep Learning Approach** | Fully Connected Neural Networks (FCNN) |\n", + "| **Advanced Approach** | Convolutional Neural Networks (CNNs) |\n", + "\n", + "---\n", + "\n", + "### **Applications of MNIST Classification**\n", + "- Optical Character Recognition (**OCR**) in postal services.\n", + "- Digit recognition for **bank check processing**.\n", + "- Handwriting analysis in **touchscreen devices**.\n", + "\n", + "### **Tutorial 1: PyTorch Machine Learning Tutorial**\n", + "**Objective: Train an ML model using PyTorch to classify images in the MNIST dataset (handwritten digits from 0 to 9).**\n", + "\n", + "Note that this Jupyter Notebook is the PyTorch version of the TensorFlow tutorial already provided.\n", + "\n", + "### **Step 1: Import Required Libraries**" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "90cfa80b-543d-49b0-88bb-6b6c36e89a5c", + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import torchvision\n", + "import torch.nn as nn\n", + "import torch.optim as optim\n", + "import matplotlib.pyplot as plt\n", + "import torchvision.transforms as transforms" + ] + }, + { + "cell_type": "markdown", + "id": "1c709df1-0ecf-4401-a129-b3330cd2e2b4", + "metadata": {}, + "source": [ + "### **Step 2: Load the MNIST Dataset**\n", + "The MNIST dataset consists of 28×28 grayscale images of handwritten digits (0-9).\n", + "We'll use torchvision to load and preprocess the data." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "cfb43a2e-b044-466e-bf0c-ddee47127730", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz\n", + "Failed to download (trying next):\n", + "HTTP Error 404: Not Found\n", + "\n", + "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/train-images-idx3-ubyte.gz\n", + "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/train-images-idx3-ubyte.gz to /bsuhome/tnde/scratch/ml_tutorials/data/MNIST/raw/train-images-idx3-ubyte.gz\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100.0%\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Extracting /bsuhome/tnde/scratch/ml_tutorials/data/MNIST/raw/train-images-idx3-ubyte.gz to /bsuhome/tnde/scratch/ml_tutorials/data/MNIST/raw\n", + "\n", + "Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz\n", + "Failed to download (trying next):\n", + "HTTP Error 404: Not Found\n", + "\n", + "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/train-labels-idx1-ubyte.gz\n", + "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/train-labels-idx1-ubyte.gz to /bsuhome/tnde/scratch/ml_tutorials/data/MNIST/raw/train-labels-idx1-ubyte.gz\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "102.8%\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Extracting /bsuhome/tnde/scratch/ml_tutorials/data/MNIST/raw/train-labels-idx1-ubyte.gz to /bsuhome/tnde/scratch/ml_tutorials/data/MNIST/raw\n", + "\n", + "Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz\n", + "Failed to download (trying next):\n", + "HTTP Error 404: Not Found\n", + "\n", + "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/t10k-images-idx3-ubyte.gz\n", + "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/t10k-images-idx3-ubyte.gz to /bsuhome/tnde/scratch/ml_tutorials/data/MNIST/raw/t10k-images-idx3-ubyte.gz\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100.0%\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Extracting /bsuhome/tnde/scratch/ml_tutorials/data/MNIST/raw/t10k-images-idx3-ubyte.gz to /bsuhome/tnde/scratch/ml_tutorials/data/MNIST/raw\n", + "\n", + "Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz\n", + "Failed to download (trying next):\n", + "HTTP Error 404: Not Found\n", + "\n", + "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/t10k-labels-idx1-ubyte.gz\n", + "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/t10k-labels-idx1-ubyte.gz to /bsuhome/tnde/scratch/ml_tutorials/data/MNIST/raw/t10k-labels-idx1-ubyte.gz\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "112.7%" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Extracting /bsuhome/tnde/scratch/ml_tutorials/data/MNIST/raw/t10k-labels-idx1-ubyte.gz to /bsuhome/tnde/scratch/ml_tutorials/data/MNIST/raw\n", + "\n", + "Training dataset size: 60000\n", + "Test dataset size: 10000\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "# Define transformation to normalize the data\n", + "transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))])\n", + "\n", + "# Load training and test datasets\n", + "train_dataset = torchvision.datasets.MNIST(root='/bsuhome/tnde/scratch/ml_tutorials/data', train=True, transform=transform, download=True)\n", + "test_dataset = torchvision.datasets.MNIST(root='/bsuhome/tnde/scratch/ml_tutorials/data', train=False, transform=transform, download=True)\n", + "\n", + "# Create data loaders for batching\n", + "train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=64, shuffle=True)\n", + "test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=64, shuffle=False)\n", + "\n", + "# Check dataset shape\n", + "print(f\"Training dataset size: {len(train_dataset)}\")\n", + "print(f\"Test dataset size: {len(test_dataset)}\")" + ] + }, + { + "cell_type": "markdown", + "id": "3b1c4c22-eef1-4212-89ac-682a07b596b9", + "metadata": {}, + "source": [ + "### **Step 3: Build a Neural Network Model**\n", + "We define a feedforward neural network with one hidden layer." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "d3c3c8c6-2cf4-455e-9e82-e0813e331092", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "NeuralNet(\n", + " (flatten): Flatten(start_dim=1, end_dim=-1)\n", + " (fc1): Linear(in_features=784, out_features=128, bias=True)\n", + " (relu): ReLU()\n", + " (dropout): Dropout(p=0.2, inplace=False)\n", + " (fc2): Linear(in_features=128, out_features=10, bias=True)\n", + ")" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "class NeuralNet(nn.Module):\n", + " def __init__(self):\n", + " super(NeuralNet, self).__init__()\n", + " self.flatten = nn.Flatten() # Flatten 28x28 images into 1D array\n", + " self.fc1 = nn.Linear(28*28, 128) # Fully connected layer with 128 neurons\n", + " self.relu = nn.ReLU() # Activation function\n", + " self.dropout = nn.Dropout(0.2) # Dropout to reduce overfitting\n", + " self.fc2 = nn.Linear(128, 10) # Output layer with 10 classes (digits 0-9)\n", + "\n", + " def forward(self, x):\n", + " x = self.flatten(x)\n", + " x = self.fc1(x)\n", + " x = self.relu(x)\n", + " x = self.dropout(x)\n", + " x = self.fc2(x)\n", + " return x\n", + "\n", + "# Instantiate the model\n", + "model = NeuralNet()\n", + "\n", + "# Define loss function and optimizer\n", + "criterion = nn.CrossEntropyLoss()\n", + "optimizer = optim.Adam(model.parameters(), lr=0.001)\n", + "\n", + "# Move model to GPU if available\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", + "model.to(device)" + ] + }, + { + "cell_type": "markdown", + "id": "d3a752d4-336f-481b-92e5-9bd34b1f88b9", + "metadata": {}, + "source": [ + "### **Step 4: Train the Model**" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "3d5b2e51-6d9c-40cf-a247-3e1bf0445b5c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch [1/10], Loss: 0.4327\n", + "Epoch [2/10], Loss: 0.2336\n", + "Epoch [3/10], Loss: 0.1881\n", + "Epoch [4/10], Loss: 0.1610\n", + "Epoch [5/10], Loss: 0.1486\n", + "Epoch [6/10], Loss: 0.1370\n", + "Epoch [7/10], Loss: 0.1290\n", + "Epoch [8/10], Loss: 0.1210\n", + "Epoch [9/10], Loss: 0.1191\n", + "Epoch [10/10], Loss: 0.1122\n", + "Training complete!\n" + ] + } + ], + "source": [ + "num_epochs = 10\n", + "\n", + "for epoch in range(num_epochs):\n", + " model.train() # Set model to training mode\n", + " running_loss = 0.0\n", + " \n", + " for images, labels in train_loader:\n", + " images, labels = images.to(device), labels.to(device) # Move to GPU if available\n", + " \n", + " optimizer.zero_grad() # Zero the gradients\n", + " outputs = model(images) # Forward pass\n", + " loss = criterion(outputs, labels) # Compute loss\n", + " loss.backward() # Backpropagation\n", + " optimizer.step() # Update weights\n", + " \n", + " running_loss += loss.item()\n", + " \n", + " print(f\"Epoch [{epoch+1}/{num_epochs}], Loss: {running_loss/len(train_loader):.4f}\")\n", + "\n", + "print(\"Training complete!\")" + ] + }, + { + "cell_type": "markdown", + "id": "b62f4fdf-0a8e-4b29-9dfd-4dc80ee1a83d", + "metadata": {}, + "source": [ + "### **Step 5: Evaluate the Model**" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "e52b7245-3214-4a9f-af62-c964f15536f3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Test Accuracy: 0.9724\n" + ] + } + ], + "source": [ + "model.eval() # Set model to evaluation mode\n", + "correct = 0\n", + "total = 0\n", + "\n", + "with torch.no_grad():\n", + " for images, labels in test_loader:\n", + " images, labels = images.to(device), labels.to(device) # Move to GPU if available\n", + " outputs = model(images)\n", + " _, predicted = torch.max(outputs, 1) # Get the class with highest probability\n", + " total += labels.size(0)\n", + " correct += (predicted == labels).sum().item()\n", + "\n", + "accuracy = correct / total\n", + "print(f\"Test Accuracy: {accuracy:.4f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "299c3c62-6447-44b4-b658-6836b27fd186", + "metadata": {}, + "source": [ + "### **Step 6: Make Predictions**" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "c8a76f91-399b-4eb7-b517-4c83ae414fe1", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Get a batch of test images\n", + "images, labels = next(iter(test_loader))\n", + "images, labels = images.to(device), labels.to(device)\n", + "\n", + "# Make predictions\n", + "model.eval()\n", + "with torch.no_grad():\n", + " outputs = model(images)\n", + " _, predicted = torch.max(outputs, 1)\n", + "\n", + "# Display an example image and prediction\n", + "plt.imshow(images[0].cpu().squeeze(), cmap='gray')\n", + "plt.title(f\"Predicted: {predicted[0].item()}, Actual: {labels[0].item()}\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "c8540e46-7cd1-4844-b11e-f20f4a651641", + "metadata": {}, + "source": [ + "### **Next Steps**\n", + "- Try using a Convolutional Neural Network (CNN) for better performance.\n", + "- Experiment with different optimizers and activation functions.\n", + "- Use a custom dataset (e.g., images of animals or handwritten characters)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b139bea8-374e-4d38-9117-41ce3792de7b", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "ad67ba6d-df22-4fac-9bee-f7cc6817c49e", + "metadata": {}, + "source": [ + "## **PyTorch CNN Tutorial: Handwritten Digit Classification**\n", + "**Objective: Train a Convolutional Neural Network (CNN) using PyTorch to classify handwritten digits in the MNIST dataset.**\n", + "\n", + "### **Step 1: Import Required Libraries**" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "31368e43-9110-4980-bc88-0dfe556787f4", + "metadata": {}, + "outputs": [], + "source": [ + "# import torch\n", + "import numpy as np\n", + "# import torchvision\n", + "# import torch.nn as nn\n", + "# import torch.optim as optim\n", + "# import matplotlib.pyplot as plt\n", + "# import torchvision.transforms as transforms" + ] + }, + { + "cell_type": "markdown", + "id": "a91ee26e-0c36-4817-990b-092d4deb0d5d", + "metadata": {}, + "source": [ + "### **Step 2: Load and Preprocess the MNIST Dataset**" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "7d475045-211f-45c2-af45-baecda4bb5bf", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training dataset size: 60000\n", + "Test dataset size: 10000\n" + ] + } + ], + "source": [ + "# Define transformation (convert images to tensors and normalize)\n", + "transform = transforms.Compose([\n", + " transforms.ToTensor(),\n", + " transforms.Normalize((0.5,), (0.5,)) # Normalize images to [-1, 1]\n", + "])\n", + "\n", + "# Load training and test datasets\n", + "train_dataset = torchvision.datasets.MNIST(root='/bsuhome/tnde/scratch/ml_tutorials/data', train=True, transform=transform, download=True)\n", + "test_dataset = torchvision.datasets.MNIST(root='/bsuhome/tnde/scratch/ml_tutorials/data', train=False, transform=transform, download=True)\n", + "\n", + "# Create data loaders for batching\n", + "train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=64, shuffle=True)\n", + "test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=64, shuffle=False)\n", + "\n", + "# Check dataset shape\n", + "print(f\"Training dataset size: {len(train_dataset)}\")\n", + "print(f\"Test dataset size: {len(test_dataset)}\")" + ] + }, + { + "cell_type": "markdown", + "id": "38dfb758-124a-4f9f-971b-57c05f3d76bf", + "metadata": {}, + "source": [ + "### **Step 3: Define the CNN Architecture**\n", + "Instead of a Dense Neural Network, we now use:\n", + "\n", + "- Convolutional layers to extract features.\n", + "- MaxPooling layers to reduce dimensions.\n", + "- Dropout layers to prevent overfitting." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "e1618f18-621d-4b91-b535-c537e286800d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "CNN(\n", + " (conv1): Conv2d(1, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (relu1): ReLU()\n", + " (pool1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", + " (conv2): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (relu2): ReLU()\n", + " (pool2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", + " (flatten): Flatten(start_dim=1, end_dim=-1)\n", + " (fc1): Linear(in_features=3136, out_features=128, bias=True)\n", + " (relu3): ReLU()\n", + " (dropout): Dropout(p=0.5, inplace=False)\n", + " (fc2): Linear(in_features=128, out_features=10, bias=True)\n", + ")" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "class CNN(nn.Module):\n", + " def __init__(self):\n", + " super(CNN, self).__init__()\n", + " self.conv1 = nn.Conv2d(in_channels=1, out_channels=32, kernel_size=3, stride=1, padding=1)\n", + " self.relu1 = nn.ReLU()\n", + " self.pool1 = nn.MaxPool2d(kernel_size=2, stride=2)\n", + "\n", + " self.conv2 = nn.Conv2d(in_channels=32, out_channels=64, kernel_size=3, stride=1, padding=1)\n", + " self.relu2 = nn.ReLU()\n", + " self.pool2 = nn.MaxPool2d(kernel_size=2, stride=2)\n", + "\n", + " self.flatten = nn.Flatten()\n", + " self.fc1 = nn.Linear(64 * 7 * 7, 128) # 7x7 after pooling\n", + " self.relu3 = nn.ReLU()\n", + " self.dropout = nn.Dropout(0.5)\n", + "\n", + " self.fc2 = nn.Linear(128, 10) # Output layer for 10 classes\n", + "\n", + " def forward(self, x):\n", + " x = self.pool1(self.relu1(self.conv1(x)))\n", + " x = self.pool2(self.relu2(self.conv2(x)))\n", + " x = self.flatten(x)\n", + " x = self.relu3(self.fc1(x))\n", + " x = self.dropout(x)\n", + " x = self.fc2(x)\n", + " return x\n", + "\n", + "# Instantiate the model\n", + "model = CNN()\n", + "\n", + "# Define loss function and optimizer\n", + "criterion = nn.CrossEntropyLoss()\n", + "optimizer = optim.Adam(model.parameters(), lr=0.001)\n", + "\n", + "# Move model to GPU if available\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", + "model.to(device)" + ] + }, + { + "cell_type": "markdown", + "id": "08e84720-d679-4c01-b7ce-139b96d0a310", + "metadata": {}, + "source": [ + "### **Step 4: Train the CNN Model**" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "744a42a2-7d58-4cba-b39c-433a8f6becaf", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch [1/10], Train Loss: 0.2486, Train Acc: 0.9239, Val Loss: 0.0526, Val Acc: 0.9839\n", + "Epoch [2/10], Train Loss: 0.0908, Train Acc: 0.9732, Val Loss: 0.0347, Val Acc: 0.9889\n", + "Epoch [3/10], Train Loss: 0.0669, Train Acc: 0.9801, Val Loss: 0.0296, Val Acc: 0.9905\n", + "Epoch [4/10], Train Loss: 0.0553, Train Acc: 0.9831, Val Loss: 0.0295, Val Acc: 0.9903\n", + "Epoch [5/10], Train Loss: 0.0472, Train Acc: 0.9855, Val Loss: 0.0251, Val Acc: 0.9927\n", + "Epoch [6/10], Train Loss: 0.0415, Train Acc: 0.9875, Val Loss: 0.0255, Val Acc: 0.9924\n", + "Epoch [7/10], Train Loss: 0.0354, Train Acc: 0.9890, Val Loss: 0.0221, Val Acc: 0.9933\n", + "Epoch [8/10], Train Loss: 0.0307, Train Acc: 0.9903, Val Loss: 0.0250, Val Acc: 0.9927\n", + "Epoch [9/10], Train Loss: 0.0297, Train Acc: 0.9905, Val Loss: 0.0237, Val Acc: 0.9932\n", + "Epoch [10/10], Train Loss: 0.0264, Train Acc: 0.9918, Val Loss: 0.0286, Val Acc: 0.9925\n", + "Training complete!\n" + ] + } + ], + "source": [ + "num_epochs = 10\n", + "train_losses = []\n", + "val_losses = []\n", + "train_accuracies = []\n", + "val_accuracies = []\n", + "\n", + "for epoch in range(num_epochs):\n", + " model.train()\n", + " running_loss = 0.0\n", + " correct, total = 0, 0\n", + "\n", + " for images, labels in train_loader:\n", + " images, labels = images.to(device), labels.to(device)\n", + "\n", + " optimizer.zero_grad()\n", + " outputs = model(images)\n", + " loss = criterion(outputs, labels)\n", + " loss.backward()\n", + " optimizer.step()\n", + "\n", + " running_loss += loss.item()\n", + " _, predicted = torch.max(outputs, 1)\n", + " total += labels.size(0)\n", + " correct += (predicted == labels).sum().item()\n", + "\n", + " train_loss = running_loss / len(train_loader)\n", + " train_accuracy = correct / total\n", + " train_losses.append(train_loss)\n", + " train_accuracies.append(train_accuracy)\n", + "\n", + " # Validate the model\n", + " model.eval()\n", + " val_loss = 0.0\n", + " correct, total = 0, 0\n", + "\n", + " with torch.no_grad():\n", + " for images, labels in test_loader:\n", + " images, labels = images.to(device), labels.to(device)\n", + " outputs = model(images)\n", + " loss = criterion(outputs, labels)\n", + " val_loss += loss.item()\n", + " _, predicted = torch.max(outputs, 1)\n", + " total += labels.size(0)\n", + " correct += (predicted == labels).sum().item()\n", + "\n", + " val_loss /= len(test_loader)\n", + " val_accuracy = correct / total\n", + " val_losses.append(val_loss)\n", + " val_accuracies.append(val_accuracy)\n", + "\n", + " print(f\"Epoch [{epoch+1}/{num_epochs}], Train Loss: {train_loss:.4f}, Train Acc: {train_accuracy:.4f}, Val Loss: {val_loss:.4f}, Val Acc: {val_accuracy:.4f}\")\n", + "\n", + "print(\"Training complete!\")" + ] + }, + { + "cell_type": "markdown", + "id": "a64463dd-2303-46f8-b531-3870f3627800", + "metadata": {}, + "source": [ + "### **Step 5: Evaluate the Model**" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "f7c4ec51-29ab-42d3-8f6c-5e039806745d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Test Accuracy: 0.9925\n" + ] + } + ], + "source": [ + "model.eval()\n", + "correct, total = 0, 0\n", + "\n", + "with torch.no_grad():\n", + " for images, labels in test_loader:\n", + " images, labels = images.to(device), labels.to(device)\n", + " outputs = model(images)\n", + " _, predicted = torch.max(outputs, 1)\n", + " total += labels.size(0)\n", + " correct += (predicted == labels).sum().item()\n", + "\n", + "accuracy = correct / total\n", + "print(f\"Test Accuracy: {accuracy:.4f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "79eacc3c-9840-4b67-b396-ae6ffc54b988", + "metadata": {}, + "source": [ + "### **Step 6: Visualize Training Progress**\n", + "Plot the accuracy and loss curves for both training and validation." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "87ee73f7-2b94-4bff-9706-5d543c0815d8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAGwCAYAAABB4NqyAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAABSlElEQVR4nO3deVxU9f4/8NfMwAzbMOybIGIuiAsgbkh69WqolT/N+mpmmmWZpRZ565aZpnbLW/d6NTMt7+1qdq/KbbfSFCvT1NJM0BKXXABZZBOGdYCZ8/vjMCPDJvuZ5fV8PM4D5syZM+8Ri5efVSYIggAiIiIiOyKXugAiIiKirsYARERERHaHAYiIiIjsDgMQERER2R0GICIiIrI7DEBERERkdxiAiIiIyO44SF2AJTIYDMjKyoJarYZMJpO6HCIiImoBQRBQUlKCoKAgyOXNt/EwADUiKysLISEhUpdBREREbZCRkYHg4OBmr2EAaoRarQYg/gG6u7tLXA0RERG1hFarRUhIiOn3eHMYgBph7PZyd3dnACIiIrIyLRm+wkHQREREZHcYgIiIiMjuMAARERGR3eEYICIi6hR6vR7V1dVSl0E2RqlU3nKKe0swABERUYcSBAE5OTkoKiqSuhSyQXK5HGFhYVAqle26DwMQERF1KGP48fPzg4uLCxeUpQ5jXKg4Ozsb3bt3b9ffLQYgIiLqMHq93hR+vL29pS6HbJCvry+ysrJQU1MDR0fHNt+Hg6CJiKjDGMf8uLi4SFwJ2Spj15der2/XfSQPQJs2bUJYWBicnJwQExODw4cPN3ntJ598gjvuuAO+vr5wd3dHbGws9u3bZ3bNtm3bIJPJGhyVlZWd/VGIiKgWu72os3TU3y1JA1BiYiISEhKwbNkynDp1CqNGjcKkSZOQnp7e6PWHDh3CHXfcgT179uDkyZMYO3YsJk+ejFOnTpld5+7ujuzsbLPDycmpKz4SERERWQFJxwD94x//wLx58/Doo48CANavX499+/Zh8+bNWLNmTYPr169fb/b4tddew+eff44vvvgC0dHRpvMymQwBAQGdWjsRERFZL8lagKqqqnDy5EnEx8ebnY+Pj8fRo0dbdA+DwYCSkhJ4eXmZnS8tLUVoaCiCg4Nx9913N2ghqk+n00Gr1ZodRERE7TFmzBgkJCRIXQY1QbIAlJ+fD71eD39/f7Pz/v7+yMnJadE91q5di7KyMkyfPt10Ljw8HNu2bcPu3buxc+dOODk5IS4uDhcvXmzyPmvWrIFGozEdISEhbftQLVBYVoUL10s67f5ERNQ6jY0brXvMnTu3Tff95JNP8Morr7Srtrlz52Lq1Kntugc1TvJp8PUHMwmC0KIBTjt37sTKlSvx+eefw8/Pz3R+xIgRGDFihOlxXFwcBg8ejLfeegsbNmxo9F5Lly7FkiVLTI+1Wm2nhKADZ6/j0e0/Y2A3Db5YfHuH35+IiFovOzvb9H1iYiJWrFiB8+fPm845OzubXV9dXd2i6df1eyfIskjWAuTj4wOFQtGgtSc3N7dBq1B9iYmJmDdvHv73v/9h/PjxzV4rl8sxdOjQZluAVCoV3N3dzY7OEB6oBgCkZmtRWd2+6XtERNZAEASUV9VIcgiC0KIaAwICTIdGozGNIw0ICEBlZSU8PDzwv//9D2PGjIGTkxP+85//oKCgADNnzkRwcDBcXFwwcOBA7Ny50+y+9bvAevTogddeew2PPPII1Go1unfvji1btrTrz/f777/HsGHDoFKpEBgYiBdeeAE1NTWm5z/66CMMHDgQzs7O8Pb2xvjx41FWVgYAOHjwIIYNGwZXV1d4eHggLi4OaWlp7arHmkjWAqRUKhETE4OkpCTcc889pvNJSUmYMmVKk6/buXMnHnnkEezcuRN33XXXLd9HEAQkJydj4MCBHVJ3e3TzcIaPmxL5pVX4LasYMaH81wER2baKaj0iVuy79YWd4OzqCXBRdsyvueeffx5r167F1q1boVKpUFlZiZiYGDz//PNwd3fHV199hdmzZ6Nnz54YPnx4k/dZu3YtXnnlFbz44ov46KOP8MQTT2D06NEIDw9vdU2ZmZm48847MXfuXGzfvh3nzp3DY489BicnJ6xcuRLZ2dmYOXMm3njjDdxzzz0oKSnB4cOHIQgCampqMHXqVDz22GPYuXMnqqqqcPz4cbtavkDSLrAlS5Zg9uzZGDJkCGJjY7Flyxakp6djwYIFAMSuqczMTGzfvh2AGH7mzJmDN998EyNGjDC1Hjk7O0Oj0QAAVq1ahREjRqB3797QarXYsGEDkpOT8fbbb0vzIeuQyWSICvHAgdRcnEovYgAiIrISCQkJmDZtmtm5Z5991vT94sWL8fXXX+PDDz9sNgDdeeedePLJJwGIoWrdunU4ePBgmwLQpk2bEBISgo0bN0ImkyE8PBxZWVl4/vnnsWLFCmRnZ6OmpgbTpk1DaGgoAJgaAwoLC1FcXIy7774bt912GwCgX79+ra7BmkkagGbMmIGCggKsXr0a2dnZGDBgAPbs2WP6QWVnZ5utCfTuu++ipqYGCxcuxMKFC03nH3roIWzbtg0AUFRUhPnz5yMnJwcajQbR0dE4dOgQhg0b1qWfrSnGAJScUSR1KUREnc7ZUYGzqydI9t4dZciQIWaP9Xo9/vrXvyIxMRGZmZnQ6XTQ6XRwdXVt9j6DBg0yfW/sasvNzW1TTampqYiNjTVrtYmLi0NpaSmuXbuGyMhIjBs3DgMHDsSECRMQHx+P++67D56envDy8sLcuXMxYcIE3HHHHRg/fjymT5+OwMDANtVijSQfBP3kk0+a0nB9xlBjdPDgwVveb926dVi3bl0HVNY5okI8AQAp14qkLYSIqAvIZLIO64aSUv1gs3btWqxbtw7r16/HwIED4erqioSEBFRVVTV7n/qDp2UyGQwGQ5tqamzSkHHck0wmg0KhQFJSEo4ePYr9+/fjrbfewrJly/DTTz8hLCwMW7duxVNPPYWvv/4aiYmJeOmll5CUlGQ2kciWSb4Vhr0ZFCJ21WUUVqCgVCdxNURE1BaHDx/GlClT8OCDDyIyMhI9e/ZsdrJNZ4iIiMDRo0fNBnsfPXoUarUa3bp1AyAGobi4OKxatQqnTp2CUqnEp59+aro+OjoaS5cuxdGjRzFgwADs2LGjSz+DlBiAupi7kyNu8xX/JcFuMCIi69SrVy9T60pqaioef/zxFq9h11rFxcVITk42O9LT0/Hkk08iIyMDixcvxrlz5/D555/j5ZdfxpIlSyCXy/HTTz/htddew88//4z09HR88sknyMvLQ79+/XDlyhUsXboUx44dQ1paGvbv348LFy7Y1Tgg62+XtEJRIZ64lFeG5IwijOvX/JR/IiKyPMuXL8eVK1cwYcIEuLi4YP78+Zg6dSqKi4s7/L0OHjxott0TcHPs6549e/Dcc88hMjISXl5emDdvHl566SUA4r6Yhw4dwvr166HVahEaGoq1a9di0qRJuH79Os6dO4f3338fBQUFCAwMxKJFi/D44493eP2WSia0dKEEO6LVaqHRaFBcXNwpawJ98GMaln/2K0b19sEH85qeLUBEZG0qKytx5coVhIWFcRNq6hTN/R1rze9vdoFJIDrEAwCQklEEg4H5k4iIqKsxAEmgb4AaKgc5tJU1uFJQJnU5REREdocBSAKOCjkGdBNngyWnF0lbDBERkR1iAJJIVG03GGeCERERdT0GIIkwABEREUmHAUgixgDEneGJiIi6HgOQRII9xZ3hawwCfsvSSl0OERGRXWEAkohMJkNksAcAdoMRERF1NQYgCXEcEBGR7RgzZgwSEhJMj3v06IH169c3+xqZTIbPPvus3e/dUfexJwxAEorq7gEASM64IW0hRER2bPLkyRg/fnyjzx07dgwymQy//PJLq+974sQJzJ8/v73lmVm5ciWioqIanM/OzsakSZM69L3q27ZtGzw8PDr1PboSA5CEBtV2gXFneCIi6cybNw/ffvst0tLSGjz373//G1FRURg8eHCr7+vr6wsXF5eOKPGWAgICoFKpuuS9bAUDkIQ0zjd3hk+5ViRtMUREduruu++Gn58ftm3bZna+vLwciYmJmDdvHgoKCjBz5kwEBwfDxcUFAwcOxM6dO5u9b/0usIsXL2L06NFwcnJCREQEkpKSGrzm+eefR58+feDi4oKePXti+fLlqK6uBiC2wKxatQopKSmQyWSQyWSmmut3gZ05cwZ//OMf4ezsDG9vb8yfPx+lpaWm5+fOnYupU6fi73//OwIDA+Ht7Y2FCxea3qst0tPTMWXKFLi5ucHd3R3Tp0/H9evXTc+npKRg7NixUKvVcHd3R0xMDH7++WcAQFpaGiZPngxPT0+4urqif//+2LNnT5traQnuBi+xyBAPcWf49CL8MZw7wxORjREEoLpcmvd2dAFkslte5uDggDlz5mDbtm1YsWIFZLWv+fDDD1FVVYVZs2ahvLwcMTExeP755+Hu7o6vvvoKs2fPRs+ePTF8+K03tTYYDJg2bRp8fHzw448/QqvVmo0XMlKr1di2bRuCgoJw5swZPPbYY1Cr1fjzn/+MGTNm4Ndff8XXX3+NAwcOAAA0Gk2De5SXl2PixIkYMWIETpw4gdzcXDz66KNYtGiRWcj77rvvEBgYiO+++w6///47ZsyYgaioKDz22GO3/Dz1CYKAqVOnwtXVFd9//z1qamrw5JNPYsaMGTh48CAAYNasWYiOjsbmzZuhUCiQnJwMR0dHAMDChQtRVVWFQ4cOwdXVFWfPnoWbm1ur62gNBiCJRYd44JNfMnGKA6GJyBZVlwOvBUnz3i9mAUrXFl36yCOP4G9/+xsOHjyIsWPHAhC7v6ZNmwZPT094enri2WefNV2/ePFifP311/jwww9bFIAOHDiA1NRUXL16FcHBwQCA1157rcG4nZdeesn0fY8ePfCnP/0JiYmJ+POf/wxnZ2e4ubnBwcEBAQEBTb7Xf//7X1RUVGD79u1wdRU//8aNGzF58mS8/vrr8PcX/7Ht6emJjRs3QqFQIDw8HHfddRe++eabNgWgAwcO4PTp07hy5QpCQkIAAB988AH69++PEydOYOjQoUhPT8dzzz2H8PBwAEDv3r1Nr09PT8e9996LgQMHAgB69uzZ6hpai11gEosK8QTAneGJiKQUHh6OkSNH4t///jcA4NKlSzh8+DAeeeQRAIBer8err76KQYMGwdvbG25ubti/fz/S09NbdP/U1FR0797dFH4AIDY2tsF1H330EW6//XYEBATAzc0Ny5cvb/F71H2vyMhIU/gBgLi4OBgMBpw/f950rn///lAoFKbHgYGByM3NbdV71X3PkJAQU/gBgIiICHh4eCA1NRUAsGTJEjz66KMYP348/vrXv+LSpUuma5966in85S9/QVxcHF5++WWcPn26TXW0BluAJBYeeHNn+KsFZejp27lNfkREXcrRRWyJkeq9W2HevHlYtGgR3n77bWzduhWhoaEYN24cAGDt2rVYt24d1q9fj4EDB8LV1RUJCQmoqqpq0b0FoeE/cGX1uud+/PFH3H///Vi1ahUmTJgAjUaDXbt2Ye3ata36HIIgNLh3Y+9p7H6q+5zBYGjVe93qPeueX7lyJR544AF89dVX2Lt3L15++WXs2rUL99xzDx599FFMmDABX331Ffbv3481a9Zg7dq1WLx4cZvqaQm2AEnMbGd4doMRka2RycRuKCmOFoz/qWv69OlQKBTYsWMH3n//fTz88MOmX96HDx/GlClT8OCDDyIyMhI9e/bExYsXW3zviIgIpKenIyvrZhg8duyY2TVHjhxBaGgoli1bhiFDhqB3794NZqYplUro9c1vnxQREYHk5GSUlZWZ3Vsul6NPnz4trrk1jJ8vIyPDdO7s2bMoLi5Gv379TOf69OmDZ555Bvv378e0adOwdetW03MhISFYsGABPvnkE/zpT3/CP//5z06p1YgByAJwRWgiIum5ublhxowZePHFF5GVlYW5c+eanuvVqxeSkpJw9OhRpKam4vHHH0dOTk6L7z1+/Hj07dsXc+bMQUpKCg4fPoxly5aZXdOrVy+kp6dj165duHTpEjZs2IBPP/3U7JoePXrgypUrSE5ORn5+PnS6hkuozJo1C05OTnjooYfw66+/4rvvvsPixYsxe/Zs0/ifttLr9UhOTjY7zp49i/Hjx2PQoEGYNWsWfvnlFxw/fhxz5szBH/7wBwwZMgQVFRVYtGgRDh48iLS0NBw5cgQnTpwwhaOEhATs27cPV65cwS+//IJvv/3WLDh1BgYgC3BzQcQiSesgIrJ38+bNw40bNzB+/Hh0797ddH758uUYPHgwJkyYgDFjxiAgIABTp05t8X3lcjk+/fRT6HQ6DBs2DI8++iheffVVs2umTJmCZ555BosWLUJUVBSOHj2K5cuXm11z7733YuLEiRg7dix8fX0bnYrv4uKCffv2obCwEEOHDsV9992HcePGYePGja37w2hEaWkpoqOjzY4777zTNA3f09MTo0ePxvjx49GzZ08kJiYCABQKBQoKCjBnzhz06dMH06dPx6RJk7Bq1SoAYrBauHAh+vXrh4kTJ6Jv377YtGlTu+ttjkxorGPSzmm1Wmg0GhQXF8Pd3b3T3y+jsByj3vgOjgoZzqycACdHxa1fRERkgSorK3HlyhWEhYXByclJ6nLIBjX3d6w1v7/ZAmQBgj2d4e2qRLVewNls7gxPRETU2RiALIBMJru5MWp6kaS1EBER2QMGIAsRyZ3hiYiIugwDkIWIYgAiIiLqMgxAFsLYApReWI7CspYtrEVEZKk4v4Y6S0f93WIAshAaZ0f0NO4Mz1YgIrJSxtWFy8sl2gCVbJ5x9e2623i0BbfCsCBRIR64nFeGUxlFGBvuJ3U5REStplAo4OHhYdpTysXFpcltGYhay2AwIC8vDy4uLnBwaF+EYQCyIFG1O8NzHBARWTPjTuVt3ViTqDlyuRzdu3dvd7BmALIgxoHQKRlFzW5mR0RkyWQyGQIDA+Hn54fq6mqpyyEbo1QqIZe3fwQPA5AFCQ9wh9JBjuKKalwtKEeYj6vUJRERtZlCoWj3OA2izsJB0BZE6SDHgCBx6e7kjBsSV0NERGS7GIAsTFSIJwCuCE1ERNSZGIAsTGSIBgAXRCQiIupMDEAWJrq2BehsthaV1XqJqyEiIrJNDEAWJsTLGV61O8Oncmd4IiKiTsEAZGHMdoZnNxgREVGnYACyQJHBHgAYgIiIiDoLA5AFiuruAYABiIiIqLMwAFmgqNoWoLQC7gxPRETUGRiALJDGxRE9a1eBTrlWJG0xRERENogByEKZBkJzQUQiIqIOxwBkoSI5E4yIiKjTMABZKNPO8NfEneGJiIio4zAAWah+geLO8EXl4s7wRERE1HEYgCyU0kGO/rU7w6ewG4yIiKhDMQBZMK4ITURE1DkYgCyYMQCdYgAiIiLqUAxAFswYgFKztNDVcGd4IiKijsIAZMG6e7nAy1WJKr0BZ7O4MzwREVFHYQCyYDKZDJHBGgAcCE1ERNSRGIAsXFSIJwAOhCYiIupIDEAWLjJEbAFiACIiIuo4DEAWzjgQ+mpBOW5wZ3giIqIOwQBk4TxclAir3Rk+mTvDExERdQgGICtg2heM3WBEREQdggHICnBFaCIioo7FAGQFIuu0AHFneCIiovZjALIC/QLVUCrkuFFejTTuDE9ERNRuDEBWQOWgQETtzvDsBiMiImo/yQPQpk2bEBYWBicnJ8TExODw4cNNXvvJJ5/gjjvugK+vL9zd3REbG4t9+/Y1uO7jjz9GREQEVCoVIiIi8Omnn3bmR+gSHAdERETUcSQNQImJiUhISMCyZctw6tQpjBo1CpMmTUJ6enqj1x86dAh33HEH9uzZg5MnT2Ls2LGYPHkyTp06Zbrm2LFjmDFjBmbPno2UlBTMnj0b06dPx08//dRVH6tTRHf3AMAARERE1BFkgoSjaocPH47Bgwdj8+bNpnP9+vXD1KlTsWbNmhbdo3///pgxYwZWrFgBAJgxYwa0Wi327t1rumbixInw9PTEzp07W3RPrVYLjUaD4uJiuLu7t+ITdZ6r+WUY8/eDUCrkOLMqHioHhdQlERERWZTW/P6WrAWoqqoKJ0+eRHx8vNn5+Ph4HD16tEX3MBgMKCkpgZeXl+ncsWPHGtxzwoQJzd5Tp9NBq9WaHZYm1NsFni6OqNIbkJpdInU5REREVk2yAJSfnw+9Xg9/f3+z8/7+/sjJyWnRPdauXYuysjJMnz7ddC4nJ6fV91yzZg00Go3pCAkJacUn6RoymcxsOjwRERG1neSDoGUymdljQRAanGvMzp07sXLlSiQmJsLPz69d91y6dCmKi4tNR0ZGRis+QdfhQGgiIqKO4SDVG/v4+EChUDRomcnNzW3QglNfYmIi5s2bhw8//BDjx483ey4gIKDV91SpVFCpVK38BF2PAYiIiKhjSNYCpFQqERMTg6SkJLPzSUlJGDlyZJOv27lzJ+bOnYsdO3bgrrvuavB8bGxsg3vu37+/2Xtai8hgDwDAlfwyFJVzZ3giIqK2kqwFCACWLFmC2bNnY8iQIYiNjcWWLVuQnp6OBQsWABC7pjIzM7F9+3YAYviZM2cO3nzzTYwYMcLU0uPs7AyNRgMAePrppzF69Gi8/vrrmDJlCj7//HMcOHAAP/zwgzQfsgN5uirRw9sFVwvKkZxRhDF9/W79IiIiImpA0jFAM2bMwPr167F69WpERUXh0KFD2LNnD0JDQwEA2dnZZmsCvfvuu6ipqcHChQsRGBhoOp5++mnTNSNHjsSuXbuwdetWDBo0CNu2bUNiYiKGDx/e5Z+vM9zcGb5Y2kKIiIismKTrAFkqS1wHyGjbkStY+cVZjO3ri60PD5O6HCIiIothFesAUdtEdfcEIA6EZnYlIiJqGwYgK1N3Z/j0Qu4MT0RE1BYMQFZG5aBAP+4MT0RE1C4MQFYomusBERERtQsDkBXigohERETtwwBkhYwB6LcsLapqDNIWQ0REZIUYgKxQqLcLPFwcUVVjQGq25e1cT0REZOkYgKyQTCYzbYvBbjAiIqLWYwCyUjdXhC6StA4iIiJrxABkpaK6ewBgCxAREVFbMABZqajaLrDL+WUoLq+WthgiIiIrwwBkpTxdlQj1dgEAJF8rkrYYIiIiK8MAZMVM6wGlF0laBxERkbVhALJipoHQbAEiIiJqFQYgK1Z3RWjuDE9ERNRyDEBWrF+gOxwVMhSWVSGjsELqcoiIiKwGA5AVc3JUICJQ3Bn+VMYNiashIiKyHgxAVo4boxIREbUeA5CVMy6IyBWhiYiIWo4ByMpFhXgCAH7lzvBEREQtxgBk5Xp4u0DjLO4Mfy6HO8MTERG1BAOQlZPJZIjkOCAiIqJWYQCyAVwRmoiIqHUYgGxAtDEAcUVoIiKiFmEAsgHGLrDLedwZnoiIqCUYgGyAl6sS3b3EneG5LxgREdGtMQDZCC6ISERE1HIMQDaCAYiIiKjlGIBsRN0VobkzPBERUfMYgGxERO3O8AVlVbh2gzvDExERNYcByEY4OSrQz7QzfJG0xRAREVk4BiAbwgURiYiIWoYByIYYAxCnwhMRETWPAciGGAPQr5nFqNZzZ3giIqKmMADZkDAfV7g7OUBXY8C57BKpyyEiIrJYDEA2xHxn+BvSFkNERGTBGIBsjHFjVM4EIyIiahoDkI2puyAiERERNY4ByMZEBnsAAC7llaG4gjvDExERNYYByMZ4u6lMO8Of5nR4IiKiRjEA2aBILohIRETULAYgG8Sd4YmIiJrHAGSD6q4IzZ3hiYiIGmIAskH9g8Sd4fNLuTM8ERFRYxiAbFDdneHZDUZERNQQA5CNMk6HZwAiIiJqiAHIRnEgNBERUdMYgGyUcUVo7gxPRETUEAOQjQrzvrkz/Pkc7gxPRERUFwOQjZLLb+4Mz41RiYiIzDEA2bAorghNRETUKAYgG3ZzIPQNaQshIiKyMAxANswYgC7llUFbyZ3hiYiIjBiAbJi3mwohXs4AgNMZxRJXQ0REZDkYgGxcVIgnAHaDERER1cUAZOMigzUAuCAiERFRXQxANi66dkHE5AzuDE9ERGTEAGTj+gdp4CAXd4bPLOLO8ERERAADkM3jzvBEREQNMQDZAS6ISEREZI4ByA5Ecmd4IiIiMwxAdsDYAnSGO8MTEREBYACyCz19XKHmzvBEREQmDEB2QC6X1dkXrEjSWoiIiCyB5AFo06ZNCAsLg5OTE2JiYnD48OEmr83OzsYDDzyAvn37Qi6XIyEhocE127Ztg0wma3BUVlZ24qewfJHBHgAYgIiIiACJA1BiYiISEhKwbNkynDp1CqNGjcKkSZOQnp7e6PU6nQ6+vr5YtmwZIiMjm7yvu7s7srOzzQ4nJ6fO+hhWgS1AREREN0kagP7xj39g3rx5ePTRR9GvXz+sX78eISEh2Lx5c6PX9+jRA2+++SbmzJkDjUbT5H1lMhkCAgLMjubodDpotVqzw9ZE1a4IfSmvlDvDExGR3ZMsAFVVVeHkyZOIj483Ox8fH4+jR4+2696lpaUIDQ1FcHAw7r77bpw6darZ69esWQONRmM6QkJC2vX+lsjHTYVgT2cIAnDmGneGJyIi+yZZAMrPz4der4e/v7/ZeX9/f+Tk5LT5vuHh4di2bRt2796NnTt3wsnJCXFxcbh48WKTr1m6dCmKi4tNR0ZGRpvf35KxG4yIiEjkIHUBMpnM7LEgCA3OtcaIESMwYsQI0+O4uDgMHjwYb731FjZs2NDoa1QqFVQqVZvf01pEhXjgy9PZOMUVoYmIyM5J1gLk4+MDhULRoLUnNze3QatQe8jlcgwdOrTZFiB7UbcFiDvDExGRPZMsACmVSsTExCApKcnsfFJSEkaOHNlh7yMIApKTkxEYGNhh97RWA7oZd4bXcWd4IiKya5J2gS1ZsgSzZ8/GkCFDEBsbiy1btiA9PR0LFiwAII7NyczMxPbt202vSU5OBiAOdM7Ly0NycjKUSiUiIiIAAKtWrcKIESPQu3dvaLVabNiwAcnJyXj77be7/PNZGidHBcID1fg1U4uUjGIEe7pIXRIREZEkJA1AM2bMQEFBAVavXo3s7GwMGDAAe/bsQWhoKABx4cP6awJFR0ebvj958iR27NiB0NBQXL16FQBQVFSE+fPnIycnBxqNBtHR0Th06BCGDRvWZZ/LkkWFeODXTC2SM27grkFsFSMiIvskEzgYpAGtVguNRoPi4mK4u7tLXU6H+vDnDDz30WkM7eGJDxd0XFcjERGR1Frz+1vyrTCoa0XXLojIneGJiMieMQDZmZ4+blA7OaCy2oAL17kzPBER2ScGIDsjl8u4MSoREdm9NgWgjIwMXLt2zfT4+PHjSEhIwJYtWzqsMOo8pvWAuCAiERHZqTYFoAceeADfffcdACAnJwd33HEHjh8/jhdffBGrV6/u0AKp40VySwwiIrJzbQpAv/76q2la+f/+9z8MGDAAR48exY4dO7Bt27aOrI86gbEF6Pe8UpRwZ3giIrJDbQpA1dXVpr2zDhw4gP/3//4fAHEj0uzs7I6rjjqFr1qFbh7cGZ6IiOxXmwJQ//798c477+Dw4cNISkrCxIkTAQBZWVnw9vbu0AKpc0TVToc/xW4wIiKyQ20KQK+//jreffddjBkzBjNnzkRkZCQAYPfu3Vxx2UpEcxwQERHZsTZthTFmzBjk5+dDq9XC09PTdH7+/PlwceH+UtYgst7O8DKZTNqCiIiIulCbWoAqKiqg0+lM4SctLQ3r16/H+fPn4efn16EFUucYEKSBQi5DXokOWcWVUpdDRETUpdoUgKZMmWLaob2oqAjDhw/H2rVrMXXqVGzevLlDC6TO4axUIDxADQBIYTcYERHZmTYFoF9++QWjRo0CAHz00Ufw9/dHWloatm/fjg0bNnRogdR5ojgOiIiI7FSbAlB5eTnUarH1YP/+/Zg2bRrkcjlGjBiBtLS0Di2QOg9XhCYiInvVpgDUq1cvfPbZZ8jIyMC+ffsQHx8PAMjNzb3l9vNkOYwB6ExmMWq4MzwREdmRNgWgFStW4Nlnn0WPHj0wbNgwxMbGAhBbg6Kjozu0QOo8t/m6Qa1yQEW1Hue5MzwREdmRNgWg++67D+np6fj555+xb98+0/lx48Zh3bp1HVYcdS65XIZBIRoAQEoGV4QmIiL70aYABAABAQGIjo5GVlYWMjMzAQDDhg1DeHh4hxVHne/mQOgb0hZCRETUhdoUgAwGA1avXg2NRoPQ0FB0794dHh4eeOWVV2AwcCyJNYkKEddy4kwwIiKyJ21aCXrZsmV477338Ne//hVxcXEQBAFHjhzBypUrUVlZiVdffbWj66ROElnbBXYxV9wZXu3kKHFFREREna9NAej999/Hv/71L9Mu8AAQGRmJbt264cknn2QAsiJ+aid083BGZlEFzlwrxshePlKXRERE1Ona1AVWWFjY6Fif8PBwFBYWtrso6lqmcUDXiiStg4iIqKu0KQBFRkZi48aNDc5v3LgRgwYNandR1LW4ICIREdmbNnWBvfHGG7jrrrtw4MABxMbGQiaT4ejRo8jIyMCePXs6ukbqZFHdPQBwZ3giIrIfbWoB+sMf/oALFy7gnnvuQVFREQoLCzFt2jT89ttv2Lp1a0fXSJ3MuDN8bokO2dwZnoiI7IBMEASho26WkpKCwYMHQ6/Xd9QtJaHVaqHRaFBcXGw3W3vc+eZhnM3WYtOswbhzYKDU5RAREbVaa35/t3khRLItxm6wFK4HREREdoABiADcHAh9igGIiIjsAAMQAQCijTvDX+PO8EREZPtaNQts2rRpzT5fVFTUnlpIQj193eCmckCprgYXrpciIsg+xj4REZF9alUA0mg0t3x+zpw57SqIpKGQyzAoWIOjlwqQnFHEAERERDatVQGIU9xtW1SIB45eKkBKRhEeGN5d6nKIiIg6DccAkYlpRWgOhCYiIhvHAEQmxgB0IbcEpboaaYshIiLqRAxAZOLn7oQgjRMEATjNjVGJiMiGMQCRmbr7ghEREdkqBiAyY+wG44rQRERkyxiAyExUiCcAtgAREZFtYwAiMwO6uUMhl+G6Vofs4gqpyyEiIuoUDEBkxkXpgD7+agBAcnqRtMUQERF1EgYgaoDrARERka1jAKIGohmAiIjIxjEAUQPGqfBnMouhNwjSFkNERNQJGICogdt83eCqVKC8So8L10ukLoeIiKjDMQBRA+LO8B4A2A1GRES2iQGIGmXsBuOCiEREZIsYgKhRnAlGRES2jAGIGmWcCXbhegnKuDM8ERHZGAYgapSfuxMCNU4wCMDpa8VSl0NERNShGICoSewGIyIiW8UARE3izvBERGSrGICoSWwBIiIiW8UARE0aGKyBXAbkaCuRU1wpdTlEREQdhgGImmS2M3zGDYmrISIi6jgMQNSs6NoFEU+xG4yIiGwIAxA1iwOhiYjIFjEAUbOiQjwBAGeucWd4IiKyHQxA1KxefuLO8GVVelzM5c7wRERkGxiAqFkKuQwDgzUAgOT0ImmLISIi6iAMQHRLxm4wrgdERES2ggGIbokLIhIRka1hAKJbMk6F587wRERkKxiA6Jb86+wMfyaTO8MTEZH1kzwAbdq0CWFhYXByckJMTAwOHz7c5LXZ2dl44IEH0LdvX8jlciQkJDR63ccff4yIiAioVCpERETg008/7aTq7UdksAcAdoMREZFtkDQAJSYmIiEhAcuWLcOpU6cwatQoTJo0Cenp6Y1er9Pp4Ovri2XLliEyMrLRa44dO4YZM2Zg9uzZSElJwezZszF9+nT89NNPnflRbF5UbTcYZ4IREZEtkAmCINnqdsOHD8fgwYOxefNm07l+/fph6tSpWLNmTbOvHTNmDKKiorB+/Xqz8zNmzIBWq8XevXtN5yZOnAhPT0/s3Lmz0XvpdDrodDrTY61Wi5CQEBQXF8Pd3b0Nn8z2/Hi5APdv+RGBGiccWzpO6nKIiIga0Gq10Gg0Lfr9LVkLUFVVFU6ePIn4+Hiz8/Hx8Th69Gib73vs2LEG95wwYUKz91yzZg00Go3pCAkJafP726qB3cSd4bOLK3Fdy53hiYjIukkWgPLz86HX6+Hv72923t/fHzk5OW2+b05OTqvvuXTpUhQXF5uOjIyMNr+/rXJV3dwZ/hS7wYiIyMpJPghaJpOZPRYEocG5zr6nSqWCu7u72UENcT0gIiKyFZIFIB8fHygUigYtM7m5uQ1acFojICCgw+9JopsB6Ia0hRAREbWTZAFIqVQiJiYGSUlJZueTkpIwcuTINt83Nja2wT3379/frnuSyDgTjDvDExGRtXOQ8s2XLFmC2bNnY8iQIYiNjcWWLVuQnp6OBQsWABDH5mRmZmL79u2m1yQnJwMASktLkZeXh+TkZCiVSkRERAAAnn76aYwePRqvv/46pkyZgs8//xwHDhzADz/80OWfz9b09lObdob/PbcUfQPUUpdERETUJpIGoBkzZqCgoACrV69GdnY2BgwYgD179iA0NBSAuPBh/TWBoqOjTd+fPHkSO3bsQGhoKK5evQoAGDlyJHbt2oWXXnoJy5cvx2233YbExEQMHz68yz6XrTLuDP/j5UIkZ9xgACIiIqsl6TpAlqo16wjYmzV7U/Hu95cxc1gI1kwbJHU5REREJlaxDhBZp+jagdCcCk9ERNaMAYhaJSrEE4C4M3x5FXeGJyIi68QARK0SoHFCgHvtzvDXuDM8ERFZJwYgajUuiEhERNaOAYhaLZIBiIiIrBwDELWasQXo2OUC/JrJbjAiIrI+DEDUatHdPdDD2wVF5dW4Z9MRvPP9JRi4MjQREVkRBiBqNSdHBT55Mg4T+vujWi/gr3vP4YF//YisogqpSyMiImoRBiBqEy9XJd55MAZ/nTYQzo4K/Hi5EBPXH8KXp7OkLo2IiOiWGICozWQyGe4f1h17nh6FyGANtJU1WLTjFP70vxSUVFZLXR4REVGTGICo3cJ8XPHREyOxaGwvyGXAx79cw50bDuNkWqHUpRERETWKAYg6hKNCjmcn9MWu+bHo5uGMjMIK/N87x7Au6QJq9AapyyMiIjLDAEQdaliYF/YmjMLUqCAYBODNby7i/949hrSCMqlLIyIiMmEAog7n7uSI9fdH4837o6B2csCp9CLc+eZhfPhzBgSB0+WJiEh6DEDUaaZEdcPep0dhWJgXyqr0eO6j01i44xcUlVdJXRoREdk5BiDqVMGeLtj52Ag8N6EvHOQy7DmTg4nrD+Po7/lSl0ZERHaMAYg6nUIuw8KxvfDJkyPR08cVOdpKzHrvJ7y2JxW6Gr3U5RERkR1iAKIuMyjYA18+dTtmDusOQQC2HLqMe94+it9zS6QujYiI7AwDEHUpF6UD1kwbiC2zY+Dp4oiz2VrcteEHfHDsKgdIExFRl2EAIknE9w/AvoTRGN3HF7oaA5Z//hvmvf8z8kp0UpdGRER2gAGIJOPn7oRtc4fi5ckRUDrI8e25XExcfwjfnrsudWlERGTjGIBIUnK5DA/HhWH3ojiEB6hRUFaFR7b9jOWf/YqKKg6QJiKizsEARBYhPMAdny2Mw7zbwwAAH/yYhskbf8CvmcUSV0ZERLaIAYgshpOjAsvvjsD2R4bBT63C77mluGfTEbz7/SUYDBwgTUREHYcBiCzO6D6++DphNOIj/FGtF7Bm7zk8+N5PyC6ukLo0IiKyEQxAZJG8XJV4d3YM/jptIJwdFTh6qQAT1x/GV6ezpS6NiIhsAAMQWSyZTIb7h3XHV0/djkHBGhRXVGPhjl/wp/+loFRXI3V5RERkxRiAyOL19HXDx0+MxKKxvSCXAR//cg13vnkYJ9NuSF0aERFZKQYgsgqOCjmendAXu+bHopuHM9ILyzH93WNYl3QBNXqD1OUREZGVYQAiqzIszAt7E0ZhalQQ9AYBb35zEdPfPYb0gnKpSyMiIivCAERWx93JEevvj8ab90dBrXLAL+lFmPTmIXx08hr3EyMiohZhACKrNSWqG/YmjMKwHl4oq9Lj2Q9TsGjHKRSVV0ldGhERWTgGILJqwZ4u2Dl/BJ6b0BcOchm+OpONiesP4+ilfKlLIyIiC8YARFZPIZdh4dhe+OTJkQjzcUWOthKz/vUT1uxJRVUNB0gTEVFDDEBkMwYFe+Crp27HzGEhEATg3UOXcc+mI/g9t0Tq0oiIyMIwAJFNcVE6YM20QXh3dgw8XRzxW5YWd234AR8cu8oB0kREZMIARDZpQv8A7EsYjVG9faCrMWD5579h3vs/I79UJ3VpRERkARiAyGb5uTvh/YeHYcXdEVA6yPHtuVxMXH8I353Llbo0IiKSGAMQ2TS5XIZHbg/D7kVxCA9QI7+0Cg9vO4EVn/+Kymq91OUREZFEGIDILoQHuOOzhXF4JC4MALD9WBrufusH/JZVLHFlREQkBQYgshtOjgqsmByB7Y8Mg69ahd9zSzH17SNYl3QBmUUVUpdHRERdSCZwakwDWq0WGo0GxcXFcHd3l7oc6gSFZVV44ePT2H/2uunckFBPTI4MwqSBAfBTO0lYHRERtUVrfn8zADWCAcg+CIKA3SlZ2PFTOo5fLYTxvwS5DBjR0xuTI4MwsX8APF2V0hZKREQtwgDUTgxA9ienuBJfncnGl6ezcCq9yHTeQS7DqN4+uHtQEOL7+0Pt5ChdkURE1CwGoHZiALJvGYXl+PJ0Nr5IycLZbK3pvNJBjrF9fTE5Mgh/DPeDi9JBwiqJiKg+BqB2YgAio99zS/Hl6Sx8kZKFS3llpvPOjgqMj/DH5EGB+ENfX6gcFBJWSUREAANQuzEAUX2CIOBcTgm+SMnCF6ezkFF4c9aY2skBE/oH4O5BgYjr5QNHBSdXEhFJgQGonRiAqDmCIOD0tWJ8kZKFL09nI0dbaXrO08URkwYGYvKgIAwL84JCLpOwUiIi+8IA1E4MQNRSBoOAn9Nu4IuULOz9NRv5pVWm5/zUKtw5MBCTI4MwuLsHZDKGISKizsQA1E4MQNQWNXoDfrxcaApD2soa03PdPJxxd6TYMtQ/yJ1hiIioEzAAtRMDELVXVY0Bhy/m4YuULCSdvY6yqpv7joX5uGLyILFlqLe/WsIqiYhsCwNQOzEAUUeqrNbju3O5+OJ0Fr5JzYWuxmB6LjxAjcmRQbh7UCBCvV0lrJKIyPoxALUTAxB1llJdDQ6cvY4vT2fh+wt5qNbf/M9vULAGkwcF4a5BgQjycJawSiIi68QA1E4MQNQVisurse+3HHxxOgtHLxVAb7j5n+LQHp64e1AQ7hwYCF+1SsIqiYisBwNQOzEAUVfLL9Vh7685+CIlCyfq7UsWe5s3Jg8KwsQBAfBw4b5kRERNYQBqJwYgklJ2cQW+Op2NL05nIyWjyHTeuC/Z5Mgg3BHBfcmIiOpjAGonBiCyFOkF5fjyTBa+SMlGar19yf7Y1w93RwZiXLg/nJXcioOIiAGonRiAyBL9nluCL1Ky8cXpLFyusy+Zi1KB8f38MWlAAIaFecHbjWOGiMg+MQC1EwMQWTJBEJCaXYIvajdpvXajwuz5Xn5uGBbmhWE9vDAszIszyojIbjAAtRMDEFkLQRCQUrsv2aELebiYW9rgmm4ezhge5oWhYWIg6unjypWoicgmMQC1EwMQWavCsiqcuFqIE1cKcfxqIX7L0ppNrwcAHzclhoSKYWhYmBf6Bbpz01YisgkMQO3UaQFIEIBvXwH63wMEDOy4+xI1oVRXg1/SbuDE1UIcv1KIUxlFqKqzEjUAqFUOGBzqaQpEg4I1UDlwUDURWR8GoHbqtAD0+wHgP/cCkAED7wPGvgh49ey4+xPdgq5GjzPXivHTlUKcuFqIn6/eQKmuxuwapYMcUSEepjFEg0M94aZykKhiIqKWs6oAtGnTJvztb39DdnY2+vfvj/Xr12PUqFFNXv/9999jyZIl+O233xAUFIQ///nPWLBggen5bdu24eGHH27wuoqKCjg5ObWopk4LQIWXgW9eAX77RHwsdwAGzwFG/xlwD+y49yFqIb1BQGq2FsdrA9GJq4XIL60yu0Yhl6F/kDuG1gaioT284OXKBRmJyPJYTQBKTEzE7NmzsWnTJsTFxeHdd9/Fv/71L5w9exbdu3dvcP2VK1cwYMAAPPbYY3j88cdx5MgRPPnkk9i5cyfuvfdeAGIAevrpp3H+/Hmz1wYEBLS4rk4fA5SdAnyzWmwRAgAHZ2D4fCAuAXDx6vj3I2ohQRBwOb9MHENUO46o/iwzAOjt54ahYV7i4OoenGlGRJbBagLQ8OHDMXjwYGzevNl0rl+/fpg6dSrWrFnT4Prnn38eu3fvRmpqquncggULkJKSgmPHjgEQA1BCQgKKiopaXIdOp4NOpzM91mq1CAkJ6fxB0FePAN+sAjJ+Eh+rNEDcU8CIJwAldwYny5BVVIETVwvFbrMrhY3ONAv2dMawHpxpRkTSak0Akqxjv6qqCidPnsQLL7xgdj4+Ph5Hjx5t9DXHjh1DfHy82bkJEybgvffeQ3V1NRwdxa0BSktLERoaCr1ej6ioKLzyyiuIjo5uspY1a9Zg1apV7fxEbdAjDnhkH3Bhn9gilPubOEj6p3eB0c8BMXMBB3Y1kLSCPJwxJaobpkR1A9D4TLNrNypw7UYmPjmVCUCcaTa0h5ep24wzzYjI0kgWgPLz86HX6+Hv72923t/fHzk5OY2+Jicnp9Hra2pqkJ+fj8DAQISHh2Pbtm0YOHAgtFot3nzzTcTFxSElJQW9e/du9L5Lly7FkiVLTI+NLUBdQiYD+k4EescDv34EfPcqcOMqsPc54NhGcaD0wP8D5JyVQ5bBy1WJCf0DMKG/2K1cd6bZT1cKkZxRhPzSKuz9NQd7fxX/W1arHBDTwxNDe4jdZgM504yIJCb51I76zeSCIDTbdN7Y9XXPjxgxAiNGjDA9HxcXh8GDB+Ott97Chg0bGr2nSqWCSiXx9gFyOTBoOhAxFTi1Hfj+DaAoDfj0ceCH9cC45UDfO8XARGRB3FQOGN3HF6P7+AIQZ5qdvlYsjiG6UoiTaTdQoqvBwfN5OHg+DwCgMs40qx1DxJlmRNTVJPs/jo+PDxQKRYPWntzc3AatPEYBAQGNXu/g4ABvb+9GXyOXyzF06FBcvHixYwrvbA5KYOijQORMsSvsyHogLxXY9QAQPBQY9zIQ1vQsOSKpqRwUpu6vhWMbzjQ7fqUQBWVV+OmK2GIE3JxpNqyHF2JCPdE3QI1Qb1d2mxFRp5EsACmVSsTExCApKQn33HOP6XxSUhKmTJnS6GtiY2PxxRdfmJ3bv38/hgwZYhr/U58gCEhOTsbAgVa28KDSFRi1BBjyMHBkA/DTO8C1E8D7dwO3/REYtwIIanpcE5GlUMhlGNBNgwHdNHjk9jDTTLPjtYOqf7pSiMyiCpy+VozT14rxrx+uABDXI7rN1w19/d3Q21+NPv5q9PF3Q4inC+QMRkTUThYxDf6dd95BbGwstmzZgn/+85/47bffEBoaiqVLlyIzMxPbt28HcHMa/OOPP47HHnsMx44dw4IFC8ymwa9atQojRoxA7969odVqsWHDBnzwwQc4cuQIhg0b1qK6LHIrjJLrwKG/ASe3AobahesipgB/XA74ND62icha1J1pdvpaEX7PLUVltaHRa50c5ejl54Y+fmr0CRBDUW8/Nbp5ODMYEdk5q5gFBgAzZsxAQUEBVq9ejezsbAwYMAB79uxBaGgoACA7Oxvp6emm68PCwrBnzx4888wzePvttxEUFIQNGzaYwg8AFBUVYf78+cjJyYFGo0F0dDQOHTrU4vBjsdT+wF1/B2IXAgfXAKf/B5z9HEj9Eoh6ABjzAqAJlrpKojapP9NMbxBw7UY5LlwvxYXrJbVHKS7licHo10wtfs3Umt3DRalAbz+xtaivvxq9/d3Qx1+NQI0Tp+QTUQOSrwRtiSyyBai+678B3/4FOL9HfKxQAcMeA25fArg2Ph6KyNrV6A1ILxSD0cXrJTh/vQQXr5ficn4pqvWN/69MrXJAL3/zFqM+/mr4qVUMRkQ2xmoWQrRUVhGAjDKOAwdWAWk/iI+VamDkIrGlSKWWtjaiLlKtNyCtoKxBi9HV/DLUGBr/X5y7kwP6+Ktrxxe51bYaqeHjpmQwIrJSDEDtZFUBCBB3mb/0jbiYYnaKeM7FGxj1J2DIPMCxZXugEdmaqhoDruSX4cL1ErMWo6sFZWgiF8HTxdEUivqYBl+ruf8ZkRVgAGonqwtARgYDkPq52DVW8Lt4zj1YHB8UORNQcJ0VIgCorNbjcl4ZLuaKrUXnc0pxMbcE6YXlaOr/iD5uSvT2qx107a9G3wA1+vipoXFpfAYqEXU9BqB2stoAZKSvAZL/C3z/OqAVtyaATx9g7DJx5hib94kaVVGlx6U8sRvN2Fp04XpJoxvCGvmpVbVdaW6mqfq9/dVwd2IwIupqDEDtZPUByKi6EjjxL+DwWqBCXHAOgVHiGkK3/ZFBiKiFynQ1+D3XfHzRxeslyCqubPI1gRonhAeoER7oLn4NcEdPX1c4KuRdWDmRfWEAaiebCUBGlVpxX7FjbwNVtTt59xgFjF8JBA+RtDQia1ZSWY2LubUz0mq70S5cL8F1ra7R6x0VMvTyU9cGIjEc9QtQw5cz0og6BANQO9lcADIqzRNbg35+D9BXief63iXuM+bXT9raiGxIcXk1LuSW4FxOCc5la3EupwTnc0pQqqtp9HpPF0eEB7gjPFCNfrVfe/up4azkhrFErcEA1E42G4CMitKBg68DKTsAwQBABkTeD4xZCniGSl0dkU0yGARkFlWYhaLUHC2u5jc+I00mA8K8XREeKHaf9Q0Qw1GwJ1e8JmoKA1A72XwAMso7L84YS90tPpY7inuPjX4OcPOTtjYiO1FZrcfF66VIzdHiXHYJzl/XIjW7BIVlVY1e76pUoG+AGn0D3NGvTjjSOHPQNREDUDvZTQAyyjwpriF0+aD42NEVGPEEMHIx4OwhZWVEdkkQBOSV6sRAVNtSdC67BL/nlqJK3/geaUEap5sDrmvHFoX5uMKBg67JjjAAtZPdBSCjy98D36wSAxEAOHkAtz8DDJsPKF0kLY2IxBWvr+aXIbXe2KLMosan6SsV4saxYjea2jTOyNeNg67JNjEAtZPdBiBAXFX63Jdi11jeOfGcWwAw5nkgejagYDM7kaUprqjG+ZwSnMvRmsYYnc8pQVmVvtHrvV2V6FsnEPULcEdvfzc4OXLQNVk3BqB2susAZGTQA6cTge/WAMXp4jmvnuJiiv2nAXI2qxNZMoNBwLUbFTdDUW032pWCskZXu5bLgB4+ruIstDrrFwV7OrO1iKwGA1A7MQDVUaMDTm4Dvn8DKM8Xz/kPFBdT7H0HF1MksjIVVXpczC3BuWxxbNH5nBKkZmtxo7y60etdlQr08HFFD29XhHq71B7iYz+1ijPSyKIwALUTA1AjdKXAj5uBoxsAnVY85xEK+IYDPr0B717idhs+vQFXXwYjIisiCALySnRIzSnB+dqWotScEvyeW4JqfdO/Ipwc5Qj1ckV3bxf0qBOMQr1dEOThDAXDEXUxBqB2YgBqRnkh8MM64PgWoKaJbQBUGsCnF+DdWwxEPr3F7716cmd6IitSrTcgraAMV/PLcbWgDOmF5bhaUI60gjJcu1EBfWMLGNVyVMgQ4lm3xUj8GurtgmBPFygd2I1OHY8BqJ0YgFqgvBDIOQMUXATyf6/9egEoygDQ1F8pGeDR/WZLkXevm+FIHcBWIyIrUq03IPNGBdIKy00hKa2gDFcLypBRWNHkdH1AHG/UzdMZPbxd0d3LxdRq1MNHfMzB2NRWDEDtxADUDtUVQOFlIP/izXCUfwEo+P1m11ljlGrzViNTOOoFODp3Xf1E1G56g4AcbSXS8stMLUZpBWIrUlpBOSqqG5+dZhTg7iQGIm9XhPq4mIJSqLcL1E6ciUpNYwBqJwagTiAIQGlubSi6KAai/Avi90VptVtyNEYGaEIa71JzD2KrEZGVMY43aiwYXS0oQ0ll4/ulGfm4KU1daaFerujhc7OLzcNF2UWfgiwVA1A7MQB1sRodUHjlZjeaqUvtIlBZ1PTrHF0B79tqQ1Ef81YjpWuXlU9EHUMQBBSVV5sFovQ6Aamgie1BjDTOjujh7YLudcYciY9duPijnWAAaicGIAshCEB5wc2WorrjjQqvAEIzzeju3W62FNXtUnMP5hpGRFZKW1mN9ILyOq1GN7vYrmt1zb7WyVEON5UDlAo5lA5yqBwUtV/Fxze/V0CpkEPlKBe/1rnG+Bqz1ynkUDk29pqG1zrIZQxhnYwBqJ0YgKxATRVw42qdLrU64ai8oOnXOTjXhqE6XWpufgBkdbrTjN/XPm7192jbaxu8f3Pfo+F5R1fA1YfdgmSXKqr0tbPUbgYjY+tRVlEFmpmw1mVkMohhqG5oqheSGgQzU7C6ed7bTQk/tQp+7k7wU6vgq1ZB5cCB4wADULsxAFm58sI6oajOeKPCK4Ch8cXebIajizjTzrOHuE6TZ6j5Vyf+fSb7o6vRI6e4EhXVeuiqDajSG1BVY4CuRl/7VTyqagymx1U1BlTp619vqHO9vt61N8/VPV/TRcnLw8VRDEVqJ7Nw5Ode95wKLkqHLqlHKgxA7cQAZKP0NeKA67rhyDjOSBBgmr5/q+9N/8nU/x71zrf3fvXvfYv7VVcATS5BUMvZyzwUmYJSD3GwuQMHkRJ1JL1BuBmKmghU9cOYeK0Bump9g2srq/UoKK3C9ZJK5Gp1yCvRNbvkQH1uKofaUGQejPzUTmZf1SqHjuuu05UABZeAwktAweXar5cA377AlI0d8x61WvP727ajIFFdCgdx0LT3bQAmSl1Nx6vRieswFV0FbqSJYe9GmthVWJQGVNwAKgrFI+tUIzeQiTPrGrQe9RC/dwvg+CmiVlLIZXBWKuCsVADo+Cn8giCguKIauSU65Gp1yC2pxPXar7klOuTV+b68So9SXQ1K82pwOa+s2fs6OcqbDkh1znm6OIpBybgESsElsdW9btgpvd74m1Q1X0NnYwtQI9gCRDapUtswFNUNSjUVzb9eoQI8QsxDUd2g5OzJ8UdEFqxUV4Pr2kpTUMor0dUGJ/PQ1NRSBEpUI0SWizBZDnrIchAmy0FPuXj4o5mxlwAEFx/IvG8DvG4DvHuKX336AAEDOvQzsgWIiBpycgcCBopHfYIAlOWJwehGWsNWpOJrgF4n/suu4PfG76/SAJ7dbwYks6DUnQtaEknMTeUAN1833Obr1vRF+hpU5l2BNvMcKq9fgCH/dzgWX4FraRrcdTmQo+nutmLBBVeEAFwRAnHVEIArQgCu1h5lVW7wrlbCr1wFv2In+Oer0LvIFY8EdMIHbSG2ADWCLUBE9ehrAO21xrvWbqQBZbm3voebf9OtR+7dxC5KSyMIgEEvLtQp6Ot9b6h3vvY54zVyhfiZuSYVWRqDXvxHjXEsjml8ziXxv2lDM4tRKt3EfR29b4Peoye0rt2RqwxGpjwImTqXm61KJTqxtalEh4JSXaOz8KK7e+DTJ+M69KOxBYiIOpbCoTa49Gj8+apyoCi9NhBdNQ9KRWniNiil18Xj2vGGr5c7AJpgMQy5+QMQ6oUKQ72AUe98g5AitOB8vcDS4N563HJQeUuo3MXPpA4A1IGA2r/2a+1jt9rHSpf2vxeJP+PKIqAsX1x9vixPPCpuAApHcaako3Pt17rf1/3qLAZXhdJ6u3UFASjJrm21rTcAufCK2KLbFAcnU8gRu6zqfHXzN/2ZKAB41h59mylFbxBQUGoMRmIX3HWtDj5qaSddsAWoEWwBIupAgiD+8mls3NGNq0BxBqBvfoVfiyaT1x4KsdXH+L2hGqgub/l9VJracBRwMyC5BZg/VgfYZ1diTRVQni8GmdK8m6GmLLde0Km9pqOWu5DJzUORKTTVP1cbmOqfu1XYUrqIYaOtIcvYdV23Bafgd3EwcuHl5v/+yR0Br7A6AaenuEaa922AOshqJzywBYiILIdMBrh4iUe3wQ2fNxjEf6kaQ1F5vhggZPI6gcL4fUvOK8T3bPS8XPwfe/3z8trX1A8xDd6nkfPN/fLSlQAlOXWObPFrab3H1eWArlg88i80/+fppDFvOTIGo/rBydGpfT+3ziQI4p+NMciYBZg63xvPN7clTlNUGnFhUFdfwM1XHKRv0It/1tUV4gyk6orao7zO92U3u4AEA1BVKh6dqdnAVO+8whHQZtaGnsvNbzItU4jj74zBpu4AZE2IZXY7dyG2ADWCLUBE1GWMYcAYiEqv3wxGJdlASZ3Ht5qpV5eTR/NdbsbQ5KDqmM+hrxFXYW8swNQ9jC04zXXBNEamqA00fuJXNz8x3JjO+d487+LTvgCor64TiuqEI1Noqv9ceePXV5eL3cONvaa1n7/pPxgxzBiDjfdtYuDxuk0MP3a2thdbgIiIrIVMJs7Qc3IHfPs0fZ0giP/ar9tyVLdlqW5wqqkUW00qi4C81Obf39mz+S43Z0+gouhmsCnNayTU5IrdnK0dM6V0azzA1A82bn5ioOuqbhmFI6DQiK1tnUVfIwbaxsJRVVOBqkxc70sdcDPseIZZdmufBWMAIiKyBjKZ+AvZSSOuoNsU4yDgui1H9bvcjIdeV7tA5g0g92xHFHmz26nJYON38xp7HvitcAAUakCllroSu8UARERkS2QysdXG2RPwC2/6OuPg9Oa63EpzgPIb4r3cfBtvmTEFHj9xnJecm3KSdWAAIiKyR3UHp/v1k7oaoi5nnfPciIiIiNqBAYiIiIjsDgMQERER2R0GICIiIrI7DEBERERkdxiAiIiIyO4wABEREZHdYQAiIiIiu8MARERERHaHAYiIiIjsDgMQERER2R0GICIiIrI7DEBERERkdxiAiIiIyO44SF2AJRIEAQCg1WolroSIiIhayvh72/h7vDkMQI0oKSkBAISEhEhcCREREbVWSUkJNBpNs9fIhJbEJDtjMBiQlZUFtVoNmUzWoffWarUICQlBRkYG3N3dO/Te1Hr8eVgW/jwsC38eloc/k+YJgoCSkhIEBQVBLm9+lA9bgBohl8sRHBzcqe/h7u7Ov7wWhD8Py8Kfh2Xhz8Py8GfStFu1/BhxEDQRERHZHQYgIiIisjsMQF1MpVLh5ZdfhkqlkroUAn8eloY/D8vCn4fl4c+k43AQNBEREdkdtgARERGR3WEAIiIiIrvDAERERER2hwGIiIiI7A4DUBfatGkTwsLC4OTkhJiYGBw+fFjqkuzWmjVrMHToUKjVavj5+WHq1Kk4f/681GURxJ+NTCZDQkKC1KXYtczMTDz44IPw9vaGi4sLoqKicPLkSanLsks1NTV46aWXEBYWBmdnZ/Ts2ROrV6+GwWCQujSrxgDURRITE5GQkIBly5bh1KlTGDVqFCZNmoT09HSpS7NL33//PRYuXIgff/wRSUlJqKmpQXx8PMrKyqQuza6dOHECW7ZswaBBg6Quxa7duHEDcXFxcHR0xN69e3H27FmsXbsWHh4eUpdml15//XW888472LhxI1JTU/HGG2/gb3/7G9566y2pS7NqnAbfRYYPH47Bgwdj8+bNpnP9+vXD1KlTsWbNGgkrIwDIy8uDn58fvv/+e4wePVrqcuxSaWkpBg8ejE2bNuEvf/kLoqKisH79eqnLsksvvPACjhw5wlZqC3H33XfD398f7733nuncvffeCxcXF3zwwQcSVmbd2ALUBaqqqnDy5EnEx8ebnY+Pj8fRo0clqorqKi4uBgB4eXlJXIn9WrhwIe666y6MHz9e6lLs3u7duzFkyBD83//9H/z8/BAdHY1//vOfUpdlt26//XZ88803uHDhAgAgJSUFP/zwA+68806JK7Nu3Ay1C+Tn50Ov18Pf39/svL+/P3JyciSqiowEQcCSJUtw++23Y8CAAVKXY5d27dqFX375BSdOnJC6FAJw+fJlbN68GUuWLMGLL76I48eP46mnnoJKpcKcOXOkLs/uPP/88yguLkZ4eDgUCgX0ej1effVVzJw5U+rSrBoDUBeSyWRmjwVBaHCOut6iRYtw+vRp/PDDD1KXYpcyMjLw9NNPY//+/XBycpK6HAJgMBgwZMgQvPbaawCA6Oho/Pbbb9i8eTMDkAQSExPxn//8Bzt27ED//v2RnJyMhIQEBAUF4aGHHpK6PKvFANQFfHx8oFAoGrT25ObmNmgVoq61ePFi7N69G4cOHUJwcLDU5dilkydPIjc3FzExMaZzer0ehw4dwsaNG6HT6aBQKCSs0P4EBgYiIiLC7Fy/fv3w8ccfS1SRfXvuuefwwgsv4P777wcADBw4EGlpaVizZg0DUDtwDFAXUCqViImJQVJSktn5pKQkjBw5UqKq7JsgCFi0aBE++eQTfPvttwgLC5O6JLs1btw4nDlzBsnJyaZjyJAhmDVrFpKTkxl+JBAXF9dgWYgLFy4gNDRUoorsW3l5OeRy81/XCoWC0+DbiS1AXWTJkiWYPXs2hgwZgtjYWGzZsgXp6elYsGCB1KXZpYULF2LHjh34/PPPoVarTa1zGo0Gzs7OEldnX9RqdYOxV66urvD29uaYLIk888wzGDlyJF577TVMnz4dx48fx5YtW7BlyxapS7NLkydPxquvvoru3bujf//+OHXqFP7xj3/gkUcekbo0q8Zp8F1o06ZNeOONN5CdnY0BAwZg3bp1nHItkabGXm3duhVz587t2mKogTFjxnAavMS+/PJLLF26FBcvXkRYWBiWLFmCxx57TOqy7FJJSQmWL1+OTz/9FLm5uQgKCsLMmTOxYsUKKJVKqcuzWgxAREREZHc4BoiIiIjsDgMQERER2R0GICIiIrI7DEBERERkdxiAiIiIyO4wABEREZHdYQAiIiIiu8MARERERHaHAYiIqAkymQyfffaZ1GUQUSdgACIiizR37lzIZLIGx8SJE6UujYhsADdDJSKLNXHiRGzdutXsnEqlkqgaIrIlbAEiIoulUqkQEBBgdnh6egIQu6c2b96MSZMmwdnZGWFhYfjwww/NXn/mzBn88Y9/hLOzM7y9vTF//nyUlpaaXfPvf/8b/fv3h0qlQmBgIBYtWmT2fH5+Pu655x64uLigd+/e2L17t+m5GzduYNasWfD19YWzszN69+7dILARkWViACIiq7V8+XLce++9SElJwYMPPoiZM2ciNTUVAFBeXo6JEyfC09MTJ06cwIcffogDBw6YBZzNmzdj4cKFmD9/Ps6cOYPdu3ejV69eZu+xatUqTJ8+HadPn8add96JWbNmobCw0PT+Z8+exd69e5GamorNmzfDx8en6/4AiKjtBCIiC/TQQw8JCoVCcHV1NTtWr14tCIIgABAWLFhg9prhw4cLTzzxhCAIgrBlyxbB09NTKC0tNT3/1VdfCXK5XMjJyREEQRCCgoKEZcuWNVkDAOGll14yPS4tLRVkMpmwd+9eQRAEYfLkycLDDz/cMR+YiLoUxwARkcUaO3YsNm/ebHbOy8vL9H1sbKzZc7GxsUhOTgYApKamIjIyEq6urqbn4+LiYDAYcP78echkMmRlZWHcuHHN1jBo0CDT966urlCr1cjNzQUAPPHEE7j33nvxyy+/ID4+HlOnTsXIkSPb9FmJqGsxABGRxXJ1dW3QJXUrMpkMACAIgun7xq5xdnZu0f0cHR0bvNZgMAAAJk2ahLS0NHz11Vc4cOAAxo0bh4ULF+Lvf/97q2omoq7HMUBEZLV+/PHHBo/Dw8MBABEREUhOTkZZWZnp+SNHjkAul6NPnz5Qq9Xo0aMHvvnmm3bV4Ovri7lz5+I///kP1q9fjy1btrTrfkTUNdgCREQWS6fTIScnx+ycg4ODaaDxhx9+iCFDhuD222/Hf//7Xxw/fhzvvfceAGDWrFl4+eWX8dBDD2HlypXIy8vD4sWLMXv2bPj7+wMAVq5ciQULFsDPzw+TJk1CSUkJjhw5gsWLF7eovhUrViAmJgb9+/eHTqfDl19+iX79+nXgnwARdRYGICKyWF9//TUCAwPNzvXt2xfnzp0DIM7Q2rVrF5588kkEBATgv//9LyIiIgAALi4u2LdvH55++mkMHToULi4uuPfee/GPf/zDdK+HHnoIlZWVWLduHZ599ln4+Pjgvvvua3F9SqUSS5cuxdWrV+Hs7IxRo0Zh165dHfDJiaizyQRBEKQugoiotWQyGT799FNMnTpV6lKIyApxDBARERHZHQYgIiIisjscA0REVom990TUHmwBIiIiIrvDAERERER2hwGIiIiI7A4DEBEREdkdBiAiIiKyOwxAREREZHcYgIiIiMjuMAARERGR3fn/04WzTps9LS4AAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot Accuracy\n", + "plt.plot(train_accuracies, label='Train Accuracy')\n", + "plt.plot(val_accuracies, label='Validation Accuracy')\n", + "plt.xlabel('Epochs')\n", + "plt.ylabel('Accuracy')\n", + "plt.legend()\n", + "plt.show()\n", + "\n", + "# Plot Loss\n", + "plt.plot(train_losses, label='Train Loss')\n", + "plt.plot(val_losses, label='Validation Loss')\n", + "plt.xlabel('Epochs')\n", + "plt.ylabel('Loss')\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "68629592-505c-426a-adba-8ef5db629cb6", + "metadata": {}, + "source": [ + "### **Step 7: Make Predictions**" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "03831a52-a724-4646-b80d-e40948ead455", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Get a batch of test images\n", + "images, labels = next(iter(test_loader))\n", + "images, labels = images.to(device), labels.to(device)\n", + "\n", + "# Make predictions\n", + "model.eval()\n", + "with torch.no_grad():\n", + " outputs = model(images)\n", + " _, predicted = torch.max(outputs, 1)\n", + "\n", + "# Display an example image and prediction\n", + "plt.imshow(images[0].cpu().squeeze(), cmap='gray')\n", + "plt.title(f\"Predicted: {predicted[0].item()}, Actual: {labels[0].item()}\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "30518560-e8f2-403e-8987-ad578c5aa724", + "metadata": {}, + "source": [ + "### **Next Steps for More Complexity**\n", + "- Increase CNN Depth - Add more convolutional layers.\n", + "- Use Data Augmentation - Improve generalization with `torchvision.transforms.RandomRotation` and `RandomHorizontalFlip`.\n", + "- Apply Transfer Learning - Use a pre-trained model like ResNet or VGG16.\n", + "- Train on Custom Datasets - Try it with a dataset like CIFAR-10 or Fashion-MNIST." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3e334386-d730-449e-9fc3-dace4f9150f7", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "ad4b514a-e3c0-457f-90c6-7c3bf5bf5ae9", + "metadata": { + "tags": [] + }, + "source": [ + "## **Advanced TensorFlow Tutorial: CNN for Fashion Image Classification**\n", + "\n", + "Note that the MNIST handwritten digits problem is a relatively simple and widely studied problem. Even with a simle model we can get a better model performance. Now, let’s make this tutorial more complex by incorporating TensorBoard for visualization and data augmentation for better generalization. We will build a Convolutional Neural Network (CNN) to classify images from the Fashion-MNIST dataset, which is more challenging than MNIST.\n", + "\n", + "**Objective: Train a deep CNN on the Fashion-MNIST dataset, use TensorBoard for visualization, and apply data augmentation to improve generalization.**\n", + "\n", + "### **The Fashion-MNIST Problem: Clothing Item Classification** \n", + "\n", + "#### **Overview** \n", + "**Fashion-MNIST** is a machine learning dataset designed as a more challenging replacement for the original **MNIST handwritten digit dataset**. The goal is to classify images of **clothing items** into one of **10 categories** using machine learning or deep learning models.\n", + "\n", + "#### **Why Fashion-MNIST?** \n", + "- **More challenging** than MNIST because clothing items have more complex patterns. \n", + "- **Same format as MNIST**, making it easy to experiment with advanced models like CNNs. \n", + "- **Real-world relevance** in applications like **retail, e-commerce, and fashion industry AI**.\n", + "\n", + "---\n", + "\n", + "### **Problem Definition**\n", + "The task is to build a **supervised classification model** that can recognize different types of clothing items from grayscale images.\n", + "\n", + "1. **Input:** A **28×28 grayscale image** of a clothing item. \n", + "2. **Output:** A **single label (0-9)** corresponding to the clothing category. \n", + "3. **Model Type:** **Supervised classification problem**.\n", + "\n", + "---\n", + "\n", + "### **Dataset Breakdown**\n", + "- **Training Set:** 60,000 images. \n", + "- **Test Set:** 10,000 images. \n", + "- **Classes (10 Categories):** \n", + " | Label | Class Name | Example |\n", + " |--------|------------|---------|\n", + " | 0 | T-shirt/top | 👕 |\n", + " | 1 | Trouser | 👖 |\n", + " | 2 | Pullover | 🧥 |\n", + " | 3 | Dress | 👗 |\n", + " | 4 | Coat | 🧥 |\n", + " | 5 | Sandal | 🩴 |\n", + " | 6 | Shirt | 👚 |\n", + " | 7 | Sneaker | 👟 |\n", + " | 8 | Bag | 👜 |\n", + " | 9 | Ankle boot | 👢 |\n", + "\n", + "---\n", + "\n", + "### **Challenges of the Fashion-MNIST Problem**\n", + "1. **More Visual Complexity** – Unlike MNIST, fashion images have textures and patterns. \n", + "2. **Class Similarity** – Some items (e.g., shirts and coats) look similar, making classification harder. \n", + "3. **Generalization** – The model must recognize items despite variations in style and texture.\n", + "\n", + "---\n", + "\n", + "### **Approaches to Solve Fashion-MNIST**\n", + "| Approach | Method |\n", + "|----------|--------|\n", + "| **Basic Approach** | Logistic Regression, k-Nearest Neighbors (KNN) |\n", + "| **Deep Learning Approach** | Fully Connected Neural Networks (FCNN) |\n", + "| **Advanced Approach** | Convolutional Neural Networks (CNNs) |\n", + "| **State-of-the-Art** | Transfer Learning (using ResNet, EfficientNet, etc.) |\n", + "\n", + "---\n", + "\n", + "### **Applications of Fashion-MNIST Classification**\n", + "- **E-commerce AI** – Automatically tag and sort clothing items. \n", + "- **Retail Analytics** – Identify fashion trends using image recognition. \n", + "- **Virtual Try-On Systems** – Power fashion recommendation systems. \n", + "\n", + "\n", + "### **Here we put all the code together.**" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "8ce65a01-6534-49ba-8342-3597eb7b85ba", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch [1/10], Loss: 0.6872, Accuracy: 0.7507\n", + "Epoch [2/10], Loss: 0.5213, Accuracy: 0.8094\n", + "Epoch [3/10], Loss: 0.4757, Accuracy: 0.8270\n", + "Epoch [4/10], Loss: 0.4407, Accuracy: 0.8368\n", + "Epoch [5/10], Loss: 0.4151, Accuracy: 0.8486\n", + "Epoch [6/10], Loss: 0.4024, Accuracy: 0.8554\n", + "Epoch [7/10], Loss: 0.3814, Accuracy: 0.8608\n", + "Epoch [8/10], Loss: 0.3742, Accuracy: 0.8668\n", + "Epoch [9/10], Loss: 0.3646, Accuracy: 0.8688\n", + "Epoch [10/10], Loss: 0.3574, Accuracy: 0.8722\n", + "Test Accuracy: 0.2931\n", + "code complete\n" + ] + } + ], + "source": [ + "import torch\n", + "import datetime\n", + "import numpy as np\n", + "import torchvision\n", + "import torch.nn as nn\n", + "import torch.optim as optim\n", + "import matplotlib.pyplot as plt\n", + "import torchvision.transforms as transforms\n", + "from torch.utils.tensorboard import SummaryWriter\n", + "\n", + "# import torch\n", + "# import torchvision\n", + "# import torch.nn as nn\n", + "# import torch.optim as optim\n", + "# import matplotlib.pyplot as plt\n", + "# import torchvision.transforms as transforms\n", + "\n", + "# Set device\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", + "\n", + "# Data augmentation and normalization\n", + "transform = transforms.Compose([\n", + " transforms.RandomHorizontalFlip(),\n", + " transforms.RandomRotation(10),\n", + " transforms.RandomResizedCrop(28, scale=(0.9, 1.0)),\n", + " transforms.ToTensor(),\n", + " transforms.Normalize((0.5,), (0.5,))\n", + "])\n", + "\n", + "# Load dataset\n", + "train_dataset = torchvision.datasets.FashionMNIST(root='/bsuhome/tnde/scratch/ml_tutorials/data', train=True, transform=transform, download=True)\n", + "test_dataset = torchvision.datasets.FashionMNIST(root='/bsuhome/tnde/scratch/ml_tutorials/data', train=False, transform=transforms.ToTensor(), download=True)\n", + "\n", + "train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=64, shuffle=True)\n", + "test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=64, shuffle=False)\n", + "\n", + "# Define CNN model\n", + "class CNN(nn.Module):\n", + " def __init__(self):\n", + " super(CNN, self).__init__()\n", + " self.conv1 = nn.Conv2d(1, 32, kernel_size=3, padding=1)\n", + " self.bn1 = nn.BatchNorm2d(32)\n", + " self.pool = nn.MaxPool2d(2, 2)\n", + " \n", + " self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)\n", + " self.bn2 = nn.BatchNorm2d(64)\n", + " \n", + " self.fc1 = nn.Linear(64 * 7 * 7, 128)\n", + " self.dropout = nn.Dropout(0.5)\n", + " self.fc2 = nn.Linear(128, 10)\n", + "\n", + " def forward(self, x):\n", + " x = self.pool(torch.relu(self.bn1(self.conv1(x))))\n", + " x = self.pool(torch.relu(self.bn2(self.conv2(x))))\n", + " x = x.view(-1, 64 * 7 * 7)\n", + " x = torch.relu(self.fc1(x))\n", + " x = self.dropout(x)\n", + " x = self.fc2(x)\n", + " return x\n", + "\n", + "# Initialize model, loss, and optimizer\n", + "model = CNN().to(device)\n", + "criterion = nn.CrossEntropyLoss()\n", + "optimizer = optim.Adam(model.parameters(), lr=0.001)\n", + "\n", + "# Set up TensorBoard\n", + "log_dir = \"logs/\" + datetime.datetime.now().strftime(\"%Y%m%d-%H%M%S\")\n", + "writer = SummaryWriter(log_dir=log_dir)\n", + "\n", + "# Training loop\n", + "num_epochs = 10\n", + "for epoch in range(num_epochs):\n", + " model.train()\n", + " running_loss = 0.0\n", + " correct, total = 0, 0\n", + " \n", + " for images, labels in train_loader:\n", + " images, labels = images.to(device), labels.to(device)\n", + " \n", + " optimizer.zero_grad()\n", + " outputs = model(images)\n", + " loss = criterion(outputs, labels)\n", + " loss.backward()\n", + " optimizer.step()\n", + " \n", + " running_loss += loss.item()\n", + " _, predicted = torch.max(outputs, 1)\n", + " total += labels.size(0)\n", + " correct += (predicted == labels).sum().item()\n", + " \n", + " train_accuracy = correct / total\n", + " train_loss = running_loss / len(train_loader)\n", + " \n", + " # Log metrics\n", + " writer.add_scalar('Loss/train', train_loss, epoch)\n", + " writer.add_scalar('Accuracy/train', train_accuracy, epoch)\n", + " \n", + " print(f\"Epoch [{epoch+1}/{num_epochs}], Loss: {train_loss:.4f}, Accuracy: {train_accuracy:.4f}\")\n", + "\n", + "# Evaluate model\n", + "model.eval()\n", + "correct, total = 0, 0\n", + "with torch.no_grad():\n", + " for images, labels in test_loader:\n", + " images, labels = images.to(device), labels.to(device)\n", + " outputs = model(images)\n", + " _, predicted = torch.max(outputs, 1)\n", + " total += labels.size(0)\n", + " correct += (predicted == labels).sum().item()\n", + "\n", + "test_accuracy = correct / total\n", + "print(f\"Test Accuracy: {test_accuracy:.4f}\")\n", + "writer.add_scalar('Accuracy/test', test_accuracy)\n", + "writer.close()\n", + "\n", + "print(\"code complete\")\n", + "# Launch TensorBoard with: tensorboard --logdir=logs/" + ] + }, + { + "cell_type": "markdown", + "id": "6bd7bbcc-9514-4f45-bfff-c1be238ffdf1", + "metadata": {}, + "source": [ + "### Note:\n", + "The test accuracy is very low, but this tutorial focuses more on the workflow rather than the model's performance. Our model is most likely overfitting. For improved model performance, one may tune the parameters or make the model complex. For parameter tuning, one way is to use grid search to find the opotimal parameters within a given parameter space." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "7d9df74a-23cb-44d5-8495-3163c9712640", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "WARNING:tensorflow:From /bsuhome/tnde/miniconda3/envs/ml_tutorial/lib/python3.9/site-packages/tensorflow/python/summary/summary_iterator.py:31: tf_record_iterator (from tensorflow.python.lib.io.tf_record) is deprecated and will be removed in a future version.\n", + "Instructions for updating:\n", + "Use eager execution and: \n", + "`tf.data.TFRecordDataset(path)`\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAGwCAYAAABB4NqyAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAABPs0lEQVR4nO3deVxU5f4H8M/MAMMim6yDIOKSgogpJFcUMxfc0igt9RqmaWWZSppXyaU0k7QyS6/ci6HeSpPUFn+JJmqZ5o6iJLgvLA4gKLswMHN+fxBTE2iAwJnl83695pWcOXPme4SYj89znvOVCIIggIiIiMiESMUugIiIiKilMQARERGRyWEAIiIiIpPDAEREREQmhwGIiIiITA4DEBEREZkcBiAiIiIyOWZiF6CPNBoNbt26BVtbW0gkErHLISIionoQBAHFxcXw8PCAVPrgMR4GoDrcunULXl5eYpdBREREjZCRkQFPT88H7sMAVAdbW1sA1X+BdnZ2IldDRERE9VFUVAQvLy/t5/iDMADVoWbay87OjgGIiIjIwNTn8hVeBE1EREQmhwGIiIiITA4DEBEREZkcXgP0ENRqNSorK8Uug4yEubk5ZDKZ2GUQEZkEBqBGEAQB2dnZKCgoELsUMjIODg5wd3fn/aeIiJoZA1Aj1IQfV1dXWFtb88OKHpogCCgrK0Nubi4AQKFQiFwREZFxYwBqILVarQ0/Tk5OYpdDRsTKygoAkJubC1dXV06HERE1I14E3UA11/xYW1uLXAkZo5qfK15bRkTUvBiAGonTXtQc+HNFRNQyGICIiIjI5DAAERERkclhAKKH0r9/f0RGRopdBhERUYMwAJkIiUTywMekSZMaddxvvvkG7777bpPUeOTIEchkMgwdOrRJjkdERPpHEATkFpXjel6pqHVwGbyJUCqV2j/Hx8dj8eLFuHjxonZbzRLsGpWVlTA3N//b47Zu3brJatywYQNmzJiBzz77DOnp6Wjbtm2THbuh6nv+RER0f5VqDa7eLkGasghpymKk3ipCmrII+aUq9O/sgk2Te4lWG0eAmoAgCChTVYnyEAShXjW6u7trH/b29pBIJNqvy8vL4eDggK+//hr9+/eHpaUlvvzyS+Tn52P8+PHw9PSEtbU1unXrhq+++krnuH+dAmvXrh2WL1+OF198Eba2tmjbti1iY2P/tr7S0lJ8/fXXePXVV/Hkk09i06ZNtfbZuXMngoKCYGlpCWdnZzzzzDPa5yoqKvCvf/0LXl5ekMvl6NSpE+Li4gAAmzZtgoODg86xvvvuO50VV++88w4effRRbNiwAe3bt4dcLocgCNizZw/69u0LBwcHODk54cknn8TVq1d1jpWZmYlx48ahdevWsLGxQVBQEI4fP44bN25AKpXi1KlTOvuvWbMG3t7e9f7eEREZgrulKhy5kofPDl3DnK/PYvgnh9B18Y8YuvoQ3og/i9hfruHwlTzkl6oglQDllWpR6+UIUBO4V6mG3+IfRXnv1KVDYG3RNN/GefPm4aOPPsLGjRshl8tRXl6OwMBAzJs3D3Z2dti1axciIiLQvn17BAcH3/c4H330Ed5991289dZb2L59O1599VX069cPXbp0ue9r4uPj0blzZ3Tu3BnPP/88ZsyYgUWLFmlDyq5du/DMM89gwYIF+OKLL6BSqbBr1y7t6ydOnIijR4/i008/Rffu3XH9+nXk5eU16PyvXLmCr7/+Gjt27NDehLC0tBSzZ89Gt27dUFpaisWLF+Ppp59GcnIypFIpSkpK8Pjjj6NNmzbYuXMn3N3dcfr0aWg0GrRr1w6DBg3Cxo0bERQUpH2fjRs3YtKkSVzyTkQGSa0RcCO/9PdRneqRnTRlEZSF5XXubys3g6/CDr4K29//a4dH3GxhZSHuzV4ZgEgrMjJSZ1QFAN58803tn2fMmIE9e/Zg27ZtDwxAw4cPx2uvvQagOlR9/PHH+Pnnnx8YgOLi4vD8888DAIYOHYqSkhLs378fgwYNAgC89957GDduHJYsWaJ9Tffu3QEAly5dwtdff43ExETt/u3bt2/IqQMAVCoVvvjiC7i4uGi3jR49uladrq6uSE1Nhb+/P7Zs2YLbt2/j5MmT2unAjh07avefOnUqpk2bhlWrVkEul+Ps2bNITk7GN9980+D6iIhaWklFFS78HnRSlUVIVRbjUnYx7t1n9KZta2udoOOnsIOno5Ve/oOPAagJWJnLkLp0iGjv3VT+PEoBVLf9eP/99xEfH4+srCxUVFSgoqICNjY2DzxOQECA9s81U201Pa7qcvHiRZw4cUIbCszMzDB27Fhs2LBBG2iSk5Px0ksv1fn65ORkyGQyPP744/U6z/vx9vbWCT8AcPXqVSxatAjHjh1DXl4eNBoNACA9PR3+/v5ITk5Gjx497nstVHh4OF5//XV8++23GDduHDZs2IAnnngC7dq1e6haiYiakiAIyLx7D6naUZ3qkZ30O2V17m9pLkVndzv4/R52/BR26OxuC1tLw7l2kgGoCUgkkiabhhLTX4PNRx99hI8//hirV69Gt27dYGNjg8jISKhUqgce568XD0skEm1wqEtcXByqqqrQpk0b7TZBEGBubo67d+/C0dGx1kXaf/ag5wBAKpXWut6mrlYTdQW7kSNHwsvLC+vXr4eHhwc0Gg38/f21fwd/994WFhaIiIjAxo0b8cwzz2DLli1YvXr1A19DRNScyivVuJhdrDuFlV2E4vKqOvd3t7OEn4fuFFY7JxvIpPo3qtMQhv+pTc3m0KFDeOqpp7RTUxqNBpcvX4avr2+TvUdVVRU+//xzfPTRRwgLC9N5bvTo0di8eTNef/11BAQEYP/+/Zg8eXKtY3Tr1g0ajQYHDx7Ujhj9mYuLC4qLi1FaWqoNOcnJyX9bW35+PtLS0vDf//4XoaGhAIDDhw/r7BMQEIDPPvsMd+7cue8o0NSpU+Hv749169ahsrKy1jQjEVFzEAQBucUV1VNXt/4Y2bmeVwpNHWswzGUSdHK11V6v4/d72HG0sWj54lsAAxDdV8eOHbFjxw4cOXIEjo6OWLVqFbKzs5s0AP3www+4e/cupkyZAnt7e53nxowZg7i4OLz++ut4++23MXDgQHTo0AHjxo1DVVUVdu/ejX/9619o164dXnjhBbz44ovai6Bv3ryJ3NxcPPfccwgODoa1tTXeeustzJgxAydOnKhzldlfOTo6wsnJCbGxsVAoFEhPT8f8+fN19hk/fjyWL1+O8PBwREdHQ6FQ4MyZM/Dw8EDv3r0BAL6+vvjHP/6BefPm4cUXX/zbUSMiooZSVWlwJbfkj1Gd7OqRnTuldY/YO9lY6FyY7Odhhw4urWAuM53F4QxAdF+LFi3C9evXMWTIEFhbW+Pll19GeHg4CgsLm+w94uLiMGjQoFrhB6geAVq+fDlOnz6N/v37Y9u2bXj33Xfx/vvvw87ODv369dPuGxMTg7feeguvvfYa8vPz0bZtW7z11lsAqu9V9OWXX2Lu3LmIjY3FoEGD8M477+Dll19+YG1SqRRbt27FzJkz4e/vj86dO+PTTz9F//79tftYWFhg7969mDNnDoYPH46qqir4+fnh3//+t86xpkyZgiNHjuDFF198iL8tIiLgTqlKG3RqRneu3i5Bpbr2sI5UAnRwaaWduqoZ2XGxlevlhcktSSLwZiS1FBUVwd7eHoWFhbCzs9N5rry8HNevX4ePjw8sLS1FqpAMzXvvvYetW7ciJSXlgfvx54vItFWqNcgtroCy4B6UheXILiyHsrAcysLqr7MK7uF2cUWdr7W1NNNekFwzsvOImy0sm3CxjL570Of3X3EEiKgZlZSUIC0tDWvWrGmyliFEZJhUVRrkFJUju6gctwruacNN9p8Czu2SCtRnWMLbyRq+7n8a1fGwQxsH/Vxurq8YgIia0euvv46vvvoK4eHhnP4iMmIVVWrkFFZAWXgP2UW/j9rUjOL8/nVePcONuUwCd3tLKOysqv/rYAmFnSXc7a2gsLdEB9dWaCXnx/fD4t8gUTPatGlTvS64JiL9VV6pRk5ROW4VlCO76I+pqZqvswvLkVfy4NuD1LCQSatDze8Pd3sreDhYwt3OEgr76sDjZGMBqYEvMTcEDECNxEunqDnw54qoZd1TqX8fobmnc73NHwGn/L4rqf5Kbib9PdRYwuP3MFMTcmoCT2sbC05T6QkGoAaquclfWVkZlzNTkysrq77rKjvREzWd3OJy/HolD1l37+HWny4szi68h7tltW+KWhdLc6k21NQOONVfO1ibM9wYEAagBpLJZHBwcNC2drC2tuYPPD00QRBQVlaG3NxcODg4aJuxElHj5BaXY89v2dh1TokTN+488NobK3MZFA51h5qar+2tGG6MDQNQI7i7uwPAA/tbETWGg4OD9ueLiBomt6gcu3/Lxq4UJU7+JfQEeNqjs5stFA5WtQKOnaUZw40JYgBqBIlEAoVCAVdX1zp7ShE1hrm5OUd+iBoop6gcu1OUSEjJxsmbuqHnUS8HjOimwLBu7vB0tBavSNJLDEAPQSaT8QOLiKiFZReWY/dvSiSkKHHq5l2d0NOjbU3oUaCNA6/TpPtjACIiIr2XXViOhJQ/Qs+f9WzrgOHdFBjeTQEPhh6qJwYgIiLSS8rCe0hIyUZCihJJfwk9gd6OGN5NgWH+7gw91CgMQEREpDduFdzTjvScTi/QeS6oJvR0c4fCnqGHHg4DEBERiSqr4B52pyixK0WJM38KPRLJn0KPvwLu9mwQTE2HAYiIiFpc5t0y7E6pXrKenFGg3S6RAI95t8bwbu4Y1k0BNzuGHmoeDEBERNQiMu+WISFFiV0p2Tj719DTrjVGdFNgqL87Qw+1CAYgIiJqNhl3yrTX9JzNLNRu/3PoGebvDleGHmphDEBERNSkMu6UYdfvoefcX0JPr3atMSJAgaFdGXpIXAxARET00O4XeqQSoJdP9UjPEH93uNoy9JB+YAAiIqJGSc//I/SkZOmGnmAfJwz/faTHxVYuYpVEdWMAIiKieruZX6oNPb9lFWm3SyXAP9o7YXg3BYYw9JABYAAiIqIHupH3R+g5f0s39PTu8EfocW7F0EOGQyp2AevWrYOPjw8sLS0RGBiIQ4cOPXD/zZs3o3v37rC2toZCocDkyZORn5+vs09BQQGmT58OhUIBS0tL+Pr6IiEhoTlPg4jIaAiCgN+yCrF63yUM/+QQ+n/4Mz748SLO3yqCTCpB347OWP50N5xcMAibp/4DE4K9GX7I4Ig6AhQfH4/IyEisW7cOffr0wX//+18MGzYMqampaNu2ba39Dx8+jIkTJ+Ljjz/GyJEjkZWVhWnTpmHq1Kn49ttvAQAqlQqDBw+Gq6srtm/fDk9PT2RkZMDW1ralT4+IyGCUV6px9Go+9qXl4MCFXCgLy7XPyaQShPw+0hPm5wYnhh0yAhJBEASx3jw4OBg9e/ZETEyMdpuvry/Cw8MRHR1da/8PP/wQMTExuHr1qnbbmjVrsHLlSmRkZAAA/vOf/+CDDz7AhQsXYG5u3qi6ioqKYG9vj8LCQtjZ2TXqGERE+u52cQV+upCLfWk5OHwlD2UqtfY5K3MZ+nZyxiBfVwz2c0drGwsRKyWqn4Z8fos2AqRSqZCUlIT58+frbA8LC8ORI0fqfE1ISAgWLFiAhIQEDBs2DLm5udi+fTtGjBih3Wfnzp3o3bs3pk+fju+//x4uLi745z//iXnz5kEmk9V53IqKClRUVGi/LioqqnM/IiJDJggCLuYUY39adehJzijAn/8J7G5niYG+rhjk64beHZxgaV7370wiYyBaAMrLy4NarYabm5vOdjc3N2RnZ9f5mpCQEGzevBljx45FeXk5qqqqMGrUKKxZs0a7z7Vr13DgwAFMmDABCQkJuHz5MqZPn46qqiosXry4zuNGR0djyZIlTXdyRER6QlWlwfHr+drQk3n3ns7z/m3sMMjXDYN83dDVww4SiUSkSolaluirwP76P5sgCPf9HzA1NRUzZ87E4sWLMWTIECiVSsydOxfTpk1DXFwcAECj0cDV1RWxsbGQyWQIDAzErVu38MEHH9w3AEVFRWH27Nnar4uKiuDl5dVEZ0hE1LLulqrw08Vc7E/LxcFLt1FSUaV9zsJMir4dnTHQ1xUDu7ixwzqZLNECkLOzM2QyWa3Rntzc3FqjQjWio6PRp08fzJ07FwAQEBAAGxsbhIaGYtmyZVAoFFAoFDA3N9eZ7vL19UV2djZUKhUsLGrPY8vlcsjlvKiPiAyTIAi4ersU+9NysD8tF6du3oHmT1Nbzq3kGNjFFQN9XdG3kzOsLUT/ty+R6ET7v8DCwgKBgYFITEzE008/rd2emJiIp556qs7XlJWVwcxMt+SaoFNzLXefPn2wZcsWaDQaSKXVq/wvXboEhUJRZ/ghIjJEVWoNTt64i/1pOdiXloMb+WU6z3dxt8UgXzcM9HVFd08HSKWc2iL6M1H/GTB79mxEREQgKCgIvXv3RmxsLNLT0zFt2jQA1VNTWVlZ+PzzzwEAI0eOxEsvvYSYmBjtFFhkZCR69eoFDw8PAMCrr76KNWvWYNasWZgxYwYuX76M5cuXY+bMmaKdJxFRUyi8V4mDl25jf1oOfrqQi6LyP6a2zGUS/KO9kzb0eDpai1gpkf4TNQCNHTsW+fn5WLp0KZRKJfz9/ZGQkABvb28AgFKpRHp6unb/SZMmobi4GGvXrsWcOXPg4OCAAQMGYMWKFdp9vLy8sHfvXrzxxhsICAhAmzZtMGvWLMybN6/Fz4+I6GHdzC/FvrRc7EvNwckbd1D1p7ktR2tzPNGletVWaCdn2Fo27tYfRKZI1PsA6SveB4iIxKLWCDiTfrc69KTl4Epuic7zHV1baZeq92zrCBmntoi0DOI+QEREVK2kogqHLt1GYloOfr54G3dKVdrnZFIJerVrrQ097ZxtRKyUyHgwABERiSCr4B72p+UgMTUHx6/dgUqt0T5nZ2mG/p1dMcjPDY8/4gJ7K05tETU1BiAiohag0Qg4l1WIfanVq7YuZBfrPN/Oyfr3C5jdENTOEeYy0XtVExk1BiAiomZyT6XG4St52JeagwMXc3G7+I+WO1IJEOjtqA09HVxseBdmohbEAERE1ITKVFXYnZKNXSlK/HolDxVVf0xttZKb4fFHXDDQ1xX9O7uywSiRiBiAiIgekkYj4Pj1O9ielIndvyl1uqq3cbDCYL/qe/ME+zjBwoxTW0T6gAGIiKiRbuSV4pvTmdhxOgtZBX80GfV2ssYzPTwxxN8Nnd1sObVFpIcYgIiIGqCovBK7zimxIykTp27e1W63lZthRIACYwI9EejtyNBDpOcYgIiI/oZaI+DwlTzsSMrEj+eztdf1SCVA304uGN2zDYZ0dYeluexvjkRE+oIBiIjoPi7nFGP76Ux8dyYLOUV/rODq6NoKYwI9Ef5oG7jbW4pYIRE1FgMQEdGf3C1V4f/O3cKOpEyczSzUbnewNseo7h4Y3dMTAZ72nOIiMnAMQERk8irVGvx88TZ2JGVi/4UcVKqrWySaSSXo39kVYwLb4IkurpCbcYqLyFgwABGRyTp/qxA7krLwfXIW8v/Uf8tPYYfRgZ546lEPOLeSi1ghETUXBiAiMim3iyvwfXIWtidl6rSjcG5lgfBH22B0oCd8FQ/uIk1Eho8BiIiMXnmlGvvTcrHjdCYOXroNtaZ6istCJsUgP1eM7umJfo+4sP8WkQlhACIioyQIApIzCrDjdCb+76wShfcqtc896uWA0YGeGBmggIM121EQmSIGICIyKsrCe/jmdBa+OZ2Jq7dLtdvd7SzxdM82GN3TEx1dW4lYIRHpAwYgIjJ491Rq/Hg+GztOZ+LwlTwI1TNcsDSXYmhXd4wO9ERIB2fIpFy6TkTVGICIyCAJgoAT1+9gx+lMJKRko6SiSvtcr3atMSbQE8O6ucPW0lzEKolIXzEAEZFBybhThh2nM/HN6Syk3ynTbvdqbYVnenhidE9PtHWyFrFCIjIEDEBEpPdKKqqQcE6J7aczceL6He12GwsZhnerbkD6WLvWkHKKi4jqiQGIiPSSWiPg6NV87DidiT2/ZeNepRoAIJEAfTo4Y3RgdQNSawv+GiOihuNvDiLSK1dvl2BHUia+PZMFZWG5dnt7ZxuMDvTE0z3awMPBSsQKicgYMAARkV64VXAPi7//DfvScrXb7CzNMLK7B0YHeqKHlwMbkBJRk2EAIiJRaTQCvjqZjuiECyipqIJMKkG/Ts4YE+iFgb6usDRnA1IianoMQEQkmpv5pZi34xyOXau+sLlHWwesHB2ATm62IldGRMaOAYiIWpxaI2Djr9fx4d6LKK/UwMpchjeHdMakkHa8WSERtQgGICJqUZdyivGv7eeQnFEAAAjp4IT3nwngvXuIqEUxABFRi6hUaxDz81WsOXAZlWoBtnIzvDXCF+Me8+LFzUTU4hiAiKjZpWQWYu72s7iQXQwAGNjFFcue9ofCnsvZiUgcDEBE1GzKK9VYve8y1h+6BrVGgKO1Od4Z1RWjuntw1IeIRMUARETN4uSNO5i3/Ryu5ZUCAJ4MUOCdUV3h3EoucmVERAxARNTESiuqsHLPBXx+7CYEAXC1lWNZuD/CurqLXRoRkRYDEBE1mUOXb2P+jhRkFdwDADwX5IkFw/1gb20ucmVERLoYgIjooRWWVWLZrlRsS8oEALRxsML7o7shtJOLyJUREdWNAYiIHsqP57Ox6LvfkFtcAYkEeKF3O8wd0hk2cv56ISL9xd9QRNQoeSUVeHvneew6pwQAtHexwYrRAXisXWuRKyMi+nsMQETUIIIgYOfZW3hn53ncLauETCrBy/3aY9bATmxcSkQGgwGIiOpNWXgPC7/9Dfsv5AIAfBV2WDk6AN087UWujIioYRiAiOhvCYKArSczsHxXGoorqmAhk2LGgI6Y1r8DzGVSscsjImowBiAieqD0/DLM/+YcjlzNBwA86uWAD8YEoJObrciVERE1HgMQEdVJrRGw6cgNfPjjRdyrVMPSXIo3wzpjch8fyKRsY0FEho0BiIhquZJbjLnbz+FMegEAoHd7J7w/uhu8nWzELYyIqIkwABGRVqVag/8evIpP91+BSq1BK7kZ3hrui3GPeUHKUR8iMiKiX724bt06+Pj4wNLSEoGBgTh06NAD99+8eTO6d+8Oa2trKBQKTJ48Gfn5+XXuu3XrVkgkEoSHhzdD5UTG5besQjy19ld8uPcSVGoNBnRxReLsfvhncFuGHyIyOqIGoPj4eERGRmLBggU4c+YMQkNDMWzYMKSnp9e5/+HDhzFx4kRMmTIF58+fx7Zt23Dy5ElMnTq11r43b97Em2++idDQ0OY+DSKDVl6pxso9F/DUv39FqrIIjtbmWD32UcS9EASFvZXY5RERNQtRA9CqVaswZcoUTJ06Fb6+vli9ejW8vLwQExNT5/7Hjh1Du3btMHPmTPj4+KBv37545ZVXcOrUKZ391Go1JkyYgCVLlqB9+/YtcSpEBinp5h2M+PQQ1v18FWqNgBEBCiTOfhzhPdpAIuGoDxEZL9ECkEqlQlJSEsLCwnS2h4WF4ciRI3W+JiQkBJmZmUhISIAgCMjJycH27dsxYsQInf2WLl0KFxcXTJkypV61VFRUoKioSOdBZMxKK6rwzs7zGPOfo7h6uxQutnL8NyIQ//5nTzi3kotdHhFRsxPtIui8vDyo1Wq4ubnpbHdzc0N2dnadrwkJCcHmzZsxduxYlJeXo6qqCqNGjcKaNWu0+/z666+Ii4tDcnJyvWuJjo7GkiVLGnUeRIbm8OU8zP/mHDLv3gMAPBvoiYUj/GBvbS5yZURELUf0i6D/OswuCMJ9h95TU1Mxc+ZMLF68GElJSdizZw+uX7+OadOmAQCKi4vx/PPPY/369XB2dq53DVFRUSgsLNQ+MjIyGn9CRHqq8F4l5m0/h+fjjiPz7j20cbDC5y/2wgfPdmf4ISKTI9oIkLOzM2QyWa3Rntzc3FqjQjWio6PRp08fzJ07FwAQEBAAGxsbhIaGYtmyZcjJycGNGzcwcuRI7Ws0Gg0AwMzMDBcvXkSHDh1qHVcul0Mu57A/Ga/E1Bws/C4FOUUVAIAXentj7tAuaCXnnTCIyDSJ9tvPwsICgYGBSExMxNNPP63dnpiYiKeeeqrO15SVlcHMTLdkmay6+7QgCOjSpQtSUlJ0nl+4cCGKi4vxySefwMvLq4nPgki/5ZdU4J3/S8X/nb0FAGjvbIMVYwLwWLvWIldGRCQuUf/5N3v2bERERCAoKAi9e/dGbGws0tPTtVNaUVFRyMrKwueffw4AGDlyJF566SXExMRgyJAhUCqViIyMRK9eveDh4QEA8Pf313kPBweHOrcTGTNBELDz7C0s+b9U3ClVQSoBXu7XAZGDOsHSXCZ2eUREohM1AI0dOxb5+flYunQplEol/P39kZCQAG9vbwCAUqnUuSfQpEmTUFxcjLVr12LOnDlwcHDAgAEDsGLFCrFOgUjvZBeWY+F3KdiXlgsA6OJui5VjAhDg6SBuYUREekQiCIIgdhH6pqioCPb29igsLISdnZ3Y5RDViyAIiD+ZgfcS0lBcXgVzmQQzBnTCtMc7wMJM9PUORETNriGf37wCksgIpOeX4a1vU3D4Sh4AoLuXAz4YE4BH3GxFroyISD8xABEZsLulKvz7pyv4/OhNqNQaWJpL8WZYZ0zu4wMZ+3cREd0XAxCRASqvVGPDr9cR8/NVFJdXAQD6dnTGsnB/tHO2Ebk6IiL9xwBEZEDUGgHbkzLwceJlZBeVAwB8FXaIGtYFoZ2c2b+LiKieGICIDIAgCNiflosVey7gcm4JAKCNgxXeHPIInureBlJOdxERNQgDEJGeO51+F+8nXMCJG3cAAA7W5nj9iY54/h/evKcPEVEjMQAR6amrt0vwwZ6L2HO+ul2M3EyKF/v6YNrjHWBvxd5dREQPgwGISM/kFpXjk/2XsfVkBtQaAVIJMCbQE28MfgQKeyuxyyMiMgoMQER6oqSiCrEHr2L9oeu4V6kGAAzydcW/hnbh/XyIiJoYAxCRyFRVGnx1Ih2f7r+M/FIVAKBHWwdEDfNFLx82LSUiag4MQEQi0WgE7EpR4sO9F3EzvwxAdbf2fw3tjCFd3bmknYioGTEAEYngyNU8vL/7As5lFgIAnFvJETmoE8Y+5gVzGft2ERE1NwYgohaUpizC+7sv4OCl2wAAGwsZXnm8A6b09YGNnP87EhG1FP7GJWoBWQX38NHei/j2TBYEATCTSjAhuC1mDOwE51ZyscsjIjI5DEBEzaigrLpZ6f+O3oSqSgMAeDJAgTfDOrNnFxGRiBiAiJpBeaUam47cwLqfrqDo92alvds7Yf6wLuju5SBucURExABE1JTUGgE7Tmfi48RLUBZWNyvt4m6LecO6oP8jLlzZRUSkJxiAiJqAIAj46WIuVuy+iIs5xQCqm5XOHvwIwnu0gYzNSomI9AoDENFDOpN+F+/vvoDj16ubldpbVTcrjejNZqVERPqKAYioka7nleKDHy8gIaW6WamFmRST+7TDa493hL01m5USEekzBiCiBrpdXIFP9l/C1hMZqNIIkEiAMT2rm5V6OLBZKRGRIWAAIqqnkooqrP/lGtYfuoYyVXWz0gFdXDFvaBd0dmezUiIiQ8IARPQ3KtV/NCvNK6luVtrdywFRw7rgH+2dRK6OiIgagwGI6D4EQUBCSjY++PECbvzerNTH2QZzh3TGMH82KyUiMmQMQER1OHo1H+/vTsNZbbNSC8wa2AnjerVls1IiIiPAAET0Jxeyi7Bi9wX8dLG6Wam1hQwv92uPqaHt0YrNSomIjAZ/oxOhulnpx4mXsON0prZZ6fhebTFzYCe42LJZKRGRsWEAIpNWWFaJdT9fwcYjN7TNSkd0U+DNIZ3hw2alRERGiwGITNaV3GJM+Ow4cooqAADBPq0RNdwXj7JZKRGR0WMAIpN0MbsYEz47hrwSFXycbbDoSV880dmVK7uIiEwEAxCZnN+yChERdxx3yyrhp7DDl1OD0drGQuyyiIioBTEAkUk5m1GAiLjjKCqvQndPe3z+YjD7dhERmSAGIDIZSTfvYNKGkyiuqEKgtyM2Tn4MdpYMP0REpogBiEzC8Wv5mLzpJMpUavTyaY0Nkx7jfX2IiEwYPwHI6P16JQ9T/ncS5ZUa9OnohPUTg2BtwR99IiJTxk8BMmo/X8zFK18koaJKg8cfccF/IwJhaS4TuywiIhIZAxAZrX2pOXht82mo1BoM8nXDvyf0gNyM4YeIiBiAyEjtTlFixldnUKURMMzfHZ+M6wELMzYxJSKiagxAZHS+T87C7K/PQq0RMKq7B1Y91x1m7OBORER/wgBERmV7Uib+tf0sNAIwuqcnVo4JgEzKuzsTEZEuBiAyGltPpCPq2xQIAjC+lxfeC+8GKcMPERHVgQGIjMIXR29g0ffnAQATe3vjnZFdGX6IiOi+GIDI4MUdvo53f0gFAEzt64MFI3zZ1JSIiB6IAYgMWszPV7FizwUAwGv9O2DukM4MP0RE9LcavDSmXbt2WLp0KdLT05ujHqJ6+3T/ZW34mTWwE8MPERHVW4MD0Jw5c/D999+jffv2GDx4MLZu3YqKiopGF7Bu3Tr4+PjA0tISgYGBOHTo0AP337x5M7p37w5ra2soFApMnjwZ+fn52ufXr1+P0NBQODo6wtHREYMGDcKJEycaXR/pH0EQ8OGPF7Eq8RIAYO6Qznhj8CMMP0REVG8NDkAzZsxAUlISkpKS4Ofnh5kzZ0KhUOD111/H6dOnG3Ss+Ph4REZGYsGCBThz5gxCQ0MxbNiw+44uHT58GBMnTsSUKVNw/vx5bNu2DSdPnsTUqVO1+/z8888YP348fvrpJxw9ehRt27ZFWFgYsrKyGnqqpIcEQUD07gtY+9MVAMCC4b6Y/kRHkasiIiJDIxEEQXiYA1RWVmLdunWYN28eKisr4e/vj1mzZmHy5Ml/+y/y4OBg9OzZEzExMdptvr6+CA8PR3R0dK39P/zwQ8TExODq1avabWvWrMHKlSuRkZFR53uo1Wo4Ojpi7dq1mDhxYp37VFRU6IxiFRUVwcvLC4WFhbCzs3vgOVDLEQQBS/4vFZuO3AAAvDPSD5P6+IhbFBER6Y2ioiLY29vX6/O70bfHraysxNdff41Ro0Zhzpw5CAoKwmeffYbnnnsOCxYswIQJEx74epVKhaSkJISFhelsDwsLw5EjR+p8TUhICDIzM5GQkABBEJCTk4Pt27djxIgR932fsrIyVFZWonXr1vfdJzo6Gvb29tqHl5fXA2unlqfRCFjw3W/a8LP86W4MP0RE1GgNXgV2+vRpbNy4EV999RVkMhkiIiLw8ccfo0uXLtp9wsLC0K9fvwceJy8vD2q1Gm5ubjrb3dzckJ2dXedrQkJCsHnzZowdOxbl5eWoqqrCqFGjsGbNmvu+z/z589GmTRsMGjTovvtERUVh9uzZ2q9rRoBIP6g1AubvOIdtSZmQSIAVowPwXBC/P0RE1HgNHgF67LHHcPnyZcTExCAzMxMffvihTvgBAD8/P4wbN65ex/vrNJkgCPedOktNTcXMmTOxePFiJCUlYc+ePbh+/TqmTZtW5/4rV67EV199hW+++QaWlpb3rUEul8POzk7nQfqhSq3BnK+TsS0pE1IJ8PFzjzL8EBHRQ2vwCNC1a9fg7e39wH1sbGywcePGB+7j7OwMmUxWa7QnNze31qhQjejoaPTp0wdz584FAAQEBMDGxgahoaFYtmwZFAqFdt8PP/wQy5cvx759+xAQEFCfUyM9U6nWIHJrMnalKGEmleCTcT0wIkDx9y8kIiL6Gw0eAcrNzcXx48drbT9+/DhOnTpV7+NYWFggMDAQiYmJOtsTExMREhJS52vKysogleqWLJPJAFSPHNX44IMP8O6772LPnj0ICgqqd02kPyqq1Ji++TR2pShhLpNg3YSeDD9ERNRkGhyApk+fXueKq6ysLEyfPr1Bx5o9ezY+++wzbNiwAWlpaXjjjTeQnp6undKKiorSWbk1cuRIfPPNN4iJicG1a9fw66+/YubMmejVqxc8PDwAVE97LVy4EBs2bEC7du2QnZ2N7OxslJSUNPRUSSTllWpM+yIJe1NzYGEmRWxEEMK6uotdFhERGZEGT4GlpqaiZ8+etbb36NEDqampDTrW2LFjkZ+fj6VLl0KpVMLf3x8JCQnaKTalUqlzT6BJkyahuLgYa9euxZw5c+Dg4IABAwZgxYoV2n3WrVsHlUqFMWPG6LzX22+/jXfeeadB9VHLu6dS4+UvTuHQ5TxYmkuxfmIQQju5iF0WEREZmQbfB8jJyQk//PADevfurbP9yJEjGDFiBO7evdukBYqhIfcRoKZTpqrClE2ncPRaPqwtZIh74TH07uAkdllERGQgmvU+QIMHD0ZUVBQKCwu12woKCvDWW29h8ODBDa+WCEBxeSVe2HACR6/lo5XcDJ+/2Ivhh4iImk2Dp8A++ugj9OvXD97e3ujRowcAIDk5GW5ubvjiiy+avEAyfoX3qsNPckYBbC2rw0+Pto5il0VEREaswQGoTZs2OHfuHDZv3oyzZ8/CysoKkydPxvjx42Fubt4cNZIRKyhTISLuBFKyCuFgbY4vpwTDv4292GUREZGRa3AAAqrv8/Pyyy83dS1kYvJLKjDhs+O4kF0MJxsLfDk1GL4KXnNFRETNr1EBCKheDZaeng6VSqWzfdSoUQ9dFBm/3OJyTFh/HJdzS+BiK8eWqcHo5GYrdllERGQiGnUn6KeffhopKSmQSCTaGxDWtK9Qq9VNWyEZnezCcvxz/TFcyyuFu50ltrwUjPYurcQui4iITEiDV4HNmjULPj4+yMnJgbW1Nc6fP49ffvkFQUFB+Pnnn5uhRDImWQX3MDb2KK7llaKNgxXiX/kHww8REbW4Bo8AHT16FAcOHICLiwukUimkUin69u2L6OhozJw5E2fOnGmOOskIpOeXYfz6Y8gquAev1lb46qV/wNPRWuyyiIjIBDV4BEitVqNVq+p/sTs7O+PWrVsAAG9vb1y8eLFpqyOjcT2vFGNjjyKr4B58nG3w9Su9GX6IiEg0DR4B8vf3x7lz59C+fXsEBwdj5cqVsLCwQGxsLNq3b98cNZKBu5JbjPHrj+N2cQU6urbClqnBcLWzFLssIiIyYQ0OQAsXLkRpaSkAYNmyZXjyyScRGhoKJycnxMfHN3mBZNguZBdhwvrjyC9VoYu7Lb6cGgznVnKxyyIiIhPX4F5gdblz5w4cHR21K8EMHXuBNY3fsgoREXccd8sq0dXDDl9OCYajjYXYZRERkZFqtl5gVVVVMDMzw2+//aazvXXr1kYTfqhpnM0owD/XH8Pdskp093LAlqn/YPghIiK90aApMDMzM3h7e/NeP/RASTfvYNKGkyiuqEKgtyM2TX4MtpZsk0JERPqjwavAFi5ciKioKNy5c6c56iEDd/xaPiLiTqC4ogrBPq3x+Yu9GH6IiEjvNPgi6E8//RRXrlyBh4cHvL29YWNjo/P86dOnm6w4Miy/XsnDlP+dRHmlBn07OmP9xCBYWcjELouIiKiWBgeg8PDwZiiDDN3PF3PxyhdJqKjSoH9nF/zn+UBYmjP8EBGRfmqSVWDGhqvAGmZfag5e23waKrUGg/3csPafPSA3Y/ghIqKW1ZDP70Z3gycCgN0pSsz46gyqNAKGd3PHJ+N6wFzW4EvLiIiIWlSDA5BUKn3gkneuEDMd3ydnYfbXZ6HWCHjqUQ989Gx3mDH8EBGRAWhwAPr22291vq6srMSZM2fwv//9D0uWLGmywki/7UjKxNztZ6ERgDGBnlgxOgAyKe8FRUREhqHJrgHasmUL4uPj8f333zfF4UTFa4AeTFl4D6ErfkKVRsD4Xm3xXrg/pAw/REQksma7E/SDBAcHY9++fU11ONJje8/noEoj4FEvByx/muGHiIgMT5MEoHv37mHNmjXw9PRsisORnktMzQEADO/mzhYoRERkkBp8DdBfm54KgoDi4mJYW1vjyy+/bNLiSP8U3qvEsWv5AIDBfu4iV0NERNQ4DQ5AH3/8sU4AkkqlcHFxQXBwMBwdHZu0ONI/P1/MRZVGQEfXVvBxtvn7FxAREemhBgegSZMmNUMZZChqpr8G+7mJXAkREVHjNfgaoI0bN2Lbtm21tm/btg3/+9//mqQo0k+qKg0OXrwNgAGIiIgMW4MD0Pvvvw9nZ+da211dXbF8+fImKYr007Fr+SiuqIKLrRyPejqIXQ4REVGjNTgA3bx5Ez4+PrW2e3t7Iz09vUmKIv1UM/01yNeVS9+JiMigNTgAubq64ty5c7W2nz17Fk5OTk1SFOkfQRCwL606AIVx9RcRERm4BgegcePGYebMmfjpp5+gVquhVqtx4MABzJo1C+PGjWuOGkkP/JZVBGVhOawtZOjdgUGXiIgMW4NXgS1btgw3b97EwIEDYWZW/XKNRoOJEyfyGiAjlpiaDQB4/BEXWJrLRK6GiIjo4TQ4AFlYWCA+Ph7Lli1DcnIyrKys0K1bN3h7ezdHfaQn9nL5OxERGZEGB6AanTp1QqdOnZqyFtJTGXfKcCG7GDKpBAO6uIpdDhER0UNr8DVAY8aMwfvvv19r+wcffIBnn322SYoi/VKz+uuxdo5wsLYQuRoiIqKH1+AAdPDgQYwYMaLW9qFDh+KXX35pkqJIv/xx92eu/iIiIuPQ4ABUUlICC4vaowDm5uYoKipqkqJIfxSUqXDixh0AQBiv/yEiIiPR4ADk7++P+Pj4Wtu3bt0KPz+/JimK9MeBC7lQawR0cbeFV2trscshIiJqEg2+CHrRokUYPXo0rl69igEDBgAA9u/fjy1btmD79u1NXiCJi81PiYjIGDU4AI0aNQrfffcdli9fju3bt8PKygrdu3fHgQMHYGdn1xw1kkjKK9U4eInNT4mIyPg0ahn8iBEjtBdCFxQUYPPmzYiMjMTZs2ehVqubtEASz9Gr+ShTqeFuZ4lubezFLoeIiKjJNPgaoBoHDhzA888/Dw8PD6xduxbDhw/HqVOnmrI2ElnNzQ8H+blCImHzUyIiMh4NGgHKzMzEpk2bsGHDBpSWluK5555DZWUlduzYwQugjYxG80fzUy5/JyIiY1PvEaDhw4fDz88PqampWLNmDW7duoU1a9Y8dAHr1q2Dj48PLC0tERgYiEOHDj1w/82bN6N79+6wtraGQqHA5MmTkZ+fr7NPTSCTy+Xw8/PDt99++9B1mpqzmQW4XVyBVnIz/KN9a7HLISIialL1DkB79+7F1KlTsWTJEowYMQIy2cM3xIyPj0dkZCQWLFiAM2fOIDQ0FMOGDUN6enqd+x8+fBgTJ07ElClTcP78eWzbtg0nT57E1KlTtfscPXoUY8eORUREBM6ePYuIiAg899xzOH78+EPXa0pqVn893tkFcjM2PyUiIuNS7wB06NAhFBcXIygoCMHBwVi7di1u3779UG++atUqTJkyBVOnToWvry9Wr14NLy8vxMTE1Ln/sWPH0K5dO8ycORM+Pj7o27cvXnnlFZ1rj1avXo3BgwcjKioKXbp0QVRUFAYOHIjVq1c/VK2mpiYA8eaHRERkjOodgHr37o3169dDqVTilVdewdatW9GmTRtoNBokJiaiuLi4QW+sUqmQlJSEsLAwne1hYWE4cuRIna8JCQlBZmYmEhISIAgCcnJysH37dp3WHEePHq11zCFDhtz3mABQUVGBoqIinYcpu5FXisu5JTCTStC/M5ufEhGR8WnwKjBra2u8+OKLOHz4MFJSUjBnzhy8//77cHV1xahRo+p9nLy8PKjVari56Y4wuLm5ITs7u87XhISEYPPmzRg7diwsLCzg7u4OBwcHnWuRsrOzG3RMAIiOjoa9vb324eXlVe/zMEY1oz/B7VvD3spc5GqIiIiaXqOXwQNA586dsXLlSmRmZuKrr75q1DH+urxaEIT7LrlOTU3FzJkzsXjxYiQlJWHPnj24fv06pk2b1uhjAkBUVBQKCwu1j4yMjEadi7H4Y/qLq7+IiMg4NepGiH8lk8kQHh6O8PDwer/G2dkZMpms1shMbm5urRGcGtHR0ejTpw/mzp0LAAgICICNjQ1CQ0OxbNkyKBQKuLu7N+iYACCXyyGXy+tduzG7U6rCqZvVzU8H8fofIiIyUg81AvQwLCwsEBgYiMTERJ3tiYmJCAkJqfM1ZWVlkEp1S65ZjSYIAoDqa5X+esy9e/fe95ika39aDjQC0NXDDm0crMQuh4iIqFk0yQhQY82ePRsREREICgpC7969ERsbi/T0dO2UVlRUFLKysvD5558DAEaOHImXXnoJMTExGDJkCJRKJSIjI9GrVy94eHgAAGbNmoV+/fphxYoVeOqpp/D9999j3759OHz4sGjnaUjY/JSIiEyBqAFo7NixyM/Px9KlS6FUKuHv74+EhAR4e3sDAJRKpc49gSZNmoTi4mKsXbsWc+bMgYODAwYMGIAVK1Zo9wkJCcHWrVuxcOFCLFq0CB06dEB8fDyCg4Nb/PwMzT2VGr9cZvNTIiIyfhKhZu6ItIqKimBvb4/CwkKT6nCfmJqDlz4/hTYOVjg87wn2/yIiIoPSkM9v0a4BIv2TmFp98fhgPzeGHyIiMmoMQAQAUGsE7E/LBcDpLyIiMn4MQAQAOJN+F/mlKthZmqGXD5ufEhGRcWMAIgB/rP56oosrzGX8sSAiIuPGTzoCwOXvRERkWhiACFdyS3AtrxTmMgkef8RF7HKIiIiaHQMQaUd/endwhq0lm58SEZHxYwAineXvREREpoAByMTdLq7AmYwCAMBgXwYgIiIyDQxAJm5/Wg4EAQjwtIe7vaXY5RAREbUIBiATp139xdEfIiIyIQxAJqxMVYXDV/IAAIO7MgAREZHpYAAyYb9cykNFlQZera3Q2c1W7HKIiIhaDAOQCauZ/grzc2fzUyIiMikMQCaqSq3BgQu8+zMREZkmBiATlXTzLu6WVcLB2hxB3o5il0NERNSiGIBM1N7fp78GdHGFGZufEhGRieEnnwkSBOFP1/9w+ouIiEwPA5AJupRTgvQ7ZbAwkyK0E5ufEhGR6WEAMkE1vb/6dnSGjdxM5GqIiIhaHgOQCdLe/ZnTX0REZKIYgExMTlE5zmYWQiIBBvq6il0OERGRKBiATEzN6M+jXg5wtWXzUyIiMk0MQCaG019EREQMQCalpKIKR6/mA+DydyIiMm0MQCbk4MXbUKk18HG2QQeXVmKXQ0REJBoGIBNSs/x9sJ8bm58SEZFJYwAyEZVqDQ5cyAXA63+IiIgYgEzEyet3UFReBScbC/Rsy+anRERk2hiATMSfm5/KpJz+IiIi08YAZAL+3PyU019EREQMQCYhTVmMrIJ7sDRn81MiIiKAAcgk7P199VdoJxdYWchEroaIiEh8DEAmgNNfREREuhiAjFxWwT2cv1UEqQQY2IXNT4mIiAAGIKO37/fRn0BvRzi1kotcDRERkX5gADJynP4iIiKqjQHIiBXeq8Sxa9XNTwf7uYtcDRERkf5gADJiP1/MRZVGQEfXVvBxthG7HCIiIr3BAGTEOP1FRERUNwYgI6Wq0uDgxdsAGICIiIj+igHISB27lo/iiiq42MrxqKeD2OUQERHpFQYgI1Uz/TXI1xVSNj8lIiLSwQBkhARBwL40Xv9DRER0P6IHoHXr1sHHxweWlpYIDAzEoUOH7rvvpEmTIJFIaj26du2qs9/q1avRuXNnWFlZwcvLC2+88QbKy8ub+1T0xm9ZRVAWlsPaQoaQDs5il0NERKR3RA1A8fHxiIyMxIIFC3DmzBmEhoZi2LBhSE9Pr3P/Tz75BEqlUvvIyMhA69at8eyzz2r32bx5M+bPn4+3334baWlpiIuLQ3x8PKKiolrqtESX+Hvz036dXGBpzuanREREfyVqAFq1ahWmTJmCqVOnwtfXF6tXr4aXlxdiYmLq3N/e3h7u7u7ax6lTp3D37l1MnjxZu8/Ro0fRp08f/POf/0S7du0QFhaG8ePH49SpUy11WqLby+XvREREDyRaAFKpVEhKSkJYWJjO9rCwMBw5cqRex4iLi8OgQYPg7e2t3da3b18kJSXhxIkTAIBr164hISEBI0aMuO9xKioqUFRUpPMwVBl3ynAhuxgyqQQD2PyUiIioTmZivXFeXh7UajXc3HRHKdzc3JCdnf23r1cqldi9eze2bNmis33cuHG4ffs2+vbtC0EQUFVVhVdffRXz58+/77Gio6OxZMmSxp2InqlZ/RXk7QhHGwuRqyEiItJPol8ELZHoLtEWBKHWtrps2rQJDg4OCA8P19n+888/47333sO6detw+vRpfPPNN/jhhx/w7rvv3vdYUVFRKCws1D4yMjIadS76YO/v1/9w+ouIiOj+RBsBcnZ2hkwmqzXak5ubW2tU6K8EQcCGDRsQEREBCwvdUY5FixYhIiICU6dOBQB069YNpaWlePnll7FgwQJIpbUzn1wuh1wuf8gzEl9BmQonb9wFAISx+SkREdF9iTYCZGFhgcDAQCQmJupsT0xMREhIyANfe/DgQVy5cgVTpkyp9VxZWVmtkCOTySAIAgRBePjC9diBC7lQawR0cbdFWydrscshIiLSW6KNAAHA7NmzERERgaCgIPTu3RuxsbFIT0/HtGnTAFRPTWVlZeHzzz/XeV1cXByCg4Ph7+9f65gjR47EqlWr0KNHDwQHB+PKlStYtGgRRo0aBZnMuJeEs/kpERFR/YgagMaOHYv8/HwsXboUSqUS/v7+SEhI0K7qUiqVte4JVFhYiB07duCTTz6p85gLFy6ERCLBwoULkZWVBRcXF4wcORLvvfdes5+PmMor1Th4ic1PiYiI6kMiGPu8UCMUFRXB3t4ehYWFsLOzE7ucevnpQi4mbzoJdztLHI0aUK8LyYmIiIxJQz6/RV8FRk2j5uaHg/xcGX6IiIj+BgOQEdBo/tz8lKu/iIiI/g4DkBE4m1mA28UVaCU3wz/atxa7HCIiIr3HAGQEalZ/Pd7ZBXIz417pRkRE1BQYgIxATQAK4+ovIiKiemEAMnA38kpxObcEZlIJ+ndm81MiIqL6YAAycDWjP8HtW8PeylzkaoiIiAwDA5CB09792ZfTX0RERPXFAGTA7pSqcOrmHQDAIF7/Q0REVG8MQAZsf1oONALgp7CDpyObnxIREdUXA5ABY/NTIiKixmEAMlD3VGr8cpnNT4mIiBqDAchAHb6Sh/JKDdo4WKGrh2E0bCUiItIXDEAGKjE1GwAwyJfNT4mIiBqKAcgAqTUC9qflAmDzUyIiosZgADJAZ9LvIr9UBVtLMwSz+SkREVGDMQAZoJrVXwO6uMJcxm8hERFRQ/HT0wBx+TsREdHDYQAyMFdyS3AtrxTmMgkef8RF7HKIiIgMEgOQgakZ/endwRm2lmx+SkRE1BgMQAamZvk7p7+IiIgajwHIgNwursCZjAIA7P5ORET0MBiADMj+tBwIAhDgaQ93e0uxyyEiIjJYDEAGRLv6i6M/RERED4UByECUqapw+EoeAGBwVwYgIiKih8EAZCB+uZSHiioNvFpbobObrdjlEBERGTQGIAPxx/SXO5ufEhERPSQGIANQpdZg/wXe/ZmIiKipMAAZgFM376KgrBIO1uZ4rJ2j2OUQEREZPAYgA6BtftrZFWZsfkpERPTQ+Gmq5wRBYPNTIiKiJsYApOcu5ZQg/U4ZLMyk6Mfmp0RERE2CAUjP1fT+6tPBCTZyM5GrISIiMg4MQHruj+kvd5ErISIiMh4MQHosp6gcZzMLAQCDfF1FroaIiMh4MADpsZrRnx5tHeBqx+anRERETYUBSI9x9RcREVHzYADSUyUVVTh6NR8AEMYARERE1KQYgPTUwYu3oVJr4ONsgw4urcQuh4iIyKgwAOmpmuXvg/3c2PyUiIioiTEA6aFKtQYHLuQC4PU/REREzYEBSA+dvH4HReVVcLKxQM+2bH5KRETU1BiA9NDemuanXVwhk3L6i4iIqKkxAOkZNj8lIiJqfgxAeiZVWYSsgnuwNJcitBObnxIRETUH0QPQunXr4OPjA0tLSwQGBuLQoUP33XfSpEmQSCS1Hl27dtXZr6CgANOnT4dCoYClpSV8fX2RkJDQ3KfSJGpGf/p2dIGVhUzkaoiIiIyTqAEoPj4ekZGRWLBgAc6cOYPQ0FAMGzYM6enpde7/ySefQKlUah8ZGRlo3bo1nn32We0+KpUKgwcPxo0bN7B9+3ZcvHgR69evR5s2bVrqtB5KTQDizQ+JiIiaj5mYb75q1SpMmTIFU6dOBQCsXr0aP/74I2JiYhAdHV1rf3t7e9jb22u//u6773D37l1MnjxZu23Dhg24c+cOjhw5AnNzcwCAt7f3A+uoqKhARUWF9uuioqKHOq/Gyiq4h/O3iiCRAAPY/JSIiKjZiDYCpFKpkJSUhLCwMJ3tYWFhOHLkSL2OERcXh0GDBukEnJ07d6J3796YPn063Nzc4O/vj+XLl0OtVt/3ONHR0dpwZW9vDy8vr8ad1EPa9/voT2BbRzi3kotSAxERkSkQLQDl5eVBrVbDzU13qsfNzQ3Z2dl/+3qlUondu3drR49qXLt2Ddu3b4darUZCQgIWLlyIjz76CO+99959jxUVFYXCwkLtIyMjo3En9ZC4+ouIiKhliDoFBqBWmwdBEOrV+mHTpk1wcHBAeHi4znaNRgNXV1fExsZCJpMhMDAQt27dwgcffIDFixfXeSy5XA65XNwRl8J7lTh2rbr5KQMQERFR8xItADk7O0Mmk9Ua7cnNza01KvRXgiBgw4YNiIiIgIWFhc5zCoUC5ubmkMn+WEHl6+uL7OxsqFSqWvvri58v5qJKI6CDiw3as/kpERFRsxJtCszCwgKBgYFITEzU2Z6YmIiQkJAHvvbgwYO4cuUKpkyZUuu5Pn364MqVK9BoNNptly5dgkKh0NvwA/x5+std5EqIiIiMn6jL4GfPno3PPvsMGzZsQFpaGt544w2kp6dj2rRpAKqvzZk4cWKt18XFxSE4OBj+/v61nnv11VeRn5+PWbNm4dKlS9i1axeWL1+O6dOnN/v5NJaqSoODF28D4PQXERFRSxD1GqCxY8ciPz8fS5cuhVKphL+/PxISErSrupRKZa17AhUWFmLHjh345JNP6jyml5cX9u7dizfeeAMBAQFo06YNZs2ahXnz5jX7+TTWsWv5KK6ognMrOXp4OYhdDhERkdGTCIIgiF2EvikqKoK9vT0KCwthZ2fX7O+36Lvf8MWxmxjfywvRzwQ0+/sREREZo4Z8foveCsPUCYKAfWlc/k5ERNSSGIBE9ltWEZSF5bC2kCGkg7PY5RAREZkEBiCRJaZW3wagXycXWJqz+SkREVFLYAAS2V7e/ZmIiKjFMQCJKONOGS5kF0MmlWBAFzY/JSIiaikMQCKqGf0J8naEo43+3qSRiIjI2DAAiajm+h9OfxEREbUsBiCRFJSpcPLGXQBAGNtfEBERtSgGIJEcuJALtUZAZzdbtHWyFrscIiIik8IAJJJErv4iIiISDQOQCMor1Th4ic1PiYiIxMIAJIKjV/NRplLDzU6Obm3sxS6HiIjI5DAAiaBm+fsgXzdIpRKRqyEiIjI9DEAtTKNh81MiIiKxMQC1sLOZBbhdXIFWcjP07uAkdjlEREQmiQGohdWs/nr8ERfIzdj8lIiISAwMQC2My9+JiIjExwDUgm7kleJybgnMpBI80ZnNT4mIiMRiJnYBpiT9ThmcW8nR2b0V7K3NxS6HiIjIZDEAtaB+j7jgxFsDcadMJXYpREREJo1TYC1MKpXAuZVc7DKIiIhMGgMQERERmRwGICIiIjI5DEBERERkchiAiIiIyOQwABEREZHJYQAiIiIik8MARERERCaHAYiIiIhMDgMQERERmRwGICIiIjI5DEBERERkchiAiIiIyOQwABEREZHJMRO7AH0kCAIAoKioSORKiIiIqL5qPrdrPscfhAGoDsXFxQAALy8vkSshIiKihiouLoa9vf0D95EI9YlJJkaj0eDWrVuwtbWFRCJp0mMXFRXBy8sLGRkZsLOza9JjU8Px+6Ff+P3QL/x+6B9+Tx5MEAQUFxfDw8MDUumDr/LhCFAdpFIpPD09m/U97Ozs+MOrR/j90C/8fugXfj/0D78n9/d3Iz81eBE0ERERmRwGICIiIjI5DEAtTC6X4+2334ZcLhe7FAK/H/qG3w/9wu+H/uH3pOnwImgiIiIyORwBIiIiIpPDAEREREQmhwGIiIiITA4DEBEREZkcBqAWtG7dOvj4+MDS0hKBgYE4dOiQ2CWZrOjoaDz22GOwtbWFq6srwsPDcfHiRbHLIlR/byQSCSIjI8UuxaRlZWXh+eefh5OTE6ytrfHoo48iKSlJ7LJMUlVVFRYuXAgfHx9YWVmhffv2WLp0KTQajdilGTQGoBYSHx+PyMhILFiwAGfOnEFoaCiGDRuG9PR0sUszSQcPHsT06dNx7NgxJCYmoqqqCmFhYSgtLRW7NJN28uRJxMbGIiAgQOxSTNrdu3fRp08fmJubY/fu3UhNTcVHH30EBwcHsUszSStWrMB//vMfrF27FmlpaVi5ciU++OADrFmzRuzSDBqXwbeQ4OBg9OzZEzExMdptvr6+CA8PR3R0tIiVEQDcvn0brq6uOHjwIPr16yd2OSappKQEPXv2xLp167Bs2TI8+uijWL16tdhlmaT58+fj119/5Si1nnjyySfh5uaGuLg47bbRo0fD2toaX3zxhYiVGTaOALUAlUqFpKQkhIWF6WwPCwvDkSNHRKqK/qywsBAA0Lp1a5ErMV3Tp0/HiBEjMGjQILFLMXk7d+5EUFAQnn32Wbi6uqJHjx5Yv3692GWZrL59+2L//v24dOkSAODs2bM4fPgwhg8fLnJlho3NUFtAXl4e1Go13NzcdLa7ubkhOztbpKqohiAImD17Nvr27Qt/f3+xyzFJW7duxenTp3Hy5EmxSyEA165dQ0xMDGbPno233noLJ06cwMyZMyGXyzFx4kSxyzM58+bNQ2FhIbp06QKZTAa1Wo333nsP48ePF7s0g8YA1IIkEonO14Ig1NpGLe/111/HuXPncPjwYbFLMUkZGRmYNWsW9u7dC0tLS7HLIQAajQZBQUFYvnw5AKBHjx44f/48YmJiGIBEEB8fjy+//BJbtmxB165dkZycjMjISHh4eOCFF14QuzyDxQDUApydnSGTyWqN9uTm5tYaFaKWNWPGDOzcuRO//PILPD09xS7HJCUlJSE3NxeBgYHabWq1Gr/88gvWrl2LiooKyGQyESs0PQqFAn5+fjrbfH19sWPHDpEqMm1z587F/PnzMW7cOABAt27dcPPmTURHRzMAPQReA9QCLCwsEBgYiMTERJ3tiYmJCAkJEakq0yYIAl5//XV88803OHDgAHx8fMQuyWQNHDgQKSkpSE5O1j6CgoIwYcIEJCcnM/yIoE+fPrVuC3Hp0iV4e3uLVJFpKysrg1Sq+3Etk8m4DP4hcQSohcyePRsREREICgpC7969ERsbi/T0dEybNk3s0kzS9OnTsWXLFnz//fewtbXVjs7Z29vDyspK5OpMi62tba1rr2xsbODk5MRrskTyxhtvICQkBMuXL8dzzz2HEydOIDY2FrGxsWKXZpJGjhyJ9957D23btkXXrl1x5swZrFq1Ci+++KLYpRk0LoNvQevWrcPKlSuhVCrh7++Pjz/+mEuuRXK/a682btyISZMmtWwxVEv//v25DF5kP/zwA6KionD58mX4+Phg9uzZeOmll8QuyyQVFxdj0aJF+Pbbb5GbmwsPDw+MHz8eixcvhoWFhdjlGSwGICIiIjI5vAaIiIiITA4DEBEREZkcBiAiIiIyOQxAREREZHIYgIiIiMjkMAARERGRyWEAIiIiIpPDAEREREQmhwGIiOg+JBIJvvvuO7HLIKJmwABERHpp0qRJkEgktR5Dhw4VuzQiMgJshkpEemvo0KHYuHGjzja5XC5SNURkTDgCRER6Sy6Xw93dXefh6OgIoHp6KiYmBsOGDYOVlRV8fHywbds2ndenpKRgwIABsLKygpOTE15++WWUlJTo7LNhwwZ07doVcrkcCoUCr7/+us7zeXl5ePrpp2FtbY1OnTph586d2ufu3r2LCRMmwMXFBVZWVujUqVOtwEZE+okBiIgM1qJFizB69GicPXsWzz//PMaPH4+0tDQAQFlZGYYOHQpHR0ecPHkS27Ztw759+3QCTkxMDKZPn46XX34ZKSkp2LlzJzp27KjzHkuWLMFzzz2Hc+fOYfjw4ZgwYQLu3Lmjff/U1FTs3r0baWlpiImJgbOzc8v9BRBR4wlERHrohRdeEGQymWBjY6PzWLp0qSAIggBAmDZtms5rgoODhVdffVUQBEGIjY0VHB0dhZKSEu3zu3btEqRSqZCdnS0IgiB4eHgICxYsuG8NAISFCxdqvy4pKREkEomwe/duQRAEYeTIkcLkyZOb5oSJqEXxGiAi0ltPPPEEYmJidLa1bt1a++fevXvrPNe7d28kJycDANLS0tC9e3fY2Nhon+/Tpw80Gg0uXrwIiUSCW7duYeDAgQ+sISAgQPtnGxsb2NraIjc3FwDw6quvYvTo0Th9+jTCwsIQHh6OkJCQRp0rEbUsBiAi0ls2Nja1pqT+jkQiAQAIgqD9c137WFlZ1et45ubmtV6r0WgAAMOGDcPNmzexa9cu7Nu3DwMHDsT06dPx4YcfNqhmImp5vAaIiAzWsWPHan3dpUsXAICfnx+Sk5NRWlqqff7XX3+FVCrFI488AltbW7Rr1w779+9/qBpcXFwwadIkfPnll1i9ejViY2Mf6nhE1DI4AkREequiogLZ2dk628zMzLQXGm/btg1BQUHo27cvNm/ejBMnTiAuLg4AMGHCBLz99tt44YUX8M477+D27duYMWMGIiIi4ObmBgB45513MG3aNLi6umLYsGEoLi7Gr7/+ihkzZtSrvsWLFyMwMBBdu3ZFRUUFfvjhB/j6+jbh3wARNRcGICLSW3v27IFCodDZ1rlzZ1y4cAFA9QqtrVu34rXXXoO7uzs2b94MPz8/AIC1tTV+/PFHzJo1C4899hisra0xevRorFq1SnusF154AeXl5fj444/x5ptvwtnZGWPGjKl3fRYWFoiKisKNGzdgZWWF0NBQbN26tQnOnIiam0QQBEHsIoiIGkoikeDbb79FeHi42KUQkQHiNUBERERkchiAiIiIyOTwGiAiMkicvSeih8ERICIiIjI5DEBERERkchiAiIiIyOQwABEREZHJYQAiIiIik8MARERERCaHAYiIiIhMDgMQERERmZz/Bzz8ZzapJjKbAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import os\n", + "import tensorflow as tf\n", + "event_files = [f for f in os.listdir(log_dir) if f.startswith(\"events\")]\n", + "\n", + "# Read scalar data from event files\n", + "train_losses = []\n", + "train_acc = []\n", + "for event_file in event_files:\n", + " for e in tf.compat.v1.train.summary_iterator(os.path.join(log_dir, event_file)):\n", + " for v in e.summary.value:\n", + " if v.tag == 'Loss/train': # NB: Adjust if your tag is different\n", + " train_losses.append(v.simple_value)\n", + " elif v.tag == 'Accuracy/train': # NB: Adjust if your tag is different\n", + " train_acc.append(v.simple_value)\n", + "\n", + "# Plot the extracted values\n", + "plt.plot(train_losses, label='Train Loss')\n", + "plt.xlabel('Epochs')\n", + "plt.ylabel('Loss')\n", + "plt.legend()\n", + "plt.show()\n", + "\n", + "plt.plot(train_acc, label='Train Accuracy')\n", + "plt.xlabel('Epochs')\n", + "plt.ylabel('Accuracy')\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "e33821ec-7b5a-4b04-a5f6-6a9b9fe3b3f7", + "metadata": { + "jp-MarkdownHeadingCollapsed": true, + "tags": [] + }, + "source": [ + "### **TensorBoard**\n", + "\n", + "TensorBoard allows you to monitor model training in real time.\n", + "\n", + "### **What is TensorBoard?** \n", + "TensorBoard is a **visualization tool** that comes with TensorFlow. It helps **monitor, debug, and optimize** machine learning models by providing interactive visualizations for: \n", + "\n", + "- **Training progress** (loss and accuracy curves) \n", + "- **Model architecture** (graph visualization) \n", + "- **Weight distributions** (to analyze parameter updates) \n", + "- **Performance metrics** (scalars, histograms, images, etc.) \n", + "- **Hyperparameter tuning** (using HParams) \n", + "\n", + "---\n", + "### **Why Use TensorBoard?**\n", + "1. **Track Model Training Progress** \n", + " - View loss and accuracy curves in real-time to detect overfitting or underfitting. \n", + "\n", + "2. **Visualize the Computation Graph** \n", + " - Understand the model structure and debug layer connections. \n", + "\n", + "3. **Analyze Weights and Biases** \n", + " - Track how model parameters evolve during training. \n", + "\n", + "4. **Compare Multiple Runs** \n", + " - Evaluate different hyperparameters and optimizers side by side. \n", + "\n", + "5. **Monitor Data Inputs and Outputs** \n", + " - Check how input data is transformed at different layers. \n", + "\n", + "---\n", + "\n", + "### **TensorBoard Features**\n", + "| Feature | What It Does |\n", + "|---------|-------------|\n", + "| **Scalars** | Tracks metrics like loss & accuracy over time. |\n", + "| **Graphs** | Displays the model’s computational graph. |\n", + "| **Histograms** | Shows weight and bias distributions. |\n", + "| **Images** | Visualizes input images during training. |\n", + "| **HParams** | Helps tune hyperparameters like learning rate. |\n", + "\n", + "---\n", + "\n", + "### **Example TensorBoard Workflow**\n", + "If you are training a CNN on Fashion-MNIST, TensorBoard can help: \n", + "- Monitor accuracy and loss curves. \n", + "- Check if weights are updating properly. \n", + "- Compare multiple optimizers (SGD, Adam, etc.). \n", + "\n", + "\n", + "##### **Note: On Borah, you may not be able to use tensorboard if you do not have GPU access. One possible solution is to install `tensorflow-cpu` instead. It is the CPU-only version of TensorFlor. If you do have GPU access, make sure CUDA is available or properly loaded.**\n", + "\n", + "\n", + "### **Visualizing with TensorBoard: Run TensorBoard in Jupyter Notebook**\n", + "\n", + "If you prefer running it inside Jupyter Notebook, you can use:\n", + "\n", + "```ruby\n", + "%load_ext tensorboard\n", + "%tensorboard --logdir=runs\n", + "```\n", + "\n", + "But this is not always reliable on remote clusters. Note that if your Jupyter Notebook is not in the folder containing `runs/`, you need to specify the correct path. For example, if `runs/` is inside `/home/user/project/`, but your notebook is in `/home/user/notebooks/`, then modify the command as follows:\n", + "\n", + "```ruby\n", + "%load_ext tensorboard\n", + "%tensorboard --logdir=/home/user/project/runs\n", + "```\n", + "\n", + "You can also move your notebook to the project/ folder to avoid path issues.\n", + "\n", + "\n", + "### **Visualizing with TensorBoard: Run TensorBoard in Terminal**\n", + "Start TensorBoard by running the following command in your terminal:\n", + "\n", + "```ruby\n", + "tensorboard --logdir=runs\n", + "```\n", + "\n", + "Then open your browser at http://localhost:6006/.\n", + "\n", + "\n", + "### Key Features of this Tutorial:\n", + "- Uses PyTorch's DataLoader for handling large datasets efficiently\n", + "- Implements a Convolutional Neural Network (CNN) for image classification\n", + "- Utilizes Dropout (0.5) to prevent overfitting\n", + "- Includes TensorBoard for logging training loss and accuracy\n", + "- Runs on GPU if available" + ] + }, + { + "cell_type": "markdown", + "id": "c2f8fa3e-b903-4d8b-9365-734da64bd573", + "metadata": {}, + "source": [ + "## The End." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "ml_tutorial", + "language": "python", + "name": "ml_tutorial" + }, + "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.9.15" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/template/ml_tutorials/tensorboard.ipynb b/template/ml_tutorials/tensorboard.ipynb new file mode 100644 index 0000000..6a5a3d3 --- /dev/null +++ b/template/ml_tutorials/tensorboard.ipynb @@ -0,0 +1,60 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "29f42078-1557-4b3d-a97d-f2a91d557996", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "ERROR: Could not find `tensorboard`. Please ensure that your PATH\n", + "contains an executable `tensorboard` program, or explicitly specify\n", + "the path to a TensorBoard binary by setting the `TENSORBOARD_BINARY`\n", + "environment variable." + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%load_ext tensorboard\n", + "%tensorboard --logdir=\"~/runs\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "95d24083-aa39-417f-ac8e-f5253d1b92d4", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext tensorboard\n", + "%tensorboard --logdir=" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "ml_tutorial", + "language": "python", + "name": "ml_tutorial" + }, + "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.9.15" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/template/ml_tutorials/tensorflow_tutorial.ipynb b/template/ml_tutorials/tensorflow_tutorial.ipynb new file mode 100644 index 0000000..b4369a8 --- /dev/null +++ b/template/ml_tutorials/tensorflow_tutorial.ipynb @@ -0,0 +1,1350 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "0a14f733-6ecd-426c-9a31-a535e7f11f9d", + "metadata": {}, + "source": [ + "# **Machine Learning Tutorial - TensorFlow**\n", + "\n", + "This Jupyter Notebook files is a simple tutorial for Python users on the BSU Borah cluster. We will focus on TensorFlow in this tutorial.\n", + "\n", + "## **Scenario 1: Starting a new project.**\n", + "\n", + "If you are starting a new project, it is better to create a new Python environment and install all the packages needed in it. Follow the steps in the link below to create a new Python environment on Borah.\n", + "\n", + "[Click here](https://bsu-docs.readthedocs.io/en/latest/software/conda/)\n", + " \n", + "For simplicity I will show the steps here, assuming that you will not need to use GPUs and already have conda/mamba installed. Ideally, if you know all the packages you will be using in your project, then it is better to install all of them at the point of creating your Python environment. This helps to prevent conflicts between package versions and dependencies. Here, we will create a new Python environment calle `ml_tutorial` that has some of the most popular and widely used Machine Learning (ML) Python packages installed in it. In this environment we need the following packages:\n", + "- pandas\n", + "- numpy\n", + "- matplotlib\n", + "- ipykernel\n", + "- pytorch (Note: Torch (built on Lua, a scripting language) and and PyTorch (built on Python) differ in origin. Also, the community and support for torch is diminishing, so it recommended to install PyTorch instead of torch. However, in Python, torch is the main package name for PyTorch. When you install PyTorch, you import it using `import torch`, not `import pytorch`.\n", + "- torchvision\n", + "- tensorflow\n", + "- tensorflow-gpu (for those who have need for GPUs)\n", + "- tensorboard\n", + "- scikit-learn\n", + "\n", + "Notice, how there are no white spaces in my environment name. This is very important. You can change the environment.\n", + "\n", + "Also note, per the new tensorflow update, once you install tensorflow you don't necessary have to install tensorbaord separately. However, for the purpose of this tutorial, I will just go ahead to install the two of them separately.\n", + " \n", + "Run the following commands:\n", + "\n", + "### **Step 1: Create a Python environment**\n", + "\n", + "``` ruby\n", + "mamba create -n ml_tutorial -c conda-forge matplotlib numpy pandas ipykernel pytorch torchvision tensorflow tensorflow-gpu tensorboard scikit-learn\n", + "```\n", + "\n", + "By extension, if you have up to `n` packages, then the code will be:\n", + "\n", + "```ruby\n", + "mamba create -n climate -c conda-forge package1 package2 package3 ... packagen\n", + "```\n", + "\n", + "### **Step 2: Add your environment to Borah `OnDemand`**\n", + "\n", + "``` ruby\n", + "python -m ipykernel install --user --name ml_tutorial --display-name \"ml_tutorial\"\n", + "```\n", + "\n", + "## **Scenario 2: Installing in an already existing Python environment**\n", + "If you already have and existing Python environment for your project, but wants to install additional Python libraries for your ML applications, then just simply skip creating a new Python environment. Just be aware that sometimes, you might have conflicts with some package versions and dependencies, this is normal and can be fixed. Though, sometimes the conflicts are not so easily fixed.\n", + "\n", + "```ruby\n", + "mamba install -c conda-forge package1 package2 package3 ... packagen\n", + "```\n", + "\n", + "Thus, by extension, if we only want to install the ML libraries in our existing Python environment, we will use the following command.\n", + "\n", + "```ruby\n", + "mamba install -c conda-forge pytorch torchvision tensorflow tensorflow-gpu tensorboard scikit-learn\n", + "```\n", + "\n", + "Great!!! \n", + "Now the rest of this notebook demonstrates how to do a simple analysis using TensorFlow.\n", + "\n", + "## **ML Tutorial**\n", + "Here we will rely on some in-built datasets in Python to build very simple ML models. Note that the idea here is to demonstrate simply how to install and use this libraries on Borah. We don't care so much about the model's accuracy or performance.\n", + "\n", + "### **The MNIST Problem: Handwritten Digit Classification** \n", + "\n", + "### **Overview** \n", + "The **MNIST (Modified National Institute of Standards and Technology) dataset** is a classic **machine learning problem** where the goal is to classify **handwritten digits (0-9)**. The dataset consists of **70,000 grayscale images** of digits, each **28×28 pixels** in size. \n", + "\n", + "#### **Why is MNIST Important?** \n", + "- It serves as the **\"Hello World\"** of deep learning and computer vision.\n", + "- It helps in testing **image classification algorithms**.\n", + "- It is small and easy to use but still challenging enough to evaluate different models.\n", + "\n", + "---\n", + "\n", + "### **Problem Definition**\n", + "The task is to train a **machine learning model** that can **automatically recognize handwritten digits** from images.\n", + "\n", + "1. **Input:** A **grayscale image (28×28 pixels)** of a handwritten digit.\n", + "2. **Output:** A **single label (0-9)** representing the digit in the image.\n", + "3. **Model Type:** This is a **supervised classification** problem.\n", + "\n", + "---\n", + "\n", + "### **Dataset Breakdown**\n", + "- **Training Set:** 60,000 images.\n", + "- **Test Set:** 10,000 images.\n", + "- **Classes:** 10 (digits 0-9).\n", + "- **Image Properties:**\n", + " - 28×28 pixels.\n", + " - Each pixel has a value between **0 (black) and 255 (white)**.\n", + " - No color channels (grayscale).\n", + " - Images vary in style due to different handwriting.\n", + "\n", + "---\n", + "\n", + "### **Challenges of the MNIST Problem**\n", + "1. **Variability in Handwriting:** Different people write digits differently.\n", + "2. **Noise in Data:** Some images might be blurry or poorly written.\n", + "3. **Generalization:** The model should work on unseen handwritten digits.\n", + "\n", + "---\n", + "\n", + "### **Approaches to Solve MNIST**\n", + "There are several ways to tackle the problem:\n", + "\n", + "| Approach | Method |\n", + "|----------|--------|\n", + "| **Basic Approach** | Logistic Regression, k-Nearest Neighbors (KNN) |\n", + "| **Deep Learning Approach** | Fully Connected Neural Networks (FCNN) |\n", + "| **Advanced Approach** | Convolutional Neural Networks (CNNs) |\n", + "\n", + "---\n", + "\n", + "### **Applications of MNIST Classification**\n", + "- Optical Character Recognition (**OCR**) in postal services.\n", + "- Digit recognition for **bank check processing**.\n", + "- Handwriting analysis in **touchscreen devices**.\n", + "\n", + "### **Tutorial 1: TensorFlow Machine Learning Tutorial**\n", + "**Objective: Train an ML model using TensorFlow to classify images in the MNIST dataset (handwritten digits from 0 to 9).**\n", + "\n", + "### **Step 1: Import Required Libraries**" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "363c90d7-6c4d-4710-9a2a-e65670b0fc3d", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import tensorflow as tf\n", + "from tensorflow import keras\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "id": "f3928958-9003-416d-8d00-e6632ee62201", + "metadata": {}, + "source": [ + "### **Step 2: Load the MNIST Dataset**\n", + "The MNIST handwritten digits recognition problem is very popular in the ML world. The MNIST dataset consists of 28×28 grayscale images of handwritten digits (0-9). Due to its wide usage, the dataset is available in Python, so there is not need to download it from an external source." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "0f7e7144-b774-4cb0-b1a0-38da3bff00b2", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training data shape: (60000, 28, 28), Labels shape: (60000,)\n", + "Test data shape: (10000, 28, 28), Labels shape: (10000,)\n" + ] + } + ], + "source": [ + "# Load dataset\n", + "mnist = keras.datasets.mnist\n", + "(x_train, y_train), (x_test, y_test) = mnist.load_data()\n", + "\n", + "# Normalize data (scale pixel values between 0 and 1)\n", + "x_train, x_test = x_train / 255.0, x_test / 255.0\n", + "\n", + "# Check dataset shape\n", + "print(f\"Training data shape: {x_train.shape}, Labels shape: {y_train.shape}\")\n", + "print(f\"Test data shape: {x_test.shape}, Labels shape: {y_test.shape}\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "658d4a9d-aa9c-49ca-bac4-9bf673eaa658", + "metadata": {}, + "source": [ + "### **Step 3: Build a Neural Network Model**\n", + "We will create a simple feedforward neural network with one hidden layer." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "45a41557-9991-4629-b49f-2e77e11a3300", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"sequential\"\n", + "_________________________________________________________________\n", + "Layer (type) Output Shape Param # \n", + "=================================================================\n", + "flatten (Flatten) (None, 784) 0 \n", + "_________________________________________________________________\n", + "dense (Dense) (None, 128) 100480 \n", + "_________________________________________________________________\n", + "dropout (Dropout) (None, 128) 0 \n", + "_________________________________________________________________\n", + "dense_1 (Dense) (None, 10) 1290 \n", + "=================================================================\n", + "Total params: 101,770\n", + "Trainable params: 101,770\n", + "Non-trainable params: 0\n", + "_________________________________________________________________\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-02-11 12:21:40.097909: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcuda.so.1'; dlerror: libcuda.so.1: cannot open shared object file: No such file or directory; LD_LIBRARY_PATH: /cm/shared/apps/slurm/current/lib64/slurm:/cm/shared/apps/slurm/current/lib64:/cm/shared/apps/jupyterhub/lib:/bsuhome/tnde/.conda/envs/mass_cal/lib/\n", + "2025-02-11 12:21:40.097943: W tensorflow/stream_executor/cuda/cuda_driver.cc:269] failed call to cuInit: UNKNOWN ERROR (303)\n", + "2025-02-11 12:21:40.097965: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:156] kernel driver does not appear to be running on this host (cpu139): /proc/driver/nvidia/version does not exist\n", + "2025-02-11 12:21:40.098238: I tensorflow/core/platform/cpu_feature_guard.cc:142] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations: SSE4.1 SSE4.2 AVX AVX2 AVX512F FMA\n", + "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n" + ] + } + ], + "source": [ + "model = keras.Sequential([\n", + " keras.layers.Flatten(input_shape=(28, 28)), # Flatten 28x28 images into 1D array\n", + " keras.layers.Dense(128, activation='relu'), # Fully connected layer with 128 neurons\n", + " keras.layers.Dropout(0.2), # Dropout to reduce overfitting\n", + " keras.layers.Dense(10, activation='softmax') # Output layer with 10 classes (digits 0-9)\n", + "])\n", + "\n", + "# Compile model\n", + "model.compile(optimizer='adam',\n", + " loss='sparse_categorical_crossentropy',\n", + " metrics=['accuracy'])\n", + "\n", + "# Model summary\n", + "model.summary()\n" + ] + }, + { + "cell_type": "markdown", + "id": "2a01964d-6ffb-4cd3-9915-69344acc0e22", + "metadata": {}, + "source": [ + "### **Step 4: Train the Model**" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "b08cbe69-e1fd-40aa-a727-31904e1f0701", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-02-11 12:21:43.730625: I tensorflow/compiler/mlir/mlir_graph_optimization_pass.cc:185] None of the MLIR Optimization Passes are enabled (registered 2)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/10\n", + "1875/1875 [==============================] - 2s 1ms/step - loss: 0.2997 - accuracy: 0.9119 - val_loss: 0.1446 - val_accuracy: 0.9569\n", + "Epoch 2/10\n", + "1875/1875 [==============================] - 2s 1ms/step - loss: 0.1439 - accuracy: 0.9575 - val_loss: 0.1019 - val_accuracy: 0.9697\n", + "Epoch 3/10\n", + "1875/1875 [==============================] - 2s 1ms/step - loss: 0.1059 - accuracy: 0.9683 - val_loss: 0.0879 - val_accuracy: 0.9738\n", + "Epoch 4/10\n", + "1875/1875 [==============================] - 2s 1ms/step - loss: 0.0887 - accuracy: 0.9732 - val_loss: 0.0765 - val_accuracy: 0.9775\n", + "Epoch 5/10\n", + "1875/1875 [==============================] - 2s 1ms/step - loss: 0.0737 - accuracy: 0.9773 - val_loss: 0.0722 - val_accuracy: 0.9785\n", + "Epoch 6/10\n", + "1875/1875 [==============================] - 2s 1ms/step - loss: 0.0661 - accuracy: 0.9790 - val_loss: 0.0684 - val_accuracy: 0.9808\n", + "Epoch 7/10\n", + "1875/1875 [==============================] - 2s 1ms/step - loss: 0.0586 - accuracy: 0.9810 - val_loss: 0.0708 - val_accuracy: 0.9789\n", + "Epoch 8/10\n", + "1875/1875 [==============================] - 2s 1ms/step - loss: 0.0536 - accuracy: 0.9829 - val_loss: 0.0731 - val_accuracy: 0.9789\n", + "Epoch 9/10\n", + "1875/1875 [==============================] - 2s 1ms/step - loss: 0.0488 - accuracy: 0.9839 - val_loss: 0.0732 - val_accuracy: 0.9792\n", + "Epoch 10/10\n", + "1875/1875 [==============================] - 2s 1ms/step - loss: 0.0438 - accuracy: 0.9856 - val_loss: 0.0753 - val_accuracy: 0.9783\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.fit(x_train, y_train, epochs=10, validation_data=(x_test, y_test))" + ] + }, + { + "cell_type": "markdown", + "id": "2759a52b-fe97-4bc9-a76d-e6defd0fd1f9", + "metadata": {}, + "source": [ + "### **Step 5: Evaluate the Model**" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "52f577d8-63f3-497e-824b-452d4755e20c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "313/313 [==============================] - 0s 504us/step - loss: 0.0753 - accuracy: 0.9783\n", + "Test accuracy: 0.9783\n" + ] + } + ], + "source": [ + "test_loss, test_acc = model.evaluate(x_test, y_test)\n", + "print(f\"Test accuracy: {test_acc:.4f}\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "74662deb-62f1-4119-accc-282cba0fddc8", + "metadata": {}, + "source": [ + "### **Step 6: Make Predictions**\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "6fc9465f-552b-4193-a8a2-9d07305b9ab3", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "predictions = model.predict(x_test)\n", + "\n", + "# Plot example image and predicted label\n", + "plt.imshow(x_test[0], cmap='gray')\n", + "plt.title(f\"Predicted: {np.argmax(predictions[0])}, Actual: {y_test[0]}\")\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d227b0d9-13b1-426e-bd76-466605fbf0db", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "e2046d4f-5edf-4986-beb8-c3ccfcc4ff36", + "metadata": { + "tags": [] + }, + "source": [ + "## **Tutorial 2: TensorFlow CNN Tutorial - Handwritten Digit Classification**\n", + "**Objective: Train a Convolutional Neural Network (CNN) using TensorFlow to classify handwritten digits in the MNIST dataset.**\n", + "\n", + "### **Step 1: Import Required Libraries**" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "fce2cd34-9821-4984-982d-442287d8fda1", + "metadata": {}, + "outputs": [], + "source": [ + "# import numpy as np\n", + "# import tensorflow as tf\n", + "# from tensorflow import keras\n", + "# import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "id": "f98cb82f-4f67-42b6-9f76-e39371834a70", + "metadata": {}, + "source": [ + "### **Step 2: Load and Preprocess the MNIST Dataset**" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "7b7943c8-a4c6-4ffa-917e-26bdb8549857", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training data shape: (60000, 28, 28, 1), Labels shape: (60000,)\n", + "Test data shape: (10000, 28, 28, 1), Labels shape: (10000,)\n" + ] + } + ], + "source": [ + "# Load dataset\n", + "mnist = keras.datasets.mnist\n", + "(x_train, y_train), (x_test, y_test) = mnist.load_data()\n", + "\n", + "# Reshape data to include a channel dimension (for CNNs)\n", + "x_train = x_train.reshape(-1, 28, 28, 1).astype(\"float32\") / 255.0\n", + "x_test = x_test.reshape(-1, 28, 28, 1).astype(\"float32\") / 255.0\n", + "\n", + "# Print dataset shape\n", + "print(f\"Training data shape: {x_train.shape}, Labels shape: {y_train.shape}\")\n", + "print(f\"Test data shape: {x_test.shape}, Labels shape: {y_test.shape}\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "e9ac1566-2bbe-4452-b491-219f4ea558ae", + "metadata": { + "tags": [] + }, + "source": [ + "### **Step 3: Define the CNN Architecture**\n", + "Instead of a simple Dense Neural Network, we will use:\n", + "\n", + "- Convolutional layers to extract features.\n", + "- MaxPooling layers to reduce dimensions.\n", + "- Dropout layers to prevent overfitting." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "4c292179-2693-4c7a-9266-6fea2e9ffc54", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"sequential_1\"\n", + "_________________________________________________________________\n", + "Layer (type) Output Shape Param # \n", + "=================================================================\n", + "conv2d (Conv2D) (None, 26, 26, 32) 320 \n", + "_________________________________________________________________\n", + "max_pooling2d (MaxPooling2D) (None, 13, 13, 32) 0 \n", + "_________________________________________________________________\n", + "conv2d_1 (Conv2D) (None, 11, 11, 64) 18496 \n", + "_________________________________________________________________\n", + "max_pooling2d_1 (MaxPooling2 (None, 5, 5, 64) 0 \n", + "_________________________________________________________________\n", + "flatten_1 (Flatten) (None, 1600) 0 \n", + "_________________________________________________________________\n", + "dense_2 (Dense) (None, 128) 204928 \n", + "_________________________________________________________________\n", + "dropout_1 (Dropout) (None, 128) 0 \n", + "_________________________________________________________________\n", + "dense_3 (Dense) (None, 10) 1290 \n", + "=================================================================\n", + "Total params: 225,034\n", + "Trainable params: 225,034\n", + "Non-trainable params: 0\n", + "_________________________________________________________________\n" + ] + } + ], + "source": [ + "model = keras.Sequential([\n", + " # First Convolutional Layer\n", + " keras.layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),\n", + " keras.layers.MaxPooling2D(pool_size=(2, 2)),\n", + "\n", + " # Second Convolutional Layer\n", + " keras.layers.Conv2D(64, (3, 3), activation='relu'),\n", + " keras.layers.MaxPooling2D(pool_size=(2, 2)),\n", + "\n", + " # Flatten the output\n", + " keras.layers.Flatten(),\n", + " \n", + " # Fully Connected Layer\n", + " keras.layers.Dense(128, activation='relu'),\n", + " keras.layers.Dropout(0.5),\n", + "\n", + " # Output Layer with 10 neurons (for digits 0-9)\n", + " keras.layers.Dense(10, activation='softmax')\n", + "])\n", + "\n", + "# Compile the model\n", + "model.compile(optimizer='adam',\n", + " loss='sparse_categorical_crossentropy',\n", + " metrics=['accuracy'])\n", + "\n", + "# Model summary\n", + "model.summary()\n" + ] + }, + { + "cell_type": "markdown", + "id": "217e3a83-0018-4447-9919-7bb6de5ac292", + "metadata": {}, + "source": [ + "### **Step 4: Train the CNN Model**" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "84159592-8c67-4ebe-98e9-3433e18666de", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/10\n", + "938/938 [==============================] - 5s 5ms/step - loss: 0.2331 - accuracy: 0.9299 - val_loss: 0.0530 - val_accuracy: 0.9834\n", + "Epoch 2/10\n", + "938/938 [==============================] - 5s 5ms/step - loss: 0.0819 - accuracy: 0.9763 - val_loss: 0.0339 - val_accuracy: 0.9893\n", + "Epoch 3/10\n", + "938/938 [==============================] - 5s 5ms/step - loss: 0.0597 - accuracy: 0.9823 - val_loss: 0.0301 - val_accuracy: 0.9892\n", + "Epoch 4/10\n", + "938/938 [==============================] - 5s 5ms/step - loss: 0.0478 - accuracy: 0.9852 - val_loss: 0.0306 - val_accuracy: 0.9902\n", + "Epoch 5/10\n", + "938/938 [==============================] - 5s 5ms/step - loss: 0.0410 - accuracy: 0.9876 - val_loss: 0.0281 - val_accuracy: 0.9904\n", + "Epoch 6/10\n", + "938/938 [==============================] - 5s 5ms/step - loss: 0.0341 - accuracy: 0.9898 - val_loss: 0.0249 - val_accuracy: 0.9914\n", + "Epoch 7/10\n", + "938/938 [==============================] - 5s 5ms/step - loss: 0.0310 - accuracy: 0.9904 - val_loss: 0.0236 - val_accuracy: 0.9929\n", + "Epoch 8/10\n", + "938/938 [==============================] - 5s 5ms/step - loss: 0.0271 - accuracy: 0.9911 - val_loss: 0.0234 - val_accuracy: 0.9926\n", + "Epoch 9/10\n", + "938/938 [==============================] - 5s 5ms/step - loss: 0.0236 - accuracy: 0.9927 - val_loss: 0.0217 - val_accuracy: 0.9936\n", + "Epoch 10/10\n", + "938/938 [==============================] - 5s 5ms/step - loss: 0.0198 - accuracy: 0.9937 - val_loss: 0.0236 - val_accuracy: 0.9922\n" + ] + } + ], + "source": [ + "history = model.fit(x_train, y_train, epochs=10, validation_data=(x_test, y_test), batch_size=64)" + ] + }, + { + "cell_type": "markdown", + "id": "b38eab64-6927-4a01-acec-32381a203f69", + "metadata": {}, + "source": [ + "### **Step 5: Evaluate the Model**" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "5fa415ed-cdf9-4cdc-a941-7a6c3535b1d5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "313/313 [==============================] - 0s 1ms/step - loss: 0.0236 - accuracy: 0.9922\n", + "Test Accuracy: 0.9922\n" + ] + } + ], + "source": [ + "test_loss, test_acc = model.evaluate(x_test, y_test)\n", + "print(f\"Test Accuracy: {test_acc:.4f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "80940672-a504-43e9-876c-fe5068471c6f", + "metadata": {}, + "source": [ + "### **Step 6: Visualize Training Progress**\n", + "Plot the accuracy and loss curves for both training and validation." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "7a5b52ee-8d16-42bb-89f3-2897e7f63c73", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot Accuracy\n", + "plt.plot(history.history['accuracy'], label='Train Accuracy')\n", + "plt.plot(history.history['val_accuracy'], label='Validation Accuracy')\n", + "plt.xlabel('Epochs')\n", + "plt.ylabel('Accuracy')\n", + "plt.legend()\n", + "plt.show()\n", + "\n", + "# Plot Loss\n", + "plt.plot(history.history['loss'], label='Train Loss')\n", + "plt.plot(history.history['val_loss'], label='Validation Loss')\n", + "plt.xlabel('Epochs')\n", + "plt.ylabel('Loss')\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "ce9a1cb3-7009-4164-aa08-21782800f2f4", + "metadata": {}, + "source": [ + "### **Step 7: Make Predictions**" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "acb9a6ae-d303-4a44-a5c8-37d17008fe72", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaEAAAGxCAYAAADLfglZAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAlkElEQVR4nO3df3QU9b3/8ddCwobEZCs/kk0EY04uSDRKLz8k5oL8sERjSYFIC9peA0quXoGWxuotRY9R7yGUKtf2gHhuG0BqoHhailZSMJUk6AlU5KAgpZQfQUIhIgjZiBAMfO4ffLNfliTAhF0++fF8nDPnuLPznnnvMOaVz8xk1mWMMQIAwIJOthsAAHRchBAAwBpCCABgDSEEALCGEAIAWEMIAQCsIYQAANYQQgAAawghAIA1hBD8li5dKpfL5Z/CwsLUq1cvTZkyRf/85z+vSQ833XSTJk+e7H9dVlYml8ulsrIyR+upqKhQfn6+Tpw4EdT+JGny5Mm66aabWlTb8Hmamx577LGr7m/AgAFyuVx68cUXW7yO4uJi5efnX3UvV2L//v1yuVxaunRpi+onT558yX26adOm4DaMoCKE0MiSJUu0ceNGlZSUKDc3VytWrNCwYcN08uTJa97LgAEDtHHjRg0YMMBRXUVFhZ577rmQhNDVaPg8F08PPfSQJGn8+PFXtf6PPvpIW7dulSQVFha2eD3FxcV67rnnrqqXa+WZZ55pcp/26NFDN9xwgwYPHmy7RVxCmO0G0PqkpqZq0KBBkqSRI0fq7NmzeuGFF7R69Wp9//vfb7Lmq6++UmRkZNB7iYmJUVpaWtDXa0tTn8cYo+9///tKTEzU6NGjr2r9v/nNbyRJ3/72t7VmzRpVVFQoPT39qtbZ2iUnJys5OTlgXnl5uY4ePaqnn35anTt3ttQZrgQjIVxWww/NTz/9VNL50x/XXXedtm/froyMDEVHR+vuu++WJJ05c0b//d//rX79+sntdqtnz56aMmWKPv/884B1fv3113rqqafk9XoVGRmpoUOH6oMPPmi07eZOx/31r39VVlaWunfvroiICCUnJ2vmzJmSpPz8fD355JOSpKSkJP9pmQvXsXLlSt15552KiorSddddp3vuucc/grjQ0qVLdfPNN8vtdislJUXLli1r0T68lNLSUu3bt09TpkxRp04t/1/y9OnTWr58uQYOHKj/+Z//kSQtXry4yWXXrl2ru+++Wx6PR5GRkUpJSVFBQYGk8/++CxculKSA01r79++/5Kkzl8sVcApvz549mjJlivr06aPIyEjdcMMNysrK0vbt21v8Ga9UYWGhXC6XHn744ZBvC1eHEMJl7dmzR5LUs2dP/7wzZ87oO9/5jkaNGqU333xTzz33nM6dO6exY8dq7ty5evDBB7VmzRrNnTtXJSUlGjFihE6dOuWvz83N1YsvvqiHHnpIb775pu6//35lZ2fr+PHjl+1n3bp1GjZsmA4cOKD58+frz3/+s55++ml99tlnkqSpU6dqxowZkqRVq1b5T880nNKbM2eOHnjgAd1yyy1644039Nvf/la1tbUaNmyY/va3v/m3s3TpUk2ZMkUpKSn6wx/+oKefflovvPCC1q9f36inhusS+/fvd7x/CwsL1alTJ02ZMsVx7YVWrVql48eP6+GHH1afPn00dOhQrVy5Ul9++WWj7d133306d+6cXn31Vf3pT3/SD3/4Qx08eFDS+dNbEyZMkKSA01vx8fGO+jl06JC6d++uuXPnau3atVq4cKHCwsI0ZMgQ7dq167L1LpdLI0aMcLRNSaqpqdHvf/973X333UpKSnJcj2vMAP/PkiVLjCSzadMm8/XXX5va2lrz9ttvm549e5ro6GhTXV1tjDEmJyfHSDKLFy8OqF+xYoWRZP7whz8EzN+8ebORZF555RVjjDE7d+40ksyPf/zjgOWKioqMJJOTk+OfV1paaiSZ0tJS/7zk5GSTnJxsTp061exn+cUvfmEkmcrKyoD5Bw4cMGFhYWbGjBkB82tra43X6zXf+973jDHGnD171iQkJJgBAwaYc+fO+Zfbv3+/CQ8PN4mJiQH1Dz/8sOncubPZv39/sz015fjx4yYiIsLcc889juqaMmrUKBMREWGOHz9ujPn//56FhYX+ZWpra01MTIwZOnRowOe62LRp00xTPx4qKyuNJLNkyZJG70kyzz77bLPrrK+vN2fOnDF9+vQJ+Ldvbp2dO3c2o0aNanZ9zVm0aJGRZFasWOG4FtceIyE0kpaWpvDwcEVHR2vMmDHyer3685//rLi4uIDl7r///oDXb7/9tr7xjW8oKytL9fX1/umb3/ymvF6v/3RYaWmpJDW6vvS9731PYWGXvkz5j3/8Q3v37tUjjzyiiIgIx59t3bp1qq+v10MPPRTQY0REhIYPH+7vcdeuXTp06JAefPBBuVwuf31iYmKT11gKCwtVX1+vxMRER/0UFRXp9OnTmjp1quPPcqHKykqVlpYqOztb3/jGNyRJ3/3udxUdHR1wSq6iokI+n0+PP/54wOcKhfr6es2ZM0e33HKLunTporCwMHXp0kW7d+/Wzp07r6j+3XffdbzdwsJCde/e/apv8sC1wY0JaGTZsmVKSUlRWFiY4uLimjwNExkZqZiYmIB5n332mU6cOKEuXbo0ud6jR49Kko4dOyZJ8nq9Ae+HhYWpe/ful+yt4dpSr169ruzDXKThlF1zd0w1XJNprseGeS057daUwsJC9ezZU2PHjr2q9SxevFjGGE2YMCHgjsDvfOc7Kioq0t///nf169fvqvefE3l5eVq4cKH+67/+S8OHD9f111+vTp06aerUqQGnZoNp27Zt+vDDD/WjH/1Ibrc7JNtAcBFCaCQlJcV/d1xzmvotukePHurevbvWrl3bZE10dLQk+YOmurpaN9xwg//9+vp6/w//5jRcl2q4fuFUjx49JEm///3vLzlqubDHizU1ryW2bt2qrVu36oknnlB4eHiL13Pu3Dn/jQLZ2dlNLrN48WLNmzfvqvdfw+izrq4uYH5T/26vv/66HnroIc2ZMydg/tGjR/2jtWBruC39akeWuHYIIQTNmDFj9Lvf/U5nz57VkCFDml2u4WJzUVGRBg4c6J//xhtvqL6+/pLb6Nu3r5KTk7V48WLl5eU1+9tuw/yLf+O+5557FBYWpr179zY6nXihm2++WfHx8VqxYoXy8vL8ofvpp5+qoqJCCQkJl+zzSjT8wHzkkUeuaj3r1q3TwYMHNW3aNP8NBReaPn26li1bpjlz5ig9PV0ej0evvvqqJk2a1OwpuQv3X9euXf3z4+LiFBERoW3btgUs/+abbzZah8vlavTvs2bNGv3zn//Uv/zLvzj+nJdTV1en119/XXfccYdSU1ODvn6EBiGEoJk0aZKKiop033336Uc/+pHuuOMOhYeH6+DBgyotLdXYsWM1fvx4paSk6Ac/+IFefvllhYeH61vf+pY++eQTvfjii41O8TVl4cKFysrKUlpamn784x/rxhtv1IEDB7Ru3ToVFRVJkm677TZJ0i9/+Uvl5OQoPDxcN998s2666SY9//zzmj17tvbt26d7771X119/vT777DN98MEHioqK0nPPPadOnTrphRde0NSpUzV+/Hjl5ubqxIkTys/Pb/IU3SOPPKLXXntNe/fuvaLrQg23U6enpyslJaXZ5VwuV8C1qqYUFhYqLCxMP/vZz5oMx0cffVQ//OEPtWbNGo0dO1YvvfSSpk6dqm9961vKzc1VXFyc9uzZo48//lgLFiwI2H8///nPlZmZqc6dO+v2229Xly5d9IMf/ECLFy9WcnKy+vfvrw8++EDLly9vtN0xY8Zo6dKl6tevn26//XZt2bJFv/jFL674VGBYWJiGDx9+xdeFVq9erS+++IJRUFtj+84ItB4Nd1Nt3rz5ksvl5OSYqKioJt/7+uuvzYsvvmj69+9vIiIizHXXXWf69etnHn30UbN7927/cnV1deaJJ54wsbGxJiIiwqSlpZmNGzeaxMTEy94dZ4wxGzduNJmZmcbj8Ri3222Sk5Mb3W03a9Ysk5CQYDp16tRoHatXrzYjR440MTExxu12m8TERDNhwgTzl7/8JWAdv/nNb0yfPn1Mly5dTN++fc3ixYtNTk5Oo7vjGu4YvPhuvOY03Al48R2GF6qtrTWSzKRJk5pd5vPPPzddunQx48aNa3aZ48ePm65du5qsrCz/vOLiYjN8+HATFRVlIiMjzS233GJ+/vOf+9+vq6szU6dONT179jQulyvgs9XU1JipU6eauLg4ExUVZbKyssz+/fsb3R13/Phx88gjj5jY2FgTGRlphg4dat577z0zfPhwM3z4cP9yzd0dJylgucsZPXq0iYqKMj6f74prYJ/LGGNsBSCA5hUXF2vMmDH6+OOP/SMToL3hFm2glSotLdWkSZMIILRrjIQAANYwEgIAWEMIAQCsIYQAANYQQgAAa1rdH6ueO3dOhw4dUnR0dMgfsAgACD5jjGpra5WQkHDZ78hqdSF06NAh9e7d23YbAICrVFVVddknZLS603END7kEALRtV/LzPGQh9MorrygpKUkREREaOHCg3nvvvSuq4xQcALQPV/LzPCQhtHLlSs2cOVOzZ8/W1q1bNWzYMGVmZurAgQOh2BwAoI0KyRMThgwZogEDBmjRokX+eSkpKRo3bpwKCgouWevz+eTxeILdEgDgGqupqbnsk/GDPhI6c+aMtmzZooyMjID5GRkZqqioaLR8XV2dfD5fwAQA6BiCHkJHjx7V2bNnFRcXFzA/Li6uyW+kLCgokMfj8U/cGQcAHUfIbky4+IKUMabJi1SzZs1STU2Nf6qqqgpVSwCAVibofyfUo0cPde7cudGo58iRI41GR9L5rxFu7iuaAQDtW9BHQl26dNHAgQNVUlISML+kpETp6enB3hwAoA0LyRMT8vLy9O///u8aNGiQ7rzzTv3v//6vDhw4oMceeywUmwMAtFEhCaGJEyfq2LFjev7553X48GGlpqaquLhYiYmJodgcAKCNanXfrMrfCQFA+2Dl74QAALhShBAAwBpCCABgDSEEALCGEAIAWEMIAQCsIYQAANYQQgAAawghAIA1hBAAwBpCCABgDSEEALCGEAIAWEMIAQCsIYQAANYQQgAAawghAIA1hBAAwBpCCABgDSEEALCGEAIAWEMIAQCsIYQAANYQQgAAawghAIA1hBAAwBpCCABgDSEEALCGEAIAWEMIAQCsIYQAANYQQgAAawghAIA1hBAAwBpCCABgDSEEALCGEAIAWEMIAQCsIYQAANYQQgAAawghAIA1hBAAwBpCCABgDSEEALCGEAIAWEMIAQCsIYQAANYQQgAAawghAIA1hBAAwBpCCABgDSEEALCGEAIAWEMIAQCsIYQAANYEPYTy8/PlcrkCJq/XG+zNAADagbBQrPTWW2/VX/7yF//rzp07h2IzAIA2LiQhFBYWxugHAHBZIbkmtHv3biUkJCgpKUmTJk3Svn37ml22rq5OPp8vYAIAdAxBD6EhQ4Zo2bJlWrdunX7961+rurpa6enpOnbsWJPLFxQUyOPx+KfevXsHuyUAQCvlMsaYUG7g5MmTSk5O1lNPPaW8vLxG79fV1amurs7/2ufzEUQA0A7U1NQoJibmksuE5JrQhaKionTbbbdp9+7dTb7vdrvldrtD3QYAoBUK+d8J1dXVaefOnYqPjw/1pgAAbUzQQ+gnP/mJysvLVVlZqb/+9a+aMGGCfD6fcnJygr0pAEAbF/TTcQcPHtQDDzygo0ePqmfPnkpLS9OmTZuUmJgY7E0BANq4kN+Y4JTP55PH47HdBgDgKl3JjQk8Ow4AYA0hBACwhhACAFhDCAEArCGEAADWEEIAAGsIIQCANYQQAMAaQggAYA0hBACwhhACAFhDCAEArAn5l9rh2powYYLjmtzc3BZt69ChQ45rTp8+7bimqKjIcU11dbXjGknas2dPi+oAtAwjIQCANYQQAMAaQggAYA0hBACwhhACAFhDCAEArCGEAADWEEIAAGsIIQCANYQQAMAaQggAYA0hBACwhhACAFjjMsYY201cyOfzyePx2G6jzdq3b5/jmptuuin4jVhWW1vborodO3YEuRME28GDBx3XzJs3r0Xb+vDDD1tUh/NqamoUExNzyWUYCQEArCGEAADWEEIAAGsIIQCANYQQAMAaQggAYA0hBACwhhACAFhDCAEArCGEAADWEEIAAGsIIQCANWG2G0Bw5ebmOq65/fbbW7StnTt3Oq5JSUlxXDNgwADHNSNGjHBcI0lpaWmOa6qqqhzX9O7d23HNtVRfX++45vPPP3dcEx8f77imJQ4cONCiOh5gGnqMhAAA1hBCAABrCCEAgDWEEADAGkIIAGANIQQAsIYQAgBYQwgBAKwhhAAA1hBCAABrCCEAgDWEEADAGh5g2s68++6716SmpdauXXtNtnP99de3qO6b3/ym45otW7Y4rhk8eLDjmmvp9OnTjmv+8Y9/OK5pyUNwu3Xr5rhm7969jmtwbTASAgBYQwgBAKxxHEIbNmxQVlaWEhIS5HK5tHr16oD3jTHKz89XQkKCunbtqhEjRmjHjh3B6hcA0I44DqGTJ0+qf//+WrBgQZPvz5s3T/Pnz9eCBQu0efNmeb1ejR49WrW1tVfdLACgfXF8Y0JmZqYyMzObfM8Yo5dfflmzZ89Wdna2JOm1115TXFycli9frkcfffTqugUAtCtBvSZUWVmp6upqZWRk+Oe53W4NHz5cFRUVTdbU1dXJ5/MFTACAjiGoIVRdXS1JiouLC5gfFxfnf+9iBQUF8ng8/ql3797BbAkA0IqF5O44l8sV8NoY02heg1mzZqmmpsY/VVVVhaIlAEArFNQ/VvV6vZLOj4ji4+P9848cOdJodNTA7XbL7XYHsw0AQBsR1JFQUlKSvF6vSkpK/PPOnDmj8vJypaenB3NTAIB2wPFI6Msvv9SePXv8rysrK/XRRx+pW7duuvHGGzVz5kzNmTNHffr0UZ8+fTRnzhxFRkbqwQcfDGrjAIC2z3EIffjhhxo5cqT/dV5eniQpJydHS5cu1VNPPaVTp07p8ccf1/HjxzVkyBC98847io6ODl7XAIB2wWWMMbabuJDP55PH47HdBgCH7r//fsc1b7zxhuOaTz75xHHNhb84O/HFF1+0qA7n1dTUKCYm5pLL8Ow4AIA1hBAAwBpCCABgDSEEALCGEAIAWEMIAQCsIYQAANYQQgAAawghAIA1hBAAwBpCCABgDSEEALCGEAIAWBPUb1YF0D7ExsY6rnnllVcc13Tq5Pz34Oeff95xDU/Dbr0YCQEArCGEAADWEEIAAGsIIQCANYQQAMAaQggAYA0hBACwhhACAFhDCAEArCGEAADWEEIAAGsIIQCANTzAFEAj06ZNc1zTs2dPxzXHjx93XLNr1y7HNWi9GAkBAKwhhAAA1hBCAABrCCEAgDWEEADAGkIIAGANIQQAsIYQAgBYQwgBAKwhhAAA1hBCAABrCCEAgDU8wBRox/7t3/6tRXU//elPg9xJ08aNG+e45pNPPgl+I7CGkRAAwBpCCABgDSEEALCGEAIAWEMIAQCsIYQAANYQQgAAawghAIA1hBAAwBpCCABgDSEEALCGEAIAWMMDTIF27L777mtRXXh4uOOad99913HNxo0bHdegfWEkBACwhhACAFjjOIQ2bNigrKwsJSQkyOVyafXq1QHvT548WS6XK2BKS0sLVr8AgHbEcQidPHlS/fv314IFC5pd5t5779Xhw4f9U3Fx8VU1CQBonxzfmJCZmanMzMxLLuN2u+X1elvcFACgYwjJNaGysjLFxsaqb9++ys3N1ZEjR5pdtq6uTj6fL2ACAHQMQQ+hzMxMFRUVaf369XrppZe0efNmjRo1SnV1dU0uX1BQII/H45969+4d7JYAAK1U0P9OaOLEif7/Tk1N1aBBg5SYmKg1a9YoOzu70fKzZs1SXl6e/7XP5yOIAKCDCPkfq8bHxysxMVG7d+9u8n232y232x3qNgAArVDI/07o2LFjqqqqUnx8fKg3BQBoYxyPhL788kvt2bPH/7qyslIfffSRunXrpm7duik/P1/333+/4uPjtX//fv3sZz9Tjx49NH78+KA2DgBo+xyH0IcffqiRI0f6Xzdcz8nJydGiRYu0fft2LVu2TCdOnFB8fLxGjhyplStXKjo6OnhdAwDaBZcxxthu4kI+n08ej8d2G0Cr07VrV8c177//fou2deuttzquGTVqlOOaiooKxzVoO2pqahQTE3PJZXh2HADAGkIIAGANIQQAsIYQAgBYQwgBAKwhhAAA1hBCAABrCCEAgDWEEADAGkIIAGANIQQAsIYQAgBYQwgBAKwJ+TerAgiOJ5980nHNv/7rv7ZoW2vXrnVcwxOx0RKMhAAA1hBCAABrCCEAgDWEEADAGkIIAGANIQQAsIYQAgBYQwgBAKwhhAAA1hBCAABrCCEAgDWEEADAGh5gCljw7W9/23HNM88847jG5/M5rpGk559/vkV1gFOMhAAA1hBCAABrCCEAgDWEEADAGkIIAGANIQQAsIYQAgBYQwgBAKwhhAAA1hBCAABrCCEAgDWEEADAGh5gClyl7t27O6751a9+5bimc+fOjmuKi4sd10jSpk2bWlQHOMVICABgDSEEALCGEAIAWEMIAQCsIYQAANYQQgAAawghAIA1hBAAwBpCCABgDSEEALCGEAIAWEMIAQCs4QGmwAVa8pDQtWvXOq5JSkpyXLN3717HNc8884zjGuBaYiQEALCGEAIAWOMohAoKCjR48GBFR0crNjZW48aN065duwKWMcYoPz9fCQkJ6tq1q0aMGKEdO3YEtWkAQPvgKITKy8s1bdo0bdq0SSUlJaqvr1dGRoZOnjzpX2bevHmaP3++FixYoM2bN8vr9Wr06NGqra0NevMAgLbN0Y0JF1+AXbJkiWJjY7VlyxbdddddMsbo5Zdf1uzZs5WdnS1Jeu211xQXF6fly5fr0UcfDV7nAIA276quCdXU1EiSunXrJkmqrKxUdXW1MjIy/Mu43W4NHz5cFRUVTa6jrq5OPp8vYAIAdAwtDiFjjPLy8jR06FClpqZKkqqrqyVJcXFxAcvGxcX537tYQUGBPB6Pf+rdu3dLWwIAtDEtDqHp06dr27ZtWrFiRaP3XC5XwGtjTKN5DWbNmqWamhr/VFVV1dKWAABtTIv+WHXGjBl66623tGHDBvXq1cs/3+v1Sjo/IoqPj/fPP3LkSKPRUQO32y23292SNgAAbZyjkZAxRtOnT9eqVau0fv36Rn/1nZSUJK/Xq5KSEv+8M2fOqLy8XOnp6cHpGADQbjgaCU2bNk3Lly/Xm2++qejoaP91Ho/Ho65du8rlcmnmzJmaM2eO+vTpoz59+mjOnDmKjIzUgw8+GJIPAABouxyF0KJFiyRJI0aMCJi/ZMkSTZ48WZL01FNP6dSpU3r88cd1/PhxDRkyRO+8846io6OD0jAAoP1wGWOM7SYu5PP55PF4bLeBDqpv376Oa/7+97+HoJPGxo4d67jmT3/6Uwg6Aa5MTU2NYmJiLrkMz44DAFhDCAEArCGEAADWEEIAAGsIIQCANYQQAMAaQggAYA0hBACwhhACAFhDCAEArCGEAADWEEIAAGsIIQCANS36ZlWgtUtMTGxR3TvvvBPkTpr25JNPOq55++23Q9AJYBcjIQCANYQQAMAaQggAYA0hBACwhhACAFhDCAEArCGEAADWEEIAAGsIIQCANYQQAMAaQggAYA0hBACwhgeYol36j//4jxbV3XjjjUHupGnl5eWOa4wxIegEsIuREADAGkIIAGANIQQAsIYQAgBYQwgBAKwhhAAA1hBCAABrCCEAgDWEEADAGkIIAGANIQQAsIYQAgBYwwNM0eoNHTrUcc2MGTNC0AmAYGMkBACwhhACAFhDCAEArCGEAADWEEIAAGsIIQCANYQQAMAaQggAYA0hBACwhhACAFhDCAEArCGEAADW8ABTtHrDhg1zXHPdddeFoJOm7d2713HNl19+GYJOgLaHkRAAwBpCCABgjaMQKigo0ODBgxUdHa3Y2FiNGzdOu3btClhm8uTJcrlcAVNaWlpQmwYAtA+OQqi8vFzTpk3Tpk2bVFJSovr6emVkZOjkyZMBy9177706fPiwfyouLg5q0wCA9sHRjQlr164NeL1kyRLFxsZqy5Ytuuuuu/zz3W63vF5vcDoEALRbV3VNqKamRpLUrVu3gPllZWWKjY1V3759lZubqyNHjjS7jrq6Ovl8voAJANAxtDiEjDHKy8vT0KFDlZqa6p+fmZmpoqIirV+/Xi+99JI2b96sUaNGqa6ursn1FBQUyOPx+KfevXu3tCUAQBvT4r8Tmj59urZt26b3338/YP7EiRP9/52amqpBgwYpMTFRa9asUXZ2dqP1zJo1S3l5ef7XPp+PIAKADqJFITRjxgy99dZb2rBhg3r16nXJZePj45WYmKjdu3c3+b7b7Zbb7W5JGwCANs5RCBljNGPGDP3xj39UWVmZkpKSLltz7NgxVVVVKT4+vsVNAgDaJ0fXhKZNm6bXX39dy5cvV3R0tKqrq1VdXa1Tp05JOv8okp/85CfauHGj9u/fr7KyMmVlZalHjx4aP358SD4AAKDtcjQSWrRokSRpxIgRAfOXLFmiyZMnq3Pnztq+fbuWLVumEydOKD4+XiNHjtTKlSsVHR0dtKYBAO2D49Nxl9K1a1etW7fuqhoCAHQcPEUbuMDHH3/suObuu+92XPPFF184rgHaIx5gCgCwhhACAFhDCAEArCGEAADWEEIAAGsIIQCANYQQAMAaQggAYA0hBACwhhACAFhDCAEArCGEAADWuMzlHo19jfl8Pnk8HtttAACuUk1NjWJiYi65DCMhAIA1hBAAwBpCCABgDSEEALCGEAIAWEMIAQCsIYQAANYQQgAAawghAIA1hBAAwBpCCABgTasLoVb2KDsAQAtdyc/zVhdCtbW1tlsAAATBlfw8b3VP0T537pwOHTqk6OhouVyugPd8Pp969+6tqqqqyz6ZtT1jP5zHfjiP/XAe++G81rAfjDGqra1VQkKCOnW69Fgn7Br1dMU6deqkXr16XXKZmJiYDn2QNWA/nMd+OI/9cB774Tzb++FKv5Kn1Z2OAwB0HIQQAMCaNhVCbrdbzz77rNxut+1WrGI/nMd+OI/9cB774by2th9a3Y0JAICOo02NhAAA7QshBACwhhACAFhDCAEArCGEAADWtKkQeuWVV5SUlKSIiAgNHDhQ7733nu2Wrqn8/Hy5XK6Ayev12m4r5DZs2KCsrCwlJCTI5XJp9erVAe8bY5Sfn6+EhAR17dpVI0aM0I4dO+w0G0KX2w+TJ09udHykpaXZaTZECgoKNHjwYEVHRys2Nlbjxo3Trl27ApbpCMfDleyHtnI8tJkQWrlypWbOnKnZs2dr69atGjZsmDIzM3XgwAHbrV1Tt956qw4fPuyftm/fbrulkDt58qT69++vBQsWNPn+vHnzNH/+fC1YsECbN2+W1+vV6NGj293DcC+3HyTp3nvvDTg+iouLr2GHoVdeXq5p06Zp06ZNKikpUX19vTIyMnTy5En/Mh3heLiS/SC1kePBtBF33HGHeeyxxwLm9evXz/z0pz+11NG19+yzz5r+/fvbbsMqSeaPf/yj//W5c+eM1+s1c+fO9c87ffq08Xg85tVXX7XQ4bVx8X4wxpicnBwzduxYK/3YcuTIESPJlJeXG2M67vFw8X4wpu0cD21iJHTmzBlt2bJFGRkZAfMzMjJUUVFhqSs7du/erYSEBCUlJWnSpEnat2+f7ZasqqysVHV1dcCx4Xa7NXz48A53bEhSWVmZYmNj1bdvX+Xm5urIkSO2WwqpmpoaSVK3bt0kddzj4eL90KAtHA9tIoSOHj2qs2fPKi4uLmB+XFycqqurLXV17Q0ZMkTLli3TunXr9Otf/1rV1dVKT0/XsWPHbLdmTcO/f0c/NiQpMzNTRUVFWr9+vV566SVt3rxZo0aNUl1dne3WQsIYo7y8PA0dOlSpqamSOubx0NR+kNrO8dDqvsrhUi7+fiFjTKN57VlmZqb/v2+77TbdeeedSk5O1muvvaa8vDyLndnX0Y8NSZo4caL/v1NTUzVo0CAlJiZqzZo1ys7OtthZaEyfPl3btm3T+++/3+i9jnQ8NLcf2srx0CZGQj169FDnzp0b/SZz5MiRRr/xdCRRUVG67bbbtHv3btutWNNwdyDHRmPx8fFKTExsl8fHjBkz9NZbb6m0tDTg+8c62vHQ3H5oSms9HtpECHXp0kUDBw5USUlJwPySkhKlp6db6sq+uro67dy5U/Hx8bZbsSYpKUlerzfg2Dhz5ozKy8s79LEhSceOHVNVVVW7Oj6MMZo+fbpWrVql9evXKykpKeD9jnI8XG4/NKXVHg8Wb4pw5He/+50JDw83hYWF5m9/+5uZOXOmiYqKMvv377fd2jXzxBNPmLKyMrNv3z6zadMmM2bMGBMdHd3u90Ftba3ZunWr2bp1q5Fk5s+fb7Zu3Wo+/fRTY4wxc+fONR6Px6xatcps377dPPDAAyY+Pt74fD7LnQfXpfZDbW2teeKJJ0xFRYWprKw0paWl5s477zQ33HBDu9oP//mf/2k8Ho8pKyszhw8f9k9fffWVf5mOcDxcbj+0peOhzYSQMcYsXLjQJCYmmi5dupgBAwYE3I7YEUycONHEx8eb8PBwk5CQYLKzs82OHTtstxVypaWlRlKjKScnxxhz/rbcZ5991ni9XuN2u81dd91ltm/fbrfpELjUfvjqq69MRkaG6dmzpwkPDzc33nijycnJMQcOHLDddlA19fklmSVLlviX6QjHw+X2Q1s6Hvg+IQCANW3imhAAoH0ihAAA1hBCAABrCCEAgDWEEADAGkIIAGANIQQAsIYQAgBYQwgBAKwhhAAA1hBCAABr/g/pJY8hW3yw9AAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "predictions = model.predict(x_test)\n", + "\n", + "# Plot example image and predicted label\n", + "plt.imshow(x_test[0].reshape(28, 28), cmap='gray')\n", + "plt.title(f\"Predicted: {np.argmax(predictions[0])}, Actual: {y_test[0]}\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "12f3d007-6fe1-4753-a8a0-3894fc955867", + "metadata": {}, + "source": [ + "The simple feedforward neural network model had an accuracy of 97.84\\%. Meanwhile the accuracy for the current CNN model 99.26\\%. This is expected since the CNN is a more complex model. However, notice that the CNN model took a longer time to train. This is also expected since more complex models require a longer training time. Hence, depending on your specific case, you should find a nice to strike a balance between model accuracy and model complexity (or training time).\n", + "\n", + "### **Next Steps for More Complexity**\n", + "The following steps could help you improve the model's accuracy or performance.\n", + "- Increase CNN Depth - Add more convolutional layers. An overly complex model will lead to overfitting. Be sure to avoid overfitting by striking a balance between model complexity and overfitting. We can apply Monte dropout to avoid overfitting. Also, an overly complex model will require more computing resources to train, else, it might take an unnecessarily way too long time to train.\n", + "- Use Data Augmentation - Improve generalization with ImageDataGenerator.\n", + "- Apply Transfer Learning - Use a pre-trained model like ResNet or VGG16.\n", + "- Train on Custom Datasets - Try it with a dataset like CIFAR-10 or Fashion-MNIST." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7901e217-d3cd-430a-b127-887182f92b8e", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "880f7865-bfc0-45d7-aa76-29c8c478bd79", + "metadata": {}, + "source": [ + "## **Tutorial 3: Advanced TensorFlow Tutorial - CNN for Fashion Image Classification**\n", + "\n", + "Note that the MNIST handwritten digits problem is a relatively simple and widely studied problem. Even with a simle model we can get a better model performance. Now, let’s make this tutorial more complex by incorporating TensorBoard for visualization and data augmentation for better generalization. We will build a Convolutional Neural Network (CNN) to classify images from the Fashion-MNIST dataset, which is more challenging than MNIST.\n", + "\n", + "**Objective: Train a deep CNN on the Fashion-MNIST dataset, use TensorBoard for visualization, and apply data augmentation to improve generalization.**\n", + "\n", + "### **The Fashion-MNIST Problem: Clothing Item Classification** \n", + "\n", + "#### **Overview** \n", + "**Fashion-MNIST** is a machine learning dataset designed as a more challenging replacement for the original **MNIST handwritten digit dataset**. The goal is to classify images of **clothing items** into one of **10 categories** using machine learning or deep learning models.\n", + "\n", + "#### **Why Fashion-MNIST?** \n", + "- **More challenging** than MNIST because clothing items have more complex patterns. \n", + "- **Same format as MNIST**, making it easy to experiment with advanced models like CNNs. \n", + "- **Real-world relevance** in applications like **retail, e-commerce, and fashion industry AI**.\n", + "\n", + "---\n", + "\n", + "### **Problem Definition**\n", + "The task is to build a **supervised classification model** that can recognize different types of clothing items from grayscale images.\n", + "\n", + "1. **Input:** A **28×28 grayscale image** of a clothing item. \n", + "2. **Output:** A **single label (0-9)** corresponding to the clothing category. \n", + "3. **Model Type:** **Supervised classification problem**.\n", + "\n", + "---\n", + "\n", + "### **Dataset Breakdown**\n", + "- **Training Set:** 60,000 images. \n", + "- **Test Set:** 10,000 images. \n", + "- **Classes (10 Categories):** \n", + " | Label | Class Name | Example |\n", + " |--------|------------|---------|\n", + " | 0 | T-shirt/top | 👕 |\n", + " | 1 | Trouser | 👖 |\n", + " | 2 | Pullover | 🧥 |\n", + " | 3 | Dress | 👗 |\n", + " | 4 | Coat | 🧥 |\n", + " | 5 | Sandal | 🩴 |\n", + " | 6 | Shirt | 👚 |\n", + " | 7 | Sneaker | 👟 |\n", + " | 8 | Bag | 👜 |\n", + " | 9 | Ankle boot | 👢 |\n", + "\n", + "---\n", + "\n", + "### **Challenges of the Fashion-MNIST Problem**\n", + "1. **More Visual Complexity** – Unlike MNIST, fashion images have textures and patterns. \n", + "2. **Class Similarity** – Some items (e.g., shirts and coats) look similar, making classification harder. \n", + "3. **Generalization** – The model must recognize items despite variations in style and texture.\n", + "\n", + "---\n", + "\n", + "### **Approaches to Solve Fashion-MNIST**\n", + "| Approach | Method |\n", + "|----------|--------|\n", + "| **Basic Approach** | Logistic Regression, k-Nearest Neighbors (KNN) |\n", + "| **Deep Learning Approach** | Fully Connected Neural Networks (FCNN) |\n", + "| **Advanced Approach** | Convolutional Neural Networks (CNNs) |\n", + "| **State-of-the-Art** | Transfer Learning (using ResNet, EfficientNet, etc.) |\n", + "\n", + "---\n", + "\n", + "### **Applications of Fashion-MNIST Classification**\n", + "- **E-commerce AI** – Automatically tag and sort clothing items. \n", + "- **Retail Analytics** – Identify fashion trends using image recognition. \n", + "- **Virtual Try-On Systems** – Power fashion recommendation systems. \n", + "\n", + "\n", + "### **Step 1: Import Required Libraries**" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "750738e3-b544-43b5-aab2-17ff26282773", + "metadata": {}, + "outputs": [], + "source": [ + "import datetime # For TensorBoard logs\n", + "# import numpy as np\n", + "# import tensorflow as tf\n", + "# from tensorflow import keras\n", + "# import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "id": "17f37a80-dc17-4937-a67b-c65874880693", + "metadata": {}, + "source": [ + "### **Step 2: Load and Preprocess the Fashion-MNIST Dataset**\n", + "Fashion-MNIST consists of 70,000 grayscale images (28×28 pixels) in 10 classes, such as shoes, bags, and shirts." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "70669df2-8079-44df-9393-91fca72cf1d3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training data shape: (60000, 28, 28, 1), Labels shape: (60000,)\n", + "Test data shape: (10000, 28, 28, 1), Labels shape: (10000,)\n" + ] + } + ], + "source": [ + "# Load dataset\n", + "fashion_mnist = keras.datasets.fashion_mnist\n", + "(x_train, y_train), (x_test, y_test) = fashion_mnist.load_data()\n", + "\n", + "# Normalize the data (scale pixel values between 0 and 1)\n", + "x_train, x_test = x_train / 255.0, x_test / 255.0\n", + "\n", + "# Reshape to include a single channel (needed for CNNs)\n", + "x_train = x_train.reshape(-1, 28, 28, 1).astype(\"float32\")\n", + "x_test = x_test.reshape(-1, 28, 28, 1).astype(\"float32\")\n", + "\n", + "# Print dataset shape\n", + "print(f\"Training data shape: {x_train.shape}, Labels shape: {y_train.shape}\")\n", + "print(f\"Test data shape: {x_test.shape}, Labels shape: {y_test.shape}\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "ff4e6bfb-e0f3-4762-9e5a-58c1b11f1291", + "metadata": { + "tags": [] + }, + "source": [ + "### **Step 3: Set Up TensorBoard for Visualization**\n", + "TensorBoard allows you to monitor model training in real time.\n", + "\n", + "### **What is TensorBoard?** \n", + "TensorBoard is a **visualization tool** that comes with TensorFlow. It helps **monitor, debug, and optimize** machine learning models by providing interactive visualizations for: \n", + "\n", + "- **Training progress** (loss and accuracy curves) \n", + "- **Model architecture** (graph visualization) \n", + "- **Weight distributions** (to analyze parameter updates) \n", + "- **Performance metrics** (scalars, histograms, images, etc.) \n", + "- **Hyperparameter tuning** (using HParams) \n", + "\n", + "---\n", + "### **Why Use TensorBoard?**\n", + "1. **Track Model Training Progress** \n", + " - View loss and accuracy curves in real-time to detect overfitting or underfitting. \n", + "\n", + "2. **Visualize the Computation Graph** \n", + " - Understand the model structure and debug layer connections. \n", + "\n", + "3. **Analyze Weights and Biases** \n", + " - Track how model parameters evolve during training. \n", + "\n", + "4. **Compare Multiple Runs** \n", + " - Evaluate different hyperparameters and optimizers side by side. \n", + "\n", + "5. **Monitor Data Inputs and Outputs** \n", + " - Check how input data is transformed at different layers. \n", + "\n", + "---\n", + "\n", + "### **TensorBoard Features**\n", + "| Feature | What It Does |\n", + "|---------|-------------|\n", + "| **Scalars** | Tracks metrics like loss & accuracy over time. |\n", + "| **Graphs** | Displays the model’s computational graph. |\n", + "| **Histograms** | Shows weight and bias distributions. |\n", + "| **Images** | Visualizes input images during training. |\n", + "| **HParams** | Helps tune hyperparameters like learning rate. |\n", + "\n", + "---\n", + "\n", + "### **Example TensorBoard Workflow**\n", + "If you are training a CNN on Fashion-MNIST, TensorBoard can help: \n", + "- Monitor accuracy and loss curves. \n", + "- Check if weights are updating properly. \n", + "- Compare multiple optimizers (SGD, Adam, etc.). \n", + "\n", + "\n", + "##### **On Borah, you may not be able to use tensorboard if you do not have GPU access. One possible solution is to install `tensorflow-cpu` instead. It is the CPU-only version of TensorFlor. If you do have GPU access, make sure CUDA is properly loaded.**" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "32d2116f-ab2b-4fab-a8ce-28b5d3403699", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-02-11 12:22:52.739166: I tensorflow/core/profiler/lib/profiler_session.cc:131] Profiler session initializing.\n", + "2025-02-11 12:22:52.739198: I tensorflow/core/profiler/lib/profiler_session.cc:146] Profiler session started.\n", + "2025-02-11 12:22:52.739452: I tensorflow/core/profiler/lib/profiler_session.cc:164] Profiler session tear down.\n" + ] + } + ], + "source": [ + "# Define TensorBoard log directory\n", + "log_dir = \"/bsuhome/tnde/scratch/tensorboard/logs/fit/\" + datetime.datetime.now().strftime(\"%Y%m%d-%H%M%S\")\n", + "tensorboard_callback = keras.callbacks.TensorBoard(log_dir=log_dir, histogram_freq=1)" + ] + }, + { + "cell_type": "markdown", + "id": "880e0077-c2fb-41bb-a243-f58a22f37f87", + "metadata": {}, + "source": [ + "### **Step 4: Create a Data Augmentation Pipeline**" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "efd672d7-b2f7-4435-9ef1-5ddc1ff084df", + "metadata": {}, + "outputs": [], + "source": [ + "# Create a data augmentation layer\n", + "data_augmentation = keras.Sequential([\n", + " keras.layers.RandomFlip(\"horizontal\"),\n", + " keras.layers.RandomRotation(0.1),\n", + " keras.layers.RandomZoom(0.1),\n", + "])\n" + ] + }, + { + "cell_type": "markdown", + "id": "e0a22fa7-bdf1-4c41-8d1c-8906774d26b2", + "metadata": {}, + "source": [ + "### **Step 5: Define the CNN Architecture**\n", + "This CNN has:\n", + "\n", + "- Data augmentation (for better generalization).\n", + "- Batch normalization (for stable training).\n", + "- Dropout layers (to prevent overfitting). **Dropout** is a **regularization technique**.\n", + "\n", + "Note: If you set dropout rate at 0.5, for instance, then the following will happen to the your model: \n", + "\n", + "1. **During training**, the model randomly \"drops\" (sets to zero) **50% of the neurons** in the specified layer **at each iteration**. \n", + "2. This forces the network to **learn multiple independent representations**, making it **more robust** and **less reliant on specific neurons**. \n", + "3. **During inference (testing/prediction), dropout is turned off**, and all neurons contribute to the final prediction. However, their outputs are **scaled down** to match the expected magnitude. \n", + "\n", + "---\n", + "\n", + "### **Why Use Dropout?**\n", + "- **Reduces Overfitting** – Prevents the model from relying too much on specific neurons. \n", + "- **Encourages Generalization** – Forces different parts of the network to learn useful patterns. \n", + "- **Acts Like an Ensemble Method** – By training on different \"sub-networks,\" it mimics the effect of training multiple models. \n", + "\n", + "---\n", + "\n", + "### **Choosing the Dropout Rate**\n", + "- **0.1 - 0.3** → Small dropout, prevents mild overfitting. \n", + "- **0.4 - 0.6** → Moderate dropout, commonly used in deep networks. \n", + "- **0.7+** → Very aggressive, can lead to underfitting. \n", + "\n", + "Therefore, it is very important to choose a dropout rate that is not to small or too large in order to prevent both overfitting and underfitting. However, there is not generally accepted dropout rate, it depends on your data. Whether a dropout rate is too small or too large is also data specific." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "d58ecc08-8afd-4a1c-9788-6493a3f06e6f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"sequential_3\"\n", + "_________________________________________________________________\n", + "Layer (type) Output Shape Param # \n", + "=================================================================\n", + "sequential_2 (Sequential) (None, 28, 28, 1) 0 \n", + "_________________________________________________________________\n", + "conv2d_2 (Conv2D) (None, 26, 26, 32) 320 \n", + "_________________________________________________________________\n", + "batch_normalization (BatchNo (None, 26, 26, 32) 128 \n", + "_________________________________________________________________\n", + "max_pooling2d_2 (MaxPooling2 (None, 13, 13, 32) 0 \n", + "_________________________________________________________________\n", + "conv2d_3 (Conv2D) (None, 11, 11, 64) 18496 \n", + "_________________________________________________________________\n", + "batch_normalization_1 (Batch (None, 11, 11, 64) 256 \n", + "_________________________________________________________________\n", + "max_pooling2d_3 (MaxPooling2 (None, 5, 5, 64) 0 \n", + "_________________________________________________________________\n", + "flatten_2 (Flatten) (None, 1600) 0 \n", + "_________________________________________________________________\n", + "dense_4 (Dense) (None, 128) 204928 \n", + "_________________________________________________________________\n", + "dropout_2 (Dropout) (None, 128) 0 \n", + "_________________________________________________________________\n", + "dense_5 (Dense) (None, 10) 1290 \n", + "=================================================================\n", + "Total params: 225,418\n", + "Trainable params: 225,226\n", + "Non-trainable params: 192\n", + "_________________________________________________________________\n" + ] + } + ], + "source": [ + "model = keras.Sequential([\n", + " data_augmentation, # Apply augmentation to input images\n", + "\n", + " # First convolutional block\n", + " keras.layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),\n", + " keras.layers.BatchNormalization(),\n", + " keras.layers.MaxPooling2D(pool_size=(2, 2)),\n", + "\n", + " # Second convolutional block\n", + " keras.layers.Conv2D(64, (3, 3), activation='relu'),\n", + " keras.layers.BatchNormalization(),\n", + " keras.layers.MaxPooling2D(pool_size=(2, 2)),\n", + "\n", + " # Flatten and Fully Connected Layers\n", + " keras.layers.Flatten(),\n", + " keras.layers.Dense(128, activation='relu'),\n", + " keras.layers.Dropout(0.5), # Reduce overfitting. This drops out 50% of the nodes, per each iteration.\n", + "\n", + " # Output Layer\n", + " keras.layers.Dense(10, activation='softmax')\n", + "])\n", + "\n", + "# Compile the model\n", + "model.compile(optimizer='adam',\n", + " loss='sparse_categorical_crossentropy',\n", + " metrics=['accuracy'])\n", + "\n", + "# Build and display the model summary\n", + "model.build(input_shape=(None, 28, 28, 1)) # None is used for batch size\n", + "model.summary()" + ] + }, + { + "cell_type": "markdown", + "id": "e1d83f08-0e63-4840-89db-528af0c985f7", + "metadata": { + "tags": [] + }, + "source": [ + "### **Step 6: Train the Model with TensorBoard**" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "85e1f85e-f92d-4509-8c33-f66524f23232", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/15\n", + " 6/938 [..............................] - ETA: 39s - loss: 2.6852 - accuracy: 0.2943 " + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-02-11 12:22:55.075229: I tensorflow/core/profiler/lib/profiler_session.cc:131] Profiler session initializing.\n", + "2025-02-11 12:22:55.075264: I tensorflow/core/profiler/lib/profiler_session.cc:146] Profiler session started.\n", + "2025-02-11 12:22:55.095899: I tensorflow/core/profiler/lib/profiler_session.cc:66] Profiler session collecting data.\n", + "2025-02-11 12:22:55.097526: I tensorflow/core/profiler/lib/profiler_session.cc:164] Profiler session tear down.\n", + "2025-02-11 12:22:55.138621: I tensorflow/core/profiler/rpc/client/save_profile.cc:136] Creating directory: /bsuhome/tnde/scratch/tensorboard/logs/fit/20250211-122252/train/plugins/profile/2025_02_11_12_22_55\n", + "\n", + "2025-02-11 12:22:55.142900: I tensorflow/core/profiler/rpc/client/save_profile.cc:142] Dumped gzipped tool data for trace.json.gz to /bsuhome/tnde/scratch/tensorboard/logs/fit/20250211-122252/train/plugins/profile/2025_02_11_12_22_55/cpu139.trace.json.gz\n", + "2025-02-11 12:22:55.146452: I tensorflow/core/profiler/rpc/client/save_profile.cc:136] Creating directory: /bsuhome/tnde/scratch/tensorboard/logs/fit/20250211-122252/train/plugins/profile/2025_02_11_12_22_55\n", + "\n", + "2025-02-11 12:22:55.163323: I tensorflow/core/profiler/rpc/client/save_profile.cc:142] Dumped gzipped tool data for memory_profile.json.gz to /bsuhome/tnde/scratch/tensorboard/logs/fit/20250211-122252/train/plugins/profile/2025_02_11_12_22_55/cpu139.memory_profile.json.gz\n", + "2025-02-11 12:22:55.186546: I tensorflow/core/profiler/rpc/client/capture_profile.cc:251] Creating directory: /bsuhome/tnde/scratch/tensorboard/logs/fit/20250211-122252/train/plugins/profile/2025_02_11_12_22_55\n", + "Dumped tool data for xplane.pb to /bsuhome/tnde/scratch/tensorboard/logs/fit/20250211-122252/train/plugins/profile/2025_02_11_12_22_55/cpu139.xplane.pb\n", + "Dumped tool data for overview_page.pb to /bsuhome/tnde/scratch/tensorboard/logs/fit/20250211-122252/train/plugins/profile/2025_02_11_12_22_55/cpu139.overview_page.pb\n", + "Dumped tool data for input_pipeline.pb to /bsuhome/tnde/scratch/tensorboard/logs/fit/20250211-122252/train/plugins/profile/2025_02_11_12_22_55/cpu139.input_pipeline.pb\n", + "Dumped tool data for tensorflow_stats.pb to /bsuhome/tnde/scratch/tensorboard/logs/fit/20250211-122252/train/plugins/profile/2025_02_11_12_22_55/cpu139.tensorflow_stats.pb\n", + "Dumped tool data for kernel_stats.pb to /bsuhome/tnde/scratch/tensorboard/logs/fit/20250211-122252/train/plugins/profile/2025_02_11_12_22_55/cpu139.kernel_stats.pb\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "938/938 [==============================] - 19s 19ms/step - loss: 0.7870 - accuracy: 0.7147 - val_loss: 0.6088 - val_accuracy: 0.7693\n", + "Epoch 2/15\n", + "938/938 [==============================] - 17s 18ms/step - loss: 0.5915 - accuracy: 0.7836 - val_loss: 0.5084 - val_accuracy: 0.8220\n", + "Epoch 3/15\n", + "938/938 [==============================] - 17s 18ms/step - loss: 0.5289 - accuracy: 0.8098 - val_loss: 0.5158 - val_accuracy: 0.8044\n", + "Epoch 4/15\n", + "938/938 [==============================] - 17s 19ms/step - loss: 0.4926 - accuracy: 0.8225 - val_loss: 0.4575 - val_accuracy: 0.8296\n", + "Epoch 5/15\n", + "938/938 [==============================] - 17s 18ms/step - loss: 0.4748 - accuracy: 0.8289 - val_loss: 0.4297 - val_accuracy: 0.8478\n", + "Epoch 6/15\n", + "938/938 [==============================] - 19s 20ms/step - loss: 0.4514 - accuracy: 0.8357 - val_loss: 0.4002 - val_accuracy: 0.8539\n", + "Epoch 7/15\n", + "938/938 [==============================] - 20s 22ms/step - loss: 0.4348 - accuracy: 0.8414 - val_loss: 0.4542 - val_accuracy: 0.8457\n", + "Epoch 8/15\n", + "938/938 [==============================] - 21s 23ms/step - loss: 0.4204 - accuracy: 0.8471 - val_loss: 0.3778 - val_accuracy: 0.8643\n", + "Epoch 9/15\n", + "938/938 [==============================] - 22s 24ms/step - loss: 0.4141 - accuracy: 0.8498 - val_loss: 0.4262 - val_accuracy: 0.8413\n", + "Epoch 10/15\n", + "938/938 [==============================] - 21s 23ms/step - loss: 0.4012 - accuracy: 0.8538 - val_loss: 0.5512 - val_accuracy: 0.8186\n", + "Epoch 11/15\n", + "938/938 [==============================] - 21s 22ms/step - loss: 0.3941 - accuracy: 0.8569 - val_loss: 0.3825 - val_accuracy: 0.8611\n", + "Epoch 12/15\n", + "938/938 [==============================] - 23s 24ms/step - loss: 0.3876 - accuracy: 0.8582 - val_loss: 0.3926 - val_accuracy: 0.8565\n", + "Epoch 13/15\n", + "938/938 [==============================] - 22s 23ms/step - loss: 0.3814 - accuracy: 0.8616 - val_loss: 0.3819 - val_accuracy: 0.8641\n", + "Epoch 14/15\n", + "938/938 [==============================] - 24s 25ms/step - loss: 0.3790 - accuracy: 0.8622 - val_loss: 0.3999 - val_accuracy: 0.8528\n", + "Epoch 15/15\n", + "938/938 [==============================] - 21s 22ms/step - loss: 0.3687 - accuracy: 0.8662 - val_loss: 0.3441 - val_accuracy: 0.8777\n" + ] + } + ], + "source": [ + "history = model.fit(x_train, y_train, \n", + " epochs=15, \n", + " validation_data=(x_test, y_test), \n", + " batch_size=64,\n", + " callbacks=[tensorboard_callback]) # TensorBoard callback" + ] + }, + { + "cell_type": "markdown", + "id": "86b07520-aa70-44de-81b1-9e8f0e68d114", + "metadata": {}, + "source": [ + "### **Step 8: Visualize Training Progress with TensorBoard**\n", + "To launch TensorBoard, run this command in your terminal\n", + "\n", + "```ruby\n", + "tensorboard --logdir=logs/fit\n", + "```\n", + "\n", + "Then, open a web browser and go to:\n", + "[http://localhost:6006/](http://localhost:6006/)\n", + "\n", + "\n", + "##### **On Borah, you may not be able to use tensorboard if you do not have GPU access. One possible solution is to install `tensorflow-cpu` instead. It is the CPU-only version of TensorFlor. If you do have GPU access, make sure CUDA is properly loaded.**" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "44772800-6f8d-442a-ac87-b360b291101f", + "metadata": {}, + "outputs": [], + "source": [ + "# from tensorboard import notebook\n", + "# notebook.list() # View open TensorBoard instances\n", + "# notebook.display(port=6006, height=1000)" + ] + }, + { + "cell_type": "markdown", + "id": "7063368d-44ce-49d5-b844-ebb30e5f24d1", + "metadata": {}, + "source": [ + "### **Step 7: Evaluate the Model**" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "7815a3b0-b309-4144-9965-ff9cb8c06c58", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "313/313 [==============================] - 1s 2ms/step - loss: 0.3441 - accuracy: 0.8777\n", + "Test Accuracy: 0.8777\n" + ] + } + ], + "source": [ + "test_loss, test_acc = model.evaluate(x_test, y_test)\n", + "print(f\"Test Accuracy: {test_acc:.4f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "df0d8d43-974c-4870-8fd8-3ea013428ea7", + "metadata": {}, + "source": [ + "### **Step 9: Plot Training Accuracy & Loss**" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "83b4a89f-53b8-4ae2-a4bc-a093c2d1827a", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot Accuracy\n", + "plt.plot(history.history['accuracy'], label='Train Accuracy')\n", + "plt.plot(history.history['val_accuracy'], label='Validation Accuracy')\n", + "plt.xlabel('Epochs')\n", + "plt.ylabel('Accuracy')\n", + "plt.legend()\n", + "plt.show()\n", + "\n", + "# Plot Loss\n", + "plt.plot(history.history['loss'], label='Train Loss')\n", + "plt.plot(history.history['val_loss'], label='Validation Loss')\n", + "plt.xlabel('Epochs')\n", + "plt.ylabel('Loss')\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "645e3dc6-04e9-46fb-80c1-52ba28b27cc9", + "metadata": {}, + "source": [ + "### **Step 10: Make Predictions on Test Data**" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "144f84e3-60b4-4863-a7a2-90773170ccaf", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "predictions = model.predict(x_test)\n", + "\n", + "# Plot an example image and its predicted label\n", + "plt.imshow(x_test[0].reshape(28, 28), cmap='gray')\n", + "plt.title(f\"Predicted: {np.argmax(predictions[0])}, Actual: {y_test[0]}\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "6630b01f-509a-492e-89dc-aca8bcf6a6c1", + "metadata": {}, + "source": [ + "### **Next Steps for Even More Complexity**\n", + "- Use a Pretrained Model - Apply transfer learning with models like ResNet or VGG16.\n", + "- Experiment with Hyperparameters - Change optimizer, batch size, or learning rate.\n", + "- Train on a Custom Dataset - Try a dataset from Kaggle or Google Dataset Search.\n", + "- Optimize for Deployment - Convert the model to TF Lite or TensorFlow.js." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "90cfa80b-543d-49b0-88bb-6b6c36e89a5c", + "metadata": {}, + "outputs": [], + "source": [ + "# The End." + ] + }, + { + "cell_type": "markdown", + "id": "1c709df1-0ecf-4401-a129-b3330cd2e2b4", + "metadata": {}, + "source": [ + "## The End." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "ml_tutorial", + "language": "python", + "name": "ml_tutorial" + }, + "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.9.15" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/template/script.sh.erb b/template/script.sh.erb index 8783d8d..79a3dad 100755 --- a/template/script.sh.erb +++ b/template/script.sh.erb @@ -11,45 +11,29 @@ ood_dir="'$(pwd)'" ################## Tutorial-dependent commands ##################### -## Fundamentals of R Tutorial -<%- if context.tutorial== "Fundamentals of R" -%> - # Purge the module environment to avoid conflicts - module purge - module load GCC/12.2.0 OpenMPI/4.1.4 R_tamu/4.2.2 Pandoc - - module list - - # Benchmark info - echo "TIMING - Starting Tutorials OnDemand at: $(date)" - echo "Fundamentals of R" - # Launch Fundamentals of R tutorial - set -x - R -e "rmarkdown::run(file.path($ood_dir,'TutorialsOnDemand_R.Rmd'),shiny_args=list(port=$port,host='0.0.0.0'))" - -## Data Science in R Tutorial -<%- elsif context.tutorial== "Data Science in R" -%> - # Purge the module environment to avoid conflicts +## Alphafold3 Tutorial +<%- if context.tutorial== "Alphafold3" -%> + tutorial_doc="alphafold3.ipynb" module purge - module load GCC/12.2.0 OpenMPI/4.1.4 R_tamu/4.2.2 Pandoc - - module list - + module load alphafold/3.0.0 + # Benchmark info echo "TIMING - Starting Tutorials OnDemand at: $(date)" - echo "Introduction to R" - # Launch Introduction to R tutorial + echo "Alphafold3 Tutorial" + # Launch tutorial set -x - R -e "rmarkdown::run(file.path($ood_dir,'DataScienceInR.Rmd'),shiny_args=list(port=$port,host='0.0.0.0'))" + jupyter notebook --config="${CONFIG_FILE}" $tutorial_doc -## Alphafold3 Tutorial -<%- elsif context.tutorial== "Alphafold3" -%> - tutorial_doc="alphafold3.ipynb" +## Pytorch Tutorial +<%- elsif context.tutorial== "Pytorch" -%> + tutorial_doc="pytorch_tutorial.ipynb" module purge - module load alphafold/3.0.0 + # Load any modules your tutorial needs here + module load pytorch_2.4.1_tensorflow_2.17_cuda_12.4 # Benchmark info echo "TIMING - Starting Tutorials OnDemand at: $(date)" - echo "Alphafold3 Tutorial" + echo "Pytorch Tutorial" # Launch tutorial set -x jupyter notebook --config="${CONFIG_FILE}" $tutorial_doc @@ -66,17 +50,6 @@ ood_dir="'$(pwd)'" # Launch Introduction to Python tutorial set -x jupyter notebook --config="${CONFIG_FILE}" $tutorial_doc - -## Introduction to Julia Tutorial -<%- elsif context.tutorial== "Introduction to Julia" -%> - tutorial_doc="IntroductionToJulia.ipynb" - module purge - module load foss/2022b jupyter-server/2.7.0 JupyterNotebook/7.0.3 nodejs/18.12.1 Julia/1.10.2-linux-x86_64 WebProxy - - # Benchmark info - echo "TIMING - Starting Tutorials OnDemand at: $(date)" - echo "Introduction to Julia" - # Launch Introduction to Julia tutorial - set -x - jupyter notebook --config="${JULIA_CONFIG}" $tutorial_doc +<%- else -%> + echo "context.tutorial not found" <%- end -%> diff --git a/template/test.ipynb b/template/test.ipynb index cd01533..7a8790e 100644 --- a/template/test.ipynb +++ b/template/test.ipynb @@ -30,13 +30,21 @@ "metadata": {}, "outputs": [], "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b1a4a0f9-6f56-40fe-bcd5-0787c765a833", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "ml_tutorial", "language": "python", - "name": "python3" + "name": "ml_tutorial" }, "language_info": { "codemirror_mode": { @@ -48,7 +56,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.12" + "version": "3.9.15" } }, "nbformat": 4, diff --git a/view.html.erb b/view.html.erb index 7f7742d..d5c35af 100644 --- a/view.html.erb +++ b/view.html.erb @@ -24,6 +24,18 @@ -%> <%- end -%> +<%- if usertutorial== "Pytorch" -%> + <%- user_tutorial = "#{usertutorial}" + base_url = "/node/#{host}/#{port}" + login_url = "#{base_url}/login" + next_url = "#{base_url}/notebooks/pytorch_tutorial.ipynb" + action = "#{login_url}?next=#{next_url}" + form_id = "jupyter_form#{login_url.gsub('/', '_')}" + method = "post" + target = "_blank" + onsubmit = "changeTarget()" + -%> +<%- end -%>