├── CS4501FinalCodeWalkthroughLink.txt ├── CS4501FinalReport.pdf ├── CollisionResistance.py └── CS4501FinalCode.ipynb /CS4501FinalCodeWalkthroughLink.txt: -------------------------------------------------------------------------------- 1 | https://youtu.be/aSvwHro8dbY -------------------------------------------------------------------------------- /CS4501FinalReport.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/averywit/CS4501FinalProject/HEAD/CS4501FinalReport.pdf -------------------------------------------------------------------------------- /CollisionResistance.py: -------------------------------------------------------------------------------- 1 | import hashlib 2 | import base64 3 | from io import BytesIO 4 | from PIL import Image 5 | from colorama import Fore 6 | 7 | image = input("Enter the image you would like modified: ") 8 | 9 | buffered1 = BytesIO() 10 | original_image = Image.open(image) 11 | original_image.save(buffered1, format="JPEG") 12 | original_hash = hashlib.sha256(base64.b64encode(buffered1.getvalue())).hexdigest() 13 | 14 | buffered2 = BytesIO() 15 | modified_image = Image.open(image) 16 | modified_image = modified_image.transpose(Image.Transpose.FLIP_LEFT_RIGHT) 17 | modified_image.save(buffered2, format="JPEG") 18 | modified_hash = hashlib.sha256(base64.b64encode(buffered2.getvalue())).hexdigest() 19 | modified_image.save("/Users/avery/Downloads/personal/Modified.jpg") 20 | 21 | print("") 22 | print(Fore.RESET + "Original hash: " + Fore.GREEN + original_hash) 23 | print(Fore.RESET + "Modified hash: ", end="") 24 | 25 | i = 0 26 | count = 0 27 | while i < len(original_hash): 28 | if original_hash[i] != modified_hash[i]: 29 | print(Fore.RED + modified_hash[i], end="") 30 | count += 1 31 | else: 32 | print(Fore.GREEN + modified_hash[i], end="") 33 | i += 1 34 | 35 | print("\n") 36 | print(Fore.RESET + "Hamming distance: " + Fore.RED + str(count)) 37 | -------------------------------------------------------------------------------- /CS4501FinalCode.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 102, 6 | "id": "d2178082", 7 | "metadata": { 8 | "scrolled": true 9 | }, 10 | "outputs": [ 11 | { 12 | "name": "stdout", 13 | "output_type": "stream", 14 | "text": [ 15 | "Collecting package metadata (current_repodata.json): done\n", 16 | "Solving environment: done\n", 17 | "\n", 18 | "# All requested packages already installed.\n", 19 | "\n", 20 | "Collecting package metadata (current_repodata.json): done\n", 21 | "Solving environment: done\n", 22 | "\n", 23 | "# All requested packages already installed.\n", 24 | "\n", 25 | "Collecting package metadata (current_repodata.json): done\n", 26 | "Solving environment: done\n", 27 | "\n", 28 | "# All requested packages already installed.\n", 29 | "\n" 30 | ] 31 | } 32 | ], 33 | "source": [ 34 | "# Installing packages and initializing environment required for program below\n", 35 | "# Package 1: Selenium, used to interact with the browser\n", 36 | "# Package 2: ChromeDriver, used to open and create Google Chrome browser to operate with\n", 37 | "# Package 3: ONNXRuntime, used as a machine learning model to simulate neural hash of images\n", 38 | "# Package 4: Pillow (Python Imaging Library), used to modify the inserted images\n", 39 | "# Package 5: OpenCV, used to select the first frame of a video and save it\n", 40 | "\n", 41 | "import time\n", 42 | "import sys \n", 43 | "!conda install --yes --prefix {sys.prefix} selenium\n", 44 | "!conda install --yes --prefix {sys.prefix} chromedriver-binary\n", 45 | "!conda install --yes --prefix {sys.prefix} opencv\n", 46 | "#!conda install --yes --prefix {sys.prefix} onnxruntime\n", 47 | "#!conda install --yes --prefix {sys.prefix} pillow" 48 | ] 49 | }, 50 | { 51 | "cell_type": "code", 52 | "execution_count": 103, 53 | "id": "f2b3afac", 54 | "metadata": {}, 55 | "outputs": [ 56 | { 57 | "name": "stdout", 58 | "output_type": "stream", 59 | "text": [ 60 | "Please enter video link you want to download: https://www.instagram.com/reel/CXvzcVfO-N4/?utm_source=ig_web_copy_link\n" 61 | ] 62 | } 63 | ], 64 | "source": [ 65 | "# Creating and opening a Google Chrome browser, downloading the video link\n", 66 | "link = input(\"Please enter video link you want to download: \")\n", 67 | "\n", 68 | "from selenium import webdriver\n", 69 | "from webdriver_manager.chrome import ChromeDriverManager\n", 70 | "from selenium.webdriver.chrome.service import Service\n", 71 | "from selenium.webdriver.chrome.options import Options\n", 72 | "from selenium.webdriver.common.by import By\n", 73 | "\n", 74 | "serv = Service(\"/Users/avery/.wdm/drivers/chromedriver/mac64/96.0.4664.45/chromedriver\")\n", 75 | "chrome_options = Options()\n", 76 | "driver = webdriver.Chrome(service=serv, options=chrome_options)\n", 77 | "\n", 78 | "if(link.find(\"www.tiktok.com\") != -1):\n", 79 | " driver.get(\"https://snaptik.app/\")\n", 80 | " driver.find_element(By.ID, \"url\").send_keys(link)\n", 81 | " driver.find_element(By.ID, \"submiturl\").click()\n", 82 | " time.sleep(7)\n", 83 | " driver.find_element(By.PARTIAL_LINK_TEXT, \"Download Server 02 (SnapTik)\").click()\n", 84 | " time.sleep(7)\n", 85 | " driver.quit()\n", 86 | " \n", 87 | "else:\n", 88 | " driver.get(\"https://snapinsta.app/\")\n", 89 | " driver.find_element(By.ID, \"url\").send_keys(link)\n", 90 | " driver.find_element(By.ID, \"send\").click()\n", 91 | " time.sleep(7)\n", 92 | " driver.find_element(By.PARTIAL_LINK_TEXT, \"Download Video\").click()\n", 93 | " time.sleep(7)\n", 94 | " driver.quit()" 95 | ] 96 | }, 97 | { 98 | "cell_type": "code", 99 | "execution_count": 92, 100 | "id": "ca407d27", 101 | "metadata": { 102 | "scrolled": true 103 | }, 104 | "outputs": [ 105 | { 106 | "name": "stdout", 107 | "output_type": "stream", 108 | "text": [ 109 | "Please enter original video's file name: SnapInsta_269042669_484933576593588_3726858475770358233_n.mp4\n", 110 | "The selection 1 has been recorded!\n" 111 | ] 112 | } 113 | ], 114 | "source": [ 115 | "# Randomly selecting whether or not the video is modified for the post\n", 116 | "import cv2\n", 117 | "import numpy as np\n", 118 | "import random\n", 119 | "\n", 120 | "magic8 = random.randrange(2)\n", 121 | "if(magic8 == 1):\n", 122 | " regular = \"/Users/avery/Downloads/\" + input(\"Please enter original video's file name: \")\n", 123 | " # Code modified and utilized from https://stackoverflow.com/questions/29317262/opencv-video-saving-in-python to flip the video\n", 124 | " cap = cv2.VideoCapture(regular)\n", 125 | " height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))\n", 126 | " width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))\n", 127 | " fourcc = cv2.VideoWriter_fourcc(*'mp4v')\n", 128 | " out = cv2.VideoWriter('mirrored.mp4', fourcc, 30.0, (width,height))\n", 129 | " while(cap.isOpened()):\n", 130 | " ret, frame = cap.read()\n", 131 | " if(ret==True):\n", 132 | " # Mirrors the frame on the x-axis\n", 133 | " frame = cv2.flip(frame,1)\n", 134 | " out.write(frame)\n", 135 | " if(cv2.waitKey(1) & 0xFF == ord('q')):\n", 136 | " break\n", 137 | " else:\n", 138 | " break\n", 139 | " cap.release()\n", 140 | " out.release()\n", 141 | " cv2.destroyAllWindows()\n", 142 | " mirrored = \"/Users/avery/Downloads/mirrored.mp4\"\n", 143 | "else:\n", 144 | " pass\n", 145 | "\n", 146 | "# Writing outputting result into a text file\n", 147 | "selection = open(\"selection.txt\", \"w\")\n", 148 | "selection.write(str(magic8))\n", 149 | "selection.close()\n", 150 | "print(\"The selection \" + str(magic8) + \" has been recorded!\")" 151 | ] 152 | }, 153 | { 154 | "cell_type": "code", 155 | "execution_count": 106, 156 | "id": "4a0636b8", 157 | "metadata": {}, 158 | "outputs": [ 159 | { 160 | "name": "stdout", 161 | "output_type": "stream", 162 | "text": [ 163 | "Please enter original video's file name: SnapInsta_269042669_484933576593588_3726858475770358233_n.mp4\n" 164 | ] 165 | } 166 | ], 167 | "source": [ 168 | "# Comparing the hash of two videos\n", 169 | "regular = \"/Users/avery/Downloads/\" + input(\"Please enter original video's file name: \")\n", 170 | "\n", 171 | "# Code modified and utilized from https://stackoverflow.com/questions/29317262/opencv-video-saving-in-python to flip the video\n", 172 | "cap = cv2.VideoCapture(regular)\n", 173 | "height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))\n", 174 | "width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))\n", 175 | "fourcc = cv2.VideoWriter_fourcc(*'mp4v')\n", 176 | "out = cv2.VideoWriter('mirrored.mp4', fourcc, 30.0, (width,height))\n", 177 | "while(cap.isOpened()):\n", 178 | " ret, frame = cap.read()\n", 179 | " if(ret==True):\n", 180 | " # Mirrors the frame on the x-axis\n", 181 | " frame = cv2.flip(frame,1)\n", 182 | " out.write(frame)\n", 183 | " if(cv2.waitKey(1) & 0xFF == ord('q')):\n", 184 | " break\n", 185 | " else:\n", 186 | " break\n", 187 | "cap.release()\n", 188 | "out.release()\n", 189 | "cv2.destroyAllWindows()\n", 190 | "mirrored = \"/Users/avery/Downloads/mirrored.mp4\"\n", 191 | "\n", 192 | "# Capturing the first frame of both the regular and mirrored video to compare neural hash\n", 193 | "vidcap = cv2.VideoCapture(regular)\n", 194 | "success,image = vidcap.read()\n", 195 | "cv2.imwrite(\"regularframe.jpg\", image)\n", 196 | "vidcap = cv2.VideoCapture(mirrored)\n", 197 | "success,image = vidcap.read()\n", 198 | "cv2.imwrite(\"mirroredframe.jpg\", image)\n", 199 | "\n", 200 | "# Utilizing the first frame of the regular and mirrored video for the neural hash comparison\n", 201 | "regularframe = \"/Users/avery/Downloads/regularframe.jpg\"\n", 202 | "mirroredframe = \"/Users/avery/Downloads/mirroredframe.jpg\"" 203 | ] 204 | }, 205 | { 206 | "cell_type": "markdown", 207 | "id": "3117dba0", 208 | "metadata": {}, 209 | "source": [ 210 | "# Code originally used to compare hashes resulting from NeuralHash\n", 211 | "#Open source code referenced from https://github.com/AsuharietYgvar/AppleNeuralHash2ONNX/blob/master/nnhash.py\n", 212 | "import onnxruntime\n", 213 | "import numpy as np\n", 214 | "from PIL import Image\n", 215 | "\n", 216 | "#Load ONNX model\n", 217 | "session = onnxruntime.InferenceSession(sys.argv[1])\n", 218 | "\n", 219 | "#Load output hash matrix\n", 220 | "seed1 = open(sys.argv[2], 'rb').read()[128:]\n", 221 | "seed1 = np.frombuffer(seed1, dtype=np.float32)\n", 222 | "seed1 = seed1.reshape([96, 128])\n", 223 | "\n", 224 | "#Preprocess image\n", 225 | "image = Image.open(sys.argv[3]).convert('RGB')\n", 226 | "image = image.resize([360, 360])\n", 227 | "arr = np.array(image).astype(np.float32) / 255.0\n", 228 | "arr = arr * 2.0 - 1.0\n", 229 | "arr = arr.transpose(2, 0, 1).reshape([1, 3, 360, 360])\n", 230 | "\n", 231 | "#Run model\n", 232 | "inputs = {session.get_inputs()[0].name: arr}\n", 233 | "outs = session.run(None, inputs)\n", 234 | "\n", 235 | "#Convert model output to hex hash\n", 236 | "hash_output = seed1.dot(outs[0].flatten())\n", 237 | "hash_bits = ''.join(['1' if it >= 0 else '0' for it in hash_output])\n", 238 | "hash_hex = '{:0{}x}'.format(int(hash_bits, 2), len(hash_bits) // 4)\n", 239 | "print(hash_hex)" 240 | ] 241 | }, 242 | { 243 | "cell_type": "code", 244 | "execution_count": 104, 245 | "id": "94b01860", 246 | "metadata": {}, 247 | "outputs": [ 248 | { 249 | "data": { 250 | "image/png": "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\n", 251 | "text/plain": [ 252 | "
" 253 | ] 254 | }, 255 | "metadata": { 256 | "needs_background": "light" 257 | }, 258 | "output_type": "display_data" 259 | } 260 | ], 261 | "source": [ 262 | "# Utilizing Instagram profile for engagement and creating visual graphs\n", 263 | "import pandas as pd\n", 264 | "import matplotlib.pyplot as plt\n", 265 | "from matplotlib.pyplot import figure\n", 266 | "\n", 267 | "selection = open(\"selection.txt\")\n", 268 | "output = selection.read()\n", 269 | "index = [\"Post 1\",\"Post 2\",\"Post 3\",\"Post 4\",\"Post 5\",\"Post 6\",\"Post 7\",\"Post 8\",\"Post 9\",\"Post 10\",\"Post 11\",\"Post 12\"]\n", 270 | "df = pd.DataFrame({\"Views\": [1848069, 50626, 229358, 28363, 2472605, 50269, 373530, 24461, 30531, 31915, 18645, 38025], \n", 271 | " \"Likes\": [82001, 1587, 7767, 1823, 143325, 1330, 9062, 1120, 964, 1594, 1178, 2084],\n", 272 | " \"Comments\": [74, 3, 70, 18, 197, 0, 4, 7, 39, 11, 20, 4],\n", 273 | " \"Shares\": [938, 10, 334, 35, 4004, 12, 94, 19, 101, 66, 140, 12],\n", 274 | " \"Saves\": [1537, 72, 231, 99, 5168, 57, 128, 134, 57, 92, 133, 55],\n", 275 | " \"Modified\": [output[0], output[1], output[2], output[3], output[4], output[5], output[6], output[7], output[8], output[9], output[10], output[11]]}, index = index)\n", 276 | "selection.close()\n", 277 | "df.plot.bar()\n", 278 | "plt.title('Combined Posts')\n", 279 | "plt.xlabel('Post Number')\n", 280 | "plt.ylabel('Total Engagement (Million)')\n", 281 | "plt.show()" 282 | ] 283 | }, 284 | { 285 | "cell_type": "code", 286 | "execution_count": 105, 287 | "id": "e1585b74", 288 | "metadata": {}, 289 | "outputs": [ 290 | { 291 | "data": { 292 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYQAAAETCAYAAAA23nEoAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAiwElEQVR4nO3de3SU9b3v8fdXoOARb0B0W0INIFggiRFIQFAE3BC3PV7KFgjecIObSr2gntKDpe6ytZyDltNa2VsppV3E1lWgKJUl2zsg1CIQIFzCRaKiRNkKVlJQQQLf88f8kk7CkAsOmRnyea01a57n91zm8wxhvvPcfmPujoiIyGmJDiAiIslBBUFERAAVBBERCVQQREQEUEEQEZFABUFERABonugAJ6pdu3aekZGR6BgiIill7dq1e909Lda0lC0IGRkZFBUVJTqGiEhKMbP3jzdNh4xERARQQRARkUAFQUREgBQ+hyBNx+HDhykrK+PgwYOJjnJKatWqFenp6bRo0SLRUSTBVBAk6ZWVlXHmmWeSkZGBmSU6zinF3fn0008pKyujY8eOiY4jCaZDRpL0Dh48SNu2bVUMTgIzo23bttr7EkAFQVKEisHJo/dWKtWrIJjZTjPbZGbFZlYU2tqY2atmtiM8nxs1/4NmVmpm280sP6q9V1hPqZk9YeEv0cxamtm80L7KzDLivJ0iJ2zgwIG8/PLL1doef/xxOnXqxLRp0xKUSiT+GnIOYZC7740anwS87u7TzGxSGP/fZtYdKAB6AN8EXjOzru5+BHgKGAe8BfwXcDXwIjAW+MzdLzKzAuBRYOTX3LYqGZMWVxvfOe078Vq1JEDNf8+vq66/h1GjRjF37lzy86u+2zB37lwKCwu54oor4ppFJJG+ziGj64HCMFwI3BDVPtfdD7n7e0ApkGdmFwBnuftKj/xM29M1lqlc1wLgKtN+rCSJG2+8kRdeeIFDhw4BsHPnTj766CNKS0u5++67AdizZw///M//TG5uLrm5ubz55psAZGVlsW/fPtydtm3b8vTTTwNw66238tprr1FSUkJeXh45OTlkZ2ezY8eOxGykCPUvCA68YmZrzWxcaDvf3XcDhOfzQnt7YFfUsmWhrX0YrtlebRl3rwDKgbYN2xRpDBmTFld7NAVt27YlLy+Pl156CYjsHYwcObLasfcJEyZw//33s2bNGp599lnuuOMOAPr378+bb75JSUkJnTp1YsWKFQC89dZb9O3bl5kzZzJhwgSKi4spKioiPT298TdQJKjvIaP+7v6RmZ0HvGpm22qZN9Y3e6+lvbZlqq84UozGAXzrW9+qPbFIHFUeNrr++uuZO3cuv/3tb9m4cWPV9Ndee40tW7ZUjf/tb39j//79XHHFFSxfvpwLL7yQ8ePHM2vWLD788EPatGlD69atueyyy5g6dSplZWUMGzaMLl26JGLzRIB67iG4+0fh+RNgIZAHfBwOAxGePwmzlwEdohZPBz4K7ekx2qstY2bNgbOBv8bIMcvde7t777S0mJ31iZwUN9xwA6+//jrr1q3jyy+/pGfPntWmHz16lJUrV1JcXExxcTEffvghZ555JgMGDGDFihWsWLGCgQMHkpaWxoIFC6rOPdx0000sWrSI008/nfz8fJYsWZKIzRMB6lEQzOwMMzuzchgYCmwGFgGjw2yjgefD8CKgIFw51BHoAqwOh5X2m1nfcH7gthrLVK7rRmBJOM8gkhRat27NwIEDGTNmDKNGjTpm+tChQ/mP//iPqvHi4mIAOnTowN69e9mxYwedOnXi8ssvZ/r06VUF4d1336VTp07ce++9XHfdddX2OkQaW332EM4H/mxmG4DVwGJ3fwmYBgwxsx3AkDCOu5cA84EtwEvAXeEKI4DxwGwiJ5rfIXKFEcBvgLZmVgo8QOSKJZGkMmrUKDZs2EBBQcEx05544gmKiorIzs6me/fuzJw5s2panz596Nq1KwBXXHEFH374IZdffjkA8+bNIzMzk5ycHLZt28Ztt93WOBsjEoOl6hfx3r17e31/D0GXncZPIt7LrVu30q1bt5P+Ok2Z3uOmw8zWunvvWNN0p7KIiAAqCCIiEqggiIgIoIIgIiKBCoKIiAAqCCIiEqggiNRD69atj2mbOXNmVWd1AwcOpL6XQYskK/2EpqSeKWfHeX3lJ7TYnXfeGd8cIgmmPQSREzRlyhSmT59ere3o0aOMHj2aH//4xxw5coSJEyeSm5tLdnY2v/rVrwDYvXs3AwYMICcnh8zMzKoeUEUSTXsIInFSUVHBzTffTGZmJpMnT2bWrFmcffbZrFmzhkOHDtG/f3+GDh3Kc889R35+PpMnT+bIkSN88cUXiY4uAqggiMTN9773PUaMGMHkyZMBeOWVV9i4cSMLFiwAoLy8nB07dpCbm8uYMWM4fPgwN9xwAzk5OQlMLfJ3OmQkEif9+vVj6dKlHDx4EAB3Z8aMGVVdYr/33nsMHTqUAQMGsHz5ctq3b8+tt95adWJaJNFUEETiZOzYsVxzzTUMHz6ciooK8vPzeeqppzh8+DAAb7/9Np9//jnvv/8+5513Hv/6r//K2LFjWbduXYKTi0TokJFIPXzxxRfVft7ygQceiDnfAw88QHl5ObfeeivPPPMMO3fupGfPnrg7aWlp/OlPf2LZsmX87Gc/o0WLFrRu3Vp7CJI01P21NIi6vz416T1uOtT9tYiI1EkFQUREABUEEREJVBBERARQQRARkUAFQUREABUEkXr57//+bwoKCujcuTPdu3fnmmuu4e233050rJiWLVvGX/7yl0THkBSkG9Mk5WQVZsV1fZtGb6p1urvz3e9+l9GjRzN37lwAiouL+fjjj+natWtcs8TDsmXLaN26Nf369Ut0FEkx2kMQqcPSpUtp0aJFtd8/yMnJ4fLLL2fixIlkZmaSlZXFvHnzgMgH8pVXXsmIESPo2rUrkyZN4plnniEvL4+srCzeeecdAG6//XbGjx/PoEGD6NSpE2+88QZjxoyhW7du3H777VWv9corr3DZZZfRs2dPhg8fzoEDBwDIyMjgJz/5CT179iQrK4tt27axc+dOZs6cyS9+8QtycnJYsWIFf/zjH8nMzOSSSy5hwIABjffGScrRHoJIHTZv3kyvXr2OaX/uuecoLi5mw4YN7N27l9zc3KoP3A0bNrB161batGlDp06duOOOO1i9ejW//OUvmTFjBo8//jgAn332GUuWLGHRokVce+21vPnmm8yePZvc3FyKi4tJT0/npz/9Ka+99hpnnHEGjz76KD//+c/5t3/7NwDatWvHunXrePLJJ5k+fTqzZ8/mzjvvpHXr1vzgBz8AICsri5dffpn27duzb9++RnnPJDVpD0HkBP35z39m1KhRNGvWjPPPP58rr7ySNWvWAJCbm8sFF1xAy5Yt6dy5M0OHDgUiH847d+6sWse1116LmZGVlcX5559PVlYWp512Gj169GDnzp289dZbbNmyhf79+5OTk0NhYSHvv/9+1fLDhg0DoFevXtXWG61///7cfvvt/PrXv+bIkSMn582QU4L2EETq0KNHj6rfNIhWWz9gLVu2rBo+7bTTqsZPO+00Kioqjpkvep7o+Zo1a8aQIUP4wx/+UOvrNGvWrNp6o82cOZNVq1axePFicnJyKC4upm3btsfNLk2X9hBE6jB48GAOHTrEr3/966q2NWvWcO655zJv3jyOHDnCnj17WL58OXl5eXF97b59+/Lmm29SWloKRHpdrevqpjPPPJP9+/dXjb/zzjv06dOHhx9+mHbt2rFr1664ZpRThwqCSB3MjIULF/Lqq6/SuXNnevTowZQpU7jpppvIzs7mkksuYfDgwTz22GP8wz/8Q1xfOy0tjTlz5jBq1Ciys7Pp27cv27Ztq3WZa6+9loULF1adVJ44cSJZWVlkZmYyYMAALrnkkrhmlFOHur+WBlH316cmvcdNh7q/FhGROqkgiIgI0ICCYGbNzGy9mb0QxtuY2atmtiM8nxs174NmVmpm280sP6q9l5ltCtOeMDML7S3NbF5oX2VmGXHcRhERqYeG7CFMALZGjU8CXnf3LsDrYRwz6w4UAD2Aq4EnzaxZWOYpYBzQJTyuDu1jgc/c/SLgF8CjJ7Q1IiJywupVEMwsHfgOMDuq+XqgMAwXAjdEtc9190Pu/h5QCuSZ2QXAWe6+0iNnsp+usUzluhYAV1XuPYiISOOo7x7C48APgaNRbee7+26A8HxeaG8PRF/oXBba2ofhmu3VlnH3CqAc0J0zIiKNqM6CYGb/E/jE3dfWc52xvtl7Le21LVMzyzgzKzKzoj179tQzjsjXN3XqVHr06EF2djY5OTmsWrWKjIwM9u7dm+hoInFTn64r+gPXmdk1QCvgLDP7PfCxmV3g7rvD4aBPwvxlQIeo5dOBj0J7eoz26GXKzKw5cDbw15pB3H0WMAsi9yHUbxPlVLP12/G9Xr7btq21Tl+5ciUvvPAC69ato2XLluzdu5evvvrqa71mRUUFzZur5xhJLnXuIbj7g+6e7u4ZRE4WL3H3W4BFwOgw22jg+TC8CCgIVw51JHLyeHU4rLTfzPqG8wO31Vimcl03htfQB74khd27d9OuXbuqfoPatWvHN7/5TQBmzJhRrftpgNWrV9OvXz8uvfRS+vXrx/bt2wGYM2cOw4cP59prr2Xo0KF8/vnnjBkzhtzcXC699FKefz7y36GkpIS8vDxycnLIzs5mx44dCdhqaYq+zn0I04AhZrYDGBLGcfcSYD6wBXgJuMvdK7tYHE/kxHQp8A7wYmj/DdDWzEqBBwhXLIkkg6FDh7Jr1y66du3K97//fd54442qaZXdT48fP57p06cD8O1vf5vly5ezfv16Hn74YX70ox9Vzb9y5UoKCwtZsmQJU6dOZfDgwaxZs4alS5cyceJEPv/8c2bOnMmECRMoLi6mqKiI9PT0YzKJnAwN2md192XAsjD8KXDVceabCkyN0V4EZMZoPwgMb0gWkcbSunVr1q5dy4oVK1i6dCkjR45k2rRpQPXup5977jkAysvLGT16NDt27MDMOHz4cNW6hgwZQps2bYDID98sWrSoqpAcPHiQDz74gMsuu4ypU6dSVlbGsGHD6NKlS2NurjRhOogpUg/NmjVj4MCBDBw4kKysLAoLI1dJx+p++qGHHmLQoEEsXLiQnTt3MnDgwKr1nHHGGVXD7s6zzz7LxRdfXO21unXrRp8+fVi8eDH5+fnMnj2bwYMHn+QtFFHXFSJ12r59e7Xj+MXFxVx44YXHnb+8vJz27SNXVM+ZM+e48+Xn5zNjxoyq31VYv349AO+++y6dOnXi3nvv5brrrmPjxo1x2AqRuqkgiNThwIEDjB49mu7du5Odnc2WLVuYMmXKcef/4Q9/yIMPPkj//v1r/YWyhx56iMOHD5OdnU1mZiYPPfQQAPPmzSMzM5OcnBy2bdvGbbfdFu9NEolJ3V9Lg6j761OT3uPGU/P/EDTuZ5K6vxYRkTqpIIiICKCCICIigQqCiIgAKggiIhKoIIiICKCCIFIvsbq/FjnVqOsKSTn/eeeSuK7vrpm1dwtxMrq/FklG2kMQqcPxur9++OGHyc3NJTMzk3HjxuHubN26lby8vKpld+7cSXZ2NgBr167lyiuvpFevXuTn57N7924Annjiiaq7oAsKChp/A0UCFQSROhyv++u7776bNWvWsHnzZr788kteeOEFunXrxldffcW7774LRLqhGDFiBIcPH+aee+5hwYIFrF27ljFjxjB58mQApk2bxvr169m4cSMzZ85M2HaKqCCI1KGy++tZs2aRlpbGyJEjmTNnDkuXLqVPnz5kZWWxZMkSSkpKABgxYgTz588HIgVh5MiRbN++nc2bNzNkyBBycnL46U9/SllZ5CfGs7Ozufnmm/n973+vX1GThNJfn0g91Oz++le/+hUbN26kqKiIDh06MGXKFA4ePAjAyJEjGT58OMOGDcPM6NKlC5s2baJHjx6sXLnymHUvXryY5cuXs2jRIh555BFKSkpUGCQhtIcgUodY3V9X/oZBu3btOHDgAAsWLKia3rlzZ5o1a8YjjzzCyJEjAbj44ovZs2dPVUE4fPgwJSUlHD16lF27djFo0CAee+wx9u3bx4EDBxpx60T+Tl9DROpw4MAB7rnnHvbt20fz5s256KKLmDVrFueccw5ZWVlkZGSQm5tbbZmRI0cyceJE3nvvPQC+8Y1vsGDBAu69917Ky8upqKjgvvvuo2vXrtxyyy2Ul5fj7tx///2cc845CdhKEXV/LQ2k7q9PTXqPG4+6vxYRkaSngiAiIoAKgoiIBCoIkhJS9VxXKtB7K5VUECTptWrVik8//VQfXCeBu/Ppp5/SqlWrREeRJKDLTiXppaenU1ZWxp49exId5ZTUqlUr0tPTEx1DkoAKgiS9Fi1a0LFjx0THEDnl6ZCRiIgAKggiIhLokJGI1El3+zcN2kMQERFABUFERAIVBBERAepREMyslZmtNrMNZlZiZv8e2tuY2atmtiM8nxu1zINmVmpm280sP6q9l5ltCtOeMDML7S3NbF5oX2VmGSdhW0VEpBb1Oal8CBjs7gfMrAXwZzN7ERgGvO7u08xsEjAJ+N9m1h0oAHoA3wReM7Ou7n4EeAoYB7wF/BdwNfAiMBb4zN0vMrMC4FFgZFy3VCQJ6WStJJM69xA8ovInnFqEhwPXA4WhvRC4IQxfD8x190Pu/h5QCuSZ2QXAWe6+0iN9EDxdY5nKdS0ArqrcexARkcZRr3MIZtbMzIqBT4BX3X0VcL677wYIz+eF2dsDu6IWLwtt7cNwzfZqy7h7BVAOtI2RY5yZFZlZkboxEBGJr3oVBHc/4u45QDqRb/uZtcwe65u919Je2zI1c8xy997u3jstLa2O1CIi0hANusrI3fcBy4gc+/84HAYiPH8SZisDOkQtlg58FNrTY7RXW8bMmgNnA39tSDYREfl66nOVUZqZnROGTwf+EdgGLAJGh9lGA8+H4UVAQbhyqCPQBVgdDivtN7O+4fzAbTWWqVzXjcASV1/HIiKNqj5XGV0AFJpZMyIFZL67v2BmK4H5ZjYW+AAYDuDuJWY2H9gCVAB3hSuMAMYDc4DTiVxd9GJo/w3wOzMrJbJnUBCPjRMRkfqrsyC4+0bg0hjtnwJXHWeZqcDUGO1FwDHnH9z9IKGgiIhIYuhOZRERAdTbadKoeYMS6CYlEWlc2kMQERFABUFERAIVBBERAVQQREQkUEEQERFABUFERAIVBBERAVQQREQkUEEQERFABUFERAIVBBERAVQQREQkUEEQERFABUFERAIVBBERAfR7CHKKqvn7EvptCZG6aQ9BREQAFQQREQlUEEREBFBBEBGRQAVBREQAFQQREQlUEEREBFBBEBGRQAVBREQAFQQREQlUEEREBFBBEBGRQAVBREQAFQQREQnqLAhm1sHMlprZVjMrMbMJob2Nmb1qZjvC87lRyzxoZqVmtt3M8qPae5nZpjDtCTOz0N7SzOaF9lVmlnEStlVERGpRnz2ECuB/uXs3oC9wl5l1ByYBr7t7F+D1ME6YVgD0AK4GnjSzZmFdTwHjgC7hcXVoHwt85u4XAb8AHo3DtomISAPUWRDcfbe7rwvD+4GtQHvgeqAwzFYI3BCGrwfmuvshd38PKAXyzOwC4Cx3X+nuDjxdY5nKdS0ArqrcexARkcbRoHMI4VDOpcAq4Hx33w2RogGcF2ZrD+yKWqwstLUPwzXbqy3j7hVAOdA2xuuPM7MiMyvas2dPQ6KLiEgd6l0QzKw18Cxwn7v/rbZZY7R5Le21LVO9wX2Wu/d2995paWl1RRYRkQaoV0EwsxZEisEz7v5caP44HAYiPH8S2suADlGLpwMfhfb0GO3VljGz5sDZwF8bujEiInLi6nOVkQG/Aba6+8+jJi0CRofh0cDzUe0F4cqhjkROHq8Oh5X2m1nfsM7baixTua4bgSXhPIOIiDSS5vWYpz9wK7DJzIpD24+AacB8MxsLfAAMB3D3EjObD2whcoXSXe5+JCw3HpgDnA68GB4QKTi/M7NSInsGBV9vs0REpKHqLAju/mdiH+MHuOo4y0wFpsZoLwIyY7QfJBQUERFJjPrsIYiIpISMSYurje+c9p0EJUlN6rpCREQAFQQREQlUEEREBFBBEBGRQAVBREQAFQQREQlUEEREBFBBEBGRQAVBREQAFQQREQlUEEREBFBBEBGRQAVBREQAFQQREQlUEEREBFBBEBGRQAVBREQAFQQREQlUEEREBFBBEBGRQAVBREQAFQQREQlUEEREBFBBEBGRQAVBREQAFQQREQlUEEREBFBBEBGRQAVBREQAFQQREQlUEEREBKhHQTCz35rZJ2a2OaqtjZm9amY7wvO5UdMeNLNSM9tuZvlR7b3MbFOY9oSZWWhvaWbzQvsqM8uI8zaKiEg91GcPYQ5wdY22ScDr7t4FeD2MY2bdgQKgR1jmSTNrFpZ5ChgHdAmPynWOBT5z94uAXwCPnujGiIjIiauzILj7cuCvNZqvBwrDcCFwQ1T7XHc/5O7vAaVAnpldAJzl7ivd3YGnayxTua4FwFWVew8iItJ4TvQcwvnuvhsgPJ8X2tsDu6LmKwtt7cNwzfZqy7h7BVAOtI31omY2zsyKzKxoz549JxhdRERiifdJ5Vjf7L2W9tqWObbRfZa793b33mlpaScYUUREYjnRgvBxOAxEeP4ktJcBHaLmSwc+Cu3pMdqrLWNmzYGzOfYQlYiInGQnWhAWAaPD8Gjg+aj2gnDlUEciJ49Xh8NK+82sbzg/cFuNZSrXdSOwJJxnEBGRRtS8rhnM7A/AQKCdmZUBPwGmAfPNbCzwATAcwN1LzGw+sAWoAO5y9yNhVeOJXLF0OvBieAD8BvidmZUS2TMoiMuWiYhIg9RZENx91HEmXXWc+acCU2O0FwGZMdoPEgqKiIgkju5UFhERQAVBREQCFQQREQFUEEREJFBBEBERQAVBREQCFQQREQFUEEREJFBBEBERQAVBREQCFQQREQFUEEREJFBBEBERQAVBREQCFQQREQFUEEREJFBBEBERQAVBREQCFQQREQFUEEREJFBBEBERQAVBREQCFQQREQFUEEREJFBBEBERQAVBREQCFQQREQGgeaIDiIg0eVPOrjFenpAYKgjJLEn+SESkaWiaBUEftCJfj/4PnZKaZkGQ+Kn5wQD6cJDkocLVICoI0jSkygdDquSUU1LSXGVkZleb2XYzKzWzSYnOIyLS1CRFQTCzZsB/Av8EdAdGmVn3xKYSEWlakqIgAHlAqbu/6+5fAXOB6xOcSUSkSTF3T3QGzOxG4Gp3vyOM3wr0cfe7a8w3DhgXRi8Gtsc5Sjtgb5zXeTIoZ3ylQs5UyAjKGW8nI+eF7p4Wa0KynFS2GG3HVCp3nwXMOmkhzIrcvffJWn+8KGd8pULOVMgIyhlvjZ0zWQ4ZlQEdosbTgY8SlEVEpElKloKwBuhiZh3N7BtAAbAowZlERJqUpDhk5O4VZnY38DLQDPitu5ckIMpJOxwVZ8oZX6mQMxUygnLGW6PmTIqTyiIiknjJcshIREQSTAVBREQAFQQREQmabEEws7PMrHOM9uxE5KkvM/s/ic5Qk5l9y8xahWEzs38xsxlmNt7MkuLChUpmNsDMLg7Dl5vZD8zsO4nOFc3MWpvZjWZ2v5ndE/r5Sqr/q2bW3My+Z2YvmdlGM9tgZi+a2Z1m1iLR+erDzJLmxLKZNQvv5yNm1r/GtB83Wo6meFLZzEYAjwOfAC2A2919TZi2zt17JjBeFTN7omYTcCvwNIC739vooWIws81Anrt/YWaPAp2BPwGDAdx9TALjVTGzx4l0k9KcyBVtVwEvAlcC6919YuLSRYS/zYnABmAQ8BciX9yygJvdfVMC41Uxsz8A+4BCIvcRQeT+odFAG3cfmaBo1ZhZm+NNAja4e3pj5jkeM5sN/A9gNZH/42+4+wNhWqN9JjXVglAM/JO77zazPCIfsD9y9+fMbL27X5rYhBFmVgYsA17h73dzTwd+AODuhYlJVp2ZbXH37mF4LZDr7kfD+AZ3vyShAQMzKwEygdOBD4H2oYi1IFIQMhMaEDCzjUDfkKsd8Iy754c915nu3i/BEQEws+3ufvFxpr3t7l0bO1MsZnYEeJ/qvSF4GG/v7t9ISLAazGyju2eH4ebAk0S6rRgFvNVYn0lJtRvaiJq5+24Ad19N5JvYZDO7lxhdZiRQNyL9mFwNvBYKwH53L0yWYhDsMrPBYXgn4a5zM2ubsESxuUe+AR2tHA/PR0me/wsGfBmGPwfOA3D3jcBZiQoVw2dmNjz6UJaZnWZmI4HPEpirpneBge7eMerRyd07Ah8nOlyUqsLk7hXuPg4oBpYArRsrRFId321E+82ss7u/AxD2FAYSOczRI4G5qnH3/cB9ZtYL+L2ZLSZ5Prii3QE8bWZTgHKg2MzWA+cCDyQyWA2LzWwF0AqYDcw3s7eIHDJantBkf/dfwEtm9gaR7uD/CFWHPmL1+ZUoBcCjwJNmVlkAzgGWhmnJ4nEif4cfxJj2WONGqVWRmV3t7i9VNrj7w2b2EfBUY4VoqoeMLgE+d/fSGu0tgBHu/kxikh2fmRnwfeAyd78l0XliMbNuQFciXzTKgDWVh46ShZldRmRP4a1wUcF3iXxYLEiWrGZ2DZHfBdng7q+GttOAFu5+KKHhYgh7gubuqdB7qNSiSRYEETl5zGxIZSFLZsoZ47VUEEQknszsA3f/VqJz1EU5j9VUzyGIyNdgZsfrjdiApLmYQDkbpkkXBDOb4O6/rKst0ZQzvlIhZwpkvAK4BThQo92I3OuRLJSzIdy9yT6AdTHa1ic6l3IqZ7JnJHJD36DjTFue6HzKeWKPJnkOwcxGATcBlwMroiadBVS4+z8mJFgNyhlfqZAzFTLKqaupHjL6C7CbyJ2A/y+qfT+wMSGJYlPO+EqFnKmQUU5RTXIPoZKZnQF86e5Hzawr8G3gRXc/nOBo1ShnfKVCzlTIKKeepl4Q1hI5mXMu8BZQBHzh7jcnNFgNyhlfqZAzFTLKqScZu0FoTObuXwDDgBnu/l0id4gmG+WMr1TImQoZMbMJ9WlLNOWsnyZfEEJXBjcDi0NbMp5XUc74SoWcqZARIt1d13R7Y4eoB+Wsh2T8A2tM9wEPAgvdvcTMOhHpnCvZ3IdyxtN9JH/O+0jijFFXQ3WscVPVWcCniUl1LOVsYI6mfA6hkpmdSaTDs5o3hSQV5YyvVMiZrBnN7EKgI/B/gUlRk/YDG929IiHBalDOBuZoygXBzLKI/DhOZdfCe4Db3L0kocFqUM74SoWcqZARUudqKOWsp8a+Iy+ZHkSu+R4UNT4Q+EuicymncqZCxpBrLZGffmwP7AIWEvmVt4RnU86GP5r6SeUz3L3quKy7LwPOSFyc41LO+EqFnKmQEVLkaiiUs16aekF418weMrOM8Pgx8F6iQ8WgnPGVCjlTISOkztVQylkPTb0gjAHSgOfCox3wLwlNFJtyxlcq5EyFjJDkV0NFuQ/lrFOTPKlsZq2AO4GLgE3Abz3JTi6BcsZbKuRMhYyxJOvVUDUpZ+2a6h5CIdCbyH+4fwJ+ltg4x6Wc8ZUKOVMhYxUzyzKz9cBmYIuZrTWzHonOVZNy1lOiz6on6Ez+pqjh5sToez4ZHsrZ9HKmQsYaeVPlaijlrMejqe4hVO2Ce5LcmHIcyhlfqZAzFTJGS5WroZSzHprqOYQjwOeVo8DpwBdh2N39rERli6ac8ZUKOVMhYzQzWwisA34Xmm4Berv7DQkLFYNy1vP1m2JBEJH4MLNzgX8n8gtvAMuBf3f3zxKX6ljKWc/XV0EQkYZKlauhlLOBOVQQRKShzGwekfMdK4hcDbXT3e9LaKgYlLOBOVQQRKShzGyTu2eF4ebAanfvmeBYx1DOhmmqVxmJyNeTKldDKWcDaA9BRBosVa6GUs4G5lBBEBER0CEjEREJVBBERARQQRARkUAFQUREABUEEREJVBBERASA/w+4vHNuLuLDfgAAAABJRU5ErkJggg==\n", 293 | "text/plain": [ 294 | "
" 295 | ] 296 | }, 297 | "metadata": { 298 | "needs_background": "light" 299 | }, 300 | "output_type": "display_data" 301 | }, 302 | { 303 | "data": { 304 | "image/png": "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\n", 305 | "text/plain": [ 306 | "
" 307 | ] 308 | }, 309 | "metadata": { 310 | "needs_background": "light" 311 | }, 312 | "output_type": "display_data" 313 | } 314 | ], 315 | "source": [ 316 | "df1 = df.groupby([\"Modified\"])\n", 317 | "df1.plot.bar()\n", 318 | "plt.title('Modified Posts')\n", 319 | "plt.xlabel('Post Number')\n", 320 | "plt.ylabel('Total Engagement (Million)')\n", 321 | "plt.show()" 322 | ] 323 | }, 324 | { 325 | "cell_type": "code", 326 | "execution_count": null, 327 | "id": "ad9aed6b", 328 | "metadata": {}, 329 | "outputs": [], 330 | "source": [] 331 | } 332 | ], 333 | "metadata": { 334 | "celltoolbar": "Raw Cell Format", 335 | "kernelspec": { 336 | "display_name": "Python 3 (ipykernel)", 337 | "language": "python", 338 | "name": "python3" 339 | }, 340 | "language_info": { 341 | "codemirror_mode": { 342 | "name": "ipython", 343 | "version": 3 344 | }, 345 | "file_extension": ".py", 346 | "mimetype": "text/x-python", 347 | "name": "python", 348 | "nbconvert_exporter": "python", 349 | "pygments_lexer": "ipython3", 350 | "version": "3.9.7" 351 | } 352 | }, 353 | "nbformat": 4, 354 | "nbformat_minor": 5 355 | } 356 | --------------------------------------------------------------------------------