From 318ef7970380aa2b008daa5cf20f327922da280e Mon Sep 17 00:00:00 2001 From: Mohamed Esmail Date: Sat, 8 Jul 2023 20:36:23 +0300 Subject: [PATCH] Removed sensor code + added form correctness models notebooks --- assets/models/pullUp.tflite | Bin 0 -> 11248 bytes assets/models/pullUp_v2.tflite | Bin 0 -> 24176 bytes lib/screens/camera_screen.dart | 38 +- lib/utils/exercise.dart | 2 +- ..._Keypoints_from_Videos_using_MovNet_.ipynb | 918 ++++++++++ ..._Correctness_Model_and_data_analysis.ipynb | 1472 +++++++++++++++++ 6 files changed, 2400 insertions(+), 30 deletions(-) create mode 100644 assets/models/pullUp.tflite create mode 100644 assets/models/pullUp_v2.tflite create mode 100644 notebooks/Extracting_Human_Body_Pose_Keypoints_from_Videos_using_MovNet_.ipynb create mode 100644 notebooks/Form_Correctness_Model_and_data_analysis.ipynb diff --git a/assets/models/pullUp.tflite b/assets/models/pullUp.tflite new file mode 100644 index 0000000000000000000000000000000000000000..3626ef4861a00f38a7cae5e2777a4ac48f7100e2 GIT binary patch literal 11248 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 G)czltp1|n< literal 0 HcmV?d00001 diff --git a/assets/models/pullUp_v2.tflite b/assets/models/pullUp_v2.tflite new file mode 100644 index 0000000000000000000000000000000000000000..ac8d4209b0d33660d3eceaa5f91a8e0ae9f3ffd4 GIT binary patch literal 24176 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 W4tsj_X5J9i8G%b!=e~~(_5TBYDB98h literal 0 HcmV?d00001 diff --git a/lib/screens/camera_screen.dart b/lib/screens/camera_screen.dart index 57420bf..ca5c1e2 100644 --- a/lib/screens/camera_screen.dart +++ b/lib/screens/camera_screen.dart @@ -5,7 +5,6 @@ import 'package:flutter/foundation.dart'; import 'package:flutter/material.dart'; import 'package:camera/camera.dart'; import 'package:fluttertoast/fluttertoast.dart'; -import 'package:sensors_plus/sensors_plus.dart'; import '../utils/camera/coach_tts.dart'; import '../utils/exercise.dart'; @@ -72,13 +71,6 @@ class _CameraScreenState extends State /// ****************************** - /// SENSOR-RELATED FIELDS - late StreamSubscription _accelerometerSubscription; - double _accelerationMagnitude = 0.0; - late bool isNotMoving; - - /// ****************************** - /// FormClassifier-related fields double formCorrectness = 0.0; bool showCorrectness = false; @@ -87,7 +79,7 @@ class _CameraScreenState extends State /// ****************************** /// FlutterTTS-related field - CoachTTS tts = CoachTTS(); + CoachTTS coachTTS = CoachTTS(); bool adviceCooldown = false; int currentAdvice = 0; @@ -189,16 +181,6 @@ class _CameraScreenState extends State FormClassifier(confidenceModel: widget.exercise.formCorrectnessModel); _restSecondsRemaining = widget.session.restTime; - /****** SENSOR-RELATED CODE ******/ - _accelerometerSubscription = - accelerometerEvents.listen((AccelerometerEvent event) { - // Calculate the magnitude of the acceleration vector - _accelerationMagnitude = - event.x * event.x + event.y * event.y + event.z * event.z; - }); - isNotMoving = _accelerationMagnitude == 0.0; - /*********************************/ - super.initState(); initAsync(); } @@ -221,7 +203,7 @@ class _CameraScreenState extends State classifier = PoseDetector(); classifier.loadModel(); - tts.speak( + coachTTS.speak( "Welcome to Coach.ai! Please read the following instructions carefully."); showInstructions(); @@ -283,8 +265,7 @@ class _CameraScreenState extends State */ /// Counting reps inferences - if (isNotMoving && - countingRepsMode && + if (countingRepsMode && inferenceResults[widget.exercise.trackedKeypoint][2] >= 0.3) { repCounter.startCounting( inferenceResults[widget.exercise.trackedKeypoint] @@ -301,7 +282,7 @@ class _CameraScreenState extends State showCorrectness && (warmupMode || countingRepsMode)) { // print("here"); - tts.speak(widget.exercise.correctionAdvice[ + coachTTS.speak(widget.exercise.correctionAdvice[ currentAdvice % widget.exercise.correctionAdvice.length]); currentAdvice++; adviceCooldown = true; @@ -346,7 +327,7 @@ class _CameraScreenState extends State if (_restSecondsRemaining > 0) { _restSecondsRemaining--; } else { - tts.speak("Time's up! Let's get back to work."); + coachTTS.speak("Time's up! Let's get back to work."); timer.cancel(); } }); @@ -458,7 +439,7 @@ class _CameraScreenState extends State warmupMode = false; repCounter.warmup(warmupInferences); warmedUpAtLeastOnce = true; - tts.speak( + coachTTS.speak( "You have now finished your warmup. You can start exercising now! Don't worry, I will tell you each time you perform a rep, and when you complete a set."); }); // print(warmupInferences); @@ -488,7 +469,7 @@ class _CameraScreenState extends State if (allowRestMode && (currentSetCount < widget.session.sets)) { currentSetCount++; - tts.speak( + coachTTS.speak( "You have finished your set! Take a ${widget.session.restTime} second break and come back."); if (currentSetCount < widget.session.sets) { currentlyRestingMode = true; @@ -504,7 +485,7 @@ class _CameraScreenState extends State ); } else { // At this condition, the user will have finished his required sets, and completed his workout - tts.speak( + coachTTS.speak( "Well done! You have completed your workout! Great Job!"); showDialog( context: context, @@ -603,9 +584,8 @@ class _CameraScreenState extends State @override void dispose() { - tts.tts.stop(); + coachTTS.tts.stop(); cameraController.dispose(); - _accelerometerSubscription.cancel(); isolate.stop(); super.dispose(); } diff --git a/lib/utils/exercise.dart b/lib/utils/exercise.dart index 82fd564..6e51b73 100644 --- a/lib/utils/exercise.dart +++ b/lib/utils/exercise.dart @@ -73,7 +73,7 @@ final List availableExercises = [ trackedKeypoint: kKeypointDict['nose'] as int, trackingDirection: 1, fullRepPosition: false, - formCorrectnessModel: 'models/pullUp.tflite', + formCorrectnessModel: 'models/pullUp_v2.tflite', targetedMuscles: ['Back', 'Biceps', 'Shoulders'], cameraInstructions: [ "For this exercise, you need to place your phone in a portrait orientation.", diff --git a/notebooks/Extracting_Human_Body_Pose_Keypoints_from_Videos_using_MovNet_.ipynb b/notebooks/Extracting_Human_Body_Pose_Keypoints_from_Videos_using_MovNet_.ipynb new file mode 100644 index 0000000..7127aaa --- /dev/null +++ b/notebooks/Extracting_Human_Body_Pose_Keypoints_from_Videos_using_MovNet_.ipynb @@ -0,0 +1,918 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "gpuType": "T4" + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "source": [ + "*Welcome to my Colab notebook that uses computer vision techniques to extract key information from videos. In this notebook, we will reduce the resolution of a video and convert it into frames. Then, we will pass each frame through a MovNet model to generate 17 keypoints (x, y, confidence) representing the body pose in the frame. We will then save the results from all the frames in a numpy array. This notebook is a powerful tool for analyzing human movements in videos and can be used in a variety of applications, such as sports analysis, motion capture, and more.*" + ], + "metadata": { + "id": "lj4APKU2Nor0" + } + }, + { + "cell_type": "code", + "source": [ + "!pip install -q imageio\n", + "!pip install -q opencv-python\n", + "!pip install -q git+https://github.com/tensorflow/docs" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "PcR5VCDKdjo0", + "outputId": "418dbe03-ec86-4f4f-c9e2-8f831e5db6f4" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + " Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n" + ] + } + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "o37zeSPDdO8y" + }, + "outputs": [], + "source": [ + "import tensorflow as tf\n", + "import tensorflow_hub as hub\n", + "from tensorflow_docs.vis import embed\n", + "import numpy as np\n", + "import cv2\n", + "\n", + "# Import matplotlib libraries\n", + "from matplotlib import pyplot as plt\n", + "from matplotlib.collections import LineCollection\n", + "import matplotlib.patches as patches\n", + "\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from PIL import Image\n", + "import tensorflow as tf\n", + "import tensorflow.keras.backend as K\n", + "from google.colab.patches import cv2_imshow\n", + "from tensorflow.python.ops.numpy_ops import np_config\n", + "import pandas as pd\n", + "# Some modules to display an animation using imageio.\n", + "import imageio\n", + "from IPython.display import HTML, display" + ] + }, + { + "cell_type": "code", + "source": [ + "import imageio\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.animation as animation\n", + "from skimage.transform import resize\n", + "from IPython.display import HTML\n", + "\n", + "def display_video(video):\n", + " fig = plt.figure(figsize=(15,15)) # Display size specification\n", + "\n", + " mov = []\n", + " for i in range(len(video)): # Append videos one by one to mov\n", + " img = plt.imshow(cv2.cvtColor(video[i], cv2.COLOR_BGR2RGB), animated=True)\n", + " plt.axis('off')\n", + " mov.append([img])\n", + "\n", + " # Animation creation\n", + " anime = animation.ArtistAnimation(fig, mov, interval=50, repeat_delay=1000)\n", + "\n", + " plt.close()\n", + " return anime" + ], + "metadata": { + "id": "ikZi7RSJRJIh" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "# Reducing Video Resolution" + ], + "metadata": { + "id": "TEFTzY9CJJv5" + } + }, + { + "cell_type": "code", + "source": [ + "import cv2\n", + "\n", + "# Load the input video\n", + "cap = cv2.VideoCapture('PullUP_F.mp4')\n", + "\n", + "# Set the output video codec\n", + "fourcc = cv2.VideoWriter_fourcc(*'mp4v')\n", + "\n", + "# Set the output video dimensions and frame rate\n", + "width, height = 256, 256\n", + "fps = cap.get(cv2.CAP_PROP_FPS)\n", + "\n", + "# Create the output video writer\n", + "out = cv2.VideoWriter('pullUP_F256.mp4', fourcc, fps, (width, height))\n", + "\n", + "# Process each frame of the input video\n", + "while True:\n", + " # Read a frame from the input video\n", + " ret, frame = cap.read()\n", + "\n", + " # If the frame cannot be read, break the loop\n", + " if not ret:\n", + " break\n", + "\n", + " # Resize the frame to the output dimensions\n", + " resized_frame = cv2.resize(frame, (width, height))\n", + "\n", + " # Write the resized frame to the output video\n", + " out.write(resized_frame)\n", + "\n", + "# Release the input and output video objects\n", + "cap.release()\n", + "out.release()" + ], + "metadata": { + "id": "vKGfpt2HQXAy" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "# Loading MoveNet: Ultra fast and accurate pose detection model." + ], + "metadata": { + "id": "44sseT4deAsB" + } + }, + { + "cell_type": "markdown", + "source": [ + "**[MoveNet](https://t.co/QpfnVL0YYI?amp=1)** is an ultra fast and accurate model that detects 17 keypoints of a body. The model is offered on [TF Hub](https://tfhub.dev/s?q=movenet) with two variants, known as Lightning and Thunder. Lightning is intended for latency-critical applications, while Thunder is intended for applications that require high accuracy. Both models run faster than real time (30+ FPS) on most modern desktops, laptops, and phones, which proves crucial for live fitness, health, and wellness applications.\n", + "\n", + "\n", + "\"drawing\"/\n" + ], + "metadata": { + "id": "g58Y55ODL0e5" + } + }, + { + "cell_type": "code", + "source": [ + "model_name = \"movenet_thunder\" #@param [\"movenet_lightning\", \"movenet_thunder\", \"movenet_lightning_f16.tflite\", \"movenet_thunder_f16.tflite\", \"movenet_lightning_int8.tflite\", \"movenet_thunder_int8.tflite\"]\n", + "\n", + "if \"tflite\" in model_name:\n", + " if \"movenet_lightning_f16\" in model_name:\n", + " !wget -q -O model.tflite https://tfhub.dev/google/lite-model/movenet/singlepose/lightning/tflite/float16/4?lite-format=tflite\n", + " input_size = 192\n", + " elif \"movenet_thunder_f16\" in model_name:\n", + " !wget -q -O model.tflite https://tfhub.dev/google/lite-model/movenet/singlepose/thunder/tflite/float16/4?lite-format=tflite\n", + " input_size = 256\n", + " elif \"movenet_lightning_int8\" in model_name:\n", + " !wget -q -O model.tflite https://tfhub.dev/google/lite-model/movenet/singlepose/lightning/tflite/int8/4?lite-format=tflite\n", + " input_size = 192\n", + " elif \"movenet_thunder_int8\" in model_name:\n", + " !wget -q -O model.tflite https://tfhub.dev/google/lite-model/movenet/singlepose/thunder/tflite/int8/4?lite-format=tflite\n", + " input_size = 256\n", + " else:\n", + " raise ValueError(\"Unsupported model name: %s\" % model_name)\n", + "\n", + " # Initialize the TFLite interpreter\n", + " interpreter = tf.lite.Interpreter(model_path=\"model.tflite\")\n", + " interpreter.allocate_tensors()\n", + "\n", + " def movenet(input_image):\n", + " \"\"\"Runs detection on an input image.\n", + "\n", + " Args:\n", + " input_image: A [1, height, width, 3] tensor represents the input image\n", + " pixels. Note that the height/width should already be resized and match the\n", + " expected input resolution of the model before passing into this function.\n", + "\n", + " Returns:\n", + " A [1, 1, 17, 3] float numpy array representing the predicted keypoint\n", + " coordinates and scores.\n", + " \"\"\"\n", + " # TF Lite format expects tensor type of uint8.\n", + " input_image = tf.cast(input_image, dtype=tf.uint8)\n", + " input_details = interpreter.get_input_details()\n", + " output_details = interpreter.get_output_details()\n", + " interpreter.set_tensor(input_details[0]['index'], input_image.numpy())\n", + " # Invoke inference.\n", + " interpreter.invoke()\n", + " # Get the model prediction.\n", + " keypoints_with_scores = interpreter.get_tensor(output_details[0]['index'])\n", + " return keypoints_with_scores\n", + "\n", + "else:\n", + " if \"movenet_lightning\" in model_name:\n", + " module = hub.load(\"https://tfhub.dev/google/movenet/singlepose/lightning/4\")\n", + " input_size = 192\n", + " elif \"movenet_thunder\" in model_name:\n", + " module = hub.load(\"https://tfhub.dev/google/movenet/singlepose/thunder/4\")\n", + " input_size = 256\n", + " else:\n", + " raise ValueError(\"Unsupported model name: %s\" % model_name)\n", + "\n", + " def movenet(input_image):\n", + " \"\"\"Runs detection on an input image.\n", + "\n", + " Args:\n", + " input_image: A [1, height, width, 3] tensor represents the input image\n", + " pixels. Note that the height/width should already be resized and match the\n", + " expected input resolution of the model before passing into this function.\n", + "\n", + " Returns:\n", + " A [1, 1, 17, 3] float numpy array representing the predicted keypoint\n", + " coordinates and scores.\n", + " \"\"\"\n", + " model = module.signatures['serving_default']\n", + "\n", + " # SavedModel format expects tensor type of int32.\n", + " input_image = tf.cast(input_image, dtype=tf.int32)\n", + " # Run model inference.\n", + " outputs = model(input_image)\n", + " # Output is a [1, 1, 17, 3] tensor.\n", + " keypoints_with_scores = outputs['output_0'].numpy()\n", + " return keypoints_with_scores" + ], + "metadata": { + "id": "PL2U2H9Td9Sy" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "# helper functions" + ], + "metadata": { + "id": "KV9e2xblfgEH" + } + }, + { + "cell_type": "code", + "source": [ + "#@title Cropping Algorithm\n", + "\n", + "# Confidence score to determine whether a keypoint prediction is reliable.\n", + "MIN_CROP_KEYPOINT_SCORE = 0.2\n", + "\n", + "def init_crop_region(image_height, image_width):\n", + " \"\"\"Defines the default crop region.\n", + "\n", + " The function provides the initial crop region (pads the full image from both\n", + " sides to make it a square image) when the algorithm cannot reliably determine\n", + " the crop region from the previous frame.\n", + " \"\"\"\n", + " if image_width > image_height:\n", + " box_height = image_width / image_height\n", + " box_width = 1.0\n", + " y_min = (image_height / 2 - image_width / 2) / image_height\n", + " x_min = 0.0\n", + " else:\n", + " box_height = 1.0\n", + " box_width = image_height / image_width\n", + " y_min = 0.0\n", + " x_min = (image_width / 2 - image_height / 2) / image_width\n", + "\n", + " return {\n", + " 'y_min': y_min,\n", + " 'x_min': x_min,\n", + " 'y_max': y_min + box_height,\n", + " 'x_max': x_min + box_width,\n", + " 'height': box_height,\n", + " 'width': box_width\n", + " }\n", + "\n", + "def torso_visible(keypoints):\n", + " \"\"\"Checks whether there are enough torso keypoints.\n", + "\n", + " This function checks whether the model is confident at predicting one of the\n", + " shoulders/hips which is required to determine a good crop region.\n", + " \"\"\"\n", + " return ((keypoints[0, 0, KEYPOINT_DICT['left_hip'], 2] >\n", + " MIN_CROP_KEYPOINT_SCORE or\n", + " keypoints[0, 0, KEYPOINT_DICT['right_hip'], 2] >\n", + " MIN_CROP_KEYPOINT_SCORE) and\n", + " (keypoints[0, 0, KEYPOINT_DICT['left_shoulder'], 2] >\n", + " MIN_CROP_KEYPOINT_SCORE or\n", + " keypoints[0, 0, KEYPOINT_DICT['right_shoulder'], 2] >\n", + " MIN_CROP_KEYPOINT_SCORE))\n", + "\n", + "def determine_torso_and_body_range(\n", + " keypoints, target_keypoints, center_y, center_x):\n", + " \"\"\"Calculates the maximum distance from each keypoints to the center location.\n", + "\n", + " The function returns the maximum distances from the two sets of keypoints:\n", + " full 17 keypoints and 4 torso keypoints. The returned information will be\n", + " used to determine the crop size. See determineCropRegion for more detail.\n", + " \"\"\"\n", + " torso_joints = ['left_shoulder', 'right_shoulder', 'left_hip', 'right_hip']\n", + " max_torso_yrange = 0.0\n", + " max_torso_xrange = 0.0\n", + " for joint in torso_joints:\n", + " dist_y = abs(center_y - target_keypoints[joint][0])\n", + " dist_x = abs(center_x - target_keypoints[joint][1])\n", + " if dist_y > max_torso_yrange:\n", + " max_torso_yrange = dist_y\n", + " if dist_x > max_torso_xrange:\n", + " max_torso_xrange = dist_x\n", + "\n", + " max_body_yrange = 0.0\n", + " max_body_xrange = 0.0\n", + " for joint in KEYPOINT_DICT.keys():\n", + " if keypoints[0, 0, KEYPOINT_DICT[joint], 2] < MIN_CROP_KEYPOINT_SCORE:\n", + " continue\n", + " dist_y = abs(center_y - target_keypoints[joint][0]);\n", + " dist_x = abs(center_x - target_keypoints[joint][1]);\n", + " if dist_y > max_body_yrange:\n", + " max_body_yrange = dist_y\n", + "\n", + " if dist_x > max_body_xrange:\n", + " max_body_xrange = dist_x\n", + "\n", + " return [max_torso_yrange, max_torso_xrange, max_body_yrange, max_body_xrange]\n", + "\n", + "def determine_crop_region(\n", + " keypoints, image_height,\n", + " image_width):\n", + " \"\"\"Determines the region to crop the image for the model to run inference on.\n", + "\n", + " The algorithm uses the detected joints from the previous frame to estimate\n", + " the square region that encloses the full body of the target person and\n", + " centers at the midpoint of two hip joints. The crop size is determined by\n", + " the distances between each joints and the center point.\n", + " When the model is not confident with the four torso joint predictions, the\n", + " function returns a default crop which is the full image padded to square.\n", + " \"\"\"\n", + " target_keypoints = {}\n", + " for joint in KEYPOINT_DICT.keys():\n", + " target_keypoints[joint] = [\n", + " keypoints[0, 0, KEYPOINT_DICT[joint], 0] * image_height,\n", + " keypoints[0, 0, KEYPOINT_DICT[joint], 1] * image_width\n", + " ]\n", + "\n", + " if torso_visible(keypoints):\n", + " center_y = (target_keypoints['left_hip'][0] +\n", + " target_keypoints['right_hip'][0]) / 2;\n", + " center_x = (target_keypoints['left_hip'][1] +\n", + " target_keypoints['right_hip'][1]) / 2;\n", + "\n", + " (max_torso_yrange, max_torso_xrange,\n", + " max_body_yrange, max_body_xrange) = determine_torso_and_body_range(\n", + " keypoints, target_keypoints, center_y, center_x)\n", + "\n", + " crop_length_half = np.amax(\n", + " [max_torso_xrange * 1.9, max_torso_yrange * 1.9,\n", + " max_body_yrange * 1.2, max_body_xrange * 1.2])\n", + "\n", + " tmp = np.array(\n", + " [center_x, image_width - center_x, center_y, image_height - center_y])\n", + " crop_length_half = np.amin(\n", + " [crop_length_half, np.amax(tmp)]);\n", + "\n", + " crop_corner = [center_y - crop_length_half, center_x - crop_length_half];\n", + "\n", + " if crop_length_half > max(image_width, image_height) / 2:\n", + " return init_crop_region(image_height, image_width)\n", + " else:\n", + " crop_length = crop_length_half * 2;\n", + " return {\n", + " 'y_min': crop_corner[0] / image_height,\n", + " 'x_min': crop_corner[1] / image_width,\n", + " 'y_max': (crop_corner[0] + crop_length) / image_height,\n", + " 'x_max': (crop_corner[1] + crop_length) / image_width,\n", + " 'height': (crop_corner[0] + crop_length) / image_height -\n", + " crop_corner[0] / image_height,\n", + " 'width': (crop_corner[1] + crop_length) / image_width -\n", + " crop_corner[1] / image_width\n", + " }\n", + " else:\n", + " return init_crop_region(image_height, image_width)\n", + "\n", + "def crop_and_resize(image, crop_region, crop_size):\n", + " \"\"\"Crops and resize the image to prepare for the model input.\"\"\"\n", + " boxes=[[crop_region['y_min'], crop_region['x_min'],\n", + " crop_region['y_max'], crop_region['x_max']]]\n", + " output_image = tf.image.crop_and_resize(\n", + " image, box_indices=[0], boxes=boxes, crop_size=crop_size)\n", + " return output_image\n", + "\n", + "def run_inference(movenet, image, crop_region, crop_size):\n", + " \"\"\"Runs model inferece on the cropped region.\n", + "\n", + " The function runs the model inference on the cropped region and updates the\n", + " model output to the original image coordinate system.\n", + " \"\"\"\n", + " image_height, image_width, _ = image.shape\n", + " input_image = crop_and_resize(\n", + " tf.expand_dims(image, axis=0), crop_region, crop_size=crop_size)\n", + " # Run model inference.\n", + " keypoints_with_scores = movenet(input_image)\n", + " # Update the coordinates.\n", + " for idx in range(17):\n", + " keypoints_with_scores[0, 0, idx, 0] = (\n", + " crop_region['y_min'] * image_height +\n", + " crop_region['height'] * image_height *\n", + " keypoints_with_scores[0, 0, idx, 0]) / image_height\n", + " keypoints_with_scores[0, 0, idx, 1] = (\n", + " crop_region['x_min'] * image_width +\n", + " crop_region['width'] * image_width *\n", + " keypoints_with_scores[0, 0, idx, 1]) / image_width\n", + " return keypoints_with_scores\n", + "def progress(value, max=100):\n", + " return HTML(\"\"\"\n", + " \n", + " {value}\n", + " \n", + " \"\"\".format(value=value, max=max))" + ], + "metadata": { + "id": "z6BbybzGffuV" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "#@title Helper functions for visualization\n", + "\n", + "# Dictionary that maps from joint names to keypoint indices.\n", + "KEYPOINT_DICT = {\n", + " 'nose': 0,\n", + " 'left_eye': 1,\n", + " 'right_eye': 2,\n", + " 'left_ear': 3,\n", + " 'right_ear': 4,\n", + " 'left_shoulder': 5,\n", + " 'right_shoulder': 6,\n", + " 'left_elbow': 7,\n", + " 'right_elbow': 8,\n", + " 'left_wrist': 9,\n", + " 'right_wrist': 10,\n", + " 'left_hip': 11,\n", + " 'right_hip': 12,\n", + " 'left_knee': 13,\n", + " 'right_knee': 14,\n", + " 'left_ankle': 15,\n", + " 'right_ankle': 16\n", + "}\n", + "\n", + "# Maps bones to a matplotlib color name.\n", + "KEYPOINT_EDGE_INDS_TO_COLOR = {\n", + " (0, 1): 'm',\n", + " (0, 2): 'c',\n", + " (1, 3): 'm',\n", + " (2, 4): 'c',\n", + " (0, 5): 'm',\n", + " (0, 6): 'c',\n", + " (5, 7): 'm',\n", + " (7, 9): 'm',\n", + " (6, 8): 'c',\n", + " (8, 10): 'c',\n", + " (5, 6): 'y',\n", + " (5, 11): 'm',\n", + " (6, 12): 'c',\n", + " (11, 12): 'y',\n", + " (11, 13): 'm',\n", + " (13, 15): 'm',\n", + " (12, 14): 'c',\n", + " (14, 16): 'c'\n", + "}" + ], + "metadata": { + "id": "Lf2qmtsFkoBh" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "# converting the video to frames" + ], + "metadata": { + "id": "UfEdzozfeNRa" + } + }, + { + "cell_type": "code", + "source": [ + "\n", + "np_config.enable_numpy_behavior()\n", + "def loadVid(path):\n", + " # Create a VideoCapture object and read from input file\n", + " # If the input is the camera, pass 0 instead of the video file name\n", + " cap = cv2.VideoCapture(path)\n", + "\n", + " # Check if camera opened successfully\n", + " if (cap.isOpened()== False):\n", + " print(\"Error opening video stream or file\")\n", + "\n", + " i = 0\n", + " # Read until video is completed\n", + " while(cap.isOpened()):\n", + " # Capture frame-by-frame\n", + " i += 1\n", + " ret, frame = cap.read()\n", + " if ret == True:\n", + "\n", + " #Store the resulting frame\n", + " if i == 1:\n", + " frames = frame[np.newaxis, ...]\n", + " else:\n", + " frame = frame[np.newaxis, ...]\n", + " frames = np.vstack([frames, frame])\n", + " frames = np.squeeze(frames)\n", + "\n", + " else:\n", + " break\n", + "\n", + " # When everything done, release the video capture object\n", + " cap.release()\n", + "\n", + " return frames" + ], + "metadata": { + "id": "O1UfR5vBeKDU" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "# loading the video" + ], + "metadata": { + "id": "Xvbj8JtoeqWL" + } + }, + { + "cell_type": "code", + "source": [ + "frames=loadVid(\"pullUP_F256.mp4\")\n", + "frames=tf.convert_to_tensor(frames)" + ], + "metadata": { + "id": "qDqQI7iDr88B" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "# Data Augmentation" + ], + "metadata": { + "id": "yJ6mTTuzKUDW" + } + }, + { + "cell_type": "code", + "source": [ + "def augment(frames):\n", + "\n", + " rotated_90 = tf.image.rot90(frames)\n", + " frames = tf.concat([frames, rotated_90], axis=0)\n", + " del rotated_90\n", + " flipped_images = tf.image.flip_left_right(frames)\n", + " frames = tf.concat([frames, flipped_images], axis=0)\n", + " del flipped_images\n", + " return frames" + ], + "metadata": { + "id": "ydo860uIr79h" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "frames.shape" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "QyTIU4igN8Ot", + "outputId": "c596436d-9d03-43d9-bfd9-c11b88c78bc1" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "TensorShape([5447, 256, 256, 3])" + ] + }, + "metadata": {}, + "execution_count": 12 + } + ] + }, + { + "cell_type": "code", + "source": [ + "flipped_images=tf.image.flip_left_right(frames)" + ], + "metadata": { + "id": "jJzBcENPKx8L" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "frames = tf.concat([frames, flipped_images], axis=0)" + ], + "metadata": { + "id": "a1ZdP2soa3aT" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "rotated_90 = tf.image.rot90(frames[:2000])\n", + "frames = tf.concat([frames, rotated_90], axis=0)" + ], + "metadata": { + "id": "w4Hg5cTJU7d-" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "frames.shape" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "vhHmqykkOEud", + "outputId": "efcaca6a-ce70-42f3-d97a-7f7a76c50442" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "TensorShape([12894, 256, 256, 3])" + ] + }, + "metadata": {}, + "execution_count": 18 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "# Generating the keypoints" + ], + "metadata": { + "id": "tO3PC0lVLBek" + } + }, + { + "cell_type": "code", + "source": [ + "\n", + "num_frames, image_height, image_width, _ = frames.shape\n", + "crop_region = init_crop_region(image_height, image_width)\n", + "\n", + "output_keypoints=[]\n", + "bar = display(progress(0, num_frames-1), display_id=True)\n", + "for frame_idx in range(num_frames):\n", + " keypoints_with_scores = run_inference(\n", + " movenet, frames[frame_idx, :, :, :], crop_region,\n", + " crop_size=[input_size, input_size])\n", + "\n", + " output_keypoints.append(keypoints_with_scores)\n", + "\n", + " crop_region = determine_crop_region(\n", + " keypoints_with_scores, image_height, image_width)\n", + " bar.update(progress(frame_idx, num_frames-1))\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "id": "werItaiTe63d", + "outputId": "a79f435d-56f7-4bd0-a7a7-52e26de93521" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "\n", + " \n", + " 12893\n", + " \n", + " " + ] + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "# saving the data" + ], + "metadata": { + "id": "AkLCfMrRhDKf" + } + }, + { + "cell_type": "code", + "source": [ + "output_keypoints=np.array(output_keypoints)" + ], + "metadata": { + "id": "eqx8B4AS0myD" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "np.save('pullUP_F.npy', output_keypoints)\n" + ], + "metadata": { + "id": "QqjYaco5lPGk" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "output_keypoints.shape" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "9eHu-pQZ0bwu", + "outputId": "4ad35175-974f-422c-a97b-6bba46198fdf" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(12894, 1, 1, 17, 3)" + ] + }, + "metadata": {}, + "execution_count": 22 + } + ] + }, + { + "cell_type": "code", + "source": [ + "output_keypoints" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "00W21ZaRN9Vy", + "outputId": "7bad3508-2fd7-481a-8d0e-878efc911aca" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([[[[[2.92048067e-01, 5.22662878e-01, 1.63227529e-03],\n", + " [3.94913673e-01, 5.01913488e-01, 1.96826435e-03],\n", + " [2.38119677e-01, 4.90857422e-01, 3.33389995e-04],\n", + " ...,\n", + " [5.61807513e-01, 2.85854071e-01, 1.84777826e-02],\n", + " [6.34234309e-01, 7.04065561e-01, 1.30680175e-02],\n", + " [6.71082735e-01, 2.76862174e-01, 2.23788973e-02]]]],\n", + "\n", + "\n", + "\n", + " [[[[2.92048067e-01, 5.22662878e-01, 1.63227529e-03],\n", + " [3.94913673e-01, 5.01913488e-01, 1.96826435e-03],\n", + " [2.38119677e-01, 4.90857422e-01, 3.33389995e-04],\n", + " ...,\n", + " [5.61807513e-01, 2.85854071e-01, 1.84777826e-02],\n", + " [6.34234309e-01, 7.04065561e-01, 1.30680175e-02],\n", + " [6.71082735e-01, 2.76862174e-01, 2.23788973e-02]]]],\n", + "\n", + "\n", + "\n", + " [[[[2.92048067e-01, 5.22662878e-01, 1.63227529e-03],\n", + " [3.94913673e-01, 5.01913488e-01, 1.96826435e-03],\n", + " [2.38119677e-01, 4.90857422e-01, 3.33389995e-04],\n", + " ...,\n", + " [5.61807513e-01, 2.85854071e-01, 1.84777826e-02],\n", + " [6.34234309e-01, 7.04065561e-01, 1.30680175e-02],\n", + " [6.71082735e-01, 2.76862174e-01, 2.23788973e-02]]]],\n", + "\n", + "\n", + "\n", + " ...,\n", + "\n", + "\n", + "\n", + " [[[[4.04275864e-01, 3.23877573e-01, 3.89402241e-01],\n", + " [3.80223781e-01, 3.08069646e-01, 5.12389541e-01],\n", + " [3.92473042e-01, 3.22470784e-01, 4.35176760e-01],\n", + " ...,\n", + " [6.09507143e-01, 8.54452312e-01, 6.24060869e-01],\n", + " [3.89787316e-01, 1.18164636e-01, 3.12702924e-01],\n", + " [5.94798803e-01, 7.96394706e-01, 4.97342460e-02]]]],\n", + "\n", + "\n", + "\n", + " [[[[3.98804784e-01, 3.25500667e-01, 4.40699399e-01],\n", + " [3.77842605e-01, 3.13418001e-01, 4.28768992e-01],\n", + " [3.89229625e-01, 3.21900129e-01, 4.48886395e-01],\n", + " ...,\n", + " [6.17924631e-01, 8.45811307e-01, 7.16056585e-01],\n", + " [3.87507915e-01, 1.17650755e-01, 2.68292964e-01],\n", + " [5.35457969e-01, 2.00611800e-01, 2.99425244e-01]]]],\n", + "\n", + "\n", + "\n", + " [[[[3.99027467e-01, 3.21921945e-01, 4.11806285e-01],\n", + " [3.78660828e-01, 3.10248852e-01, 5.72195470e-01],\n", + " [3.90980482e-01, 3.19023848e-01, 4.25660729e-01],\n", + " ...,\n", + " [6.10627472e-01, 8.27060342e-01, 7.39089072e-01],\n", + " [8.23044240e-01, 9.85980153e-01, 2.65734881e-01],\n", + " [8.13671947e-01, 9.91119027e-01, 2.11519226e-01]]]]],\n", + " dtype=float32)" + ] + }, + "metadata": {}, + "execution_count": 23 + } + ] + } + ] +} \ No newline at end of file diff --git a/notebooks/Form_Correctness_Model_and_data_analysis.ipynb b/notebooks/Form_Correctness_Model_and_data_analysis.ipynb new file mode 100644 index 0000000..41beed6 --- /dev/null +++ b/notebooks/Form_Correctness_Model_and_data_analysis.ipynb @@ -0,0 +1,1472 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "code", + "source": [ + "!pip install -q imageio\n", + "!pip install -q opencv-python\n", + "!pip install -q git+https://github.com/tensorflow/docs" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "q8i_jDTAlrkf", + "outputId": "391796cf-43b2-45cd-935d-2e3e8514cbcb" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + " Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import tensorflow as tf\n", + "import tensorflow_hub as hub\n", + "from tensorflow_docs.vis import embed\n", + "import numpy as np\n", + "import cv2\n", + "\n", + "# Import matplotlib libraries\n", + "from matplotlib import pyplot as plt\n", + "from matplotlib.collections import LineCollection\n", + "import matplotlib.patches as patches\n", + "\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from PIL import Image\n", + "import tensorflow as tf\n", + "import tensorflow.keras.backend as K\n", + "from google.colab.patches import cv2_imshow\n", + "from tensorflow.python.ops.numpy_ops import np_config\n", + "import pandas as pd\n", + "# Some modules to display an animation using imageio.\n", + "import imageio\n", + "from IPython.display import HTML, display" + ], + "metadata": { + "id": "13bXiiteP1fd" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "# loading the data" + ], + "metadata": { + "id": "wQAGh-DEPY5G" + } + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "m4uJNRjcLpY8" + }, + "outputs": [], + "source": [ + "trueData=np.load('pullUP_T.npy')\n", + "falseData=np.load('pullUP_F.npy')" + ] + }, + { + "cell_type": "markdown", + "source": [ + "# Data Analysis" + ], + "metadata": { + "id": "s0q_sLnUPfcU" + } + }, + { + "cell_type": "code", + "source": [ + "trueData=np.squeeze(trueData)\n", + "falseData=np.squeeze(falseData)" + ], + "metadata": { + "id": "QD2k9wKFPczO" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "trueLabes=np.ones((trueData.shape[0],1))\n", + "falseLabels=np.zeros((falseData.shape[0],1))" + ], + "metadata": { + "id": "EOEjrh7uPiJF" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "def mean_std_x_y(data):\n", + " # calculate the mean x and y values for each keypoint separately\n", + " mean_x = np.mean(data[:,:,0], axis=0)\n", + " mean_y = np.mean(data[:,:,1], axis=0)\n", + "\n", + " # define the connections between keypoints\n", + " connections = [(0,1), (0,2), (1,3), (2,4), (0,5), (0,6), (5,7), (7,9), (6,8), (8,10), (5,6), (5,11), (6,12), (11,12), (11,13), (13,15), (12,14), (14,16)]\n", + " # specify the size of the figure\n", + " plt.figure(figsize=(8, 6))\n", + " # plot the mean x and y values for each keypoint and connect them\n", + " for i, (x, y) in enumerate(zip(mean_x, mean_y)):\n", + " plt.scatter(x, y)\n", + " for a, b in connections:\n", + " plt.plot([mean_x[a], mean_x[b]], [mean_y[a], mean_y[b]], color='gray', linestyle='-', linewidth=1)\n", + "\n", + " plt.xlabel('Mean X')\n", + " plt.ylabel('Mean Y')\n", + " plt.legend()\n", + "#########################################################################################\n", + "\n", + " # calculate the standard deviation of the x and y values for each keypoint separately\n", + " std_x = np.std(data[:,:,0], axis=0)\n", + " std_y = np.std(data[:,:,1], axis=0)\n", + "\n", + " # create a bar chart of the standard deviation of the x and y values for each keypoint\n", + " x = np.arange(17)\n", + " width = 0.35\n", + " fig, ax = plt.subplots()\n", + " rects1 = ax.bar(x - width/2, std_x, width, label='X')\n", + " rects2 = ax.bar(x + width/2, std_y, width, label='Y')\n", + " ax.set_xlabel('Keypoint')\n", + " ax.set_ylabel('Standard deviation')\n", + " ax.set_title('Standard deviation of X and Y values for each keypoint')\n", + " ax.set_xticks(x)\n", + " ax.legend()\n", + " plt.show()\n", + "\n" + ], + "metadata": { + "id": "11eKOYohzqR8" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "def heatmap_x_y(data):\n", + " # create a heatmap of the distribution of keypoints\n", + " fig, ax = plt.subplots()\n", + " hist = ax.hist2d(data[:,:,0].flatten(), data[:,:,1].flatten(), bins=50)\n", + " ax.set_xlabel('X')\n", + " ax.set_ylabel('Y')\n", + " ax.set_title('Heatmap of the distribution of keypoints')\n", + " fig.colorbar(hist[3], ax=ax)\n", + " plt.show()" + ], + "metadata": { + "id": "SSIHeXfx1zp6" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "def mean_std_confi(data):\n", + " # calculate the mean confidence for each keypoint separately\n", + " mean_conf = np.mean(data[:,:,2], axis=0)\n", + "\n", + " # create a bar chart of the mean confidence for each keypoint\n", + " x = np.arange(17)\n", + " width = 0.35\n", + " fig, ax = plt.subplots()\n", + " rects1 = ax.bar(x, mean_conf, width)\n", + " ax.set_xlabel('Keypoint')\n", + " ax.set_ylabel('Mean confidence')\n", + " ax.set_title('Mean confidence for each keypoint')\n", + " ax.set_xticks(x)\n", + " plt.show()\n", + "############################################################################\n", + " # calculate the standard deviation of the confidence for each keypoint separately\n", + " std_conf = np.std(data[:,:,2], axis=0)\n", + "\n", + " # create a bar chart of the standard deviation of the confidence for each keypoint\n", + " x = np.arange(17)\n", + " width = 0.35\n", + " fig, ax = plt.subplots()\n", + " rects1 = ax.bar(x, std_conf, width)\n", + " ax.set_xlabel('Keypoint')\n", + " ax.set_ylabel('Standard deviation')\n", + " ax.set_title('Standard deviation of confidence for each keypoint')\n", + " ax.set_xticks(x)\n", + " plt.show()" + ], + "metadata": { + "id": "8MPnDrPT2Mhd" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "# True Data" + ], + "metadata": { + "id": "tbImXxJK66yE" + } + }, + { + "cell_type": "code", + "source": [ + "mean_std_x_y(trueData)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "cVoviRL80orU", + "outputId": "71171235-c37c-4166-a0d5-5b545c662907" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "WARNING:matplotlib.legend:No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "heatmap_x_y(trueData)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 472 + }, + "id": "q_WgHSbR7tfW", + "outputId": "50976763-c7ac-4e46-dec1-cdb0f4030f12" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "mean_std_confi(trueData)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 927 + }, + "id": "UHwjoWe634iV", + "outputId": "c60943be-a763-4a29-cdfd-cc0454887f91" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "# False Data" + ], + "metadata": { + "id": "TBCBLHNx724h" + } + }, + { + "cell_type": "code", + "source": [ + "mean_std_x_y(falseData)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "0R86Jn3P71fS", + "outputId": "65719f88-5007-4b68-874f-c3621e4fd11d" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "WARNING:matplotlib.legend:No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "heatmap_x_y(falseData)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 472 + }, + "id": "MG3JHgqN77rz", + "outputId": "acc4343e-e8e7-464e-cbdc-6b87c68b4f40" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAHHCAYAAABtF1i4AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABmU0lEQVR4nO3de3wU1dkH8N/sJru53wjkApEgXgBFoaFgUAtqNAJSeb2hUm5VQCQqRKtSuSioKFVKRRShgtRiQa3aqhSkIFoFRREsCiLIVSDhEnK/bLJz3j80W5Zkn5OwJLNhf9/3s5+37jNn5uzszHIyM89zDKWUAhEREZFFbFZ3gIiIiIIbByNERERkKQ5GiIiIyFIcjBAREZGlOBghIiIiS3EwQkRERJbiYISIiIgsxcEIERERWYqDESIiIrIUByN0xvvDH/6As88+G3a7Hd26dWt0+7Vr18IwDLz55punv3ON2P7atWs9740YMQLp6enNsv309HSMGDHC89+vvPIKDMPAl19+2Szb79u3L/r27dss2zpV+fn5uOmmm9CqVSsYhoHZs2fXu9yePXtgGAaeeeaZ5u3gaVb7OV555RWru0JnCA5Gmpnuh7xv37648MILm7QPy5cvx6OPPtqk2wgUH3zwAR588EFceumlWLRoEZ588kmfy7722ms+/xE5E2zduhWPPvoo9uzZY3VX6gjkvjXEhAkTsHLlSkycOBGvvvoqrr32Wqu7FLDKy8vx6KOPeg2uiUKs7gA1v+XLl2Pu3LlBMSBZs2YNbDYbXn75ZTgcDnHZ1157Dd988w3Gjx/fPJ3zw4IFC2CaZqPabN26FY899hj69u3bqKsq27dvh83WtH+3SH374IMPmnTbp8OaNWtw/fXX44EHHrC6K82iffv2qKioQGhoaKPblpeX47HHHgOAgL/iRc2HgxE6ox0+fBjh4eHagUhLcyr/CDSGUgqVlZUIDw+H0+ls0m3ptITv7vDhw4iLi7O6G83GMAyEhYVZ3Q06g/A2TQvx17/+FRkZGQgPD0dCQgJuvfVW7N+/32uZ//znP7j55ptx1llnwel0Ii0tDRMmTEBFRYVnmREjRmDu3LkAfvpBqX0B3vez586di7PPPhsRERG45pprsH//fiilMH36dLRr1w7h4eG4/vrrUVBQ4NWHf/zjHxgwYABSU1PhdDrRsWNHTJ8+HW6322u52ttRGzduRO/evREeHo4OHTpg3rx5DdofNTU1mD59Ojp27Ain04n09HT8/ve/R1VVlWcZwzCwaNEilJWVeT6nr3vcffv2xfvvv4+9e/d6lj35L3TTNPHEE0+gXbt2CAsLw1VXXYWdO3fWWdfnn3+Oa6+9FrGxsYiIiECfPn3w6aefNuhz/fjjjxg0aBAiIyPRpk0bTJgwwesz1arvmZGlS5ciIyMD0dHRiImJQdeuXfGnP/0JwE+3B2+++WYAwBVXXOH5jLWXytPT03Hddddh5cqV6NGjB8LDw/HSSy95Yic+M1KrvLwcY8aMQatWrRATE4Nhw4bh+PHjXssYhlHvFbgT16nrW33PjBw+fBh33HEHkpKSEBYWhosvvhiLFy/2WubE43n+/PmeY+WXv/wlvvjiizp9qs+uXbtw8803IyEhAREREbjkkkvw/vvve+K1t12VUpg7d67X+dRQSimMHj0aDocDb731lud93Tk/depUhIaG4siRI3XWOXr0aMTFxaGyshLA/77fDz74AN26dUNYWBi6dOnitb2Gfmag/mdGRowYgaioKBw4cACDBg1CVFQUWrdujQceeMBz/u/ZswetW7cGADz22GOe/VV7jOTl5WHkyJFo164dnE4nUlJScP3117fY23fUcLwyYpGioiIcPXq0zvvV1dV13nviiScwefJk3HLLLbjzzjtx5MgRzJkzB7/61a+wadMmz19kb7zxBsrLyzF27Fi0atUKGzZswJw5c/Djjz/ijTfeAACMGTMGBw8exKpVq/Dqq6/W27clS5bA5XLhnnvuQUFBAWbOnIlbbrkFV155JdauXYuHHnoIO3fuxJw5c/DAAw9g4cKFnravvPIKoqKikJubi6ioKKxZswZTpkxBcXEx/vCHP3ht5/jx4+jfvz9uueUW3HbbbXj99dcxduxYOBwO/Pa3vxX335133onFixfjpptuwv3334/PP/8cM2bMwLZt2/D2228DAF599VXMnz8fGzZswJ///GcAQO/evetd3yOPPIKioiL8+OOP+OMf/wgAiIqK8lrmqaeegs1mwwMPPICioiLMnDkTQ4YMweeff+5ZZs2aNejXrx8yMjIwdepU2Gw2LFq0CFdeeSX+85//oGfPnj4/U0VFBa666irs27cP9957L1JTU/Hqq69izZo14r4AgFWrVuG2227DVVddhaeffhoAsG3bNnz66ae477778Ktf/Qr33nsvnnvuOfz+979H586dAcDz/4GfbsfcdtttGDNmDEaNGoXzzz9f3GZOTg7i4uLw6KOPYvv27XjxxRexd+9ezwO3DdWQvp2ooqICffv2xc6dO5GTk4MOHTrgjTfewIgRI1BYWIj77rvPa/nXXnsNJSUlGDNmDAzDwMyZM3HDDTdg165d4hWm/Px89O7dG+Xl5bj33nvRqlUrLF68GL/+9a/x5ptv4v/+7//wq1/9Cq+++iqGDh2Kq6++GsOGDWvw5wYAt9uN3/72t1i2bBnefvttDBgwAEDDzvmhQ4di2rRpWLZsGXJycjzrdLlcePPNN3HjjTd6Xb3YsWMHBg8ejLvuugvDhw/HokWLcPPNN2PFihW4+uqrG/yZdZ8nOzsbvXr1wjPPPIN///vfePbZZ9GxY0eMHTsWrVu3xosvvoixY8fi//7v/3DDDTcAAC666CIAwI033ohvv/0W99xzD9LT03H48GGsWrUK+/bta7YHtskiiprVokWLFADxdcEFF3iW37Nnj7Lb7eqJJ57wWs+WLVtUSEiI1/vl5eV1tjdjxgxlGIbau3ev571x48ap+r763bt3KwCqdevWqrCw0PP+xIkTFQB18cUXq+rqas/7t912m3I4HKqyslLsw5gxY1RERITXcn369FEA1LPPPut5r6qqSnXr1k21adNGuVyuujvvZ5s3b1YA1J133un1/gMPPKAAqDVr1njeGz58uIqMjPS5rhMNGDBAtW/fvs77H374oQKgOnfurKqqqjzv/+lPf1IA1JYtW5RSSpmmqc4991yVnZ2tTNP0LFdeXq46dOigrr76anH7s2fPVgDU66+/7nmvrKxMnXPOOQqA+vDDD70+14l9ve+++1RMTIyqqanxuf433nijznpqtW/fXgFQK1asqDc2fPhwz3/XHsMZGRle39PMmTMVAPWPf/zD8x4ANXXqVO06pb716dNH9enTx/Pftfvpr3/9q+c9l8ulMjMzVVRUlCouLlZK/e94btWqlSooKPAs+49//EMBUO+++26dbZ1o/PjxCoD6z3/+43mvpKREdejQQaWnpyu32+31OceNGyeu78Q+/eEPf1DV1dVq8ODBKjw8XK1cudKzTGPO+czMTNWrVy+v5d566606+7L2+/373//uea+oqEilpKSo7t27N/oz136ORYsWeZYbPny4AqCmTZvm1Z/u3burjIwMz38fOXKk3uPi+PHjnn1DwYe3aSwyd+5crFq1qs6r9i+EWm+99RZM08Qtt9yCo0ePel7Jyck499xz8eGHH3qWDQ8P9/zvsrIyHD16FL1794ZSCps2bWpw326++WbExsZ6/rtXr14AgN/85jcICQnxet/lcuHAgQP19qGkpARHjx7F5ZdfjvLycnz33Xde2wkJCcGYMWM8/+1wODBmzBgcPnwYGzdu9Nm/5cuXAwByc3O93r///vsBoM4l5dNl5MiRXs8vXH755QB+uqwNAJs3b8aOHTtw++2349ixY57vqqysDFdddRU+/vhj8aHT5cuXIyUlBTfddJPnvYiICIwePVrbt7i4OJSVlWHVqlWn+vHQoUMHZGdnN3j50aNHe11ZGDt2LEJCQjzfT1NZvnw5kpOTcdttt3neCw0Nxb333ovS0lJ89NFHXssPHjwY8fHxnv8++XuTttOzZ09cdtllnveioqIwevRo7NmzB1u3bj3lz+ByuXDzzTfjvffew/Lly3HNNdd4Yo0554cNG4bPP/8cP/zwg+e9JUuWIC0tDX369PHaZmpqqteVjdpba5s2bUJeXt5p+8x33XWX139ffvnl2n0NwPNs19q1a+vc7qMzH2/TWKRnz57o0aNHnffj4+O9bt/s2LEDSimce+659a7nxH8M9u3bhylTpuCf//xnnZO5qKiowX0766yzvP67dmCSlpZW7/snbuvbb7/FpEmTsGbNGhQXF4t9SE1NRWRkpNd75513HoCf7i1fcskl9fZv7969sNlsOOecc7zeT05ORlxcHPbu3St+vlN18n6p/Qeu9vPv2LEDADB8+HCf6ygqKvL6h/FEe/fuxTnnnFPnFofudgkA3H333Xj99dfRr18/tG3bFtdccw1uueWWRqWYdujQocHLAqhzTEZFRSElJaXJ7+/v3bsX5557bp0Mn9rbOid//7rvTdpO7UDc13ZONQ1/xowZKC0txb/+9a86z8M05pwfPHgwxo8fjyVLlmDKlCkoKirCe++9hwkTJtQ5juo7tk4835KTk/3+zGFhYZ5nQmrFx8c3aHDhdDrx9NNP4/7770dSUhIuueQSXHfddRg2bBiSk5O17all42AkwJmmCcMw8K9//Qt2u71OvPa5BrfbjauvvhoFBQV46KGH0KlTJ0RGRuLAgQMYMWJEo9JA69uO9L5SCgBQWFiIPn36ICYmBtOmTUPHjh0RFhaGr776Cg899FCjU1F1GvugoL90n7/28/3hD3/wWVzt5OdQTpc2bdpg8+bNWLlyJf71r3/hX//6FxYtWoRhw4bVebDTlxOvajW1kx9obkq6780K2dnZWLFiBWbOnIm+fft6PdvR0HMe+Okf+uuuu84zGHnzzTdRVVWF3/zmN83yOU7ma1831Pjx4zFw4EC88847WLlyJSZPnowZM2ZgzZo16N69+2nqJQUiDkYCXMeOHaGUQocOHTx/xdRny5Yt+P7777F48WKvh+jqu2zfVP+Ir127FseOHcNbb72FX/3qV573d+/eXe/yBw8eRFlZmdfVke+//x4AxIfV2rdvD9M0sWPHDq+HHPPz81FYWIj27dufUv/93S8dO3YE8NPl76ysrEa3b9++Pb755hsopbz6sn379ga1dzgcGDhwIAYOHAjTNHH33XfjpZdewuTJk+v9q9hfO3bswBVXXOH579LSUhw6dAj9+/f3vBcfH4/CwkKvdi6XC4cOHfJ6rzF9a9++Pf773//CNE2vqyO1twFP9fuvbzv17fvTsZ1LLrkEd911F6677jrcfPPNePvttz23QBt6ztcaNmwYrr/+enzxxRdYsmQJunfvjgsuuKDOcjt37qxzbJ18vjXlZ66l+647duyI+++/H/fffz927NiBbt264dlnn8Vf//pXv7dNgYvPjAS4G264AXa7HY899lidv+SUUjh27BiA//1FcuIySilPaueJav/xP/kfCX/V1weXy4UXXnih3uVramo86aO1y7700kto3bo1MjIyfG6n9h+7k6ulzpo1CwA8GQmNFRkZ2ajbWSfLyMhAx44d8cwzz6C0tLROvL4UzBP1798fBw8e9Co7X15ejvnz52u3XXsc1LLZbJ7nj2pTg0/39z5//nyv7K8XX3wRNTU16Nevn+e9jh074uOPP67T7uQrI43pW//+/ZGXl4dly5Z53qupqcGcOXMQFRVV51mJU9W/f39s2LAB69ev97xXVlaG+fPnIz09HV26dPFr/VlZWVi6dClWrFiBoUOHeq6sNfScr9WvXz8kJibi6aefxkcffeTzqsjBgwc9mWYAUFxcjL/85S/o1q2b5zZIU39m4KfnoIC633V5ebknFblWx44dER0dXW96O51ZeGUkwHXs2BGPP/44Jk6ciD179mDQoEGIjo7G7t278fbbb2P06NF44IEH0KlTJ3Ts2BEPPPAADhw4gJiYGPz973+v915t7T/09957L7Kzs2G323Hrrbf63dfevXsjPj4ew4cPx7333gvDMPDqq6/6vByempqKp59+Gnv27MF5552HZcuWYfPmzZg/f76YcnnxxRdj+PDhmD9/vufW0IYNG7B48WIMGjTI66/1xsjIyMCyZcuQm5uLX/7yl4iKisLAgQMb3N5ms+HPf/4z+vXrhwsuuAAjR45E27ZtceDAAXz44YeIiYnBu+++67P9qFGj8Pzzz2PYsGHYuHEjUlJS8Oqrr3p+vCV33nknCgoKcOWVV6Jdu3bYu3cv5syZg27dunmuHnXr1g12ux1PP/00ioqK4HQ6ceWVV6JNmzYN/owncrlcuOqqq3DLLbdg+/bteOGFF3DZZZfh17/+tVe/7rrrLtx44424+uqr8fXXX2PlypVITEz0Wldj+jZ69Gi89NJLGDFiBDZu3Ij09HS8+eab+PTTTzF79mxER0ef0uc52cMPP4y//e1v6NevH+69914kJCRg8eLF2L17N/7+97+flqq0gwYN8txOi4mJwUsvvdTgc75WaGgobr31Vjz//POw2+1eD/ae6LzzzsMdd9yBL774AklJSVi4cCHy8/OxaNGiZv3M4eHh6NKlC5YtW4bzzjsPCQkJuPDCC1FTU+M5nrp06YKQkBC8/fbbyM/PPy2/TxTgmjt9J9jVpkV+8cUX9cb79Onjldpb6+9//7u67LLLVGRkpIqMjFSdOnVS48aNU9u3b/css3XrVpWVlaWioqJUYmKiGjVqlPr666/rpODV1NSoe+65R7Vu3VoZhuFJ8z0x7fBEtamtb7zxhvazfPrpp+qSSy5R4eHhKjU1VT344INq5cqVdVINaz/nl19+qTIzM1VYWJhq3769ev755xu0H6urq9Vjjz2mOnTooEJDQ1VaWpqaOHGiV/qwUo1L7S0tLVW33367iouLUwA8qbO+Pn996Y1KKbVp0yZ1ww03qFatWimn06nat2+vbrnlFrV69WptH/bu3at+/etfq4iICJWYmKjuu+8+tWLFCm1q75tvvqmuueYa1aZNG+VwONRZZ52lxowZow4dOuS1/gULFqizzz5b2e12r3W2b99eDRgwoN4++Urt/eijj9To0aNVfHy8ioqKUkOGDFHHjh3zaut2u9VDDz2kEhMTVUREhMrOzlY7d+6ss06pbyen9iqlVH5+vho5cqRKTExUDodDde3atc734Ot4Vsp3yvHJfvjhB3XTTTepuLg4FRYWpnr27Knee++9etfX2NTeE73wwgsKgHrggQc87zXknK+1YcMGBUBdc8019W639vtduXKluuiii5TT6VSdOnWqc0w39DP7Su2t71ybOnVqnVIC69atUxkZGcrhcHi+i6NHj6px48apTp06qcjISBUbG6t69erllepOZy5DKQuf4qKg1bdvXxw9ehTffPON1V0havG+/vprdOvWDX/5y18wdOjQOvH09HRceOGFeO+99yzoHZEenxkhImrhFixYgKioKE9FU6KWhs+MEBG1UO+++y62bt2K+fPnIycnp07dHqKWgoMRIqIW6p577kF+fj769++Pxx57zOruEJ0yPjNCREREluIzI0RERGQpDkaIiIjIUkH3zIhpmjh48CCio6ObfW4TIiJqWZRSKCkpQWpq6mkp+uZLZWUlXC6X3+txOBxecx21FEE3GDl48GCd2WeJiIgk+/fvR7t27Zpk3ZWVlejQPgp5h/2fQDI5ORm7d+9ucQOSoBuM1JaKvgz9EQLfJccpSBnyXz4hqUli3J13WIwrP2ertUfJqZvu0jK/1q9jczjEuOnHX3b2aHlGY3dJ3fl+iJpaDarxCZaftmkG6uNyuZB32I29G9MRE33qV1+KS0y0z9gDl8vFwUigq701E4JQhBgcjNBJdIMRm1NurjmmlGb9OnZDHgwYhv+XeSU2zeczjVNPztN/Np6vZIGfD+nmuK0fFW0gKvrUt2Oi5T56EHSDESIiokDkVibcfhTbcCvz9HWmmXEwQkREFABMKJg49dGIP22tZmlq78cff4yBAwciNTUVhmHgnXfe0bZZu3YtfvGLX8DpdOKcc87BK6+80uT9JCIioqZj6WCkrKwMF198MebOndug5Xfv3o0BAwbgiiuuwObNmzF+/HjceeedWLlyZRP3lIiIqGmZp+H/WipLb9P069cP/fr1a/Dy8+bNQ4cOHfDss88CADp37oxPPvkEf/zjH5Gdnd1U3SQiImpybqXg9mOGFn/aWq1FPTOyfv16ZGVleb2XnZ2N8ePH+2xTVVWFqqoqz38XFxc3VfeChyYjxLDJT3QbdrvPmDLlk8mmSW01EhPEOHRPxJ9wrNSnolOy3L5LihgOy5NTb6uS5M9X0lrOKHEUy6nDzmPy5yvuGCHG47YUiXG7kLpsVMt9c8fJ2zY0P7T5PeXUy5TFW8S40nz3OmZ1jV/tdeeNLUpOfTbLysW4Lq3cHinvf7NS3j/S+nWfzd+Ud2r5WlQ5+Ly8PCQledd5SEpKQnFxMSoqKuptM2PGDMTGxnpeLHhGRESBqPYBVn9eLVWLGoyciokTJ6KoqMjz2r9/v9VdIiIiqsOEgtuPV0sejLSo2zTJycnIz8/3ei8/Px8xMTEIDw+vt43T6YTTKReqIiIiIuu0qMFIZmYmli9f7vXeqlWrkJmZaVGPiIiITg/WGbFIaWkpNm/ejM2bNwP4KXV38+bN2LdvH4CfbrEMGzbMs/xdd92FXbt24cEHH8R3332HF154Aa+//jomTJhgRfeJiIhOm9psGn9eLZWlg5Evv/wS3bt3R/fu3QEAubm56N69O6ZMmQIAOHTokGdgAgAdOnTA+++/j1WrVuHiiy/Gs88+iz//+c9M6yUiImrBLL1N07dvXyhhJFdfddW+ffti06ZNTdgramr+pPGpcjl9EWHyrLpGidy+orOcmhv+X80D0BH1P7tUS4XJqbnOQyViPGxHpbx9P0WGyT8JtkrNRHxuoehSef0Zb5512+S/jY71aiXGU9/eI8ZVqObnzlUtxzVsYfKzaUozo7GU8t6Q9rq0d3eRXNbAXerfrMhiyr7unPezXICuvXb7ATKni/nzy5/2LVWLemaEiIjoTFWbFeNP+5aKgxEiIqIA4Fbwc9be09eX5nbG1xkhIiKiwMYrI0RERAGAz4wQERGRpUwYcEPzsK6mfUvF2zRERERkKV4ZocbTpsFpUhSbcIZOW7E8K64q0qTOriuUN5DUWl7/0QK5vYYufROa9E8dQ5N67NyqSV3WbT/Ed9ydmig2te36UYwnvntMjJsl8nfrb3ppU6d/6mashinPCqw9dnT99zO9Vtt/ubEmLPfNFqrpW03LuIFhqp9e/rRvqTgYISIiCgBuP2/T+NPWarxNQ0RERJbilREiIqIAEMxXRjgYISIiCgCmMmAqP7Jp/GhrNd6mISIiIkvxyggREVEA4G0aIiIispQbNrj9uGHRdEUTmh4HI3Ta+VVvwE/V7eU6ICGbCsW4ERkhxlXBcbm9rg6HZpp5w+mQ29s0P1Smpp6CZvtmYqwYV4b8l5c7wvdPSkUbeduxB8PkbSfEiHGjqkqMQ1tnRFOrwlUtt9dQNXJ7w78SMv6fd37W+hCPfc2zDLoaMDaH5rw4Qyg/nxlRfGaEiIiI6NTwyggREVEA4DMjREREZCm3ssGt/HhmpAWXg+dtGiIiIrIUr4wQEREFABMGTD+uEZhouZdGOBghIiIKAHxmhKgR7FFRYtxdWnrK69alxhohoWLcvnG7vAFdaqxOahs5fqxIDNekaVKP9x0W42ZyghwPk/ePGSp//pBSeRp6W5Wcnrr7hmifsY6vHRPbmoXyvjNK5ONKl5aN8goxrEsv1cV1qbEw5H3f1Km5Wpr+aVN/a4S4Zt26816XFk0tHwcjREREAcD/B1h5m4aIiIj88NMzI35MlNeCb9Mwm4aIiIgsxSsjREREAcD0c24aZtMQERGRX/jMCBEREVnKhI11RqgZ+ZlCZzV3WbkY92eGTVusPDOrqqgU40a4ZuZXXXqmJvXXKJW3r22vmVW3Jj1JXn2ZnHprL5H7F1LmX/9V/hExftaKcN/BvQfFtoYu7VoTNwuLNe3lh/u0aeXa9NMmPm/9TB229HdFlxasm1BZk9KvPa8p4HEwQkREFADcyoBb+VH0zI+2VuNghIiIKAC4/XyA1d2Cb9MwtZeIiIgsxSsjREREAcBUNph+ZNOYzKYhIiIif/A2DREREZFFeGWEiIgoAJjwLyMmsItCyDgYqU8g5+ufBro6IGZ1jX8b0O0/u++4u+C4f5vW1PGA5p6qEaGZhj5M3nc1yXFivKydUIcDQNR+TQ0XXZ0QHU2dFh1Dc+zYXML+19XxSEoU4ypPrnFihGp+znR1QlxyDRdbVKS8fU3cfShP3r6uVobmvDI0dVSU6eeFcN15LW9cXrWmjohu36ty+bwxNd9toPC/6FnLvdnRcntOREREZwQORoiIiAJA7dw0/rwatT23G5MnT0aHDh0QHh6Ojh07Yvr06VAnXEFWSmHKlClISUlBeHg4srKysGPHDq/1FBQUYMiQIYiJiUFcXBzuuOMOlJaWNqovHIwQEREFABOG36/GePrpp/Hiiy/i+eefx7Zt2/D0009j5syZmDNnjmeZmTNn4rnnnsO8efPw+eefIzIyEtnZ2ais/N8t3yFDhuDbb7/FqlWr8N577+Hjjz/G6NGjG9UXPjNCREQUAPyftbdxbdetW4frr78eAwYMAACkp6fjb3/7GzZs2ADgp6sis2fPxqRJk3D99dcDAP7yl78gKSkJ77zzDm699VZs27YNK1aswBdffIEePXoAAObMmYP+/fvjmWeeQWpqaoP6wisjREREZ5Di4mKvV1VVVb3L9e7dG6tXr8b3338PAPj666/xySefoF+/fgCA3bt3Iy8vD1lZWZ42sbGx6NWrF9avXw8AWL9+PeLi4jwDEQDIysqCzWbD559/3uA+88oIERFRAPC/6NlPbdPS0rzenzp1Kh599NE6yz/88MMoLi5Gp06dYLfb4Xa78cQTT2DIkCEAgLy8nzLAkpK8ZxNPSkryxPLy8tCmTRuveEhICBISEjzLNAQHI/WxOnXXz9Ri3VTnOrYwpxg3K+sfZddSNdVy3OU7vdYeKafWmhUVYlw7Db1DTiFEtdx3V5soefW7DovxmBJNeqhbU0FRl6JYpYnrykWHaH4SnHJqr/27vb6DmtTV8rPjxXiEJi3ZnZIgxo0tO8W4LSZajJvJcuox9hyQt69Lbb7ofHn7Tk366zc/iHG35oFCXf+0qcfiyuXzUrduXdq28vM3L1CYyoDpT52Rn9vu378fMTExnvedzvp/019//XUsWbIEr732Gi644AJs3rwZ48ePR2pqKoYPH37K/TgVHIwQERGdQWJiYrwGI7787ne/w8MPP4xbb70VANC1a1fs3bsXM2bMwPDhw5GcnAwAyM/PR0pKiqddfn4+unXrBgBITk7G4cPef4TV1NSgoKDA074h+MwIERFRADB/vk1zqq/GFj0rLy+H7aSryXa7HebPxSM7dOiA5ORkrF692hMvLi7G559/jszMTABAZmYmCgsLsXHjRs8ya9asgWma6NWrV4P7wisjREREAcD/WXsb13bgwIF44okncNZZZ+GCCy7Apk2bMGvWLPz2t78FABiGgfHjx+Pxxx/Hueeeiw4dOmDy5MlITU3FoEGDAACdO3fGtddei1GjRmHevHmorq5GTk4Obr311gZn0gAcjBAREQWlOXPmYPLkybj77rtx+PBhpKamYsyYMZgyZYpnmQcffBBlZWUYPXo0CgsLcdlll2HFihUICwvzLLNkyRLk5OTgqquugs1mw4033ojnnnuuUX3hYISIiCgAuGHA3cjCZSe3b4zo6GjMnj0bs2fP9rmMYRiYNm0apk2b5nOZhIQEvPbaa43a9sk4GCEiIgoAzX2bJpC03J4TERHRGYFXRuqjm6pbl9OuqQOizanX5vvrNi/XklBmjRjXjVBtmmnk/ZmuW1Vr+hYh1yHRMXR1NDR1SkK/2SPGdf2HZqpz3TT30Hy30EwjDx/1BmqVXyg/cBbx3x/FuCHVcVHyvg//sUSM62qoGC553xuhcp0Os0RTh6NcrnGjauTt685L41u5DkrI2e3FuFtT/yekXVsxbhYcF+PwUcWzlvS7ZuiOS81vrlms+W40dUiatIbKaeRG42+1nNy+peJghIiIKAAE820aDkaIiIgCQHNPlBdIWm7PiYiI6IzAKyNEREQBQMGA6cczI8qPtlbjYISIiCgA8DYNERERkUUsvzIyd+5c/OEPf0BeXh4uvvhizJkzBz179vS5/OzZs/Hiiy9i3759SExMxE033YQZM2Z4lab1lzZ118/22tRbf9PMNKnFOqYuvVaTRmcLk9NHRYZ8mVGXPmloUleVq1qMm+eniHH77kNy+/Zye9uxYjEOTXomoiPFsIqSzwMzQk7Lrmgjf7dhrePFuK1QSM91a1LeNWnVRnSUGHe1ktO+nbvEMJQmddUID5fba1Latam9Nnnfu3fIH0C3fl3qru7c0K3fJuwf/W+i5jdLc97rUuJ1fQ8UpjJgqlO/1eJPW6tZOhhZtmwZcnNzMW/ePPTq1QuzZ89GdnY2tm/fjjZt2tRZ/rXXXsPDDz+MhQsXonfv3vj+++8xYsQIGIaBWbNmWfAJiIiITo/a2Xf9ad9SWdrzWbNmYdSoURg5ciS6dOmCefPmISIiAgsXLqx3+XXr1uHSSy/F7bffjvT0dFxzzTW47bbbsGHDhmbuOREREZ0ulg1GXC4XNm7ciKysrP91xmZDVlYW1q9fX2+b3r17Y+PGjZ7Bx65du7B8+XL079/f53aqqqpQXFzs9SIiIgo0tbdp/Hm1VJbdpjl69CjcbjeSkpK83k9KSsJ3331Xb5vbb78dR48exWWXXQalFGpqanDXXXfh97//vc/tzJgxA4899thp7TsREdHpZsIG049rBP60tVqL6vnatWvx5JNP4oUXXsBXX32Ft956C++//z6mT5/us83EiRNRVFTkee3fv78Ze0xEREQ6ll0ZSUxMhN1uR35+vtf7+fn5SE5OrrfN5MmTMXToUNx5550AgK5du6KsrAyjR4/GI488Als9T+M7nU44NRkWREREVnMrA24/brX409Zqlg1GHA4HMjIysHr1agwaNAgAYJomVq9ejZycnHrblJeX1xlw2H9O6VKqcalbht0Ow6g/HUw7w6SG32lkfs4arGrkFD1/aVOPdbMShwizp2qu1WnTrv1Mi7bvOywvoJn113bgiNw+Sk7NdXVqLcZDCyvFuFuTumvTzGwbdeDUZ1zWcmr6VlQmt6+QZ80N2y8fPO4yzYzJGrrUXR275rs3K+Tv1tDMlg1darEmdVdXEkCX0i+m1et+E3SfTZP2rXQp8X6WO2guTO21SG5uLoYPH44ePXqgZ8+emD17NsrKyjBy5EgAwLBhw9C2bVvMmDEDADBw4EDMmjUL3bt3R69evbBz505MnjwZAwcO9AxKiIiIWiLl56y9qgVXYLV0MDJ48GAcOXIEU6ZMQV5eHrp164YVK1Z4Hmrdt2+f15WQSZMmwTAMTJo0CQcOHEDr1q0xcOBAPPHEE1Z9BCIiIvKT5RVYc3JyfN6WWbt2rdd/h4SEYOrUqZg6dWoz9IyIiKj5uGHA7cdkd/60tZrlgxEiIiICTOXfcx8tpOp9vVruDSYiIiI6I/DKCBERUQAw/XyA1Z+2VuNghIiIKACYMGD68dyHP22txsFIPWytEsS4WVgkxu3x0WK85vBRMa6rc9LUdUR09RB0U61r65BIOf+6MiHhYXJcU0vBiJG/G8TI09Qr3XenmebejJfjIWX+fbdGjaaegiEfW0a1ptbEEXkaerN1vO91a2oBVcfJ361jr7zvzd37xLi21oSmvo++/o9m87o6Hzqa784WHq7ZvqYOiX8lemCWlPiM6fqGGrn+jVjDBICqlttT4ONghIiIKACwAisRERFZKpifGWm5PSciIqIzAq+MEBERBQATfs5NwwdYiYiIyB/Kz2waxcEIERER+YOz9gYhZSooo/5UQ7OoWG6rSSPTpu7qZhj2NwVR0163fW1qrjYFUk7hVELNYl1as7becYjmkNZMVV4TFyHG7Y5kMa7bd7b9+XL7pFZivCZWTn8N3X9MXn+UnGJpc2iOTU3qs+HyfW64Y+VtOw7J5x1CQ8WwLS5WjOtS8rV0x6ahOfbcmvPaz/MWofL2VaWcku/v74J0XpuabevYdJ/d7l9atvY3l5pc0A5GiIiIAkkwZ9NwMEJERBQAgvk2TcsdRhEREdEZgVdGiIiIAgDnpiEiIiJL8TYNERERkUV4ZYSIiCgABPOVkeAdjCgTQP255bb4OLGpO0+uFaHPWZdz5g1NLQxDl++vievqCWin+w6Xa10oTZ0WI0JYv66eQIgmrplmXVvLQTPNfUWqXGcj/IDvadQBwN0hRYzDLW/fVqmpAaPZf0aFPI18iCZe3TZe3nx5te9YSYXYVjnlnyOj0ve6AWDf8HPFeNr8b+XtV8j909W4MUI1dTrktcNQ/tX50B27hqYOie7cMTQ1fIwa3zVm/K5dZGrOW9uZcZE/mAcjZ8Y3SERERC1W8F4ZISIiCiDBfGWEgxEiIqIAoOBfeq7uVmAg42CEiIgoAATzlRE+M0JERESW4pURIiKiABDMV0Y4GKlPmFMMG045bo+NEeOqpFSM66bb1qXo2TT901FVmu075Knczc7pYtz+41HfQd006DGRYtyVKMcdh+XUW3u+PM18xAHf6YsA4OqYJMZtLjnFsSZGTuu2a1J77bqp2jXpmypGTl0uS5WPrbivfR/b7lg5Zdzt1KRt2+S+J3yvSXl3yWnLOxZdIMbPGf6NvH5N+qo9PlaMm8Xy7wKE1FkAULr0WM3+8zc91hRSn3XlBHSpvUaUfF5D85tkaM4LVaMrx9A8gnkwwts0REREZCleGSEiIgoAwXxlhIMRIiKiAKCUAeXHgMKftlbjbRoiIiKyFK+MEBERBQAThl9Fz/xpazUORoiIiAIAnxkhb5rUW12KnambtTZUk4amm3lVM3smNCl6uvZKN+uwJoWxsJOcHhpf5bt9RZrc1l4p980MlU9GV3K0GHf+IKcAutu2EuO6P0xcCXJqbHmi/N2HFcrx0N2aO6+6tPWycjGed538/cR9UuYzZnPIx11JeoS87o/3iPFQTUo6NCnv5+ceEOOmLn1Uc15rZ93VrF83I7Mql787nHeOvP0qeVZkc9deMW4Tji3tZ9f9pmlm7dWlBmtnDSbLcTBCREQUAIL5AVYORoiIiAIAb9MQERGRpYL5yghTe4mIiMhSvDJCREQUAJSft2la8pURDkaIiIgCgAKgfM832KD2LRVv0xAREZGleGWkPrqhqS6n3SXn6+viRqj8tRjhYWLcr6E1ACNUs37NNPStPj8ixl0pMT5jFa3kWgqtNhSK8fJz4sS4Y79cQ8aMl6cqP3SpXGcj8b/yNPXHOsnfbUiFGEbMXvnYQZRcq0OFamrYaI6dxNVyrQ44Hb7XXS7XAYn7Ml9et/a80dTp0NRYMePkGjQ2XS0MTf0hd/skMW7/4aC8fp0o+dg18o6KcVNXX0nzuyf+Lpia3yTdb1Z8rByvlM+7lsKEAYMVWImIiMgqzKYhIiIisgivjBAREQUAUxkwWPSMiIiIrKKUn9k0LTidhrdpiIiIyFIcjBAREQWA2gdY/Xk11oEDB/Cb3/wGrVq1Qnh4OLp27Yovv/zyhD4pTJkyBSkpKQgPD0dWVhZ27NjhtY6CggIMGTIEMTExiIuLwx133IHSUk121kl4m6YeZnHjdmJj2XQpeJqpwnWqz28nxu1lchqcraBEjJsJcgqk0kwVX9Had/qnK1o+mara+U4LBoDwg/I06maY720D0A7PlSZur5TTO+3V8vZjd8npq7YqzVTouuu0uqnYNWnlCV8Xye2l9M5qTVqyJvVWOw19ZLi8/mr5uzFcclzbf82+t1Vo2us45NRlQ5NaDE1qsu2stmLc3PujGFfS9u3yiWM45e++vGO8GA/fL/9m6X5TVY3mvGgmzZ1Nc/z4cVx66aW44oor8K9//QutW7fGjh07EB//v/09c+ZMPPfcc1i8eDE6dOiAyZMnIzs7G1u3bkVY2E9lIIYMGYJDhw5h1apVqK6uxsiRIzF69Gi89tprDe4LByNEREQBoLkfYH366aeRlpaGRYsWed7r0KGD538rpTB79mxMmjQJ119/PQDgL3/5C5KSkvDOO+/g1ltvxbZt27BixQp88cUX6NGjBwBgzpw56N+/P5555hmkpqY2qC+8TUNERHQGKS4u9npVVdVfcPCf//wnevTogZtvvhlt2rRB9+7dsWDBAk989+7dyMvLQ1ZWlue92NhY9OrVC+vXrwcArF+/HnFxcZ6BCABkZWXBZrPh888/b3CfORghIiIKALXZNP68ACAtLQ2xsbGe14wZM+rd3q5du/Diiy/i3HPPxcqVKzF27Fjce++9WLx4MQAgLy8PAJCU5F09OCkpyRPLy8tDmzZtvOIhISFISEjwLNMQvE1DREQUAH4aUPjzzMhP/3///v2Iifnf83VOH8/kmKaJHj164MknnwQAdO/eHd988w3mzZuH4cOHn3I/TgWvjBAREZ1BYmJivF6+BiMpKSno0qWL13udO3fGvn37AADJyckAgPx873mj8vPzPbHk5GQcPnzYK15TU4OCggLPMg3BwQgREVEAaO7U3ksvvRTbt2/3eu/7779H+/btAfz0MGtycjJWr17tiRcXF+Pzzz9HZmYmACAzMxOFhYXYuHGjZ5k1a9bANE306tWrwX3hbRoiIqIAoH5++dO+MSZMmIDevXvjySefxC233IINGzZg/vz5mD9/PgDAMAyMHz8ejz/+OM4991xPam9qaioGDRoE4KcrKddeey1GjRqFefPmobq6Gjk5Obj11lsbnEkDcDBSLyM8TIybJXJOu9JMl63K5VoYRrRcx0NXRyQ0r1iMo7RMjmvqGZhhcrwmSo4XdPF9Qc6ZUSC2dfxHvpjnjpbreFQmyvUM7FX+1Rtwh8unVLVcYgblSXL7sCMV8gp0tTQ0p7yyyftX6WrgSHVG/JmCHoARoakjUqWZRj5UPi5LOsu1LGLWa84rTZ0P0ylv35aSKMaN4/LvDjTf3Xcz5Evm582uP+PCs33Nd6+rFSKKjhLDBedpaqSMkX9zU0bI63cXHBfjZ6pf/vKXePvttzFx4kRMmzYNHTp0wOzZszFkyBDPMg8++CDKysowevRoFBYW4rLLLsOKFSs8NUYAYMmSJcjJycFVV10Fm82GG2+8Ec8991yj+sLBCBERUQBo7qJnAHDdddfhuuuu8xk3DAPTpk3DtGnTfC6TkJDQqAJn9eFghIiIKBA0932aAGL5A6xz585Feno6wsLC0KtXL2zYsEFcvrCwEOPGjUNKSgqcTifOO+88LF++vJl6S0RE1ET8fXjVj6sqVrP0ysiyZcuQm5uLefPmoVevXpg9ezays7Oxffv2OkVUAMDlcuHqq69GmzZt8Oabb6Jt27bYu3cv4uLimr/zREREdFpYOhiZNWsWRo0ahZEjRwIA5s2bh/fffx8LFy7Eww8/XGf5hQsXoqCgAOvWrUPozw+jpaenN2eXiYiImsSJVVRPtX1LZdltGpfLhY0bN3rVvLfZbMjKyvLUvD/ZP//5T2RmZmLcuHFISkrChRdeiCeffBJuYTbPqqqqOnX6iYiIAk1z1xkJJJZdGTl69Cjcbne9Ne+/++67etvs2rULa9aswZAhQ7B8+XLs3LkTd999N6qrqzF16tR628yYMQOPPfZY4zpn06QYalLYDLecHmqLkdPMdCl69lI5BU8dOSbGdanLKkqTQqlhOuT+V0f5Hr5v7bFMbNur+13ytu3ydxd1QJ7GvaS9nH5ZeqGcPuoollOLbZrsU7tL/tOmOk5z7GlSm22VvgfugD41uaytvH7D7Tt3OSJP3vehxbrUUs15WaHZucIfLQAQ/X2hGFdxMWLccMmfz16gKQnglPetv84fv9u/FejSuu2+z3ul2TeGKX83rbZq9u1XEfL6Q5irEegsf4C1MUzTRJs2bTB//nxkZGRg8ODBeOSRRzBv3jyfbSZOnIiioiLPa//+/c3YYyIiogaqfQjVn1cLZdlwMTExEXa7Xax5f7KUlBSEhobCfsIIvXPnzsjLy4PL5YLDUfcvC6fT6bMuPxERUaDgMyMWcDgcyMjI8Kp5b5omVq9e7al5f7JLL70UO3fuhGn+7zbI999/j5SUlHoHIkRERBT4LL1Nk5ubiwULFmDx4sXYtm0bxo4di7KyMk92zbBhwzBx4kTP8mPHjkVBQQHuu+8+fP/993j//ffx5JNPYty4cVZ9BCIiotNDnYZXC2XpUz2DBw/GkSNHMGXKFOTl5aFbt25YsWKF56HWffv2wXbCw5xpaWlYuXIlJkyYgIsuught27bFfffdh4ceesiqj0BERHRaWFEOPlBY/ohxTk4OcnJy6o2tXbu2znuZmZn47LPPmrhXRERE1FwsH4wEJE1qrm52Tm0KnGZ2UsTIs/YezYgT4633HpLXr0uzc8lpdkqTYmlqPn7kAd/tu80cK7a1y1nJiDok9724g5y6a8jN4fhRfjbJlFeP2N2aDehmrq2Wj03TIe98FSmv3xUj/ySEVMjXgQ2377gjT05tNaPlB81twrp/2rjms6W3FuOHu8sHV+uv5dRj54+FYlzHHSen1IdoZiVWFfKMzkarBDF+YECSGG/7xh4xLqX2GrrfPA2bSz7uj10gf3fJGzWzXQeSFnyrxR8cjBAREQUA3qYhIiIia3HWXiIiIiJr8MoIERFRQDB+fvnTvmXiYISIiCgQ8DYNERERkTV4ZYSIiCgQBPGVkaAdjNgcDtgMH0UhdDnxhnxByayU6xHopjIv+VVHMa7N3tLUEVEOuRhGdYo8VXpFG7keRGWCvH9cQhkVXZ0Ou2aW+LJUuc5GpKYES3WUHI88IMd1qmLlfWOXvzoc7yzXooCmRI6h+bEqayvH476XN1Dcwff+t7njxLY2l9w5W6Rc4yW0WD7vbJr6OQnfyTu/uIO8/fgK+eCxl8i1LsxQzYVqze9SRc9zxPjxTvLJpf13TPe7qKvP5AcVIm+7/IpSeQVLNMWPAoW/M++24NRe3qYhIiIiSwXtlREiIqJAotRPL3/at1QcjBAREQWCIH5mhLdpiIiIyFK8MkJERBQIgvgBVg5GiIiIAoCh9BlvuvYtVdAORszqGpg+UtVCIiPEtqqiUozbQuXdaouLFePlSfLds9BS+YhTppxiZ2hS8MpT5dTd0lRNeqoms7kircZnzHlY3nfhR+R169RoMmOr4jUr0GQv6lKPDU37ynj5L5uiC3zvOwCI2CPvv7Dj8vaj9/r5ayZ8vpJ2ct9i9smfzV4ip+YqTeqprUqz/iq5f/Hfyam5IYXlYryqrZwyby+X+6cTfqBEjIeWhskr0KXuRmpOnsJi3zGbf08EmHa5b2nPa/4p0/wmBgw+M0JERERkjaC9MkJERBRQ+MwIERERWYq3aYiIiIiswSsjREREgSCIr4xwMEJERBQIgngwwts0REREZKmgvTJi2AwYvvLqa+R8f+XW1Duokacit2nqfOimcY84KD8xbehy+jX1BMo0dU4qe5WJ8Zo8uR5BeILveg3Jf5drIVRHyn3L76mZKlzzl4NDKJUAAFUJctypqePhitU87a7pX8hx+ZStSJWPrZooef+5NaUoWn8l9z9mn+8PEFIu981WJcftx+U6HgiRP5tRIReBcRbJ61dhofL2XfJ5H1ooF+AxXJrfHc32jQL54A3R1NowI+X6Qq4UuU6KQ6q/VK2poWKTz9vQMrl9Vby8b0I0v9kwpGPH1nxXHJhNQ0RERFYK5gqsDb5Nc/DgwabsBxEREQWpBg9GLrjgArz22mtN2RciIqLgpU7Dq4Vq8GDkiSeewJgxY3DzzTejoKCgKftEREREQaTBg5G7774b//3vf3Hs2DF06dIF7777blP2i4iIKKgY+N9zI6f0svoD+KFRD7B26NABa9aswfPPP48bbrgBnTt3RkiI9yq++uqr09pBIiIiOrM1Optm7969eOuttxAfH4/rr7++zmCkxTBsvtO5auQ0MHt8rBg3i0vlbdvk8atDkx4aWibfGFQuOYXRZ0rzz6L3a1KXP4+U45rheWlIhM9YRaImrbiVvPLIA/K2XfJXhxrfXQMAGJqZyO3yrofSZB5XR8vxmhR5A8ol7z+XXT52IvfoUizlY6Mm3Pf3UxUn983mlvvmjpVTxs0wTd+PiWGY4XJ6qLLL/Q+plFN7q2Pk1NlQTVq5TZN6DE3/dKnNKlrevyHFcmqyXzS/WW6n/N26nZrPbtel/AsnthQ73Zja2zALFizA/fffj6ysLHz77bdo3bp1U/WLiIgouARxBdYGD0auvfZabNiwAc8//zyGDRvWlH0iIiKiINLgwYjb7cZ///tftGvXrin7Q0REFJx4ZURv1apVTdkPIiKioMYKrEREREQWaaGpMERERGcY3qYJPqqm2mcWlKryM4VNkwqmKuX1O3SZwboJKB0OeQEN3eyqjmI5Ta4qTl5/1C7f7Y92l8+muO/kdVdoErx0qbXhR+S4odn3IRVy/13RcupdTaTm16RSvpgZ9YN8SocIE6sCgFvOPkV1hNz/gi6++5e8QTNzq58/pLYqTdpxrDwlcelZmtmmD8upu2ZavBhXds1s2+Wa1FvNrL3HeyVpti+GEVYg77/I70rkFUiz9upKQITInauJlOORB+QDW2lmVA4YQTwY4W0aIiIislTQXhkhIiIKJMH8ACsHI0RERIGAFViJiIjIUnxmhIiIiMgavDJCREQUAPjMCBEREVkriG/TcDBSD6WZzlrHrJbrKdgM+e5Ym88KxfjxC2PFuNJs34jU1FP4UZ7L3F4dJcZrwuWaAMcu8H3YRRyUH8DS1cGwa+po2DUlZMIK5LO5Mk7uX5UmHnFYXn9oqdw+tFzet84iuUZMaYp87FUky/2LOiCGESLMcq97tq4qTv5stmq5fk5ImaYOiGYa+vLWcgeVTa7zEbujTIyHVMrnZWH3VmI8fqNcBCfh83wxXtolUYwf6CPvn/O2a75Aqb6R0vwr6ZaP2/wMuW+uBPmHodMW+btDleaHg5ocByNERESBwM/bNLwyQkRERP4J4ts0zKYhIiIiS/HKCBERUSAI4isjHIwQEREFgGBO7eVtGiIiIrIUr4zUxy6nkfmb+mtLiJMXKJHTzCLzIuT1t9JMZV4pr9+o0qQmu+Q0PBUlH1amEP70nlli2x5LJojx6D1y+qG9Sv7ToThdbm/LKBLj+ExOu9al/oaWyqt3FmlSj+Plvy8ijsrfnaNE7p+jVG7vPO57+7p9H71XPi7tVfIU97ZiTXpmiLxv4n7QpRbL/bcfk788MzpM3v5/C8S4CpX7ZxTKKfmRe+T01/RCuX8o1Bz7prB/HJrU2hD5s6Wsk9O2Q8rl3yxtajFZjoMRIiKiQMBnRoiIiMhKfGaEiIiIgtpTTz0FwzAwfvx4z3uVlZUYN24cWrVqhaioKNx4443Iz/eu9rtv3z4MGDAAERERaNOmDX73u9+hpkZz6+wkHIwQEREFCuXHyw9ffPEFXnrpJVx00UVe70+YMAHvvvsu3njjDXz00Uc4ePAgbrjhBk/c7XZjwIABcLlcWLduHRYvXoxXXnkFU6ZMadT2ORghIiIKBP4MRPwYkJSWlmLIkCFYsGAB4uP/lwBRVFSEl19+GbNmzcKVV16JjIwMLFq0COvWrcNnn30GAPjggw+wdetW/PWvf0W3bt3Qr18/TJ8+HXPnzoWrEckeATEYmTt3LtLT0xEWFoZevXphw4YNDWq3dOlSGIaBQYMGNW0HiYiIWoji4mKvV1WVPEPouHHjMGDAAGRlZXm9v3HjRlRXV3u936lTJ5x11llYv349AGD9+vXo2rUrkpKSPMtkZ2ejuLgY3377bYP7bPkDrMuWLUNubi7mzZuHXr16Yfbs2cjOzsb27dvRpk0bn+327NmDBx54AJdffvlp75MtKlKMuwv8nNW3oFDevimnTxqmnLqLGHlWXUN3L0+zfVOTImmr0qT+2nyn8fXecIfYNmmDPPRXNjle2lbue7g8MSqO748W420OyNsvaaeZGVZePaIOyfs2drecAqkMefs1EfL+qXHKcWnW4NBi/84be1GFX+1RIW8/pExOHXbuPSavX7NvDbd8bLij5NTakMOa1Noauf+HM+XfjaR3d8vrt2n+dpVSjyPlcgRmlJx2nN9LTg1uvUne9yF+lmNoLqfrAda0tDSv96dOnYpHH3203jZLly7FV199hS+++KJOLC8vDw6HA3FxcV7vJyUlIS8vz7PMiQOR2nhtrKEsvzIya9YsjBo1CiNHjkSXLl0wb948REREYOHChT7buN1uDBkyBI899hjOPvvsZuwtERFREzlNt2n279+PoqIiz2vixIn1bm7//v247777sGTJEoSFaerMNDFLByMulwsbN270ugRks9mQlZXluQRUn2nTpqFNmza44w75r2gAqKqqqnPJioiI6EwVExPj9XI667/ytHHjRhw+fBi/+MUvEBISgpCQEHz00Ud47rnnEBISgqSkJLhcLhQWFnq1y8/PR3JyMgAgOTm5TnZN7X/XLtMQlg5Gjh49CrfbXe8lHl+Xdz755BO8/PLLWLBgQYO2MWPGDMTGxnpeJ1++IiIiCgS1t2n8eTXGVVddhS1btmDz5s2eV48ePTBkyBDP/w4NDcXq1as9bbZv3459+/YhMzMTAJCZmYktW7bg8OHDnmVWrVqFmJgYdOnSpcF9sfyZkcYoKSnB0KFDsWDBAiQmJjaozcSJE5Gbm+v57+LiYg5IiIgo8DRzBdbo6GhceOGFXu9FRkaiVatWnvfvuOMO5ObmIiEhATExMbjnnnuQmZmJSy65BABwzTXXoEuXLhg6dChmzpyJvLw8TJo0CePGjfN5RaY+lg5GEhMTYbfb673EU9/lnR9++AF79uzBwIEDPe+ZPz9sGRISgu3bt6Njx45ebZxOZ6N2CBEREf3kj3/8I2w2G2688UZUVVUhOzsbL7zwgidut9vx3nvvYezYscjMzERkZCSGDx+OadOmNWo7lg5GHA4HMjIysHr1ak96rmmaWL16NXJycuos36lTJ2zZssXrvUmTJqGkpAR/+tOfeMWDiIhargCYm2bt2rVe/x0WFoa5c+di7ty5Ptu0b98ey5cv92u7lt+myc3NxfDhw9GjRw/07NkTs2fPRllZGUaOHAkAGDZsGNq2bYsZM2YgLCysziWl2pSjk98nIiJqSYJ5bhrLByODBw/GkSNHMGXKFOTl5aFbt25YsWKF56HWffv2wabLbz/NlFvO19cx7PJ02Nr1a6a7dn53yK/2iJBz/nXtQ0rknH3TIaeIReT7jpW65X3nLJTraNSEy+1j9mrqlMjlClB5SF5/RSu5fXkHucZL6/Xy+u0Vcp0RW5V8bLnD5VPeXimv31Ek9z+0oNz3tiPl26VGjbzt6tZy/Rxll788x265iIw7TPM7UykXjtLVGUGYXCsj5KCmjomOTd5+ZYLcXCXGyfGde8W4ESp8vnK5RoxNyZ2L/UE+b4s6yMd1hGF5FYuGCYArI1axfDACADk5OfXelgHqXjI62SuvvHL6O0RERETNJiAGI0REREGPV0aIiIjISsH8zEgLuZFGREREZypeGSEiIgoEvE1DREREVgrm2zQcjNRDl5qro2rk9FObU059VRWVYtzQpu6Gy/EaOT0TTocYtheWifGwSjn11x0W5zNW9q2cvlkZL6d/OgvlzxaxT+67q7Wc9lyZKN/ZbPux3L+qBPmUc/tZLNiokY8Ne4W8f1SI/PlK28kdjCv1/d2HHCqQtx0t73tblXxewZT3PULkfR9SoUm5D9X8XGrSR2sSIuXVl2lSh01N/0z5u2+/ZJ8YVwWFYlxM3QUAu+/PrzRp0UaRPIFp/Nfyb1LCsSIxrnTfnWbXU9PjYISIiCgQ8DYNERERWSqIByPMpiEiIiJL8coIERFRADB+fvnTvqXiYISIiCgQBPFtGg5GiIiIAkAwp/bymREiIiKyFK+M1EeTr680cS0l10NQLrmegi4OTc6+rt6CLVozVXuVpo5I5/Zi3BD2X6tv5H0TkSfXYClNk2u4hJbItRLsZXIdjkRNvYOqWHl8b5e7D5e861GWKvc//lt5AzUOTa0IzaGdnyUfewkfHfcdDJNrlJhhmvo2h4V1A/rzNiFGjDv2HJPXX6Op8wE5HrorX25erTnvNeedVOcDAFQr+fMbkXKdF7Vnv9xeqM+krd2kqWFiFMv1gXTMigq/2jcb3qYhIiIiy7XgAYU/eJuGiIiILMUrI0RERAEgmB9g5WCEiIgoEATxMyO8TUNERESW4pURIiKiAMDbNORFuTQpdBr26Gh5Ac101mZxqV/b16bRuTWpxZoUQt36TYccj9hb4jNW1CVWXrdTXndVnHyxz61pH3pMTiGM/1pOvyxvL+fm2l1y/6qi5XhIhfxrYztSKMYdZeFivPDiVmI8+mvNxVTlu39mpJx2XXJOpBiP06T2Fl6WJsZdUXLf23wip3Wbh+TUXEOTumw45dRlVSNvH6Z83hqalH3slFNzlVtOTdauX/judetGuSb1tl2SHN+fJ8d1DOnYsDXf7Q/epiEiIiKyBq+MEBERBQDepiEiIiJrBfFtGg5GiIiIAkEQD0b4zAgRERFZildGiIiIAgCfGSEvujQ0myY1FzZNeunxosZ2yYs2dVc3K7AuzU6TZWfEyqnLju8PyisQ9k/cOt9pvwC0s3u2KZBTVw23fLaa4XJ6po6zQJMWreT0zuhdcmqx6dQde5pjo1LuX9R+edZfM1Tev+62vlODbRVyWnTkj/K2q89KFOM2zWTWbT6SU3O33S+nNZ9/7155A4YhhnWpu6pMc+L5Odu3rr3h0KQe6343pJIBur7La4Zx8LDcXlOOQTvTutQ/Td9PK96mISIiIrIGr4wQEREFAEMpGELxuIa0b6k4GCEiIgoEvE1DREREZA1eGSEiIgoAzKYhIiIia/E2DREREZE1eGWkHmZ5uX8r0OS8y9NVA4ZNU69Ak++vavzLi9fVG9AxjxWc+vo105QbEXKdC8TI8eoEOe6KleuY6OqUlCXJ/T92mXxsdHqmSoy7w+X+6WoimHFyjRhpGngAMDVlTEyH7wVc8WFi28O/kD9b+7/sEeOhO3R1POTz+vz7DohxHV2tC92+1dYBiYjwa/2qUj62TE3c0NVX8qceh6YGC0zNb5KuBkoLwds0REREZK0gvk3DwQgREVEACOYrI3xmhIiIiCzFKyNERESBgLdpiIiIyGot+VaLP3ibhoiIiCzFKyP1sDnlFESzSp7qXNteN921Lk1NkxrsL12KorugULMCTYqf8PnkpGZAFZeIcZsufTImVQyH58nTuNvzjovxkIo2Yrz1hjIxbpTK23doUot1qdEqTI5XJTrFePy2UjFuP+Y7rtrGiW3TVmpS6kPkvGLdsaGdZt7P9FDDrumfLvVXQ5Vqjh3N9nW/OzZN6q6u/2LKvr/7Nlz+TdXuWz/3fbNRSp8CrmvfQnEwQkREFACYTUNERERkEV4ZISIiCgTMpiEiIiIrGeZPL3/at1S8TUNERESW4pURIiKiQMDbNERERGSlYM6m4WCkHv7WEYFdc/fLn6m2ARg2uRqH0qX0a+qUGCHyVO66/aMl5fw75ToXYi0DAO62rcV4cbq8/sS1R8S4KpHrbDg3y7UyVKrcv5qUBDEecqRYjENTa8OICpfb62gOXRXm+9gJPS7XUFGhcp0M3XFrlmvqlGjoji2zskqMK03cHh8rxt3Hi8S4YZN3vqqR4/rfDT/rGxm+169bt7ZGSpF83CtXtRhvMYK4zgifGSEiIiJL8coIERFRAOBtGiIiIrJWED/Ayts0REREZCleGSEiIgoAvE1DRERE1gribBoORk6B36mtflKmnwecJrVY+/l0KX6a9Yv9r5LTI3Xpl/YSOX00ep/cHtU18vbD5dRYVSFvH3sOiOGQhDi5vWYqdbSKl+N2Ob3TeUwz1bqmvVEipNe6NXnBpWViWAmpowBQ2T9DjId/8F8xbktNFuM4lC+GzQr5vNGl7uo09XmvY2gyr6V/CHXnrS06SoybmmPDcMjlCFTNGZL6ewbjYISIiCgABPNtmoB4gHXu3LlIT09HWFgYevXqhQ0bNvhcdsGCBbj88ssRHx+P+Ph4ZGVlicsTERG1COo0vFooywcjy5YtQ25uLqZOnYqvvvoKF198MbKzs3H48OF6l1+7di1uu+02fPjhh1i/fj3S0tJwzTXX4MAB+fI3ERERBSbLByOzZs3CqFGjMHLkSHTp0gXz5s1DREQEFi5cWO/yS5Yswd13341u3bqhU6dO+POf/wzTNLF69epm7jkREdHpU3ubxp9XS2XpYMTlcmHjxo3IysryvGez2ZCVlYX169c3aB3l5eWorq5GQkL9c3pUVVWhuLjY60VERBRwTOX/q4WydDBy9OhRuN1uJCUleb2flJSEvLy8Bq3joYceQmpqqteA5kQzZsxAbGys55WWluZ3v4mIiE67IH5mpEVn0zz11FNYunQp1q5di7Cw+lMeJ06ciNzcXM9/FxcXc0DiJ5smTc+fNDrdjMFKkz6Jg3L6pbNEThFEiJy/qCIj5Pat5JlZsWu/vP5jx+X2Goauf85EMfzjFXL79Dfrf5bLo0qakVlz3KS3FeNGjZx2HbntqLx+TVq0uV/z3FmI/HNpC/Xv59TUpJVrU3M1KfchbVPFeM1B+Q9A7ay+Qv91MwabhZq0Z105Ad1M6VSvGTNm4K233sJ3332H8PBw9O7dG08//TTOP/98zzKVlZW4//77sXTpUlRVVSE7OxsvvPCC10WEffv2YezYsfjwww8RFRWF4cOHY8aMGQjRnDMnsvQbTExMhN1uR36+9z8g+fn5SE6Wc/6feeYZPPXUU/jggw9w0UUX+VzO6XQiJibG60VERBRoDPj5zEgjt/fRRx9h3Lhx+Oyzz7Bq1SpUV1fjmmuuQVnZ//5omzBhAt5991288cYb+Oijj3Dw4EHccMMNnrjb7caAAQPgcrmwbt06LF68GK+88gqmTJnSqL5YOhhxOBzIyMjwevi09mHUzMxMn+1mzpyJ6dOnY8WKFejRo0dzdJWIiKhp1VZg9efVCCtWrMCIESNwwQUX4OKLL8Yrr7yCffv2YePGjQCAoqIivPzyy5g1axauvPJKZGRkYNGiRVi3bh0+++wzAMAHH3yArVu34q9//Su6deuGfv36Yfr06Zg7dy5cLk0RxRNYfm0rNzcXCxYswOLFi7Ft2zaMHTsWZWVlGDlyJABg2LBhmDhxomf5p59+GpMnT8bChQuRnp6OvLw85OXlobS01KqPQEREFDBOTtqo0lS2rlVU9NPtstqEkI0bN6K6utrrmcxOnTrhrLPO8iSZrF+/Hl27dvW6bZOdnY3i4mJ8++23De6z5YORwYMH45lnnsGUKVPQrVs3bN68GStWrPB8sH379uHQoUOe5V988UW4XC7cdNNNSElJ8byeeeYZqz4CERGR305Xam9aWppX4saMGTO02zZNE+PHj8ell16KCy+8EACQl5cHh8OBuLg4r2VPTDLJy8urNwmlNtZQAfEAa05ODnJycuqNrV271uu/9+zZ0/QdIiIiam7+ZsT83Hb//v1ez0c6nU5t03HjxuGbb77BJ5984kcHTp3lV0aIiIjo9Dk5aUM3GMnJycF7772HDz/8EO3atfO8n5ycDJfLhcLCQq/lT0wySU5OrjcJpTbWUByMEBERBQBDKb9fjaGUQk5ODt5++22sWbMGHTp08IpnZGQgNDTUK8lk+/bt2LdvnyfJJDMzE1u2bPGawmXVqlWIiYlBly5dGtyXgLhNQ43kZ70Bf9ubjXhCuv7VCwlomnoE2gqDdk2dkEq5TomhyYs3dJc7jxaIYdOU970RJq9faaZSV5paFUZZuRhPny/XEdGtX+LqItf3ce6T9x0q5YfwKi6U65Q4DxwS47az2olxpflulaYOiu7YNDMvlNtr/qFxaPafOqbZv36S6gsZutpE2sqhmhonftQ2Cijmzy9/2jfCuHHj8Nprr+Ef//gHoqOjPc94xMbGIjw8HLGxsbjjjjuQm5uLhIQExMTE4J577kFmZiYuueQSAMA111yDLl26YOjQoZg5cyby8vIwadIkjBs3rkG3h2pxMEJERBSEXnzxRQBA3759vd5ftGgRRowYAQD44x//CJvNhhtvvNGr6Fktu92O9957D2PHjkVmZiYiIyMxfPhwTJs2rVF94WCEiIgoAJzKrZaT2zeGasDyYWFhmDt3LubOnetzmfbt22P58uWN2vbJOBghIiIKBKcpm6Yl4mCEiIgoEJxCFdU67VsoZtMQERGRpXhlhIiIKACcWEX1VNu3VByMnIk0qbu28HC5vSGn1yrNPAeGLoVRSA9VmvRNHbsjVIwrl5wiaJyVKMZdydFi3NYqSo5XySmIut8S24EjcvsqTdq1Zhp43f7XpR6bxb7niApdp5mnIkne96qoWIw7Pz4ur1+TPmoelEtX26Ll71aXlu4+XiQ3/+grMa47r2o0360uZV+3fqVdve/PrzR9M0Lk89YWJ8+27j56TIy3GLxNQ0RERGQNXhkhIiIKAIb508uf9i0VByNERESBgLdpiIiIiKzBKyNERESBgEXPiIiIyErNXQ4+kPA2DREREVmKV0aCkFlRIS+gqUegYzjlw8oW4juuXHIdDlt4mBjX1TOAW37c3AyX6x2Ebt4lxl3dO4rxqtZynY7wH33X6QCg7b8RIdeQMTW1OnSMUE09iLbJvrf940GxrRJqlAAN+W41NVR009RrpqGvKS8X4/bYWHn9mvo/OtrP7yel+fza9uap/26oqko5flRTn6eJ902zCeIHWDkYISIiCgQKgD9j1pY7FuFghIiIKBDwmREiIiIii/DKCBERUSBQ8POZkdPWk2bHwQgREVEgCOIHWHmbhoiIiCzFKyNUlyYF0R4XJ8bNkhIxbgsX0k8dcuqoji0yQozrUoeNIjl9U2mmiXd+u0+M285rK69fN417amsxbpTJKZK61GiUlsnbL5fTwn+8vYPPWNs5eWJbtybtWDfFvTSFPQB9aq0upd2Q/+p0FxXJ7a3mZ2qxX+v3s1yA36m7uu039b5pKBOA5jDWtm+hOBghIiIKAMymISIiIrIIr4wQEREFgiB+gJWDESIiokAQxIMR3qYhIiIiS/HKCBERUSAI4isjHIxQo+lSd3Wzo7rLfKfP6tIzTc26Q1q3ktvvOyDG7WHyrLqGJkVQ1dTI7Wvk/tsPHBHjMDR5fzFRYtgdpUntTYwWw/bDcvpt0pe+U4vN7ueLbY0vvhHj2rTtas2ss5pjR58aLMeVvxPHNnX6qb/r9yM9V7dvDbtDjJvV8nmlFSipuzpM7SUiIiIrMbWXiIiIyCK8MkJERBQI+MwIERERWcpU2mkHtO1bKN6mISIiIkvxyggREVEg4G0aIiIispafgxFwMEJBRDedt26q9yZdt82/WgqqskqOu1xi3HDKdUpCfpDrnChNPQVV4buOBwDYquT+2Us1dUaccr0HFR0ux4U6KJVJ8raj2rQW4wiVf67U0QIxrqt1oauP4+809jan/Pm169fVOdE9L+BnrQ3t/hP6r6vBoj3vQ0I1K9Cc1/7WgKEmx8EIERFRIOBtGiIiIrKUqeDXrRZm0xARERGdGl4ZISIiCgTK9O/ZnpYyB089OBghIiIKBHxmhIiIiCwVxM+McDBCjaZLr9WlGIrt/SmFDABl5WLYFi6npiI1SW6vSZ1Vx46LcbO4VIwbmvRVI0xOHTYrKsS4LT5WjLtbRcntd+wX4449vlOTnZq+I0STultUIsZ1x6VZJadta9PG/TzutZfQNXFbbIzc3lUthk1N2ro2PdbCf+i0qb+atGMKfByMEBERBQLepiEiIiJLKfg5GDltPWl2TO0lIiIiS/HKCBERUSDgbRoiIiKylGkC8KNWiNly64zwNg0RERFZildGiIiIAgFv0xCdPrqcfyluhMq1KAyHPMU9YqPleIKmVoOu1kSFpoZKcmsx7k6IlNdvyPuurK08DX30LrmOiTtEvhjqdsqf3x6qmco9IV6OS0rkvpf17STGj3aV+57+4nYxbpb4V8dEWyNH015XKUOVyTVkVI1cZ8Sv+j8ADM3HV1IpEF2NFUM+LoOmjkgQD0Z4m4aIiIgsxSsjREREgYDl4ImIiMhKSplQfsy8609bqwXEbZq5c+ciPT0dYWFh6NWrFzZs2CAu/8Ybb6BTp04ICwtD165dsXz58mbqKRERURNR6qerG6f64jMjp27ZsmXIzc3F1KlT8dVXX+Hiiy9GdnY2Dh8+XO/y69atw2233YY77rgDmzZtwqBBgzBo0CB88803zdxzIiIiOh0sH4zMmjULo0aNwsiRI9GlSxfMmzcPERERWLhwYb3L/+lPf8K1116L3/3ud+jcuTOmT5+OX/ziF3j++eebuedERESnUW02jT+vFsrSZ0ZcLhc2btyIiRMnet6z2WzIysrC+vXr622zfv165Obmer2XnZ2Nd955p97lq6qqUHXC1OHFxcX+d/xMp0mz003nreNX+wo5vdHm5zTpumnaVXKiGDeOy+mhIQWFYlwndq8mtVlTgVGVlolxe2qS3L7KJcdL8oS28ndjT2snxiPXbBXjUVtaifGaY8fEeFPTpd5aTdVY+LyB5rwU04bPJKYJGH58D3xm5NQcPXoUbrcbSUneP4BJSUnIy6v/Ry0vL69Ry8+YMQOxsbGeV1pa2unpPBEREZ0Wlt+maWoTJ05EUVGR57V//36ru0RERFQXb9NYIzExEXa7Hfn5+V7v5+fnIzk5ud42ycnJjVre6XTC6ZSrehIREVlNmSaUH7dpmNp7ihwOBzIyMrB69WrPe6ZpYvXq1cjMzKy3TWZmptfyALBq1SqfyxMREVFgs7zoWW5uLoYPH44ePXqgZ8+emD17NsrKyjBy5EgAwLBhw9C2bVvMmDEDAHDfffehT58+ePbZZzFgwAAsXboUX375JebPn2/lxyAiIvKP8rMCK2/TnLrBgwfjyJEjmDJlCvLy8tCtWzesWLHC85Dqvn37YLP97wJO79698dprr2HSpEn4/e9/j3PPPRfvvPMOLrzwQqs+AhERkf9MpZ9wUdKCByOGUi2496eguLgYsbGx6IvrEWJoZiAlam6atGqtFnzPmCgQ1ahqrMU/UFRUhJgYzazfp6j236UrnbcgxNCk7wtqlAtrql5v0r42FcuvjBARERF+vrLhT52RlnttgYMRIiKiAKBMBeXHbZqWfKPjjK8zQkRE1CIo0//XKWjsZLVNgYMRIiKiINXYyWqbCgcjREREAUCZyu9XYzV2stqmwsEIERFRIGjm2zS1k9VmZWV53tNNVttUgu4B1toHfGpQ7VdtGaKmwdReokBSg59mW26Oh0P9/Xeptq8nz07va1oUabLa77777tQ7cgqCbjBSUvLTFO+fYLnFPSGqBwfIRAGppKQEsbGxTbJuh8OB5ORkfJLn/79LUVFRdWannzp1Kh599FG/192Ugm4wkpqaiv379yM6OhqGYdSJFxcXIy0tDfv3729xRWOaE/dTw3A/NQz3U8NwPzXM6dxPSimUlJQgNTX1NPWurrCwMOzevRsul8vvdSml6vzb5muy2FOZrLapBN1gxGazoV27dtrlYmJieLI3APdTw3A/NQz3U8NwPzXM6dpPTXVF5ERhYWEICwtr8u2c6MTJagcNGgTgf5PV5uTkNGtfgm4wQkRERD/RTVbbXDgYISIiClK6yWqbCwcjJ3E6nZg6darPe2z0E+6nhuF+ahjup4bhfmoY7qfGycnJafbbMicLull7iYiIKLCw6BkRERFZioMRIiIishQHI0RERGQpDkaIiIjIUkE5GJk7dy7S09MRFhaGXr16YcOGDeLyb7zxBjp16oSwsDB07doVy5cHRyn5xuynBQsW4PLLL0d8fDzi4+ORlZWl3a9nisYeT7WWLl0KwzA8xYbOdI3dT4WFhRg3bhxSUlLgdDpx3nnnBcW519j9NHv2bJx//vkIDw9HWloaJkyYgMrKymbqrTU+/vhjDBw4EKmpqTAMA++88462zdq1a/GLX/wCTqcT55xzDl555ZUm7yc1ggoyS5cuVQ6HQy1cuFB9++23atSoUSouLk7l5+fXu/ynn36q7Ha7mjlzptq6dauaNGmSCg0NVVu2bGnmnjevxu6n22+/Xc2dO1dt2rRJbdu2TY0YMULFxsaqH3/8sZl73rwau59q7d69W7Vt21Zdfvnl6vrrr2+ezlqosfupqqpK9ejRQ/Xv31998sknavfu3Wrt2rVq8+bNzdzz5tXY/bRkyRLldDrVkiVL1O7du9XKlStVSkqKmjBhQjP3vHktX75cPfLII+qtt95SANTbb78tLr9r1y4VERGhcnNz1datW9WcOXOU3W5XK1asaJ4Ok1bQDUZ69uypxo0b5/lvt9utUlNT1YwZM+pd/pZbblEDBgzweq9Xr15qzJgxTdpPqzV2P52spqZGRUdHq8WLFzdVFwPCqeynmpoa1bt3b/XnP/9ZDR8+PCgGI43dTy+++KI6++yzlcvlaq4uBoTG7qdx48apK6+80uu93NxcdemllzZpPwNJQwYjDz74oLrgggu83hs8eLDKzs5uwp5RYwTVbRqXy4WNGzciKyvL857NZkNWVhbWr19fb5v169d7LQ8A2dnZPpc/E5zKfjpZeXk5qqurkZCQ0FTdtNyp7qdp06ahTZs2uOOOO5qjm5Y7lf30z3/+E5mZmRg3bhySkpJw4YUX4sknn4Tb7W6ubje7U9lPvXv3xsaNGz23cnbt2oXly5ejf//+zdLnliIYf8dbmqCqwHr06FG43e46ZW6TkpLw3Xff1dsmLy+v3uXz8vKarJ9WO5X9dLKHHnoIqampdX4AziSnsp8++eQTvPzyy9i8eXMz9DAwnMp+2rVrF9asWYMhQ4Zg+fLl2LlzJ+6++25UV1dj6tSpzdHtZncq++n222/H0aNHcdlll0EphZqaGtx11134/e9/3xxdbjF8/Y4XFxejoqIC4eHhFvWMagXVlRFqHk899RSWLl2Kt99+u9lnoQxkJSUlGDp0KBYsWIDExESruxPQTNNEmzZtMH/+fGRkZGDw4MF45JFHMG/ePKu7FlDWrl2LJ598Ei+88AK++uorvPXWW3j//fcxffp0q7tG1ChBdWUkMTERdrsd+fn5Xu/n5+cjOTm53jbJycmNWv5McCr7qdYzzzyDp556Cv/+979x0UUXNWU3LdfY/fTDDz9gz549GDhwoOc90zQBACEhIdi+fTs6duzYtJ22wKkcTykpKQgNDYXdbve817lzZ+Tl5cHlcsHhcDRpn61wKvtp8uTJGDp0KO68804AQNeuXVFWVobRo0fjkUcegc3GvzcB37/jMTExvCoSIILqSHU4HMjIyMDq1as975mmidWrVyMzM7PeNpmZmV7LA8CqVat8Ln8mOJX9BAAzZ87E9OnTsWLFCvTo0aM5umqpxu6nTp06YcuWLdi8ebPn9etf/xpXXHEFNm/ejLS0tObsfrM5lePp0ksvxc6dOz2DNQD4/vvvkZKSckYORIBT20/l5eV1Bhy1AzjFacc8gvF3vMWx+gna5rZ06VLldDrVK6+8orZu3apGjx6t4uLiVF5enlJKqaFDh6qHH37Ys/ynn36qQkJC1DPPPKO2bdumpk6dGjSpvY3ZT0899ZRyOBzqzTffVIcOHfK8SkpKrPoIzaKx++lkwZJN09j9tG/fPhUdHa1ycnLU9u3b1XvvvafatGmjHn/8cas+QrNo7H6aOnWqio6OVn/729/Url271AcffKA6duyobrnlFqs+QrMoKSlRmzZtUps2bVIA1KxZs9SmTZvU3r17lVJKPfzww2ro0KGe5WtTe3/3u9+pbdu2qblz5zK1N8AE3WBEKaXmzJmjzjrrLOVwOFTPnj3VZ5995on16dNHDR8+3Gv5119/XZ133nnK4XCoCy64QL3//vvN3GNrNGY/tW/fXgGo85o6dWrzd7yZNfZ4OlGwDEaUavx+WrdunerVq5dyOp3q7LPPVk888YSqqalp5l43v8bsp+rqavXoo4+qjh07qrCwMJWWlqbuvvtudfz48ebveDP68MMP6/29qd03w4cPV3369KnTplu3bsrhcKizzz5bLVq0qNn7Tb4ZSvFaHhEREVknqJ4ZISIiosDDwQgRERFZioMRIiIishQHI0RERGQpDkaIiIjIUhyMEBERkaU4GCEiIiJLcTBCREREluJghChIud1u9O7dGzfccIPX+0VFRUhLS8MjjzxiUc+IKNiwAitREPv+++/RrVs3LFiwAEOGDAEADBs2DF9//TW++OKLM3ZSOiIKLByMEAW55557Do8++ii+/fZbbNiwATfffDO++OILXHzxxVZ3jYiCBAcjREFOKYUrr7wSdrsdW7ZswT333INJkyZZ3S0iCiIcjBARvvvuO3Tu3Bldu3bFV199hZCQEKu7RERBhA+wEhEWLlyIiIgI7N69Gz/++KPV3SGiIMMrI0RBbt26dejTpw8++OADPP744wCAf//73zAMw+KeEVGw4JURoiBWXl6OESNGYOzYsbjiiivw8ssvY8OGDZg3b57VXSOiIMIrI0RB7L777sPy5cvx9ddfIyIiAgDw0ksv4YEHHsCWLVuQnp5ubQeJKChwMEIUpD766CNcddVVWLt2LS677DKvWHZ2Nmpqani7hoiaBQcjREREZCk+M0JERESW4mCEiIiILMXBCBEREVmKgxEiIiKyFAcjREREZCkORoiIiMhSHIwQERGRpTgYISIiIktxMEJERESW4mCEiIiILMXBCBEREVmKgxEiIiKy1P8D0lPKLLIxqXAAAAAASUVORK5CYII=\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "mean_std_confi(falseData)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 927 + }, + "id": "Fk5tpqMz7-ue", + "outputId": "6cb9ac04-70e6-415a-bf20-b69b863e931f" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "# Generating The Dataset" + ], + "metadata": { + "id": "ABlwOPaM8Pi5" + } + }, + { + "cell_type": "code", + "source": [ + "Data=np.concatenate((trueData, falseData))\n", + "labels=np.concatenate((trueLabes, falseLabels))\n", + "Data=Data.reshape((Data.shape[0], -1))" + ], + "metadata": { + "id": "B2igjhcYPkoX" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "dataSet = pd.DataFrame(Data)\n", + "dataSet['Label'] = labels\n", + "print(dataSet)\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "8GsFts6QPlE0", + "outputId": "6ad9361e-ea9d-42e1-ff7e-5d407aa260e7" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + " 0 1 2 3 4 5 6 \\\n", + "0 0.241108 0.471327 0.573825 0.211545 0.439883 0.609820 0.207885 \n", + "1 0.241786 0.471396 0.575313 0.212048 0.439816 0.610477 0.208341 \n", + "2 0.255604 0.468944 0.600364 0.227302 0.439534 0.600750 0.224995 \n", + "3 0.271612 0.467502 0.593033 0.243399 0.439005 0.604255 0.240289 \n", + "4 0.283533 0.467360 0.590714 0.258370 0.438332 0.621190 0.255666 \n", + "... ... ... ... ... ... ... ... \n", + "19881 0.406320 0.319878 0.381456 0.384293 0.309527 0.533914 0.400039 \n", + "19882 0.406719 0.323947 0.394210 0.384584 0.309538 0.488218 0.400685 \n", + "19883 0.404276 0.323878 0.389402 0.380224 0.308070 0.512390 0.392473 \n", + "19884 0.398805 0.325501 0.440699 0.377843 0.313418 0.428769 0.389230 \n", + "19885 0.399027 0.321922 0.411806 0.378661 0.310249 0.572195 0.390980 \n", + "\n", + " 7 8 9 ... 42 43 44 \\\n", + "0 0.497622 0.712120 0.245853 ... 0.984913 0.552086 0.577981 \n", + "1 0.497527 0.713256 0.245747 ... 0.985470 0.551775 0.646790 \n", + "2 0.497852 0.712447 0.258528 ... 0.986001 0.555067 0.413872 \n", + "3 0.498194 0.726268 0.273245 ... 0.859966 0.581536 0.044231 \n", + "4 0.496999 0.785706 0.289651 ... 0.976362 0.576336 0.246510 \n", + "... ... ... ... ... ... ... ... \n", + "19881 0.315975 0.600993 0.351761 ... 0.608814 0.883232 0.618532 \n", + "19882 0.319307 0.586964 0.353225 ... 0.611707 0.864686 0.607172 \n", + "19883 0.322471 0.435177 0.347669 ... 0.609507 0.854452 0.624061 \n", + "19884 0.321900 0.448886 0.338634 ... 0.617925 0.845811 0.716057 \n", + "19885 0.319024 0.425661 0.338507 ... 0.610627 0.827060 0.739089 \n", + "\n", + " 45 46 47 48 49 50 Label \n", + "0 1.004716 0.407852 0.123102 0.877871 0.454443 0.013667 1.0 \n", + "1 1.004423 0.407609 0.126057 0.999089 0.555383 0.088130 1.0 \n", + "2 1.001461 0.402184 0.142614 0.905707 0.490031 0.028396 1.0 \n", + "3 0.911371 0.408775 0.017034 0.904595 0.508741 0.009505 1.0 \n", + "4 0.925933 0.408913 0.056227 0.919955 0.554081 0.053527 1.0 \n", + "... ... ... ... ... ... ... ... \n", + "19881 0.391594 0.118545 0.348622 0.603727 0.827019 0.024959 0.0 \n", + "19882 0.389507 0.118153 0.374017 0.540024 0.199390 0.275174 0.0 \n", + "19883 0.389787 0.118165 0.312703 0.594799 0.796395 0.049734 0.0 \n", + "19884 0.387508 0.117651 0.268293 0.535458 0.200612 0.299425 0.0 \n", + "19885 0.823044 0.985980 0.265735 0.813672 0.991119 0.211519 0.0 \n", + "\n", + "[19886 rows x 52 columns]\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "dataSet = dataSet.sample(frac=1).reset_index(drop=True)\n", + "print(dataSet)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "58hIizR6PlHW", + "outputId": "dc731095-a54d-4cee-ea45-e33a8c19ca7d" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + " 0 1 2 3 4 5 6 \\\n", + "0 0.414274 0.512771 0.566444 0.401849 0.531036 0.630657 0.399837 \n", + "1 0.238784 0.579732 0.689065 0.204383 0.593788 0.705285 0.194654 \n", + "2 0.438303 0.234928 0.053487 0.389165 0.259297 0.159085 0.392102 \n", + "3 0.407979 0.388640 0.564277 0.398207 0.398896 0.867272 0.393269 \n", + "4 0.257735 0.564300 0.549202 0.256301 0.575738 0.653516 0.255406 \n", + "... ... ... ... ... ... ... ... \n", + "19881 0.472453 0.013740 0.079810 0.461054 0.003683 0.088350 0.462741 \n", + "19882 0.217967 0.520109 0.583433 0.205894 0.537245 0.566423 0.205250 \n", + "19883 0.318611 0.503385 0.532357 0.305121 0.499844 0.558199 0.306080 \n", + "19884 0.365003 0.516943 0.792096 0.351765 0.534424 0.831201 0.349424 \n", + "19885 0.491191 0.001873 0.237527 0.480246 0.002214 0.211391 0.481354 \n", + "\n", + " 7 8 9 ... 42 43 44 \\\n", + "0 0.508412 0.552270 0.406642 ... 0.758490 0.368297 0.708605 \n", + "1 0.536034 0.857052 0.214173 ... 0.985148 0.370727 0.042631 \n", + "2 0.246766 0.125590 0.433905 ... 0.633441 0.694506 0.558914 \n", + "3 0.370678 0.720681 0.413659 ... 0.912359 0.482594 0.697896 \n", + "4 0.577275 0.699240 0.286838 ... 0.682898 0.530702 0.720100 \n", + "... ... ... ... ... ... ... ... \n", + "19881 0.006235 0.099738 0.447121 ... 0.515790 0.021150 0.432649 \n", + "19882 0.515646 0.600404 0.219125 ... 0.708222 0.488991 0.787087 \n", + "19883 0.499179 0.541565 0.307655 ... 0.729369 0.496476 0.670612 \n", + "19884 0.515466 0.847680 0.360186 ... 0.699144 0.352506 0.823751 \n", + "19885 0.002806 0.207584 0.480812 ... 0.813567 0.061863 0.377723 \n", + "\n", + " 45 46 47 48 49 50 Label \n", + "0 0.908153 0.483046 0.720282 0.890200 0.464781 0.645452 0.0 \n", + "1 0.951776 0.546183 0.010918 1.009965 0.616205 0.035840 0.0 \n", + "2 0.494082 0.916525 0.337711 0.518012 0.927171 0.333892 0.0 \n", + "3 1.001534 0.595226 0.248007 0.999257 0.556489 0.095615 0.0 \n", + "4 0.857451 0.523833 0.786749 0.838329 0.539039 0.707628 1.0 \n", + "... ... ... ... ... ... ... ... \n", + "19881 0.382307 0.305971 0.513557 0.511185 0.301932 0.434094 0.0 \n", + "19882 0.881291 0.559657 0.636291 0.880278 0.520447 0.650306 0.0 \n", + "19883 0.881893 0.454307 0.539147 0.897172 0.474562 0.654785 1.0 \n", + "19884 0.848086 0.486915 0.734045 0.831969 0.455564 0.671235 0.0 \n", + "19885 0.947498 0.075425 0.414755 0.944458 0.085614 0.398845 0.0 \n", + "\n", + "[19886 rows x 52 columns]\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "dataSet.dropna(inplace=True) # removes rows with missing data\n", + "dataSet.drop_duplicates(inplace=True) # removes duplicate rows" + ], + "metadata": { + "id": "v7YOd7ixPlJj" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "dataSet" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 424 + }, + "id": "z1eSym6omBHB", + "outputId": "f190045f-284f-44cd-9029-1c42c33f6dfb" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + " 0 1 2 3 4 5 6 \\\n", + "0 0.414274 0.512771 0.566444 0.401849 0.531036 0.630657 0.399837 \n", + "1 0.238784 0.579732 0.689065 0.204383 0.593788 0.705285 0.194654 \n", + "2 0.438303 0.234928 0.053487 0.389165 0.259297 0.159085 0.392102 \n", + "3 0.407979 0.388640 0.564277 0.398207 0.398896 0.867272 0.393269 \n", + "4 0.257735 0.564300 0.549202 0.256301 0.575738 0.653516 0.255406 \n", + "... ... ... ... ... ... ... ... \n", + "19881 0.472453 0.013740 0.079810 0.461054 0.003683 0.088350 0.462741 \n", + "19882 0.217967 0.520109 0.583433 0.205894 0.537245 0.566423 0.205250 \n", + "19883 0.318611 0.503385 0.532357 0.305121 0.499844 0.558199 0.306080 \n", + "19884 0.365003 0.516943 0.792096 0.351765 0.534424 0.831201 0.349424 \n", + "19885 0.491191 0.001873 0.237527 0.480246 0.002214 0.211391 0.481354 \n", + "\n", + " 7 8 9 ... 42 43 44 \\\n", + "0 0.508412 0.552270 0.406642 ... 0.758490 0.368297 0.708605 \n", + "1 0.536034 0.857052 0.214173 ... 0.985148 0.370727 0.042631 \n", + "2 0.246766 0.125590 0.433905 ... 0.633441 0.694506 0.558914 \n", + "3 0.370678 0.720681 0.413659 ... 0.912359 0.482594 0.697896 \n", + "4 0.577275 0.699240 0.286838 ... 0.682898 0.530702 0.720100 \n", + "... ... ... ... ... ... ... ... \n", + "19881 0.006235 0.099738 0.447121 ... 0.515790 0.021150 0.432649 \n", + "19882 0.515646 0.600404 0.219125 ... 0.708222 0.488991 0.787087 \n", + "19883 0.499179 0.541565 0.307655 ... 0.729369 0.496476 0.670612 \n", + "19884 0.515466 0.847680 0.360186 ... 0.699144 0.352506 0.823751 \n", + "19885 0.002806 0.207584 0.480812 ... 0.813567 0.061863 0.377723 \n", + "\n", + " 45 46 47 48 49 50 Label \n", + "0 0.908153 0.483046 0.720282 0.890200 0.464781 0.645452 0.0 \n", + "1 0.951776 0.546183 0.010918 1.009965 0.616205 0.035840 0.0 \n", + "2 0.494082 0.916525 0.337711 0.518012 0.927171 0.333892 0.0 \n", + "3 1.001534 0.595226 0.248007 0.999257 0.556489 0.095615 0.0 \n", + "4 0.857451 0.523833 0.786749 0.838329 0.539039 0.707628 1.0 \n", + "... ... ... ... ... ... ... ... \n", + "19881 0.382307 0.305971 0.513557 0.511185 0.301932 0.434094 0.0 \n", + "19882 0.881291 0.559657 0.636291 0.880278 0.520447 0.650306 0.0 \n", + "19883 0.881893 0.454307 0.539147 0.897172 0.474562 0.654785 1.0 \n", + "19884 0.848086 0.486915 0.734045 0.831969 0.455564 0.671235 0.0 \n", + "19885 0.947498 0.075425 0.414755 0.944458 0.085614 0.398845 0.0 \n", + "\n", + "[19871 rows x 52 columns]" + ], + "text/html": [ + "\n", + "
\n", + "
\n", + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
0123456789...424344454647484950Label
00.4142740.5127710.5664440.4018490.5310360.6306570.3998370.5084120.5522700.406642...0.7584900.3682970.7086050.9081530.4830460.7202820.8902000.4647810.6454520.0
10.2387840.5797320.6890650.2043830.5937880.7052850.1946540.5360340.8570520.214173...0.9851480.3707270.0426310.9517760.5461830.0109181.0099650.6162050.0358400.0
20.4383030.2349280.0534870.3891650.2592970.1590850.3921020.2467660.1255900.433905...0.6334410.6945060.5589140.4940820.9165250.3377110.5180120.9271710.3338920.0
30.4079790.3886400.5642770.3982070.3988960.8672720.3932690.3706780.7206810.413659...0.9123590.4825940.6978961.0015340.5952260.2480070.9992570.5564890.0956150.0
40.2577350.5643000.5492020.2563010.5757380.6535160.2554060.5772750.6992400.286838...0.6828980.5307020.7201000.8574510.5238330.7867490.8383290.5390390.7076281.0
..................................................................
198810.4724530.0137400.0798100.4610540.0036830.0883500.4627410.0062350.0997380.447121...0.5157900.0211500.4326490.3823070.3059710.5135570.5111850.3019320.4340940.0
198820.2179670.5201090.5834330.2058940.5372450.5664230.2052500.5156460.6004040.219125...0.7082220.4889910.7870870.8812910.5596570.6362910.8802780.5204470.6503060.0
198830.3186110.5033850.5323570.3051210.4998440.5581990.3060800.4991790.5415650.307655...0.7293690.4964760.6706120.8818930.4543070.5391470.8971720.4745620.6547851.0
198840.3650030.5169430.7920960.3517650.5344240.8312010.3494240.5154660.8476800.360186...0.6991440.3525060.8237510.8480860.4869150.7340450.8319690.4555640.6712350.0
198850.4911910.0018730.2375270.4802460.0022140.2113910.4813540.0028060.2075840.480812...0.8135670.0618630.3777230.9474980.0754250.4147550.9444580.0856140.3988450.0
\n", + "

19871 rows × 52 columns

\n", + "
\n", + " \n", + " \n", + " \n", + "\n", + " \n", + "
\n", + "
\n", + " " + ] + }, + "metadata": {}, + "execution_count": 127 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "# spliting the dataset\n" + ], + "metadata": { + "id": "rg9Jt5EMPxM0" + } + }, + { + "cell_type": "code", + "source": [ + "from sklearn.model_selection import train_test_split\n", + "train_val_data, test_data = train_test_split(dataSet, test_size=0.2, random_state=42) # 80% train/validation, 20% test\n", + "train_data, val_data = train_test_split(train_val_data, test_size=0.25, random_state=42) # 60% train, 20% validation\n", + "print(test_data)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "r6Ijo5aDPvLA", + "outputId": "45469f0d-9c6d-4002-a7ca-06c2c4c35ed1" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + " 0 1 2 3 4 5 6 \\\n", + "3950 0.452123 0.984307 0.129076 0.449638 0.985651 0.169795 0.446063 \n", + "1272 0.891779 0.483441 0.119450 0.922138 0.470993 0.156055 0.899562 \n", + "5006 0.495788 0.034438 0.693820 0.480385 0.013265 0.632854 0.479685 \n", + "17944 0.366206 0.556530 0.642708 0.349623 0.576134 0.526209 0.349735 \n", + "3165 0.208581 0.427455 0.510736 0.206850 0.415953 0.486568 0.214054 \n", + "... ... ... ... ... ... ... ... \n", + "9711 0.498629 0.087214 0.456516 0.483167 0.075099 0.422595 0.484909 \n", + "3794 0.258800 0.523015 0.712224 0.243124 0.536637 0.760739 0.243233 \n", + "13238 0.266444 0.522313 0.851163 0.252165 0.537266 0.784377 0.251246 \n", + "4148 0.292897 0.494085 0.350980 0.281324 0.503689 0.535121 0.282096 \n", + "2813 0.352651 0.587707 0.446810 0.360870 0.600777 0.488446 0.361869 \n", + "\n", + " 7 8 9 ... 42 43 44 \\\n", + "3950 0.988002 0.176367 0.573434 ... 0.459394 0.462397 0.129529 \n", + "1272 0.483166 0.102623 0.938519 ... 0.409819 0.487178 0.444934 \n", + "5006 0.011531 0.538029 0.421910 ... 0.575523 0.759950 0.890476 \n", + "17944 0.556260 0.762152 0.352233 ... 0.897081 0.390399 0.723852 \n", + "3165 0.409603 0.343696 0.214321 ... 0.711888 0.397140 0.831780 \n", + "... ... ... ... ... ... ... ... \n", + "9711 0.074761 0.495927 0.439559 ... 0.602830 0.673721 0.636173 \n", + "3794 0.510401 0.733323 0.241347 ... 0.696036 0.437085 0.833522 \n", + "13238 0.511052 0.799108 0.248087 ... 0.699792 0.438684 0.890328 \n", + "4148 0.503986 0.538725 0.286810 ... 0.666386 0.397001 0.228303 \n", + "2813 0.605460 0.482917 0.387645 ... 0.816312 0.430951 0.761350 \n", + "\n", + " 45 46 47 48 49 50 Label \n", + "3950 0.338183 0.931621 0.495670 0.489410 0.244663 0.215536 0.0 \n", + "1272 0.202740 0.531632 0.260056 0.205491 0.500999 0.152203 0.0 \n", + "5006 0.654904 0.995823 0.529666 0.631572 0.976670 0.681222 0.0 \n", + "17944 1.004181 0.335454 0.078422 0.988211 0.303247 0.286418 0.0 \n", + "3165 0.862096 0.381074 0.744516 0.847204 0.270898 0.896383 0.0 \n", + "... ... ... ... ... ... ... ... \n", + "9711 0.574359 0.907911 0.718455 0.563487 0.875235 0.681410 0.0 \n", + "3794 0.858417 0.667540 0.923802 0.855392 0.380982 0.936620 0.0 \n", + "13238 0.853920 0.648880 0.813314 0.856072 0.388417 0.840352 0.0 \n", + "4148 0.833936 0.346985 0.724122 0.828860 0.348323 0.401752 1.0 \n", + "2813 0.858146 0.562045 0.698613 0.850839 0.552233 0.652070 0.0 \n", + "\n", + "[3975 rows x 52 columns]\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "xtrain=train_data.iloc[:, :51].values\n", + "ytrain=train_data['Label'].values\n", + "xtest=test_data.iloc[:, :51].values\n", + "ytest=test_data['Label'].values\n", + "xval=val_data.iloc[:, :51].values\n", + "yval=val_data['Label'].values" + ], + "metadata": { + "id": "ll6FGxfcP37A" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "xtrain=xtrain.reshape((xtrain.shape[0], 17,3))\n", + "xtest=xtest.reshape((xtest.shape[0], 17,3))\n", + "xval=xval.reshape((xval.shape[0], 17,3))" + ], + "metadata": { + "id": "eGDcRJ8OP7a-" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "# Form Correctness Model" + ], + "metadata": { + "id": "K2S-gc7BQUi1" + } + }, + { + "cell_type": "code", + "source": [ + "import tensorflow as tf\n", + "\n", + "# Define the input shape\n", + "input_shape = (17,3)\n", + "\n", + "# Create a sequential model\n", + "model = tf.keras.models.Sequential()\n", + "\n", + "# Add a flatten layer to flatten the input into a vector\n", + "model.add(tf.keras.layers.Flatten(input_shape=input_shape))\n", + "\n", + "# Add a dense layer with 64 nodes, using ReLU activation\n", + "model.add(tf.keras.layers.Dense(64, activation='relu'))\n", + "\n", + "# Add a dropout layer to prevent overfitting\n", + "model.add(tf.keras.layers.Dropout(0.2))\n", + "\n", + "# Add another dense layer with 32 nodes, using ReLU activation\n", + "model.add(tf.keras.layers.Dense(32, activation='relu'))\n", + "\n", + "# Add the output layer with 1 node, using sigmoid activation\n", + "model.add(tf.keras.layers.Dense(1, activation='sigmoid'))\n", + "\n", + "# Compile the model with binary crossentropy loss and Adam optimizer\n", + "model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])\n", + "\n", + "# Train the model on your data\n", + "history = model.fit(xtrain, ytrain, epochs=20, batch_size=32, validation_data=(xval, yval))" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "pCJQyhuIP-ua", + "outputId": "384f2f32-250d-4245-b09e-8d5678b15efa" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Epoch 1/20\n", + "373/373 [==============================] - 3s 2ms/step - loss: 0.3830 - accuracy: 0.8182 - val_loss: 0.2608 - val_accuracy: 0.8792\n", + "Epoch 2/20\n", + "373/373 [==============================] - 1s 2ms/step - loss: 0.2496 - accuracy: 0.8846 - val_loss: 0.2638 - val_accuracy: 0.8566\n", + "Epoch 3/20\n", + "373/373 [==============================] - 1s 3ms/step - loss: 0.2022 - accuracy: 0.9096 - val_loss: 0.1730 - val_accuracy: 0.9263\n", + "Epoch 4/20\n", + "373/373 [==============================] - 1s 4ms/step - loss: 0.1646 - accuracy: 0.9314 - val_loss: 0.1353 - val_accuracy: 0.9502\n", + "Epoch 5/20\n", + "373/373 [==============================] - 1s 2ms/step - loss: 0.1396 - accuracy: 0.9432 - val_loss: 0.1355 - val_accuracy: 0.9338\n", + "Epoch 6/20\n", + "373/373 [==============================] - 1s 2ms/step - loss: 0.1252 - accuracy: 0.9494 - val_loss: 0.1217 - val_accuracy: 0.9472\n", + "Epoch 7/20\n", + "373/373 [==============================] - 1s 2ms/step - loss: 0.1145 - accuracy: 0.9550 - val_loss: 0.0943 - val_accuracy: 0.9678\n", + "Epoch 8/20\n", + "373/373 [==============================] - 1s 2ms/step - loss: 0.1016 - accuracy: 0.9615 - val_loss: 0.0826 - val_accuracy: 0.9708\n", + "Epoch 9/20\n", + "373/373 [==============================] - 1s 2ms/step - loss: 0.0969 - accuracy: 0.9622 - val_loss: 0.0863 - val_accuracy: 0.9673\n", + "Epoch 10/20\n", + "373/373 [==============================] - 1s 2ms/step - loss: 0.0882 - accuracy: 0.9652 - val_loss: 0.0845 - val_accuracy: 0.9663\n", + "Epoch 11/20\n", + "373/373 [==============================] - 1s 2ms/step - loss: 0.0864 - accuracy: 0.9654 - val_loss: 0.0676 - val_accuracy: 0.9771\n", + "Epoch 12/20\n", + "373/373 [==============================] - 1s 2ms/step - loss: 0.0835 - accuracy: 0.9675 - val_loss: 0.0667 - val_accuracy: 0.9748\n", + "Epoch 13/20\n", + "373/373 [==============================] - 1s 2ms/step - loss: 0.0764 - accuracy: 0.9701 - val_loss: 0.0595 - val_accuracy: 0.9771\n", + "Epoch 14/20\n", + "373/373 [==============================] - 1s 2ms/step - loss: 0.0675 - accuracy: 0.9742 - val_loss: 0.0682 - val_accuracy: 0.9758\n", + "Epoch 15/20\n", + "373/373 [==============================] - 1s 2ms/step - loss: 0.0700 - accuracy: 0.9722 - val_loss: 0.0590 - val_accuracy: 0.9794\n", + "Epoch 16/20\n", + "373/373 [==============================] - 1s 2ms/step - loss: 0.0698 - accuracy: 0.9726 - val_loss: 0.0483 - val_accuracy: 0.9854\n", + "Epoch 17/20\n", + "373/373 [==============================] - 1s 1ms/step - loss: 0.0651 - accuracy: 0.9753 - val_loss: 0.0661 - val_accuracy: 0.9731\n", + "Epoch 18/20\n", + "373/373 [==============================] - 1s 2ms/step - loss: 0.0657 - accuracy: 0.9746 - val_loss: 0.0456 - val_accuracy: 0.9847\n", + "Epoch 19/20\n", + "373/373 [==============================] - 1s 2ms/step - loss: 0.0603 - accuracy: 0.9758 - val_loss: 0.0394 - val_accuracy: 0.9879\n", + "Epoch 20/20\n", + "373/373 [==============================] - 1s 2ms/step - loss: 0.0553 - accuracy: 0.9808 - val_loss: 0.0474 - val_accuracy: 0.9816\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "model.summary()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "9GPiD1maQEfs", + "outputId": "018e3512-40ff-4c4e-d7c8-da5bc1a5253a" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Model: \"sequential_2\"\n", + "_________________________________________________________________\n", + " Layer (type) Output Shape Param # \n", + "=================================================================\n", + " flatten_2 (Flatten) (None, 51) 0 \n", + " \n", + " dense_6 (Dense) (None, 64) 3328 \n", + " \n", + " dropout_2 (Dropout) (None, 64) 0 \n", + " \n", + " dense_7 (Dense) (None, 32) 2080 \n", + " \n", + " dense_8 (Dense) (None, 1) 33 \n", + " \n", + "=================================================================\n", + "Total params: 5,441\n", + "Trainable params: 5,441\n", + "Non-trainable params: 0\n", + "_________________________________________________________________\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "test_loss, test_acc = model.evaluate(xtest, ytest)\n", + "\n", + "print('Test accuracy:', test_acc)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "JfAjaiUGQIXd", + "outputId": "4fa0bcf8-ddf6-4518-aff9-f39e1ec34eeb" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "125/125 [==============================] - 0s 867us/step - loss: 0.0499 - accuracy: 0.9819\n", + "Test accuracy: 0.9818868041038513\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "# Saving The Model" + ], + "metadata": { + "id": "W8T92iCBQXyw" + } + }, + { + "cell_type": "code", + "source": [ + "from google.colab import files" + ], + "metadata": { + "id": "YlTS2sb-QLL9" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "model.save('pullUp_v2.h5')\n", + "\n", + "# Convert the saved TensorFlow model to a TensorFlow Lite model\n", + "\n", + "converter = tf.lite.TFLiteConverter.from_keras_model(model)\n", + "tflite_model = converter.convert()\n", + "\n", + "# Save the converted TensorFlow Lite model to a file\n", + "\n", + "with open('pullUp_v2.tflite', 'wb') as f:\n", + " f.write(tflite_model)\n", + "files.download('pullUp_v2.tflite')" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 34 + }, + "id": "GVOxLmqlQMyD", + "outputId": "cbe2bbd0-3202-477e-ebe1-16a2e74bc5e4" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "WARNING:absl:Found untraced functions such as _update_step_xla while saving (showing 1 of 1). These functions will not be directly callable after loading.\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "application/javascript": [ + "\n", + " async function download(id, filename, size) {\n", + " if (!google.colab.kernel.accessAllowed) {\n", + " return;\n", + " }\n", + " const div = document.createElement('div');\n", + " const label = document.createElement('label');\n", + " label.textContent = `Downloading \"${filename}\": `;\n", + " div.appendChild(label);\n", + " const progress = document.createElement('progress');\n", + " progress.max = size;\n", + " div.appendChild(progress);\n", + " document.body.appendChild(div);\n", + "\n", + " const buffers = [];\n", + " let downloaded = 0;\n", + "\n", + " const channel = await google.colab.kernel.comms.open(id);\n", + " // Send a message to notify the kernel that we're ready.\n", + " channel.send({})\n", + "\n", + " for await (const message of channel.messages) {\n", + " // Send a message to notify the kernel that we're ready.\n", + " channel.send({})\n", + " if (message.buffers) {\n", + " for (const buffer of message.buffers) {\n", + " buffers.push(buffer);\n", + " downloaded += buffer.byteLength;\n", + " progress.value = downloaded;\n", + " }\n", + " }\n", + " }\n", + " const blob = new Blob(buffers, {type: 'application/binary'});\n", + " const a = document.createElement('a');\n", + " a.href = window.URL.createObjectURL(blob);\n", + " a.download = filename;\n", + " div.appendChild(a);\n", + " a.click();\n", + " div.remove();\n", + " }\n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "application/javascript": [ + "download(\"download_718d81dd-5af8-4794-8ce7-5a049ed25591\", \"pullUp_v2.tflite\", 24176)" + ] + }, + "metadata": {} + } + ] + } + ] +} \ No newline at end of file