From 217b32f138deaa3fd385cb4e985a8286deccde27 Mon Sep 17 00:00:00 2001 From: seungwoo1124 Date: Mon, 13 May 2024 20:55:59 +0900 Subject: [PATCH 1/7] add ResNet34 example and ray nodepool --- automation/karpenter_node_pool_deploy/main.py | 8 + example/Mobilenetv2_face_emotion/.gitignore | 2 + .../download_dataset.py | 18 +++ example/Mobilenetv2_face_emotion/model.py | 60 ++++++++ example/Mobilenetv2_face_emotion/train.ipynb | 138 ++++++++++++++++++ 5 files changed, 226 insertions(+) create mode 100644 example/Mobilenetv2_face_emotion/.gitignore create mode 100644 example/Mobilenetv2_face_emotion/download_dataset.py create mode 100644 example/Mobilenetv2_face_emotion/model.py create mode 100644 example/Mobilenetv2_face_emotion/train.ipynb diff --git a/automation/karpenter_node_pool_deploy/main.py b/automation/karpenter_node_pool_deploy/main.py index 43e12d7c6b..2570ddeed5 100644 --- a/automation/karpenter_node_pool_deploy/main.py +++ b/automation/karpenter_node_pool_deploy/main.py @@ -54,6 +54,14 @@ def handler(event, context): capacity_type = 'on-demand' result = apply_nodepool_yaml(eks_cluster_name, region, profiler_nodepool_name, profiler_nodeclass_name, profiler_nodepool_family_list, capacity_type) + ray_nodepool_name = 'ray-ondemand-pool' + ray_nodepool_family_list = [ + 't3.medium', 't3.large', 'm5.large', + ] + ray_nodeclass_name = 'ec2-cpu' + capacity_type = 'on-demand' + result = apply_nodepool_yaml(eks_cluster_name, region, ray_nodepool_name, ray_nodeclass_name, ray_nodepool_family_list, capacity_type) + return { 'statusCode': 200, 'body': "complete update nodepool" diff --git a/example/Mobilenetv2_face_emotion/.gitignore b/example/Mobilenetv2_face_emotion/.gitignore new file mode 100644 index 0000000000..d3e510951c --- /dev/null +++ b/example/Mobilenetv2_face_emotion/.gitignore @@ -0,0 +1,2 @@ +cifar-10-batches-py +torch.pt \ No newline at end of file diff --git a/example/Mobilenetv2_face_emotion/download_dataset.py b/example/Mobilenetv2_face_emotion/download_dataset.py new file mode 100644 index 0000000000..d6d5d72857 --- /dev/null +++ b/example/Mobilenetv2_face_emotion/download_dataset.py @@ -0,0 +1,18 @@ +import torchvision +import torchvision.transforms as transforms +import os + + +transform = transforms.Compose( + [transforms.ToTensor(), + transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]) + +cwd = os.getcwd() + +# 학습 데이터셋 다운로드 +trainset = torchvision.datasets.CIFAR10(root=f'{cwd}/example/Mobilenetv2_face_emotion/input', train=True, + download=True, transform=transform) + +# 테스트 데이터셋 다운로드 +testset = torchvision.datasets.CIFAR10(root=f'{cwd}/example/Mobilenetv2_face_emotion/input', train=False, + download=True, transform=transform) \ No newline at end of file diff --git a/example/Mobilenetv2_face_emotion/model.py b/example/Mobilenetv2_face_emotion/model.py new file mode 100644 index 0000000000..5ac0abaa4e --- /dev/null +++ b/example/Mobilenetv2_face_emotion/model.py @@ -0,0 +1,60 @@ +from torch import nn + +class BasicBlock(nn.Module): + expansion = 1 + + def __init__(self, in_planes, planes, stride=1): + super(BasicBlock, self).__init__() + self.conv1 = nn.Conv2d(in_planes, planes, kernel_size=3, stride=stride, padding=1, bias=False) + self.bn1 = nn.BatchNorm2d(planes) + self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=1, padding=1, bias=False) + self.bn2 = nn.BatchNorm2d(planes) + + self.shortcut = nn.Sequential() + if stride != 1 or in_planes != self.expansion * planes: + self.shortcut = nn.Sequential( + nn.Conv2d(in_planes, self.expansion * planes, kernel_size=1, stride=stride, bias=False), + nn.BatchNorm2d(self.expansion * planes) + ) + + def forward(self, x): + out = nn.ReLU()(self.bn1(self.conv1(x))) + out = self.bn2(self.conv2(out)) + out += self.shortcut(x) + out = nn.ReLU()(out) + return out + +class ResNet(nn.Module): + def __init__(self, block, num_blocks, num_classes=10): + super(ResNet, self).__init__() + self.in_planes = 64 + + self.conv1 = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1, bias=False) + self.bn1 = nn.BatchNorm2d(64) + self.layer1 = self._make_layer(block, 64, num_blocks[0], stride=1) + self.layer2 = self._make_layer(block, 128, num_blocks[1], stride=2) + self.layer3 = self._make_layer(block, 256, num_blocks[2], stride=2) + self.layer4 = self._make_layer(block, 512, num_blocks[3], stride=2) + self.linear = nn.Linear(512 * block.expansion, num_classes) + + def _make_layer(self, block, planes, num_blocks, stride): + strides = [stride] + [1]*(num_blocks-1) + layers = [] + for stride in strides: + layers.append(block(self.in_planes, planes, stride)) + self.in_planes = planes * block.expansion + return nn.Sequential(*layers) + + def forward(self, x): + out = nn.ReLU()(self.bn1(self.conv1(x))) + out = self.layer1(out) + out = self.layer2(out) + out = self.layer3(out) + out = self.layer4(out) + out = nn.AdaptiveAvgPool2d((1, 1))(out) + out = out.view(out.size(0), -1) + out = self.linear(out) + return out + +def ModelClass(): + return ResNet(BasicBlock, [3, 4, 6, 3]) \ No newline at end of file diff --git a/example/Mobilenetv2_face_emotion/train.ipynb b/example/Mobilenetv2_face_emotion/train.ipynb new file mode 100644 index 0000000000..14cda6da35 --- /dev/null +++ b/example/Mobilenetv2_face_emotion/train.ipynb @@ -0,0 +1,138 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# 전처리\n", + "import pickle\n", + "import numpy as np\n", + "import torch\n", + "from torch.utils.data import DataLoader, TensorDataset, random_split\n", + "\n", + "def load_cifar_batch(filename):\n", + " with open(filename, 'rb') as file:\n", + " batch = pickle.load(file, encoding='latin1')\n", + " # 이미지 데이터 재배열: [num_samples, 3, 32, 32]\n", + " features = batch['data'].reshape((len(batch['data']), 3, 32, 32)).transpose(0, 2, 3, 1)\n", + " labels = batch['labels']\n", + " return features, labels\n", + "\n", + "def create_datasets(data_paths, test_path):\n", + " # 데이터를 로드하고 하나의 큰 훈련 데이터셋으로 결합\n", + " train_features = []\n", + " train_labels = []\n", + " for path in data_paths:\n", + " features, labels = load_cifar_batch(path)\n", + " train_features.append(features)\n", + " train_labels.append(labels)\n", + " train_features = np.concatenate(train_features)\n", + " train_labels = np.concatenate(train_labels)\n", + " \n", + " # 테스트 데이터 로드\n", + " test_features, test_labels = load_cifar_batch(test_path)\n", + "\n", + " # numpy 배열을 PyTorch 텐서로 변환\n", + " train_features = torch.tensor(train_features).permute(0, 3, 1, 2).float() / 255.0\n", + " train_labels = torch.tensor(train_labels).long()\n", + " test_features = torch.tensor(test_features).permute(0, 3, 1, 2).float() / 255.0\n", + " test_labels = torch.tensor(test_labels).long()\n", + " \n", + " # TensorDataset 생성\n", + " train_dataset = TensorDataset(train_features, train_labels)\n", + " test_dataset = TensorDataset(test_features, test_labels)\n", + " return train_dataset, test_dataset\n", + "\n", + "# 파일 경로 설정\n", + "data_paths = [f'cifar-10-batches-py/data_batch_{i}' for i in range(1, 6)]\n", + "test_path = 'cifar-10-batches-py/test_batch'\n", + "\n", + "# 데이터셋 생성\n", + "train_dataset, test_dataset = create_datasets(data_paths, test_path)\n", + "\n", + "# DataLoader 생성 예\n", + "train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)\n", + "test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# 학습\n", + "import torch\n", + "from torch import nn, optim" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from model import ModelClass\n", + "\n", + "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "model = ModelClass()\n", + "model.to(device)\n", + "\n", + "criteration = nn.CrossEntropyLoss()\n", + "optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9, weight_decay=5e-4)\n", + "\n", + "epochs = 10\n", + "# 학습 로직\n", + "for epoch in range(epochs):\n", + " model.train()\n", + " total_loss = 0\n", + " for data, targets in train_loader:\n", + " data, targets = data.to(device), targets.to(device)\n", + " optimizer.zero_grad()\n", + " outputs = model(data)\n", + " loss = criteration(outputs, targets)\n", + " loss.backward()\n", + " optimizer.step()\n", + " total_loss += loss.item()\n", + " print(f\"Epoch {epoch}, Loss: {total_loss / len(train_loader)}\")\n", + "\n", + " # 성능 테스트\n", + " model.eval()\n", + " total_correct = 0\n", + " total = 0\n", + " with torch.no_grad():\n", + " for data, targets in test_loader:\n", + " data, targets = data.to(device), targets.to(device)\n", + " outputs = model(data)\n", + " _, predicted = torch.max(outputs, 1)\n", + " total_correct += (predicted == targets).sum().item()\n", + " total += targets.size(0)\n", + " accuracy = 100 * total_correct / total\n", + " print(f\"Test Accuracy: {accuracy:.2f}%\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "swjenv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 1018ae0b988082f075e4e1595f4ad52c9dbfa051 Mon Sep 17 00:00:00 2001 From: seungwoo1124 Date: Mon, 13 May 2024 21:01:29 +0900 Subject: [PATCH 2/7] add test inference ResNet34 --- example/Mobilenetv2_face_emotion/train.ipynb | 102 ++++++++++++++++++- 1 file changed, 99 insertions(+), 3 deletions(-) diff --git a/example/Mobilenetv2_face_emotion/train.ipynb b/example/Mobilenetv2_face_emotion/train.ipynb index 14cda6da35..ba4d18ff8f 100644 --- a/example/Mobilenetv2_face_emotion/train.ipynb +++ b/example/Mobilenetv2_face_emotion/train.ipynb @@ -59,7 +59,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -70,9 +70,48 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/swjeong/swjeong/swjenv/lib/python3.11/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n", + "/home/swjeong/swjeong/swjenv/lib/python3.11/site-packages/torch/nn/modules/conv.py:456: UserWarning: Plan failed with a cudnnException: CUDNN_BACKEND_EXECUTION_PLAN_DESCRIPTOR: cudnnFinalize Descriptor Failed cudnn_status: CUDNN_STATUS_NOT_SUPPORTED (Triggered internally at ../aten/src/ATen/native/cudnn/Conv_v8.cpp:919.)\n", + " return F.conv2d(input, weight, bias, self.stride,\n", + "/home/swjeong/swjeong/swjenv/lib/python3.11/site-packages/torch/autograd/graph.py:744: UserWarning: Plan failed with a cudnnException: CUDNN_BACKEND_EXECUTION_PLAN_DESCRIPTOR: cudnnFinalize Descriptor Failed cudnn_status: CUDNN_STATUS_NOT_SUPPORTED (Triggered internally at ../aten/src/ATen/native/cudnn/Conv_v8.cpp:919.)\n", + " return Variable._execution_engine.run_backward( # Calls into the C++ engine to run the backward pass\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 0, Loss: 1.4303537471520016\n", + "Test Accuracy: 59.51%\n", + "Epoch 1, Loss: 0.8351202780557105\n", + "Test Accuracy: 69.48%\n", + "Epoch 2, Loss: 0.6135322963413985\n", + "Test Accuracy: 77.36%\n", + "Epoch 3, Loss: 0.4773394625319544\n", + "Test Accuracy: 79.37%\n", + "Epoch 4, Loss: 0.3824448018046596\n", + "Test Accuracy: 78.43%\n", + "Epoch 5, Loss: 0.31271432585957104\n", + "Test Accuracy: 80.39%\n", + "Epoch 6, Loss: 0.24858952629025025\n", + "Test Accuracy: 80.82%\n", + "Epoch 7, Loss: 0.2060038364442337\n", + "Test Accuracy: 81.37%\n", + "Epoch 8, Loss: 0.16349902953666723\n", + "Test Accuracy: 81.06%\n", + "Epoch 9, Loss: 0.13853420683270906\n", + "Test Accuracy: 80.36%\n" + ] + } + ], "source": [ "from model import ModelClass\n", "\n", @@ -112,6 +151,63 @@ " accuracy = 100 * total_correct / total\n", " print(f\"Test Accuracy: {accuracy:.2f}%\")" ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "torch.save(model.state_dict(), 'torch.pt')" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Label: 9 Inference Result: 9\n", + "Label: 2 Inference Result: 2\n", + "Label: 1 Inference Result: 1\n", + "Label: 3 Inference Result: 5\n", + "Label: 7 Inference Result: 7\n", + "Label: 3 Inference Result: 7\n", + "Label: 7 Inference Result: 7\n", + "Label: 0 Inference Result: 0\n", + "Label: 9 Inference Result: 9\n", + "Label: 9 Inference Result: 9\n" + ] + } + ], + "source": [ + "# 추론\n", + "import random\n", + "\n", + "# test 데이터셋에서 10개의 샘플을 무작위로 선택\n", + "random.seed(42)\n", + "samples = random.sample(range(len(test_dataset)), k=10)\n", + "\n", + "# 선택된 샘플에 대해 라벨 출력 및 모델 추론\n", + "for sample in samples:\n", + " data, target = test_dataset[sample]\n", + " data = data.to(device)\n", + " model.eval()\n", + " with torch.no_grad():\n", + " output = model(data.unsqueeze(0))\n", + " _, predicted = torch.max(output, 1)\n", + " print(\"Label:\", target.item(), \"Inference Result:\", predicted.item())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { From 8c3ebaaa0fbc5441b2dd9062b3098159f3bb6a18 Mon Sep 17 00:00:00 2001 From: seungwoo1124 Date: Tue, 14 May 2024 16:02:49 +0900 Subject: [PATCH 3/7] add Inference Example for ResNet34 --- example/Mobilenetv2_face_emotion/train.ipynb | 403 ++++++++++++++++++- 1 file changed, 390 insertions(+), 13 deletions(-) diff --git a/example/Mobilenetv2_face_emotion/train.ipynb b/example/Mobilenetv2_face_emotion/train.ipynb index ba4d18ff8f..b438c282ad 100644 --- a/example/Mobilenetv2_face_emotion/train.ipynb +++ b/example/Mobilenetv2_face_emotion/train.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -163,43 +163,420 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 11, "metadata": {}, "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Real Label: truck Predicted Label: truck \n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Real Label: bird Predicted Label: bird \n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, { "name": "stdout", "output_type": "stream", "text": [ - "Label: 9 Inference Result: 9\n", - "Label: 2 Inference Result: 2\n", - "Label: 1 Inference Result: 1\n", - "Label: 3 Inference Result: 5\n", - "Label: 7 Inference Result: 7\n", - "Label: 3 Inference Result: 7\n", - "Label: 7 Inference Result: 7\n", - "Label: 0 Inference Result: 0\n", - "Label: 9 Inference Result: 9\n", - "Label: 9 Inference Result: 9\n" + "Real Label: automobile Predicted Label: automobile\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Real Label: cat Predicted Label: dog \n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Real Label: horse Predicted Label: horse \n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Real Label: cat Predicted Label: horse \n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Real Label: horse Predicted Label: horse \n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Real Label: airplane Predicted Label: airplane \n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Real Label: truck Predicted Label: truck \n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAGEAAABhCAYAAADGBs+jAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAme0lEQVR4nO2d2ZIbyXKmv9hyAVALyT46rcVmJNPczrPOc8x7aF5gruZiZBrT0Wl2s7tYxcKSmbHOhUckUCT7WJVEmnjBMIMBRAGZAfcI999/dw+qUkrh+/hPHfo/ewLfx3clfBPjuxK+gfFdCd/A+K6Eb2B8V8I3ML4r4RsY35XwDYzvSvgGhn3uB//H//zflFIIGWKGVCC2i+gOoy1OK3qtQUHWhQKEDKFAKpqApqBQgFYKq8Fp0FrhDCiliEWRioL2QNE5sEbhjGKwGqUUWgEoQlKEDLlALJlS4JIDUCiUUqDl+vLm5XugMCgU1ig6A0YXNl2hM9DpQm8URsNgjTybgtOQSmFJhVwgZU0BDGAoKAX//R+GZ8n22TvhY3ZDrQ8R6u98iwJVmE+/+9HH+D3uRIR08VDn7ytVLr7crvD7LEz5/N1RVWjyLK91vY9W6vzvT+59MUd1ef/yibz+0nj2TkhhDwqU6nGmI6PQRQMKo7VMVKt1AaciCvh4Va6Tvrh2QVayfENWudHgtEZr2HSKzspu6KwsiJAKOYMqiRIzKIVWloIiK7lv3Sz1Dnq91zoPQBVwpmB0YbRwPYA1cNVDZwpGyS6QOaW6gwtWFbQGrSGjiLGQS6FkKPlldNyzlZDTSQTkDFp3aBQaUYLWahVeUWeh5gvT0HbMx4/291xYV6MGrFb0TkzErofegTHgDORSOM2ZUAqqBEgRlEFZs4q4rAq4eK4vmoh0vadV4HRhdHAzQGfU+qzWa7R9lM+7BDBGkYvMOSWIpaxm+rnj2UqIy15ssXFoNVBk89JWmFIFpRWmzlAVjaxtvX42rTvhvMWNltfGtG2tq3IzKk2UXAglokLBGE22llRgmjMhFZZpwk8zSlt0N8qzHVGmE0FrEZ1u9l8plJYF40xBKxis2PjRio8yqhDSxQKqitC6/uI694IooBQIsZBSIRVZJC/ZC89WQji+BaVx1mKHkaw60IOs25KhFIwpdE6twmwmSssbVWltVyiUPttaa1W1vxqtNMFPHD7ck1NgySdCWVB2xPRbUlY8TpEQC+H0QDx9wBrHdnuFsh366q/BOZSSRSGOX4vSq5M1GoZOYVSpjrbgDIxG5jj7QsriH1BnpSkFpjn2ujtyKUxLJFazqF6IOZ+/E8KMUppSIlplmYAWwZaiKKU5t1x/vKw6a2S1i/TPSmjmS9UVao0ISylV90Em+RMxLOR8RBePtolUNCnDMnl8zKRpT5oPYB3ZaVSO6BLQqqC1qtcVM2aqgLRG7LoGo0ArccgURc4V1SVZ2art1PZZDQkxm2255yyfjanI9V+mg+cr4bD/Fa0Nu+sf6HVAW4vuFUVpYpKJUCIlBXRRdMZhtaZ3Xd0dYgbgbGeb41SczVJz2svjnnd/+j9Mpz298lgdMW6DG24IKfHbwwfmZUGnBZ09veuw8y1dP3JzfcPG3dI5yzhYtGrmqBBSJsQkUFIWLj4klpwB0MiC8lmgZ2cNvTMYo7DaoooipUwpmVwKMWVyhiVkUZrKoMvZDX1JJSzzAWMs5AWrEkZnnBOpeaVIBVLMxOABhUVhlaEzhcFWO6wvHF2LGOq/jbrA8YBKnsPDrxz3Dww24nTC9Vs6H/Axcrj7lWmesCpjVYKuJ5iEyVtMmhl0oreGXXd538JMIacsnqoiqBATMaY1xigFQkN3bYGg645XAjoypFTwQZQRoryHqojkBVp4thJOp3u0NkynO5bploFX9OY1yhi0UsQMS/D45RG0IjBSjKEzmmxdM5/n1X6xG1S1sed5F0pO5OCJfmZ/OlDSgnEHXH8gxMjd+zuWZcZqCeKWYaTvOiLwOnxAxXvAkVRPVgpdPX+KhRQKGUWuZtKHTIy5Lgojc6m/yxqDtQZjBC6LuRHfVQCdRGtqNbmavxSr/IeUsN//gtaG4+EN02GDM4XR/h3GOqyqUfRpIc33ZBQhLxTjiK4jd5uz0KtdVRVF6aoAXT8gQY6Ythxm4nJi/+GO6bQXE+g6Uoo83D+w+AVnHc45ttst/dDjSybM79H+ihINITqU1hjbobQhJUtKRtBaMZQCPhRCLBhjMdagtaJ38to6jXNafFw1acY0gA1RCzrSRpGVqrHRV4sTROMxBPwyE/xMih7Q+CUQUsYvJ8IyiUPWimIjKXpyThJLKHPeAtWxlVIdYt0qKQZiiizzxOIXvF9YFs/iPSomVIyklAkhkFMmVlTufWBZFox1BL+QgiejSMuC0hrtRAm+WGK2FTqLMkgKlUGpjC5K4HUBcqZkTc4GBeRcUV71yTEXQmmUiSKuMc9LPMJLlBAFT572R+7dr5RsuLn5DWM63n/4wDTPzKcHToff0FoTNyPWdnSdZdiMGOsw+rwjxPYmcopVH+IQj/sHjvsP/PL2T9zd/cLjh3v2jx+YpxO5FHJ1oFTzFUNgZiHGTNf1TPPC4/09p+tbwuKZjpPsuMGhrEbpDm06lNI426OUQZuOzlgMHcYMKDRq0RStSNkRiiNpDVacfEi5KsAyl0F4sSQsAWVFrl9eCQoNRZNiIviFsCz4ZcKYxDwdmE4n/HIk+AmtNd5AyZEYFlLyKK0EUSiNLsKtlBzJKdQdIbtink9MpwPLfCKEQIyRmBIpF1JKpJRkp1kxMzlHUs7EGFm8xxhL9J7kA35emI9HCRmTRVkxS9b2GG3QOaGVwXQJrToJOHN1wijIiqwTyWSKNiQKWSlCTIKygKAhUYhFSE31NZXw4x/+KyjFZtzizIboC+/e/hmlNMfjER88WiV601EoLNOJZVK4/leKsmjrsP2OAvhpInrPMp84Hh8puZCLrPDeaXpnUCrzX/7r3xO8JwRPSokcEzEEAIwxAHz48MCHx3uBlUuAMpFDwhZFnwuqopdcgjjiXpEGQ1KZUJ2xmk+rMza2q6+FrbXOYV2H0Yau61Eo9seJ07RgxyuG2z+ibcfYDxjjyFmRsnqRb362En54/bcAaGVQSpM83L37hVLKaveHYWDYbUgpcjzNxJyw3T1FGdAO5Y7kXNg/3DOfTuwfH7h//ys5Z1IWUuOvf/wDf/zDG7TW/M3f/p04bS1RdAqB4L1seSUs3U9v/w371jDNE3d3d+SYKTFjAJ3AhkLOiSVCUpAwJJPIJBJeSMOcoQaZWmuhX4wWX2Ic2jq0NgzdBtDc3X/gcX9gd/OaH7qebhgZR0PfWUKCkBQv8c3PVoLr+vpKkEHOeY0aldZoJILORZEyTEsU56n3zBEKmkRHzpn9hwfm04nTcc+HD/eUaueVVlxvR5arLV3XMW43GFMhIwprNJ1zNcK2KKVY/ESMgcf9I4+P+3WKuYDuHP31llIKphQShbQZSONAUUK2FaDkJHO48KeqRo2lFFKIZJ1Z8gQogp+IYSb6E3F6RGfPYhUlLhTVUdTASwKFZyth3F0DiFnIWZ6Dr5O3kDVKW1LRLLHw/sPMNE2UuwNFFWJMnCZPipHD/gPzPOOXhXkSU+Csw1jLYDS7zcD19Y6/+uE1Xe8qIVawxtJbhzGG7bjDGsP1zRVvfnjDu3fvuLt7j/eeojWBwrgduX59i0KRYxKzN3SkoRdqoiohxUTKiZxlniVnYoqUnAnBE8JMKYWpHMglczwcWaYJqyJzr0iuo0z3WNfjtq9w2x9q4PnqyyrBOgdQnWE+O9qcIRYyQmT5GPA+siyeaV7IOZFzIoTIcZpECYc9fp4JwbMsC1opSj9gc2ZZZpZ5ZukcPniUhlSyOHJbMEqvZsNaS9d1DMNI1/XrrhEqPUvmrHcSXGkDuZCdQ1l7TgGVItfLmpQk79B2ZlaZnBJJaXIRxeQsiC4ngd9hmSg5orQmxgBuxI7xAop/QSW8fv2mTlp4k5QyMQZSjNzd3zGdThz2ez487pmnibc//cw0zaQYSCmQUmTxCykl/DITo6y0lDPWWOww0BnF/sMD/+9f/oXNZuTh/g5nLbHyNM45um5gM47849//A1e7K+ZlIuUkCMhotDEsMXCYTyir2WhJOhVTsb8x4geUpCJRwgnJb6vugSJEXoEQgiwWv/D+4W6NY0IKHE8HUghorTFdhzGW1z9G7LBBv4BKfbYSNptNfSWmoVRYGELgw/6RDMzLzPv375mnmYeHB+ZJArqmhBAWUWCMZ7wPZITJNFox191yPHT4ecYYTSyFVDLOdXTdwG675c3ta3HWObYZoapTTTmxBM+QE0krUcCTRKzwVppzDkPMx9NHAaJzhNjJtZXkD1LO5JzwKREWLzkGa9BaM+xuSGGm6K+ghJzT+gNaDrXlVnMW+BgWL0mWZUGrgmvsqdIY43DOUErGe1FKYyi6rmN3dcU4jIQgkW/OWdhPo8XUAcYsGLOQU2aeZ4kjkifEgPce7z0hyLVzFlOSU5u3IJbGU8FFmlOXC/Lw8llRSgKEFnddRy6ZabJoyWuumZ+SCikn5uORx7tf5e9fWgkxCj0gGbSqDA3oQk6JGCLLNHHcPxJjxOiM7sQURK3R2mCM+JXTPBGCmKOSC8Mw8OrVK7abLb/99huPj48sy4JfZvE9LS1WM3nBe46nI1fLThxn9JxOp9XZC6URSSmSYqyBYc0vK4Gel+NSMZfvXb42RjH0PUopuu7INEmcUuqFc73P6cMH7tSfPrneF1FCMx9KlbpRWZPExhix131H3/cYq7FJJhijI6WIMRbXDVCEwUTNlJTJKWOtwxorjpW26wq5aFQWOJypK1eJA8wVpbVHqVG4JNurTc8tMs/kxgtqUPnpb/uLSmhJj+bAG+HYciPolXQsOZNSZDoeX+KXX5JZW+orictbvjbnzNXVlq5zYppKIqVITIFcJOGRC7iuY3d1TcmFf/vTn3l4eCCFQFw8fd8xDD19Z4FC8B5rDXQyvWWZ8SGglUYbzdIbvF+IQSBvrlmwFEWpsdIbMUVSCpRiVkdLNY/1l5wFri5zHZ8qJaZYGWAt8YoxaGexxkERDiulxOl04u7XX79Ojnm1rbXWR9VUYamoBRTjZmC7lYg5pFizT4qMout7rq9vyTkz3N3jTpMk9DNY6zBaVztafUxWq5hSSsQY0Uphiq42X6BvS7SXKuTGQeVq6mSHyGJocLRUcmdVQi0TufQLT5VQ1jKWthu01hgtOfeVDa5yOp2OX6fuKPjlQgmsWL1tQ6mYMHS9IyWDTuKEL6st9tVfnE4nFr9gUIzDQNdZ2d5FUEeMYcX7Ei1LgY2qtTQlVRMjkqVV2a0Ipymi5BW+SkqSyr7W3EWTcxbBt9/VnPIlmko5S1BXgzi5LwJFFRijAYPtLN1gX1R79HwlrObobEN1LXmsvw1jNa7r0CmhU7WVSrIhi/d8eHxk8YFpPuG9Z+x6+qGnc0IRU8TJh4q9z8LQFVDWFZklRVlyppSam74QXEtMlqpUViUU2ipfRfQxKFohqr5QAqScVha35IwqdWlVWRgtjtpaQ9c5cdhfWglndHReMY3JTDWYCkFoZ1kp5++llJnmhePhIPA0xCfMSs4Z7z1Jq/U+a4bqo+KxlpW79JtS6KXOtr0qolQoLf4gSzHCham5LBBr1X/rjlj/LaPFBgICnsrmssqoLc6vQuAty7Le5MnNKIQYSVls4TzPcmEtSGc6njieJo7HI+9++YUQIloZrBLWPhfJ7+73CxTB/2LP60OdfYM2GmsU1gpOX1d0zavr5lcuEkcpZVTlrnLOF+bm7BNWH3GplcudoEQJIQQxb+sqr3MralVEo1O+ik+4jHDbFmw3iiEQqxkJIch6MvK3EAJ+WfDzgl8EzTjXo7U5224K5CTpxNKcvlqFaq2FosTcWU3XdRgjEWp5gnrao0n3XJhbGv90IeZL/qgJsZS2EySuXuWc8wp/2xxb0Lpe46PHF1dCS6acHdgZoj7U9Objfs/9wz0AzglxdjgcOZ5OBO8pIaBzwZqMVQaVInGRSoXOiOBdZxnHns12y5vXr3Bdh9EOpQx937EZezbbDW/e/MB2u2VZAt4HnDH0nUMVAQk5J1KO5Bwl/5EjOWUuTQzqox0BZ7/RDGDVQ86FEhMln+sjhYJZKEhCKUaJEY6H4xMT9cWUkGJ68u+24lJKnI5HDscjj4+PPNw/AEJFaKU4Ho9Mp4mSMsQkbrYIeZZzJsUsJsS4mkwRxzb0HdvtVhJFw5bO9QxDz9XVlr7v2e12dF0vlW8xobXGWUNOZlVCY3mFWhGkdPELLqLw8ziv4Pr36pZKLmuE3z4i1w+UUohhIYSI9zN+mb9ynCC3r3NUQg1UeqA9SoVvkoiPpFRXjxKn6oaeoR9wfUc/CgW9GXuM0bx6dcvpdGK73fI3f/O3dF1P1/VY43DO0vc91sqzROqWlBJ937HdbrDW4KytwXypOWm9RtVVehdK4Kkzb9BSnbNjolRx7s1XiXkWlNaARQyRXHPgL8lvvgAdNXNULpQAMSZ8LU3xfhGzUwoptlIUT0qx2nmNMoZht2G7u+Lm6oof3rzGOctut6kCFaVtNhv++Mc/4ly3plRLaavwqa0H2GwGbm6u8KGn75x8JkuQ18zmp/ZalKBrVVcL8trfREc1CMuFkpoCkkDeHMlJUrvzFCo6jNKn8TXQUde5p0qov0EqHyzW2sr3t5J0vT5bayuaMlhrGTcbNpuRcRzo+x7nJDnjnAXkPuM4MgwDzllKbUU6R8BlFWpDaY2/KmS00VWAnxI4TyPhM9Jr77d5fxwxC0uQ1x3SeKrGXbXFk1s88jUc849//VcXEzpHpDFEQow45xjHkd3uCuCc5aqoQmtRlrGG25tbxnFD5yx912O0pusF8TTlSFXdiFKKeQ7EEFd64nIekpB3DLFjd7XBe7teS7J/Z0Wtov+IntDafFb459eFGDM5zRDFtEpSSsxPiolpliK1J4v0meP5OebxsgnuvBqDDdVuSyFwK85vq7+tCG00zjmMNVxfXTEMA0YJ/6LqStZa4Odms8EYeY9qElqQdOZwzoLSlTJxzlJKrgrQv7vCP1aC0U8/ry5vsI6EMWYN+FbTVnen8FtpzbG8ZLzAJ6Qm/pUejiniF8/Dw4Nk1OaF02kCpeicq2bCYoym63qurncopVhCJquENdKYoTUoI4hp9gl1WoQcWyIoCD4SU8Yvy0qOSYGupu8FNTVBG2Po+56+70WhozjrYRgx1gpRWCnzZveV0hc75am/kArsQggBa/Y1IRXIOVZH7WQnLEFy2xWofBWfkFKmcLbFKUkh1jxLKvO3337jdJrY7/eS5uuHCje7dXVvNiNaGxafCCXjLGQnCROTAaVYfCQXX1up9MWCVBxPE+/f31XmVvIPN9fX9H230sxNCeNmpO96tuMG5xzXN7crslp3aRX1k+CzOvrWYRBTJqaC9x6ttCSbvBQpCH7tiDEyTHNFSeUCxHxhJfz0008yqUpRSOIk4X3gcDiwLIKMYowS5JSCUloiZi8BzZW/kR9nM8YUTF7j1BrdCr+TYqpl65cMaVWF0hQaD5QJMVbB+MpTpTMSSlmCzAJ+WWQH1Z3QdvNlZLtC0FIqB9aaSiSffjoeCSHw+PjI4XDEGEXnxEQJbSKmzVj7dRzzP/3T/wIK8zyzLP5MJ1DqFk1472t+uNQtec7d3t7eMgwbhnHDTo/0usfoVp4CuSR0dXgpiokqtXG8mR4AbSzUwCumyPE01XsvnKYTpWS2YUOOPSEtEBJaG2KIGCsCSxXNNJ6qEXM5CY0uyRlJwS4hsnghHJXWUIpQ8cvMZhx5/fp2jfmMMdBJmfxXoS0eHh4opTBNk5SgV1Ozlg6qyxufoVtz4o3ka+9dxqpKXYDJUigIRf0xL5MrI5qT7ACpAoSSEyF4/OLJJbMsHucWIpqI0OIhRrQxxJTWzNs8T3XX5Ao0EilGYkzs9/takh+ZveQ3utqMOM9zNU+KGEPlsM676nPp0i+ihMPh8EQJ1lpyzlhrub6+ZhgGqaCuwpnnWbj3KsDddss49IxDx/XGsd1ajJHjFLQq0pSHNOjpSt5ZJ+goxUSMnsN+z7t37wjeczgchJGtn00psszC2fz5z28FiaGwNQjzlUVN9cGFwG5urthsxIH3XUcIgZ9++on9/sDxNLE/Thhj2O22GG2q6Qvc3t7gnHTySFCaVuDykvFsJcyzlAKKOVpwzq0OzjnHMAwXgYtwObFVOpQiiKVz9J1l0xl2g+QiFELgaaQhu3XzayMxQKEQSiLEwDRPPH54ZJ5n7u/vhV6vv1cych7IK1LWSO9czpnD8YQPYQ2wdJ23tZYff/wjr17dMg4DV9dXBO+5v7/n/ft7Hg9HHj7scc5xe3uDtXbNJ0Ph9atbnHOr+V3H8zfCC/oTKn42RqJea+wTM3QZyQLrD2wTc84Ro9DdPgZ8CIJolHTGKC3d+MaU1TxJjjrz+OGB/eHAu1/e8dNPf8YvC/vDnlDNxDnH0dy8VCr1XU83btDWcmWsmLKmBK3WCo/tdluj947OGSi2Fpr1OOuxxohDV+dqCwmBBLpeIrNm2l4ynq0EU0s8OmvRCNtplJaW09rA0XaCUopxHJ8ESNZaaeRYFHPdSa2j02iDUgZjCtYalC6gJDuXQuTdLz/z888/8/btz/zff/5nQi30SkkCM2NsjQX6apoCOSeur2+4vrrBOcdm3K6LIn+Us7i+3rLdDHTOMgwdWivGcWCeN8yLx9nWy1YVoZUUDuTEssyUktntpJI8pbTyZl9cCX9p5HI2Q62TRlJ8Zd0t8DTxkUtBt8S9UtRiyJWPglZlEZimicPhwDSdatNIWJV+hq6FnN16H3nR7nlOQeYa48iXxP/E2ElDYS1yXhNANb3aSvO5mH+7T5tHQ4tNSS9hLp6vhJqVyrUGVYSUUSoTvCCEZVmYpqnCSjFXkg+QCHYYx0qAiUkwBTktpRRwiVIVZq3Fe8/j4yOn04m3b9/yr//6r5xOp7UJsRGKDd2suTBV6DpXhWIIXhoMU8worVnmWUBDTvgoFeE//vgDr19dsxlHKNeEEKUHb1mIKa4CF9CRquCFofXeY4xhGAaur69r8Pd8BbxMCU0Ra1CVn/iBnITM894DoHVcd4S1psYUT68FooDGMa15iKqoZVmY55nD4cB+vyeEcyTaigxkMTSnWEm9ap+V0pXVhJQ9SilO08TpdCKmwLJIU+HVVS+d/1rhw0gM6SLwOy9p8XeKM6SV6vSc8wrZW03SSxTxQnN0XsVK1W2LwNSu79akjZQ/nguIY4zkIs7QGH0GDjVQUqVI1k0Jnvfeczwe+e2339jv9wJHfSDlLLlpqIeWNHMjjG2Dx00JwXseg8yjHfvjl4Wl1VBpiaBLFhsffOJ0nMm54FzPdnMm65qClaLyYeCsW8/jkPeEJzMvKAZ+oRLOiEBsYDUDpeCc5H+tPWe6pmlaA7NLu6l1VUKlFXKKqFIoNQMWQ8Bby/F04t2vv7J/fORwOOC9X9nWJ0y/PtvoEGKFzJZSLD54vA/C9gbh+lt5pLWGcTOgjJHj01LB+8jxKArqXIfZOVrJZEpCjzSW1tTcyFp3VFGjMQZrvpISLqHoZSGutK+2syFyLZTVdJ2rgjdrMkfMUjuiQEHR5KwpGfxpoqiZaVlwpxMPDw8c9nsxHdUHGV2Ly1SreVIsfq7CaY60lUMWtFGyQwv0PVBY52yMZhh6jDV0rgM0OUtTekGYW1GM8FKNuQVd4bmpHNTZX4i5LLUw4StEzO2iORdCTPWkLoGJp5M01Fln6HorlQ/Dtn5H+p+32w2bcRRWte9wvSMFjS+w+MCv797W9qq8Fta+e/cO7z3zLCXyfd9zfS0B0ziOGGO4e3/H+/d3K2CQigkRdN/3bLc7rLE1InYXVMll6SSI2ZTaqZwS0zQTo1Ab0zzhnOXm5rqytw6j7VpQEIKQmFprtpsNZme+jhLaWMtCLuFmkt2gTU1wV5gmMFWU0Lphnvx4pchKk0rhNM2cTucG8rmimAZHlZJDQiQIdPT9gLGm2mW9miTgvBO0JJJa1s+1vruLYq0WcEn7V6yURBJkFKRBXQIy9SQos8aCagcXnn1lfmGg9iIllJIoSK3lOA4YYxlqxYM2UicaQ+BU/CoIoXcdWoufaDnlhmxybSL3YeHXX3/l4eFh7bhpW7zhfK0FfWy3W6xzjIMEg32Fv7Em2c8YnpVSEZ4rEYI45nmW3rllWVb2V5QvbKz4EKlTktK0Qkw90zxSSmHcjFztNnTOsd2Icm9ubuiHgc5160lnX14JlZiSLFm3QrK1Eq5x8LVVqZF31vQYIzZymgR5DEMv/Qd1xBh5fPzA3d3dmhtoqc628sSvOIZxXLs2tdZ0rsNZtwZVrcpOYga1+qBWKj9NM4f9QUzI8bDuurYDQwhP6BdjNMYahLJfatpVM24kYfT69hZrbS1KcCj9MlP0IiX84Q8/ANQ6m7JmsFRt3FBKsSwzp/lISkkcW84YfRk1n3O7DX+3yum2chuCat+5fJSSCd6v7VkK8P6iWrxVXGepwp7nhfv7h4rIhPua50W6SlMkREFO2hg6pXCdYyyDmB2jV5LPdY6+73nz5g19P/D69Stub2/oO0mtNmSka778qynhv/3jP1aMrNfsVLOxvtrt9/f3/PJLqrzOTAiJznEhVBFVdSk1+oyEEGkrt5WuXOYptBKB5Ap9lVK1L03yCG33S3m9qk4aHh/33D98oGXuoJrAym+1Ryu3cdbS97VZfTvinGXoB1nlXcf19Q2d63j16oarq52gNdNgaitQrmcCfg0l9H2HQq3wUmvZpqWATpGcZSJaSS9Bc47NNInTC4BiWRakICuRUqhR9rnU/vc6H0uW/gWUWpMoDSh8/GgQei3pv0jgay2FaK6u3nEc6XtRxDj0WGPY1mK0vh+kWtA5dtvtCgqcc5VVNevioi4ClOIle+H5JS/DCJyPVYghEo8zuWTmpSKKk4dikLOnpcljOs1MFfl477HW8vBwf2YckySCtNbsdruVXpaOniMpSd9zDIFg/ZrV63vxCcdjZplbarKWIaa0dmg26lnYWUXfdXR9T9c5bm+u6TrHzfU1281YCxIE+g7jUGMbtyIwZ+WcpHb4SGUGm25pJTQvU8FLjlUw8tHmE2JKLN6Tk6QTY0zEkGiHjANQpOEuVmfdzE0IoSZC0urAQYqIOyfVGb4WDlACCS5Y2osGvhqxltK6NfOa8mwcVDNpjYru+p7NZmQYel69uqHve16/uuFqt3uihL4fqp03F4ecNFSX186fj1sGzuMroKO3v7wDzp034nxDLfOQ/gTvA8u8EGKUQuALenttENeaeZ5rAuRMOTRhzWbGaEOKcaU+GicU63uNDLTWMs/zCmUbHO26RqE4+uo4x3HEOst2M8p5eX3H7e0NnbNr6tVYK3lkraWgoJrVnFoZpAj3krz8VAGXAOQLK+HPb38G6k5otj7KZELNr6YkB4mkfH5e21krFGwT/hj9fFwLVLJ0yLecAEhxcVNkSlIR1zA+gHNSeLDbbhiGbqWXnbNcXctK3+12XO12OOe42slRPp1zF5BZX1SAiLlJ+dzDfSb0eKKENp6iwC+shJTqySc5n7f/2v1SLsslOPupVuH2aQnIxwglxXS+xsr/nHvfqNds27+lKLVWayFY1zmMNlxdbRkHQTVXVzustdXROjbjWIvAzMp6Cpioiad1Ci3a+DzO+Xxg/MJEQh0vq8Ar1HKUikJUlvajeh52KQpTFCprTG5dkjWhf2Ev1x+YCxkRdChh/dtaOlKVq5UcHKKLqQGjkZPCkqLvO/rOMQw9P7x5Q9d3vL59xXYrEe0wDit9IY3gUpzV/JPQJ3o9wbH52pz5jLn5WMif+oBcT4l5yXgBbSEXP8/rXGPUbKXSbWXXM6ZRcrDfRbrzSS1RbYP5HMRUSlahQpq/VaXSW7Jdcga65oV7NuPIbiedPddXO3a7Bie7TwLAJxXYbXFcAJ2Ke18gRvVELi+lj15wGqSsBN1WP3LGaQGUqs3VNU7IJaO0qRmnc2lic6BPGjbWQydqU1/F2EqdDzDvOrdG6JvtWMtPbum7jt12w67Cy+vra6y1wta6Kvyaf2gCX6sleKqEM5d6RlYfj9+vojjzVRdx4bPHi1nUpgxprzdr3VCpSsi6ngxWW5Ra/VFLrl8mxylF2leb+bkQvK4rXStFPww4a9luN9zcXtH3PT/88IZxHLnebbnabtc8rxx3YNZkzCqcNv8LBTwRdPtJVEWo5wuzfa4VBny9nfBkZVweNv607ujys5eR7yXRd9k/purqdE5yvK5WTYsdl1L2YRiqfZfGwcZadl3HZhhWInHF8xcCFk7q6e/4bJliuXDBNfJViie/6zNSeaoA/h2WjH+nElSd6GpOLyaiTWNbxYlaa9eA7HI3tL85Jxm3q91WBF2rM6wxbIZBGMuWDOpcrQuqGTYtPJbRH3XZrKvxXKh1LhB7KvxPhNz+XlMj7TO/991LyNru/dLxfHOkPldLo9Y/rf8s4phL3c+XTrkFWQ3CtsDKWcPuandWQoWQYy/KaDSxs4au72rBgF1N1+fs99nSnyd3nqc6r/z6u8774GKxPYHWT3dXAySN/X1p1d3leH4L7RPXhQib5sR0hZJnobT/pqURfq2dqeUJbM1HDOMgq34zyuEcNROmlKonP1Lbmc7H20iW7ZIyPscpSgHlfDhJ69CncmtnWV8EXW1VcH5WlfITRKXP14bzNbmgjxo1rPl6xzRTfUB5ciL6eYtfVh0oJf89S6t8aHVH49goBLHxfd+vueKW6LHNtsOTaPnJTFbq+NMpnquv9JroeYJ9VkGWsyI+NjMXiniyg9b7y19Lg1LNIa+ffRlMfbYShmGgbcH2O9vKd04gpLG1FFDXmlXd0osiXOmqlFN+TVVMq5Zru+SybFJ+8JPle2Hj9eo4zx/+6IVqy7+91UxqWc1Qu/5FWHZhyj658Cej+YXzqvmKjnm7ESpb1//Gq6EarTWbjfQbO2dXQfedHPIttlzoAetaP3NLmtcGcy6d3lPYePlCqc98/rPoRZ+/98kyhk/N/8fk81NfIvd+epnmF1altvef/Ot548Xo6JJkuzRD56i0ZcI0l5Hq05QlqyLUZ67NeodPJvH0+aO5/e7cGy/UlKU+z/h/LDz1F3bDOY749zvk9VrlP+LWv48vMr7/V8DfwPiuhG9gfFfCNzC+K+EbGN+V8A2M70r4BsZ3JXwD47sSvoHxXQnfwPj/9jL6wTLhXEcAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Real Label: truck Predicted Label: truck \n" ] } ], "source": [ "# 추론\n", "import random\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import torch\n", + "from model import ModelClass\n", + "\n", + "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "model = ModelClass()\n", + "model.load_state_dict(torch.load('torch.pt'))\n", + "model.to(device)\n", "\n", "# test 데이터셋에서 10개의 샘플을 무작위로 선택\n", "random.seed(42)\n", "samples = random.sample(range(len(test_dataset)), k=10)\n", "\n", + "def convert_label(label):\n", + " class_labels = ['airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']\n", + " return class_labels[label]\n", + "\n", "# 선택된 샘플에 대해 라벨 출력 및 모델 추론\n", "for sample in samples:\n", " data, target = test_dataset[sample]\n", + " real_label = convert_label(target.item())\n", " data = data.to(device)\n", " model.eval()\n", " with torch.no_grad():\n", " output = model(data.unsqueeze(0))\n", " _, predicted = torch.max(output, 1)\n", - " print(\"Label:\", target.item(), \"Inference Result:\", predicted.item())" + " predicted_label = convert_label(predicted.item())\n", + "\n", + " data_cpu = data.cpu().detach()\n", + "\n", + " plt.figure(figsize=(3, 1))\n", + " plt.imshow(data_cpu.permute(1, 2, 0))\n", + " plt.axis('off')\n", + " plt.show()\n", + " \n", + " print(f\"Real Label: {real_label:10} Predicted Label: {predicted_label:10}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Real Label: truck Predicted Label: automobile\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Real Label: bird Predicted Label: automobile\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Real Label: automobile Predicted Label: automobile\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Real Label: cat Predicted Label: automobile\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Real Label: horse Predicted Label: automobile\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Real Label: cat Predicted Label: automobile\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Real Label: horse Predicted Label: automobile\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Real Label: airplane Predicted Label: automobile\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Real Label: truck Predicted Label: automobile\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Real Label: truck Predicted Label: automobile\n" + ] + } + ], + "source": [ + "# 학습이 이루어지지 않은 모델 추론\n", + "model = ModelClass().to(device)\n", + "\n", + "for sample in samples:\n", + " data, target = test_dataset[sample]\n", + " real_label = convert_label(target.item())\n", + " data = data.to(device)\n", + " model.eval()\n", + " with torch.no_grad():\n", + " output = model(data.unsqueeze(0))\n", + " _, predicted = torch.max(output, 1)\n", + " predicted_label = convert_label(predicted.item())\n", + "\n", + " data_cpu = data.cpu().detach()\n", + "\n", + " plt.figure(figsize=(3, 1))\n", + " plt.imshow(data_cpu.permute(1, 2, 0))\n", + " plt.axis('off')\n", + " plt.show()\n", + " \n", + " print(f\"Real Label: {real_label:10} Predicted Label: {predicted_label:10}\")" ] }, { From a23763d880bb9fff7a95306d2ce4befc19d38bef Mon Sep 17 00:00:00 2001 From: seungwoo1124 Date: Tue, 14 May 2024 18:31:29 +0900 Subject: [PATCH 4/7] add requirements, sskai_load_data.py and change directory name --- example/Mobilenetv2_face_emotion/.gitignore | 2 - example/ResNet34_CIFAR-10/.gitignore | 2 + .../download_dataset.py | 4 +- .../model.py | 0 example/ResNet34_CIFAR-10/requirements.txt | 2 + example/ResNet34_CIFAR-10/sskai_load_data.py | 69 +++++++++++++++++++ .../train.ipynb | 0 7 files changed, 75 insertions(+), 4 deletions(-) delete mode 100644 example/Mobilenetv2_face_emotion/.gitignore create mode 100644 example/ResNet34_CIFAR-10/.gitignore rename example/{Mobilenetv2_face_emotion => ResNet34_CIFAR-10}/download_dataset.py (67%) rename example/{Mobilenetv2_face_emotion => ResNet34_CIFAR-10}/model.py (100%) create mode 100644 example/ResNet34_CIFAR-10/requirements.txt create mode 100644 example/ResNet34_CIFAR-10/sskai_load_data.py rename example/{Mobilenetv2_face_emotion => ResNet34_CIFAR-10}/train.ipynb (100%) diff --git a/example/Mobilenetv2_face_emotion/.gitignore b/example/Mobilenetv2_face_emotion/.gitignore deleted file mode 100644 index d3e510951c..0000000000 --- a/example/Mobilenetv2_face_emotion/.gitignore +++ /dev/null @@ -1,2 +0,0 @@ -cifar-10-batches-py -torch.pt \ No newline at end of file diff --git a/example/ResNet34_CIFAR-10/.gitignore b/example/ResNet34_CIFAR-10/.gitignore new file mode 100644 index 0000000000..93f114f65c --- /dev/null +++ b/example/ResNet34_CIFAR-10/.gitignore @@ -0,0 +1,2 @@ +cifar-10* +torch.pt \ No newline at end of file diff --git a/example/Mobilenetv2_face_emotion/download_dataset.py b/example/ResNet34_CIFAR-10/download_dataset.py similarity index 67% rename from example/Mobilenetv2_face_emotion/download_dataset.py rename to example/ResNet34_CIFAR-10/download_dataset.py index d6d5d72857..a73bcddf75 100644 --- a/example/Mobilenetv2_face_emotion/download_dataset.py +++ b/example/ResNet34_CIFAR-10/download_dataset.py @@ -10,9 +10,9 @@ cwd = os.getcwd() # 학습 데이터셋 다운로드 -trainset = torchvision.datasets.CIFAR10(root=f'{cwd}/example/Mobilenetv2_face_emotion/input', train=True, +trainset = torchvision.datasets.CIFAR10(root=f'{cwd}/example/ResNet34_CIFAR-10/', train=True, download=True, transform=transform) # 테스트 데이터셋 다운로드 -testset = torchvision.datasets.CIFAR10(root=f'{cwd}/example/Mobilenetv2_face_emotion/input', train=False, +testset = torchvision.datasets.CIFAR10(root=f'{cwd}/example/ResNet34_CIFAR-10/', train=False, download=True, transform=transform) \ No newline at end of file diff --git a/example/Mobilenetv2_face_emotion/model.py b/example/ResNet34_CIFAR-10/model.py similarity index 100% rename from example/Mobilenetv2_face_emotion/model.py rename to example/ResNet34_CIFAR-10/model.py diff --git a/example/ResNet34_CIFAR-10/requirements.txt b/example/ResNet34_CIFAR-10/requirements.txt new file mode 100644 index 0000000000..5e3d0a980d --- /dev/null +++ b/example/ResNet34_CIFAR-10/requirements.txt @@ -0,0 +1,2 @@ +numpy==1.24.4 +torch==2.0.1 \ No newline at end of file diff --git a/example/ResNet34_CIFAR-10/sskai_load_data.py b/example/ResNet34_CIFAR-10/sskai_load_data.py new file mode 100644 index 0000000000..2a9a70a171 --- /dev/null +++ b/example/ResNet34_CIFAR-10/sskai_load_data.py @@ -0,0 +1,69 @@ +# 전처리 +def sskai_load_data(): + import pickle + import numpy as np + import torch + from torch.utils.data import DataLoader, TensorDataset, ConcatDataset, random_split + + def load_cifar_batch(filename): + with open(filename, 'rb') as file: + batch = pickle.load(file, encoding='latin1') + # 이미지 데이터 재배열: [num_samples, 3, 32, 32] + features = batch['data'].reshape((len(batch['data']), 3, 32, 32)).transpose(0, 2, 3, 1) + labels = batch['labels'] + return features, labels + + def create_datasets(data_paths, test_path): + # 데이터를 로드하고 하나의 큰 훈련 데이터셋으로 결합 + train_features = [] + train_labels = [] + for path in data_paths: + features, labels = load_cifar_batch(path) + train_features.append(features) + train_labels.append(labels) + train_features = np.concatenate(train_features) + train_labels = np.concatenate(train_labels) + + # 테스트 데이터 로드 + test_features, test_labels = load_cifar_batch(test_path) + + # numpy 배열을 PyTorch 텐서로 변환 + train_features = torch.tensor(train_features).permute(0, 3, 1, 2).float() / 255.0 + train_labels = torch.tensor(train_labels).long() + test_features = torch.tensor(test_features).permute(0, 3, 1, 2).float() / 255.0 + test_labels = torch.tensor(test_labels).long() + + # TensorDataset 생성 + train_dataset = TensorDataset(train_features, train_labels) + test_dataset = TensorDataset(test_features, test_labels) + return train_dataset, test_dataset + + data_dir_path = "./cifar-10/" + data_paths = [f'{data_dir_path}/data_batch_{i}' for i in range(1, 6)] + test_path = f'{data_dir_path}/test_batch' + + # 데이터셋 생성 + train_dataset, test_dataset = create_datasets(data_paths, test_path) + + # DataLoader 생성 예 + train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True) + test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False) + + # 데이터셋 합치기 + combined_dataset = torch.utils.data.ConcatDataset([train_dataset, test_dataset]) + + # 합친 데이터셋으로 DataLoader 생성 + combined_loader = torch.utils.data.DataLoader(combined_dataset, batch_size=64, shuffle=True) + + # combined_dataset에서 data와 label을 따로 떼어서 x, y 변수에 할당 + x = [] + y = [] + for data, label in combined_dataset: + x.append(data) + y.append(label) + + print(f"x type : {type(x[0])}, x shape : {x[0].shape}") + print(f"y type : {type(y[0])}, y shape : {y[0].shape}") + +if __name__ == '__main__': + sskai_load_data() \ No newline at end of file diff --git a/example/Mobilenetv2_face_emotion/train.ipynb b/example/ResNet34_CIFAR-10/train.ipynb similarity index 100% rename from example/Mobilenetv2_face_emotion/train.ipynb rename to example/ResNet34_CIFAR-10/train.ipynb From ea5b0997fd132fadd7297efc48e5de564d20c7b4 Mon Sep 17 00:00:00 2001 From: seungwoo1124 Date: Tue, 14 May 2024 21:02:38 +0900 Subject: [PATCH 5/7] add return x, y --- example/ResNet34_CIFAR-10/sskai_load_data.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/example/ResNet34_CIFAR-10/sskai_load_data.py b/example/ResNet34_CIFAR-10/sskai_load_data.py index 2a9a70a171..d70ece7907 100644 --- a/example/ResNet34_CIFAR-10/sskai_load_data.py +++ b/example/ResNet34_CIFAR-10/sskai_load_data.py @@ -62,8 +62,7 @@ def create_datasets(data_paths, test_path): x.append(data) y.append(label) - print(f"x type : {type(x[0])}, x shape : {x[0].shape}") - print(f"y type : {type(y[0])}, y shape : {y[0].shape}") + return x, y if __name__ == '__main__': sskai_load_data() \ No newline at end of file From 46f0728f0ec674542c0deaefb4bc63c39fd196c5 Mon Sep 17 00:00:00 2001 From: seungwoo1124 Date: Wed, 15 May 2024 21:37:59 +0900 Subject: [PATCH 6/7] remove p2 instance --- recommend/family_recommend/family/family.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/recommend/family_recommend/family/family.py b/recommend/family_recommend/family/family.py index 91434f0a96..592935201b 100644 --- a/recommend/family_recommend/family/family.py +++ b/recommend/family_recommend/family/family.py @@ -60,7 +60,7 @@ def get_family_for_inference(region): df['TotalScore'] = df.apply(get_total_instance_score, args=(max_price, max_benchmark), axis=1) groups = [ - ['g3', 'p2'], # group 1 + ['g3'], # group 1 (호환성 문제로 p2 제거) ['g4dn', 'g5g', 'p3'], # group 2 ['g6', 'gr6', 'g5'], # group 3 ['p3dn', 'p4d'], # group 4 From 78c9ce125b41819dff26f9794c2a1df629729d72 Mon Sep 17 00:00:00 2001 From: seungwoo1124 Date: Wed, 15 May 2024 21:45:54 +0900 Subject: [PATCH 7/7] remove requirements --- example/ResNet34_CIFAR-10/requirements.txt | 2 -- 1 file changed, 2 deletions(-) diff --git a/example/ResNet34_CIFAR-10/requirements.txt b/example/ResNet34_CIFAR-10/requirements.txt index 5e3d0a980d..e69de29bb2 100644 --- a/example/ResNet34_CIFAR-10/requirements.txt +++ b/example/ResNet34_CIFAR-10/requirements.txt @@ -1,2 +0,0 @@ -numpy==1.24.4 -torch==2.0.1 \ No newline at end of file