Skip to content

Instantly share code, notes, and snippets.

@R3M4G

R3M4G/Ass7_OCR.ipynb

Created May 20, 2023 07:53
Show Gist options
  • Save R3M4G/e2dd0d07ba02930f4f131ecf6b62d7a5 to your computer and use it in GitHub Desktop.
Save R3M4G/e2dd0d07ba02930f4f131ecf6b62d7a5 to your computer and use it in GitHub Desktop.
Download ZIP
dl_codes
Display the source blob
Display the rendered blob
Raw
Ass7_OCR.ipynb
Loading
Sorry, something went wrong. Reload?
Sorry, we cannot display this file.
Sorry, this file is invalid so it cannot be displayed.
Display the source blob
Display the rendered blob
Raw
assignment6Dl.ipynb
Loading
Sorry, something went wrong. Reload?
Sorry, we cannot display this file.
Sorry, this file is invalid so it cannot be displayed.
Display the source blob
Display the rendered blob
Raw
assignment6Dl_updated.ipynb
Loading
Sorry, something went wrong. Reload?
Sorry, we cannot display this file.
Sorry, this file is invalid so it cannot be displayed.
Display the source blob
Display the rendered blob
Raw
Assignment_8.ipynb
{
"nbformat": 4,
"nbformat_minor": 0,
"metadata": {
"colab": {
"provenance": []
},
"kernelspec": {
"name": "python3",
"display_name": "Python 3"
},
"language_info": {
"name": "python"
}
},
"cells": [
{
"cell_type": "code",
"execution_count": 3,
"metadata": {
"id": "gkLawkNsyolP"
},
"outputs": [],
"source": [
"import tensorflow as tf\n",
"import matplotlib.pyplot as plt\n",
"from tensorflow import keras\n",
"import numpy as np"
]
},
{
"cell_type": "code",
"source": [
"(x_train, y_train), (x_test, y_test) = keras.datasets.fashion_mnist.load_data()"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "FGvwb9MuzPnR",
"outputId": "87b7ffaa-939e-4b9d-8ded-cc2277601405"
},
"execution_count": 4,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/train-labels-idx1-ubyte.gz\n",
"29515/29515 [==============================] - 0s 0us/step\n",
"Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/train-images-idx3-ubyte.gz\n",
"26421880/26421880 [==============================] - 0s 0us/step\n",
"Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/t10k-labels-idx1-ubyte.gz\n",
"5148/5148 [==============================] - 0s 0us/step\n",
"Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/t10k-images-idx3-ubyte.gz\n",
"4422102/4422102 [==============================] - 0s 0us/step\n"
]
}
]
},
{
"cell_type": "code",
"source": [
"plt.imshow(x_train[1])"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 448
},
"id": "bu6Tslx71Nl2",
"outputId": "221321b0-6a48-432a-94e3-76e3b451a94f"
},
"execution_count": 5,
"outputs": [
{
"output_type": "execute_result",
"data": {
"text/plain": [
"<matplotlib.image.AxesImage at 0x7fda689c0fd0>"
]
},
"metadata": {},
"execution_count": 5
},
{
"output_type": "display_data",
"data": {
"text/plain": [
"<Figure size 640x480 with 1 Axes>"
],
"image/png": "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\n"
},
"metadata": {}
}
]
},
{
"cell_type": "code",
"source": [
"plt.imshow(x_train[0])"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 448
},
"id": "gQcGmq1A1ar7",
"outputId": "f1c12f7e-0435-4e9e-f7db-f170f5d9136a"
},
"execution_count": 6,
"outputs": [
{
"output_type": "execute_result",
"data": {
"text/plain": [
"<matplotlib.image.AxesImage at 0x7fda6526ba00>"
]
},
"metadata": {},
"execution_count": 6
},
{
"output_type": "display_data",
"data": {
"text/plain": [
"<Figure size 640x480 with 1 Axes>"
],
"image/png": "iVBORw0KGgoAAAANSUhEUgAAAaAAAAGdCAYAAABU0qcqAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAilUlEQVR4nO3df3DU9b3v8dfm1xIg2RBCfknAgAoqEFsKMdVSlFwgnesF5fRq650DvY4eaXCK9IdDj4r2dE5anGO9tVTvndNCnSnaOlfkyLHcKjShtGALwqXWNgdoFCwk/KjZDQlJNtnP/YNrNArC+8smnyQ8HzM7Q3a/L74fvnyTV77Z3XdCzjknAAD6WYrvBQAALk0UEADACwoIAOAFBQQA8IICAgB4QQEBALyggAAAXlBAAAAv0nwv4MMSiYSOHDmirKwshUIh38sBABg559TS0qLi4mKlpJz7OmfAFdCRI0dUUlLiexkAgIt0+PBhjR079pyPD7gCysrKkiTdqM8pTemeVwMAsOpSXNv1cs/X83PpswJas2aNHnvsMTU2NqqsrExPPvmkZs6ced7cez92S1O60kIUEAAMOv9/wuj5nkbpkxch/OxnP9OKFSu0atUqvf766yorK9O8efN07NixvtgdAGAQ6pMCevzxx3X33XfrS1/6kq655ho9/fTTGj58uH784x/3xe4AAINQ0guos7NTu3fvVmVl5fs7SUlRZWWlduzY8ZHtOzo6FIvFet0AAENf0gvoxIkT6u7uVkFBQa/7CwoK1NjY+JHta2pqFIlEem68Ag4ALg3e34i6cuVKRaPRntvhw4d9LwkA0A+S/iq4vLw8paamqqmpqdf9TU1NKiws/Mj24XBY4XA42csAAAxwSb8CysjI0PTp07Vly5ae+xKJhLZs2aKKiopk7w4AMEj1yfuAVqxYocWLF+tTn/qUZs6cqSeeeEKtra360pe+1Be7AwAMQn1SQLfffruOHz+uhx9+WI2Njbruuuu0efPmj7wwAQBw6Qo555zvRXxQLBZTJBLRbC1gEgIADEJdLq5abVQ0GlV2dvY5t/P+KjgAwKWJAgIAeEEBAQC8oIAAAF5QQAAALyggAIAXFBAAwAsKCADgBQUEAPCCAgIAeEEBAQC8oIAAAF5QQAAALyggAIAXFBAAwAsKCADgBQUEAPCCAgIAeEEBAQC8oIAAAF5QQAAALyggAIAXFBAAwAsKCADgBQUEAPCCAgIAeJHmewHAgBIK2TPOJX8dZ5E6OteceXfeVYH2lb1+Z6CcWYDjHUpLN2dcvNOcGfCCnKtB9dE5zhUQAMALCggA4AUFBADwggICAHhBAQEAvKCAAABeUEAAAC8oIACAFxQQAMALCggA4AUFBADwggICAHjBMFLgA0KpqeaM6+oyZ1Kuu8ac+dM/jLTv57Q5IklKb51pzqSdTtj388td5ky/DhYNMiw1wDmkkP1aoD+PQyjNVhUh56QL+LTgCggA4AUFBADwggICAHhBAQEAvKCAAABeUEAAAC8oIACAFxQQAMALCggA4AUFBADwggICAHhBAQEAvGAYKfAB1qGLUrBhpIfn5Zgzd1b82pz5zfEJ5owkvR0uNGdcpn0/aZUV5sxVP/yrOdP11iFzRpLknD0S4HwIInXUqGDB7m57JBYzbe/chR0DroAAAF5QQAAAL5JeQI888ohCoVCv2+TJk5O9GwDAINcnzwFde+21evXVV9/fSYCfqwMAhrY+aYa0tDQVFtqfxAQAXDr65Dmg/fv3q7i4WBMmTNCdd96pQ4fO/QqUjo4OxWKxXjcAwNCX9AIqLy/XunXrtHnzZj311FNqaGjQZz7zGbW0tJx1+5qaGkUikZ5bSUlJspcEABiAkl5AVVVV+vznP69p06Zp3rx5evnll9Xc3Kyf//znZ91+5cqVikajPbfDhw8ne0kAgAGoz18dkJOTo6uuukoHDhw46+PhcFjhcLivlwEAGGD6/H1Ap06d0sGDB1VUVNTXuwIADCJJL6Cvfe1rqqur01tvvaXf/va3uvXWW5WamqovfOELyd4VAGAQS/qP4N555x194Qtf0MmTJzVmzBjdeOON2rlzp8aMGZPsXQEABrGkF9Bzzz2X7L8S6DeJ9vZ+2U/nJ06ZM38X2WXODEuJmzOSVJeSMGf+utX+Ctbuafbj8PbjWeZMYs+nzRlJGv2GfXBn9p6j5syJWZeZM8en2welSlLBTntm1KsHTdu7RKd04vzbMQsOAOAFBQQA8IICAgB4QQEBALyggAAAXlBAAAAvKCAAgBcUEADACwoIAOAFBQQA8IICAgB4QQEBALzo819IB3gRCgXLOfuAx1P/9Xpz5u+vqTVnDsbtE+XHZvzNnJGkzxfvtof+mz3zg/rPmjOtf4mYMykjgg3ubLze/j36XxfY/59cvMucGfV6sC/fKYubzJlY5wTT9l3xdmnjBazFvBIAAJKAAgIAeEEBAQC8oIAAAF5QQAAALyggAIAXFBAAwAsKCADgBQUEAPCCAgIAeEEBAQC8oIAAAF5QQAAAL5iGjf4VdEr1AHb9A78zZ24a+WYfrOSjLlOwKdCtLsOcae4eYc6suubfzZnjV2WZM3EX7Evdv+7/tDlzKsC07tQu++fF9f99jzkjSYtyf2/OrP7fU03bd7n4BW3HFRAAwAsKCADgBQUEAPCCAgIAeEEBAQC8oIAAAF5QQAAALyggAIAXFBAAwAsKCADgBQUEAPCCAgIAeMEwUvQvF2w45kC2/1S+OXMye6Q509iVY86MTj1lzkhSVsppc+by9BPmzPFu+2DR1PSEOdPpUs0ZSXr02pfMmfar082Z9FC3OfPpYUfMGUn6/Jt/b86M0F8C7et8uAICAHhBAQEAvKCAAABeUEAAAC8oIACAFxQQAMALCggA4AUFBADwggICAHhBAQEAvKCAAABeUEAAAC8YRgpcpDFh+8DPYaG4OZMR6jJnjsRHmTOStP/0JHPmP2L2oazzC/5ozsQDDBZNVbAhuEGGhBanv2vOtDv7AFP7GXTGDQX2waJ7A+7rfLgCAgB4QQEBALwwF9C2bdt0yy23qLi4WKFQSC+++GKvx51zevjhh1VUVKTMzExVVlZq//79yVovAGCIMBdQa2urysrKtGbNmrM+vnr1an3/+9/X008/rddee00jRozQvHnz1N7eftGLBQAMHeYXIVRVVamqquqsjznn9MQTT+jBBx/UggULJEnPPPOMCgoK9OKLL+qOO+64uNUCAIaMpD4H1NDQoMbGRlVWVvbcF4lEVF5erh07dpw109HRoVgs1usGABj6klpAjY2NkqSCgoJe9xcUFPQ89mE1NTWKRCI9t5KSkmQuCQAwQHl/FdzKlSsVjUZ7bocPH/a9JABAP0hqARUWFkqSmpqaet3f1NTU89iHhcNhZWdn97oBAIa+pBZQaWmpCgsLtWXLlp77YrGYXnvtNVVUVCRzVwCAQc78KrhTp07pwIEDPR83NDRo7969ys3N1bhx47R8+XJ9+9vf1pVXXqnS0lI99NBDKi4u1sKFC5O5bgDAIGcuoF27dummm27q+XjFihWSpMWLF2vdunX6xje+odbWVt1zzz1qbm7WjTfeqM2bN2vYsGHJWzUAYNALOeeCTenrI7FYTJFIRLO1QGkh+4A+DHChkD2Sah8+6brsgzslKXWUfXjnHTv+YN9PyP5pd7wry5zJSW0zZySprtk+jPSPJ8/+PO/H+dakfzNnXm+73JwpzrAPCJWCHb+3OvPMmSvDZ3+V8Mf5xbtl5owklQz7mznzy+WzTNt3dbVre+2jikajH/u8vvdXwQEALk0UEADACwoIAOAFBQQA8IICAgB4QQEBALyggAAAXlBAAAAvKCAAgBcUEADACwoIAOAFBQQA8IICAgB4Yf51DMBFCTB8PZRmP02DTsM+fNfV5szNw18yZ37bfpk5MyatxZyJO/skcUkqCkfNmayCdnOmuXu4OZObdsqcaenONGckaXhKhzkT5P/pkxknzJn7X/2kOSNJWVNOmjPZ6bZrlcQFXttwBQQA8IICAgB4QQEBALyggAAAXlBAAAAvKCAAgBcUEADACwoIAOAFBQQA8IICAgB4QQEBALyggAAAXjCMFP0qlJ5hziTa7UMug8r7Q6c5c6I73ZzJSWkzZzJC3eZMZ8BhpJ/ObTBnjgcY+Pn66VJzJiv1tDkzJsU+IFSSStLtgzv/0F5izrzceoU5c9d/ftWckaRn/9d/MmcyNv/WtH2Ki1/YduaVAACQBBQQAMALCggA4AUFBADwggICAHhBAQEAvKCAAABeUEAAAC8oIACAFxQQAMALCggA4AUFBADw4tIeRhoKBYul2YdPhlIDdH2KPZNo77DvJ2EfchmUi9uHffan//E/f2DOHO7KMWca4/ZMTqp9gGm3gp3jO09HzJlhKRc2gPKDxqTFzJlYwj70NKiWxDBzJh5gAGyQY/fA6P3mjCS9EK0MlOsLXAEBALyggAAAXlBAAAAvKCAAgBcUEADACwoIAOAFBQQA8IICAgB4QQEBALyggAAAXlBAAAAvKCAAgBdDZhhpKM3+T3FdXYH2FWSgprPPGhySTi+Yac4cXmgflnrnJ35nzkhSY1eWObOn7XJzJpJ62pwZkWIfNNvu7INzJelI5yhzJshAzdy0U+ZMfoABpt0u2Pfaf43bj0MQQQbNvtNlP3aS1PJfWsyZnGcC7eq8uAICAHhBAQEAvDAX0LZt23TLLbeouLhYoVBIL774Yq/HlyxZolAo1Os2f/78ZK0XADBEmAuotbVVZWVlWrNmzTm3mT9/vo4ePdpze/bZZy9qkQCAocf8zH1VVZWqqqo+dptwOKzCwsLAiwIADH198hxQbW2t8vPzNWnSJC1dulQnT54857YdHR2KxWK9bgCAoS/pBTR//nw988wz2rJli7773e+qrq5OVVVV6u4++0tpa2pqFIlEem4lJSXJXhIAYABK+vuA7rjjjp4/T506VdOmTdPEiRNVW1urOXPmfGT7lStXasWKFT0fx2IxSggALgF9/jLsCRMmKC8vTwcOHDjr4+FwWNnZ2b1uAIChr88L6J133tHJkydVVFTU17sCAAwi5h/BnTp1qtfVTENDg/bu3avc3Fzl5ubq0Ucf1aJFi1RYWKiDBw/qG9/4hq644grNmzcvqQsHAAxu5gLatWuXbrrppp6P33v+ZvHixXrqqae0b98+/eQnP1Fzc7OKi4s1d+5c/dM//ZPC4XDyVg0AGPRCzjnnexEfFIvFFIlENFsLlBYKNkhxIEorsr8vKl5aYM787erh5kxbYcickaTrPvcnc2ZJwXZz5ni3/XnB9FCwQbMt3ZnmTGF6szmzNXqNOTMyzT6MNMjQU0n6ZOZb5kxzwn7uFae9a848cODvzJmC4fYBnJL0r+NfNmfiLmHO1Mft36BnpdiHIkvSr9uuMGc2XDPGtH2Xi6tWGxWNRj/2eX1mwQEAvKCAAABeUEAAAC8oIACAFxQQAMALCggA4AUFBADwggICAHhBAQEAvKCAAABeUEAAAC8oIACAFxQQAMCLpP9Kbl86qmaYM/n/+JdA+7ou+x1z5ppM+xTo9oR9GviwlLg58+bpy8wZSWpLZJgz+zvtU8GjXfYpy6kh+0RiSTrWmWXO/EtDpTmzZebT5syDR+abMymZwYbdn+weac4sGhkLsCf7Of4P47aZMxMyjpkzkrSp1f6LNI/ER5kzBelRc+by9OPmjCTdlvUf5swG2aZhXyiugAAAXlBAAAAvKCAAgBcUEADACwoIAOAFBQQA8IICAgB4QQEBALyggAAAXlBAAAAvKCAAgBcUEADAiwE7jDSUlqZQ6MKXV/7PvzfvY07WH80ZSWpzYXMmyGDRIEMNg4iktQXKdcTtp8+xeHagfVldFW4MlLs1e685s+0H5ebMje33mTMHb15rzmw5nWrOSNLxLvv/0x0NN5szrx8qMWeuv7zBnJma9VdzRgo2CDcrtd2cSQ91mTOtCfvXIUna2W4fNNtXuAICAHhBAQEAvKCAAABeUEAAAC8oIACAFxQQAMALCggA4AUFBADwggICAHhBAQEAvKCAAABeUEAAAC8G7DDSo0unKzU87IK3fyTypHkf6/92vTkjSSXD/mbOjM84Yc6UZb5tzgSRlWIfnihJk7LtAxQ3tY41Z2qbJ5szRenN5owk/bptojnz3COPmTNL7v+qOVPx8r3mTOzyYN9jdo1w5kx22Ulz5sFP/Ls5kxHqNmeau+1DRSUpN9xqzuSkBhvuaxVkKLIkZaWcNmdSJ11h2t51d0j7z78dV0AAAC8oIACAFxQQAMALCggA4AUFBADwggICAHhBAQEAvKCAAABeUEAAAC8oIACAFxQQAMALCggA4MWAHUY6/FhCqRmJC95+U+w68z4mZB43ZyTpRDzLnPk/p6aaM2Mz3zVnIqn2QYNXhBvNGUna255jzmw+fq05U5wZM2ea4hFzRpJOxkeYM20J+1DIH33vcXPmX5oqzZlbc183ZySpLMM+WLQ5Yf9+9s3OQnOmJXHhQ4rf0+7SzRlJigYYYpoV4HMw7uxfilPdhX99/KCcFPuw1NjU0abtu+LtDCMFAAxcFBAAwAtTAdXU1GjGjBnKyspSfn6+Fi5cqPr6+l7btLe3q7q6WqNHj9bIkSO1aNEiNTU1JXXRAIDBz1RAdXV1qq6u1s6dO/XKK68oHo9r7ty5am19/5c23X///XrppZf0/PPPq66uTkeOHNFtt92W9IUDAAY30zNfmzdv7vXxunXrlJ+fr927d2vWrFmKRqP60Y9+pPXr1+vmm2+WJK1du1ZXX321du7cqeuvD/YbSAEAQ89FPQcUjUYlSbm5uZKk3bt3Kx6Pq7Ly/VfrTJ48WePGjdOOHTvO+nd0dHQoFov1ugEAhr7ABZRIJLR8+XLdcMMNmjJliiSpsbFRGRkZysnJ6bVtQUGBGhvP/lLfmpoaRSKRnltJSUnQJQEABpHABVRdXa033nhDzz333EUtYOXKlYpGoz23w4cPX9TfBwAYHAK9EXXZsmXatGmTtm3bprFjx/bcX1hYqM7OTjU3N/e6CmpqalJh4dnfcBYOhxUO29/IBwAY3ExXQM45LVu2TBs2bNDWrVtVWlra6/Hp06crPT1dW7Zs6bmvvr5ehw4dUkVFRXJWDAAYEkxXQNXV1Vq/fr02btyorKysnud1IpGIMjMzFYlEdNddd2nFihXKzc1Vdna27rvvPlVUVPAKOABAL6YCeuqppyRJs2fP7nX/2rVrtWTJEknS9773PaWkpGjRokXq6OjQvHnz9MMf/jApiwUADB0h55zzvYgPisViikQimnXjQ0pLu/ChgzOe2G3e1xuxYnNGkgqGtZgz00a+Y87Ut9kHNR45nW3ODE+LmzOSlJlqz3U5++te8sP24z0ubB+mKUlZKfZBkhmhbnOmO8Drf67NOGLOHOoaZc5IUmNXjjnzZpv982lUmn0w5h8CfN62dWWYM5LU0W1/mry9y56JhNvNmRm5b5szkpQi+5f89f/2WdP2ifZ2/eXb/6hoNKrs7HN/TWIWHADACwoIAOAFBQQA8IICAgB4QQEBALyggAAAXlBAAAAvKCAAgBcUEADACwoIAOAFBQQA8IICAgB4QQEBALwI9BtR+0PK9n1KCaVf8PbP//IG8z4eWvC8OSNJdc2TzZlNjVPNmVin/TfFjhneas5kp9unTUtSbrp9X5EA04+HhbrMmXe7RpgzktSRcuHn3Hu6FTJnGjsi5sxvEleaM/FEqjkjSR0BckGmo/+tM8+cKc6MmjMtXRc+Wf+D3mrJNWdOREeaM+3D7V+Kt3dPNGckaX7hH82ZzGO2c7y748K25woIAOAFBQQA8IICAgB4QQEBALyggAAAXlBAAAAvKCAAgBcUEADACwoIAOAFBQQA8IICAgB4QQEBALwIOeec70V8UCwWUyQS0WwtUJphGGkQ0TuvD5Sb8OV6c2ZmToM583psnDlzKMDwxHgi2Pch6SkJc2Z4eqc5MyzAkMuM1G5zRpJSZP90SAQYRjoi1X4cRqR1mDPZae3mjCRlpdpzKSH7+RBEaoD/o99FL0/+Qs4hK8D/U5ezfw5WRA6aM5L044ZPmzORzx0wbd/l4qrVRkWjUWVnZ59zO66AAABeUEAAAC8oIACAFxQQAMALCggA4AUFBADwggICAHhBAQEAvKCAAABeUEAAAC8oIACAFxQQAMCLgTuMNOU22zDSRLDhk/2ldVG5OVP+zd/bM1n2AYWTM5rMGUlKl3345LAAAytHpNiHfbYHPK2DfEe2/XSJOdMdYE9b373anIkHGHIpSU1t5x4geS7pAQfAWiWc/Xw43RVssHH09DBzJjXFfu611+aZM6PftA/plaTwy/avK1YMIwUADGgUEADACwoIAOAFBQQA8IICAgB4QQEBALyggAAAXlBAAAAvKCAAgBcUEADACwoIAOAFBQQA8GLgDiPVAtswUgQWmjE1UO50YaY5Ez7ZYc60jLfvJ/tgqzkjSSkdXeZM4v/+KdC+gKGKYaQAgAGNAgIAeGEqoJqaGs2YMUNZWVnKz8/XwoULVV9f32ub2bNnKxQK9brde++9SV00AGDwMxVQXV2dqqurtXPnTr3yyiuKx+OaO3euWlt7/7z97rvv1tGjR3tuq1evTuqiAQCDX5pl482bN/f6eN26dcrPz9fu3bs1a9asnvuHDx+uwsLC5KwQADAkXdRzQNFoVJKUm5vb6/6f/vSnysvL05QpU7Ry5Uq1tbWd8+/o6OhQLBbrdQMADH2mK6APSiQSWr58uW644QZNmTKl5/4vfvGLGj9+vIqLi7Vv3z498MADqq+v1wsvvHDWv6empkaPPvpo0GUAAAapwO8DWrp0qX7xi19o+/btGjt27Dm327p1q+bMmaMDBw5o4sSJH3m8o6NDHR3vvzckFouppKSE9wH1I94H9D7eBwRcvAt9H1CgK6Bly5Zp06ZN2rZt28eWjySVl5dL0jkLKBwOKxwOB1kGAGAQMxWQc0733XefNmzYoNraWpWWlp43s3fvXklSUVFRoAUCAIYmUwFVV1dr/fr12rhxo7KystTY2ChJikQiyszM1MGDB7V+/Xp97nOf0+jRo7Vv3z7df//9mjVrlqZNm9Yn/wAAwOBkKqCnnnpK0pk3m37Q2rVrtWTJEmVkZOjVV1/VE088odbWVpWUlGjRokV68MEHk7ZgAMDQYP4R3McpKSlRXV3dRS0IAHBpCPwybAwd7vd/CJQbluR1nEv2b/tpR5IS/bcr4JLHMFIAgBcUEADACwoIAOAFBQQA8IICAgB4QQEBALyggAAAXlBAAAAvKCAAgBcUEADACwoIAOAFBQQA8IICAgB4QQEBALyggAAAXlBAAAAvKCAAgBcUEADACwoIAOAFBQQA8IICAgB4QQEBALyggAAAXlBAAAAv0nwv4MOcc5KkLsUl53kxAACzLsUlvf/1/FwGXAG1tLRIkrbrZc8rAQBcjJaWFkUikXM+HnLnq6h+lkgkdOTIEWVlZSkUCvV6LBaLqaSkRIcPH1Z2dranFfrHcTiD43AGx+EMjsMZA+E4OOfU0tKi4uJipaSc+5meAXcFlJKSorFjx37sNtnZ2Zf0CfYejsMZHIczOA5ncBzO8H0cPu7K5z28CAEA4AUFBADwYlAVUDgc1qpVqxQOh30vxSuOwxkchzM4DmdwHM4YTMdhwL0IAQBwaRhUV0AAgKGDAgIAeEEBAQC8oIAAAF4MmgJas2aNLr/8cg0bNkzl5eX63e9+53tJ/e6RRx5RKBTqdZs8ebLvZfW5bdu26ZZbblFxcbFCoZBefPHFXo875/Twww+rqKhImZmZqqys1P79+/0stg+d7zgsWbLkI+fH/Pnz/Sy2j9TU1GjGjBnKyspSfn6+Fi5cqPr6+l7btLe3q7q6WqNHj9bIkSO1aNEiNTU1eVpx37iQ4zB79uyPnA/33nuvpxWf3aAooJ/97GdasWKFVq1apddff11lZWWaN2+ejh075ntp/e7aa6/V0aNHe27bt2/3vaQ+19raqrKyMq1Zs+asj69evVrf//739fTTT+u1117TiBEjNG/ePLW3t/fzSvvW+Y6DJM2fP7/X+fHss8/24wr7Xl1dnaqrq7Vz50698sorisfjmjt3rlpbW3u2uf/++/XSSy/p+eefV11dnY4cOaLbbrvN46qT70KOgyTdfffdvc6H1atXe1rxObhBYObMma66urrn4+7ubldcXOxqamo8rqr/rVq1ypWVlflehleS3IYNG3o+TiQSrrCw0D322GM99zU3N7twOOyeffZZDyvsHx8+Ds45t3jxYrdgwQIv6/Hl2LFjTpKrq6tzzp35v09PT3fPP/98zzZ/+tOfnCS3Y8cOX8vscx8+Ds4599nPftZ95Stf8beoCzDgr4A6Ozu1e/duVVZW9tyXkpKiyspK7dixw+PK/Ni/f7+Ki4s1YcIE3XnnnTp06JDvJXnV0NCgxsbGXudHJBJReXn5JXl+1NbWKj8/X5MmTdLSpUt18uRJ30vqU9FoVJKUm5srSdq9e7fi8Xiv82Hy5MkaN27ckD4fPnwc3vPTn/5UeXl5mjJlilauXKm2tjYfyzunATeM9MNOnDih7u5uFRQU9Lq/oKBAf/7znz2tyo/y8nKtW7dOkyZN0tGjR/Xoo4/qM5/5jN544w1lZWX5Xp4XjY2NknTW8+O9xy4V8+fP12233abS0lIdPHhQ3/zmN1VVVaUdO3YoNTXV9/KSLpFIaPny5brhhhs0ZcoUSWfOh4yMDOXk5PTadiifD2c7DpL0xS9+UePHj1dxcbH27dunBx54QPX19XrhhRc8rra3AV9AeF9VVVXPn6dNm6by8nKNHz9eP//5z3XXXXd5XBkGgjvuuKPnz1OnTtW0adM0ceJE1dbWas6cOR5X1jeqq6v1xhtvXBLPg36ccx2He+65p+fPU6dOVVFRkebMmaODBw9q4sSJ/b3MsxrwP4LLy8tTamrqR17F0tTUpMLCQk+rGhhycnJ01VVX6cCBA76X4s175wDnx0dNmDBBeXl5Q/L8WLZsmTZt2qRf/epXvX59S2FhoTo7O9Xc3Nxr+6F6PpzrOJxNeXm5JA2o82HAF1BGRoamT5+uLVu29NyXSCS0ZcsWVVRUeFyZf6dOndLBgwdVVFTkeynelJaWqrCwsNf5EYvF9Nprr13y58c777yjkydPDqnzwzmnZcuWacOGDdq6datKS0t7PT59+nSlp6f3Oh/q6+t16NChIXU+nO84nM3evXslaWCdD75fBXEhnnvuORcOh926devcm2++6e655x6Xk5PjGhsbfS+tX331q191tbW1rqGhwf3mN79xlZWVLi8vzx07dsz30vpUS0uL27Nnj9uzZ4+T5B5//HG3Z88e9/bbbzvnnPvOd77jcnJy3MaNG92+ffvcggULXGlpqTt9+rTnlSfXxx2HlpYW97Wvfc3t2LHDNTQ0uFdffdV98pOfdFdeeaVrb2/3vfSkWbp0qYtEIq62ttYdPXq059bW1tazzb333uvGjRvntm7d6nbt2uUqKipcRUWFx1Un3/mOw4EDB9y3vvUtt2vXLtfQ0OA2btzoJkyY4GbNmuV55b0NigJyzrknn3zSjRs3zmVkZLiZM2e6nTt3+l5Sv7v99ttdUVGRy8jIcJdddpm7/fbb3YEDB3wvq8/96le/cpI+clu8eLFz7sxLsR966CFXUFDgwuGwmzNnjquvr/e76D7wccehra3NzZ07140ZM8alp6e78ePHu7vvvnvIfZN2tn+/JLd27dqebU6fPu2+/OUvu1GjRrnhw4e7W2+91R09etTfovvA+Y7DoUOH3KxZs1xubq4Lh8PuiiuucF//+tddNBr1u/AP4dcxAAC8GPDPAQEAhiYKCADgBQUEAPCCAgIAeEEBAQC8oIAAAF5QQAAALyggAIAXFBAAwAsKCADgBQUEAPCCAgIAePH/AIe0yFA5VNd3AAAAAElFTkSuQmCC\n"
},
"metadata": {}
}
]
},
{
"cell_type": "code",
"source": [
"x_train = x_train.astype('float32') / 255.0\n",
"x_test = x_test.astype('float32') / 255.0"
],
"metadata": {
"id": "TDbsofkV2Zck"
},
"execution_count": 8,
"outputs": []
},
{
"cell_type": "code",
"source": [
"x_train = x_train.reshape(-1, 28, 28, 1)\n",
"x_test = x_test.reshape(-1, 28, 28, 1)"
],
"metadata": {
"id": "Voh8m3u45mcF"
},
"execution_count": 9,
"outputs": []
},
{
"cell_type": "code",
"source": [
"x_train.shape"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "eLxkV2JZAZQd",
"outputId": "2a34e342-19eb-47d9-b428-ac363156552b"
},
"execution_count": 11,
"outputs": [
{
"output_type": "execute_result",
"data": {
"text/plain": [
"(60000, 28, 28, 1)"
]
},
"metadata": {},
"execution_count": 11
}
]
},
{
"cell_type": "code",
"source": [
"x_test.shape"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "7FP7fS6NAl02",
"outputId": "633cd370-97ab-4cbf-f268-5fdd4cf3a4a9"
},
"execution_count": 12,
"outputs": [
{
"output_type": "execute_result",
"data": {
"text/plain": [
"(10000, 28, 28, 1)"
]
},
"metadata": {},
"execution_count": 12
}
]
},
{
"cell_type": "code",
"source": [
"y_train.shape"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "av8P6tYNGPn1",
"outputId": "a85262fc-789e-49ce-e3e6-5b3ba49cf638"
},
"execution_count": 13,
"outputs": [
{
"output_type": "execute_result",
"data": {
"text/plain": [
"(60000,)"
]
},
"metadata": {},
"execution_count": 13
}
]
},
{
"cell_type": "code",
"source": [
"y_test.shape"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "hyB1L6ZcGUHv",
"outputId": "0a5df045-e0a3-4112-b125-0b8199aa1d2b"
},
"execution_count": 14,
"outputs": [
{
"output_type": "execute_result",
"data": {
"text/plain": [
"(10000,)"
]
},
"metadata": {},
"execution_count": 14
}
]
},
{
"cell_type": "code",
"source": [
"model = keras.Sequential([\n",
" keras.layers.Conv2D(32, (3,3), activation=\"relu\", input_shape=(28,28,1)),\n",
" keras.layers.MaxPooling2D((2,2)),\n",
" keras.layers.Dropout(0.25),\n",
" keras.layers.Conv2D(64, (3,3), activation=\"relu\"),\n",
" keras.layers.MaxPooling2D((2,2)),\n",
" keras.layers.Dropout(0.25),\n",
" keras.layers.Conv2D(128, (3,3), activation=\"relu\"),\n",
" keras.layers.Flatten(),\n",
" keras.layers.Dense(10, activation=\"softmax\")\n",
"])"
],
"metadata": {
"id": "zIDPCNqJGVgH"
},
"execution_count": 15,
"outputs": []
},
{
"cell_type": "code",
"source": [
"model.summary()"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "M7F-V_-TIS8S",
"outputId": "40e51635-0e85-4020-9223-9a311350b3d4"
},
"execution_count": 16,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"Model: \"sequential\"\n",
"_________________________________________________________________\n",
" Layer (type) Output Shape Param # \n",
"=================================================================\n",
" conv2d (Conv2D) (None, 26, 26, 32) 320 \n",
" \n",
" max_pooling2d (MaxPooling2D (None, 13, 13, 32) 0 \n",
" ) \n",
" \n",
" dropout (Dropout) (None, 13, 13, 32) 0 \n",
" \n",
" conv2d_1 (Conv2D) (None, 11, 11, 64) 18496 \n",
" \n",
" max_pooling2d_1 (MaxPooling (None, 5, 5, 64) 0 \n",
" 2D) \n",
" \n",
" dropout_1 (Dropout) (None, 5, 5, 64) 0 \n",
" \n",
" conv2d_2 (Conv2D) (None, 3, 3, 128) 73856 \n",
" \n",
" flatten (Flatten) (None, 1152) 0 \n",
" \n",
" dense (Dense) (None, 10) 11530 \n",
" \n",
"=================================================================\n",
"Total params: 104,202\n",
"Trainable params: 104,202\n",
"Non-trainable params: 0\n",
"_________________________________________________________________\n"
]
}
]
},
{
"cell_type": "code",
"source": [
"model.compile(optimizer=\"adam\", loss=\"sparse_categorical_crossentropy\", metrics=['accuracy'])\n",
"history = model.fit(x_train, y_train, epochs = 10, validation_data = (x_test, y_test))"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "ih_aR-fxIXtE",
"outputId": "5dc647c1-b86c-410e-b1b4-84d94cb16158"
},
"execution_count": 17,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"Epoch 1/10\n",
"1875/1875 [==============================] - 48s 25ms/step - loss: 0.9542 - accuracy: 0.6450 - val_loss: 88.3100 - val_accuracy: 0.3742\n",
"Epoch 2/10\n",
"1875/1875 [==============================] - 48s 26ms/step - loss: 0.6781 - accuracy: 0.7431 - val_loss: 33.7636 - val_accuracy: 0.5503\n",
"Epoch 3/10\n",
"1875/1875 [==============================] - 46s 25ms/step - loss: 0.6027 - accuracy: 0.7715 - val_loss: 195.4177 - val_accuracy: 0.2516\n",
"Epoch 4/10\n",
"1875/1875 [==============================] - 46s 25ms/step - loss: 0.5542 - accuracy: 0.7885 - val_loss: 196.1379 - val_accuracy: 0.2537\n",
"Epoch 5/10\n",
"1875/1875 [==============================] - 46s 25ms/step - loss: 0.5207 - accuracy: 0.8027 - val_loss: 141.2190 - val_accuracy: 0.3160\n",
"Epoch 6/10\n",
"1875/1875 [==============================] - 46s 24ms/step - loss: 0.4972 - accuracy: 0.8143 - val_loss: 63.7247 - val_accuracy: 0.4916\n",
"Epoch 7/10\n",
"1875/1875 [==============================] - 45s 24ms/step - loss: 0.4790 - accuracy: 0.8195 - val_loss: 75.4834 - val_accuracy: 0.4638\n",
"Epoch 8/10\n",
"1875/1875 [==============================] - 46s 25ms/step - loss: 0.4605 - accuracy: 0.8269 - val_loss: 61.2391 - val_accuracy: 0.5277\n",
"Epoch 9/10\n",
"1875/1875 [==============================] - 46s 24ms/step - loss: 0.4468 - accuracy: 0.8335 - val_loss: 65.1511 - val_accuracy: 0.5472\n",
"Epoch 10/10\n",
"1875/1875 [==============================] - 46s 25ms/step - loss: 0.4355 - accuracy: 0.8373 - val_loss: 66.9494 - val_accuracy: 0.5401\n"
]
}
]
},
{
"cell_type": "code",
"source": [
"test_loss, test_acc = model.evaluate(x_test, y_test)"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "jvQqnFcuI76V",
"outputId": "720ed7f6-4b1c-4bfe-ef6b-6fd0610bd5ea"
},
"execution_count": 18,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"313/313 [==============================] - 3s 10ms/step - loss: 66.9494 - accuracy: 0.5401\n"
]
}
]
},
{
"cell_type": "code",
"source": [
"print(\"Test accuracy:\", test_acc)"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "yqfWB3VnNpG9",
"outputId": "e6a638e0-51c2-4399-8077-49c5fcbacaff"
},
"execution_count": 19,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"Test accuracy: 0.5400999784469604\n"
]
}
]
},
{
"cell_type": "code",
"source": [],
"metadata": {
"id": "ce6tZRAGNyB1"
},
"execution_count": null,
"outputs": []
}
]
}
Raw
bfs.cpp
#include <iostream>
#include <vector>
#include <queue>
#include <omp.h>
using namespace std;
struct Node {
int id;
vector<int> neighbors;
bool visited;
Node(int id) {
this->id = id;
visited = false;
}
};
void bfs(vector<Node> &nodes, int start) {
queue<int> queue;
queue.push(start);
while (!queue.empty()) {
int current = queue.front();
queue.pop();
cout << current << " ";
#pragma omp parallel for
for (int neighbor : nodes[current].neighbors) {
if (!nodes[neighbor].visited) {
nodes[neighbor].visited = true;
queue.push(neighbor);
}
}
}
}
int main() {
int n;
cout << "Enter the number of nodes: ";
cin >> n;
vector<Node> nodes;
for (int i = 0; i < n; i++) {
nodes.push_back(Node(i));
}
for (int i = 0; i < n; i++) {
int num_neighbors;
cout << "Enter the number of neighbors for node " << i + 1 << ": ";
cin >> num_neighbors;
for (int j = 0; j < num_neighbors; j++) {
int neighbor;
cout << "Enter the neighbor " << j + 1 << " for node " << i + 1 << ": ";
cin >> neighbor;
nodes[i].neighbors.push_back(neighbor);
}
}
nodes[0].visited = true;
bfs(nodes, 0);
cout << endl;
return 0;
}
Raw
dfs.cpp
#include <iostream>
#include <vector>
#include <stack>
#include <omp.h>
void parallelDFS(const std::vector<std::vector<int> >& graph, int startVertex, std::vector<bool>& visited) {
std::stack<int> dfsStack;
dfsStack.push(startVertex);
while (!dfsStack.empty()) {
int currentVertex = dfsStack.top();
dfsStack.pop();
if (!visited[currentVertex]) {
std::cout << "Visiting vertex: " << currentVertex << std::endl;
visited[currentVertex] = true;
#pragma omp parallel for num_threads(4)
for (int i = 0; i < graph[currentVertex].size(); ++i) {
int neighborVertex = graph[currentVertex][i];
if (!visited[neighborVertex]) {
#pragma omp critical
dfsStack.push(neighborVertex);
}
}
}
}
}
int main() {
int numVertices;
std::cout << "Enter the number of vertices: ";
std::cin >> numVertices;
std::vector<std::vector<int> > graph(numVertices);
std::cout << "Enter the adjacency list for each vertex:\n";
for (int i = 0; i < numVertices; ++i) {
int numNeighbors;
std::cout << "Enter the number of neighbors for vertex " << i << ": ";
std::cin >> numNeighbors;
std::cout << "Enter the neighbors for vertex " << i << ": ";
for (int j = 0; j < numNeighbors; ++j) {
int neighborVertex;
std::cin >> neighborVertex;
graph[i].push_back(neighborVertex);
}
}
int startVertex;
std::cout << "Enter the start vertex: ";
std::cin >> startVertex;
std::vector<bool> visited(numVertices, false);
#pragma omp parallel
{
#pragma omp single
{
parallelDFS(graph, startVertex, visited);
}
}
return 0;
}
Raw
min_max.c
#include <stdio.h>
#include <stdlib.h>
#include <omp.h>
#define ARRAY_SIZE 1000
int main() {
int array[ARRAY_SIZE];
int min, max, sum;
double avg;
double start_time, end_time;
// Initialize the array with random values
for (int i = 0; i < ARRAY_SIZE; i++) {
array[i] = rand() % 1000;
}
// Initialize reduction variables
min = array[0];
max = array[0];
sum = 0;
// Start timing
start_time = omp_get_wtime();
// Compute reduction using parallel reduction pragma
#pragma omp parallel for reduction(min:min) reduction(max:max) reduction(+:sum)
for (int i = 0; i < ARRAY_SIZE; i++) {
sum += array[i];
if (array[i] < min) {
min = array[i];
}
if (array[i] > max) {
max = array[i];
}
}
// Compute average
avg = (double)sum / ARRAY_SIZE;
// End timing
end_time = omp_get_wtime();
// Print the results
printf("Array: ");
for (int i = 0; i < ARRAY_SIZE; i++) {
printf("%d ", array[i]);
}
printf("\n");
printf("Minimum: %d\n", min);
printf("Maximum: %d\n", max);
printf("Sum: %d\n", sum);
printf("Average: %.2f\n", avg);
printf("Execution time: %.6f seconds\n", end_time - start_time);
return 0;
}
Raw
parallel_bsort.cpp
#include <iostream>
#include <vector>
#include <omp.h>
#include <chrono>
using namespace std;
void bubbleSort(vector<int>& arr) {
int n = arr.size();
#pragma omp parallel for
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
int main() {
int n;
cout << "Enter the number of elements: ";
cin >> n;
vector<int> arr(n);
for (int i = 0; i < n; i++) {
cout << "Enter element " << i + 1 << ": ";
cin >> arr[i];
}
cout << "Unsorted array: ";
for (int i = 0; i < n; i++) {
cout << arr[i] << " ";
}
cout << endl;
// Bubble sort.
cout << "Sequential bubble sort: ";
auto start = std::chrono::high_resolution_clock::now();
bubbleSort(arr);
auto end = std::chrono::high_resolution_clock::now();
std::chrono::duration<double> elapsed = end - start;
cout << elapsed.count() << " seconds" << endl;
cout << "Sorted array: ";
for (int i = 0; i < n; i++) {
cout << arr[i] << " ";
}
cout << endl;
// Parallel bubble sort.
cout << "Parallel bubble sort: ";
start = std::chrono::high_resolution_clock::now();
#pragma omp parallel
bubbleSort(arr);
end = std::chrono::high_resolution_clock::now();
elapsed = end - start;
cout << elapsed.count() << " seconds" << endl;
return 0;
}
Raw
parallel_msort.cpp
#include <iostream>
#include <vector>
#include <omp.h>
#include <chrono>
using namespace std;
bool isSorted(const vector<int>& arr) {
int n = arr.size();
for (int i = 1; i < n; i++) {
if (arr[i] < arr[i - 1]) {
return false;
}
}
return true;
}
void merge(vector<int>& arr, int low, int mid, int high) {
int i = low;
int j = mid + 1;
vector<int> merged(high - low + 1);
for (int k = 0; k < merged.size(); k++) {
if (i > mid) {
merged[k] = arr[j++];
} else if (j > high) {
merged[k] = arr[i++];
} else if (arr[i] <= arr[j]) {
merged[k] = arr[i++];
} else {
merged[k] = arr[j++];
}
}
for (int k = 0; k < merged.size(); k++) {
arr[low + k] = merged[k];
}
}
void mergeSort(vector<int>& arr, int low, int high) {
if (low < high) {
int mid = (low + high) / 2;
// Recursively sort the left and right halves.
mergeSort(arr, low, mid);
mergeSort(arr, mid + 1, high);
// Merge the sorted halves.
#pragma omp parallel
{
#pragma omp for
for (int i = low; i <= high; i++) {
// Do nothing, just for parallelization.
}
merge(arr, low, mid, high);
}
}
}
int main() {
int n;
cout << "Enter the number of elements: ";
cin >> n;
vector<int> arr(n);
for (int i = 0; i < n; i++) {
cout << "Enter element " << i + 1 << ": ";
cin >> arr[i];
}
cout << "Unsorted array: ";
for (int i = 0; i < n; i++) {
cout << arr[i] << " ";
}
cout << endl;
// Merge sort.
cout << "Sequential merge sort: ";
auto start = std::chrono::high_resolution_clock::now();
mergeSort(arr, 0, n - 1);
auto end = std::chrono::high_resolution_clock::now();
std::chrono::duration<double> elapsed = end - start;
cout << elapsed.count() << " seconds" << endl;
// Parallel merge sort.
cout << "Parallel merge sort: ";
start = std::chrono::high_resolution_clock::now();
#pragma omp parallel
{
#pragma omp single
mergeSort(arr, 0, n - 1);
}
end = std::chrono::high_resolution_clock::now();
elapsed = end - start;
cout << elapsed.count() << " seconds" << endl;
cout << "Sorted array: ";
for (int i = 0; i < n; i++) {
cout << arr[i] << " ";
}
cout << endl;
// Check if the array is sorted.
if (isSorted(arr)) {
cout << "The array is sorted." << endl;
} else {
cout << "The array is not sorted." << endl;
}
return 0;
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment