hazelnut_PaDiM_1.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/danielsoy/ALOCC-CVPR2018/blob/master/hazelnut_PaDiM_1.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-ReQmXBbrEbc"
      },
      "source": [
        "Paper: https://arxiv.org/pdf/2011.08785.pdf"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "DdYkd7CVPEy4"
      },
      "outputs": [],
      "source": [
        "%pip install dotmap -q"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "K0Ey3gxRW6Cb"
      },
      "source": [
        "#### Explain dataset directory structure\n",
        "\n",
        "Here, we download 2 datasets: **MVTec-AD** (contains many different objects) and **Transistor** dataset for testing purpose\n",
        "\n",
        "**Transistor dataset should be replaced by your custom dataset.**\n",
        "\n",
        "Your custom dataset should have the following order:\n",
        "\n",
        "![image.png](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAATsAAAE7CAIAAAAtvrGQAAAACXBIWXMAABJ0AAASdAHeZh94AAAgAElEQVR4nO3de0ATZ74//s8Bh8gIGV0SGqABDaEBRBBRKmLRFuwBW7CWbcVusVusl1+rpxbXtXU9i3ZdXWtFu2K/qBVbcCu2plbcAivEQiqXhpsg5VIgCoEQyVBIwMEwwPn9wS0ol4igjHlef7WZe+SdZ+aZmefzX//3f/8HCIIwhMnj3gEEQR4ASiyCMAlKLIIwCUosgjAJSiyCMAlKLIIwCUosgjAJSiyCMAlKLIIwCUosgjAJSiyCMAlKLIIwCUosgjAJSiyCMMm0iV2dtv3OxK4QQYwH22LGmPOgNhZBmAQlFkGYBCUWQZhkgq9jH422ovjDcdfk2rv6H7Ld3tqzw5/zuPZpAlFtOpYly/Rx7wYyJf3XxI7z9Ch6nnTX9gRtuUjeP8FM8MqBUx8zPLS3L255de91j6jvP1/N7ANBHpwhPU8MbGOb5fKWYSd0yr/f/so1O7bZ/ZPMOB6rt+9e52Fp0BbkX2/Znuy856stHo++ocPtnN2cdc52rDHn1F07EB6jfSPmwCso2kaEgYkdVRvZ0Dbc5w3K6P2C585vmmPISjrJBvlNrnZi98xAlt5bTiQaNmub+mYF2aqb3P1BphjGJtbnI8nnaziGtYE62YGV75xvaGgAGDuxycejk6/cBKrz/KFomZnL6veDBKYNkhPnG+auWz0r76vvpXJTv+0fBtkBAOgaZMnJ1yoabmvhKZfnVq72d+5rxHUlF2PS4aX3AiDlq4t5DVozrof/mtVL9VvONrnk4sVr5SQ1nS3wXr0myHlm7+cNkhPn5cI1G/ztev+f/CUlOVlWTt5lcVyeW73aX2gJAG2y8yfTfqroAjIp+rDajuuzbt3Svpa2rVpyMUlW3tzJfsp5afDK5+YMnFfcexTRHwYZ9PUhU8lkJ1bXdpvUjtAMsDh2HHzcazYDg09ZWdgDrJesk6spgG6duk4OLHYbAHQ3yC7E/1Qov1hcrJszx86+94DIn/6xYfvXDZbO3h5zWJ25pyIT4v0/TowO5gBAW0VKfAK0tcanF1rOd2ZriyXJ4ouSHfGnwnt/MsjknW99dEUr8FnqPEt9/fxHiRel0WcP+HP6t+Xv35tY+dcb1x2SsZyXegssyZxTkd9cXPfP+O0+lrq2hpt1Ddpu0LU23Lyp63Tu/Yp1FV9ufe8zmW6Ot7fAUi6JSTxzyn/3qejQOTDcUTzAl4JMGZOdWJa2MGbDrpSG7nsnWHpuOf7/3pmCV2DrDsZ4/3P1mvPztxyLeq73R6EbAKChWLvhZPIW9/4mS5mXnNPm8V58zCZnFgAAefHd1XtOxFesjHTuW0r2k+7w95f8OaYA3TfjN605/EX8T69HPccC+CXx1BXtc1EXY3ovQUnJnndP/ZRH+gcN/T66r8WfkLGCY77/eKklAHQ3JP5pS3JOcZvPUo5/ZMxSl8ilH5HrDsf8sa811pUc/+iz65w3Tn6xw9sSAID8ae9bW/7x0SmPxA3CvlXeexQI00z6/Vi7oAOn9gfZDW0Pe+PqMf4G9jGw9H9rg/4fum3QgUvpp/riCgAcjwV2cLtBPnBCYTpn9dv+feftpnNWv+zN0pbfvA0AAJ1tOgAz1sCi/nu+SdwTdN/PV5dOpwMWy6yvK83ULuzIxfjIpSOkTSe7cFE+66Ut73n3z8B57v0t/mYVFy8Wj3gUCNM8iutYu6ADpwAGWlomxhUA2Jac+/pvdWRFnqxELpffbGioKS6sAODA4NkE104vg5aWlgCkrhMAANxXr3a+GLNr5ZrkgOd8vL29l3oLh0sRy3v1K3MkX29ZWf5cwHPe3t5Lvd3tLEe8FlBWVLWxPLy99b/YmYu8XUBSXUGCB2fEo0CY5BE98zTQ0jI0rsNok8W885L/61v2xCUXN9xl2futXn5ft9ZIv4emzhtOn49+f6Wd9nrikY82vPqc/zsxPw1zh9nS+8P4+IMbn5vV8FP8gci3XvJ/aUt8ybB94QDdOp0OzHDLoYG0ZJubwR0d6lB+Yjy6vmK7oAPxVi+Rbkudn4C4AsjPR58qsAz7PPGj/k7ahgRpzBWDl8fn+P/xI/8/AnS3VVyJidr7xZ5/zk/+eOl9DaClc9A7e4LeAdCRJcmHd+09vOuU96X+S2V9phwOF9rqG0gAvaZdKW/oZDlwp2B/ATI+j/S5Yo43Q+JqCtB9t7NrtFnI2yQ85b3SZyALZHHhTQNX31aREn8iRd57/mxq6Ry07iUhkMr77iSTxRdPxEuUvf/D4rivfuuFOXC7Qa63Y7quzv7/5Dzn4w5lFy9W600tuii5aea9dBE6E35iMPZ+7GSys7NjUdcSj18Ebxfvpc7DdtS4uHtYXpDExHpvD3a27GyQnY+JyTH43PO27KvYH35ogV1vLLKbRhYnx3z1i5nze973tYRySXz09TwtfLDagwMNhRdjLt20XLTOuzd/0+bYPQWSyyfj7QI85i71sGfZhW4Ju7AxZtt21o4NS+ew2ip+OHUovsHpnQMvoyb2ycHAxJpZsgCg6uL+v8gMbTpaKtoALHFD+0gtgz/aU7x9f8LeyATvPWknV88afp4DN3ft+XL7mhMAYGa3dOP2cPjoS8PWvywyOlK7J/ajdV8DAABu5x1+YM/b910Gc1bv+bRhz974yLVfAACYWgqWb4n+S//zxqbOG/+25eZHJw/vTLF746vkDz3A0vujk4fN9kXHbA073D9/zF/ecUYt7BOEgW8CAJn8p7CPrgzTUTMa3HnDya+2uD/IHy/VRnaacWaOughFyutImDVH8NSDx6K7raGO1IEZ136UHmAA0LUplQ0UcJ6awxnmN0fXRrbBLI7+GnStDQ1kJ3v4+ZGpy5A3AZiYWADQNfxS0TDSs1T3M2VxnvEQzJzMPUKQh/YEJxZBnkBonCcEedKgxCIIk6DEIgiToMQiCJNMcM8TgiCTCrWxCMIkKLEIwiQosQjCJCixCMIkKLEIwiQosQjCJCixCMIkKLEIwiQMfKN9QuhqLh2J/qZQPaQ8HvZ04IcHNsxDL4AjU5eRPvOkiHt9xb6iYd6vneWz68tTxhBaqlh8TAIBG0O9LB7H5nsUkpPiKqewzf68x7F5BjPSNra6smb41+Fbcva/vuQUlz39/kls4fPvRu1d+fQk79qj0qIor6QX0mPNRpcm7BPf8f9gsx/7ITamzT11JIkVsnedZ39BFUpZU1luQT3EOo0UkxJbmHiWFfLm3MkejVGnVdcPW5OmPn6Xpc/y6EBGDAc5UXo61CqVpr1z7DlH09mqVqlnUDTAg5RAQobBpMQ25R7ZeVn79al3Jyi03HX/+nGvj2EnwN3q+LeXROXWK34DMHDrPdran7OkFY2tXbiTV4C/s1Z6uWjGktDFfAAgCy5lqmev8CNupEhLlSYLwt5cxAUAoJXF2Tk3atQdZjPtRD5+ixz6T1lpeaY4Dxa+skzIGu4TTWlqqpy7LEj4W3bKzzXqLjNbp0UBfiJCv2ORUhVIs4oVZCfLZr7/CncDjoCqSE+SlTYCtOaIEzQcrtuKwHns/m2tsKnPkBTV3RGs3OzPV+aIpRq3kEDRwHejzBFLNaKgQDeipfRyalZ+A9B4XuI5BW7tHeov6M8tTTeVSn68fqul04zj6LN8iQsHJXoMTEosgE6bc+SNDTBhocUMvl41hQe7tNUpLh89Iq4CrsDRZkaz5PT+4ucX0FdlhGPIYj4GPc1l19JLqlTSmzW0tQ3nKYoGgB6VNPZIXDHNFTja49qSK1mpVzJC/2dbsAADAOpmUepVsA3US2xdUepVmvviMiELoF0uvZrBoRoTi1UcRx6mqUz9OUt6482Pt/oSvXOrMqMPJZZQbAcne+I3WfzBSr+FYx8E3U4qmzR3uoFua1Y2dsHsToC+beGqSuWv5Ew7DseGBqAbizNTb+N+g4mlG0szU+sxv0A3QqdRNza36gBMSWUj4JheS9uSdexgKWnjaINpyiV50mulEbvf80NDtY6KWYkFAJjg0E6O2stxYjnuv/XP4R5sAICWotiDJ3O7MS+9edQ3qeBtfw91Mu/9X2VqXEIxtnjDXzYvZAMAUJWJh46LvxC77A0TGtTwdJTIiZ37NrlYAABdfWH/wbSUFLlvmAAASMlX4hKT+Zv/tmkxBwCAKkvc91kmgGD0NRILwyLn5UX/T5zmxY07V+onqaOWtNm6f4d73+/BqFfDPN+ISFHq/v8VzwiKfN9X/x9NU6ZyiPx7pJM5ANC3kvYdTLmcJvdbO8ZeGTlG3o/V5hx5Y/PZ6rFnfEx65NKfVbjnqlCP/t6aWZ5rV4juyR0+PyCkP67QI5deU4Bb0LqF/YvgotBXvYlmWfqNMXuH+giXr3TpO4vGhH7ettBcW98BAKDKk8ppl8C1i/tDh7uuCvU0H2E1hm3LP7Q/ruOHzVsR1P8NYLOX+PBB3ahAnVGjY2RiYdrTz7+2XDj2fI9Jm0KpBVsnkX57QjjyuUMHJcbMicEMU4raZnBwHrII9oxIaNJRp2g2bKsYQeiFkIXjAEDTAEDX1ymBJ3xGv7PX3N7RxsCjGXZbuMUEnJ3hbLbe8c7ApwPQo7fXCBMTO+3pVYcTjgZP4bssPTQNgJkObVMxbLRzW5qmATDW0MEvMfMZGNB3H7rVobsAMLOhmzcbdXcelamwDwzDtMRO/bgCgIUVhwVkY6P+Z/RtUn1fofpBuBUxDTRNQwsdaJrVOiB+xwEAMAUYer1I04a2RhhB4ECq1UPmbyUfsKjCmHqGrJ++O9J8yENhVGJZjgyIKwBgzotczdU/p0gHQkGrJGnXR2srWY4ez2DK/KxyvQc7lFlZ1cD3cGUDAG5hjnU3VtV09E3rUeXkKQzdn9lzXVgdxVmlgztAy3MKDTvZ7v0D6Rm1zh9ghIU5kIpqTf8HLbLsGv0AmwEATY++EsQgTOorXvKnLwK53Me9F4Yw93o11P3g2bh9+4sXimynd9TeuEESAq6pfORF2D6rAiQHU2KP4WtXeTta0o3XkxMuK2b6vudvBwCAOS9wt7ieGx9j1rTE1bKj6lpGeYfBXUe4Z9CL/ILvE6LPUqHLHIm7jTnJ4gIw7BkmUytbKyjJvpRq5S10dBNaD38e67DAk5uRmRAdp/Gfx6XrsiWl5JCnxsxtnzKHwqxECe4xR+QleJjHp4wdkxLLnri4EjgLQJv9eeS24erWDUenqASA6WwDb8ta+0bu5khSM/J/LS0A3H5B+AcLFDH7RkksYLNDIrdi8efSYg+mAABgVi4vbIx4za2vb8Zi0fqNjdSZdOmFs1JTc+Hy8E3WmVHfGHpi7PDylq3dCQlXzh7MAADM9tk1W166vi/egCtkE0HIupDa0ymJp68Ty7d99qZo+J13XbXp980nLueJ4/MA5y1eExFy41Ds4GUB5v5qRODtuNRzcVJ+yP6oIFsD9xu5j5G+CaArOhK67vNfHrBIEHdl9A8xweP82VAk7dqXbr/p8OYFY3S3UC2qVt20mVYcfJgZaUrTATh7uEkGoDvUTSSN82xn6S9Ppu7/38T7f0xMecG7o0L5D7LdHppq68IszbERLrbodi2FsYkn/z2LSWSkiQUAnbrml+qmu6P0Bg01neDPnfe0gX9smhtJpzMgZH2IsK+J7Kg+/8m+q1jo3l3BU+5lFVp543qd9r4nh00IGw83hyn8mIpxMt7ETiqqKung0RTldL67h4jL6lDX3CiRd3D939u9VoQigDwMlNjJQpOVUklWsaKZ6sRwLt/V29ffg4fuPyIPCSUWQZiEUfdjEcToocQiCJOgxCIIk6DEIgiToMQiCJOgxCIIk6DEIgiToMQiCJOgxCIIk6DEIgiToMQiCJMw6Y32iYRq2yHMZKRvAqDadghDGWlif9zpFfHtsOWwAFhs7sPXtpuYknB9lGnHY/J4ER+GCtFFjNEz1rPiUUxIbbuJKQnXh9aQSpU5GiwfAeNO7GTVthu+JFzvJEWRNPuXW1qYac13fXaJ+5BX3DuU+VnSG3VqHcy0Efks9xUSAKDK/S4ju1AFOjr968QyjO/zmq8DammNGBMSS6kV6uHrMwOLbc0zdHjDYUxObbvhS8IBXZt6PPpiJW0tEFrjZI4sNTVt8dt/3uzdG2ZtbuzfY4toW5HI3rKr+sezkmuVW3dFeBF0a5NKQwF0U5omFWAEKnJh5JiQ2K76SzveOZx/35lqX32AKTf47fAl4eRJJy7KuSt3RK4S4ADQQ+aePhR79tx8102LLQBupYmLaPc/7Insve7V5MVGpxVXab28+YGbt7lc2Bsl5Ydui3BHravRY8KfANtzyxdfbF84NJmMKOcxiC7JzFJaB4QHC/rOqU04i1evEOp+yS7sAAC4S3cCDJbCIRZt3rsrwnvK/Rghjx0T2ljoCy2809/SMiyuANBcW9cB3Qrp+cTBK9fuZgpoqokE4IOjbwA/W/zlnl2yBV6uIldXNxe7h6oWiTypGJJY0AvtdTbT4grQQ3d2AVCksmHIdSjhJCI4GAAAxg/esctWkp55vUJyIetyNxBOAes3T0CNVuQJw5zEQm9oE+b+wn3ehxHVd/SYEDMtAJsVsDXSd8SeZhbPa+WbXisBaG1tUXLcmfTYC6LP1ruhAVMRfUy4jtXHdmVGXO8tCcd2mcuna7KlTXrztJSmJmf11oOjbuVdvpSn7AEAAIzt4B3gwweKVFEDa+umaYPLFyBPMKYllilMrWytoDb7UmpOUXUTDQC2L4T4WcrFR09clsmVKlXtjcy4f55MTL3el1LNjfTkhBNfZ1WrtJomRcG/z6fUYg5z3XpPirlPcTBdZcp3WQXFCvQchZEz0qcUC/cuCf1KK1z+4lzDa9tdu1LY4vOPrPg1hrXxVEXKsdMp5S30YEk4sijxS7Gkorn3Wha3WxTy1tpAQW8PU0d1anzc5evK3hvPLCsXv9CI1zy5fW01mfvV8fhcFQWi8E+2+aOLWyNmpIl9VLXthikJR7eT6pYOsLinwBwAAPR0qBtJCsy51sMVttNpNbQ5YYEubI2akSYWJrm2HYJMEuNNLIIwEep5QhAmQYlFECZBiUUQJkGJRRAmQYlFECZBiUUQJkGJRRAmQYlFECZBiUUQJkGJRRAmQYlFECZBiUUQJkGJRRAmYdQ4T1OMNv/0/hOZVZoh9fEI93cO7n6RCQPbIIyE3rYbL13Gh34bzqvvn8ASvhb99cGHDm2PPPV4ktLjzQg/ztgzT6bqS0fFGt/N6xZNwtAXKsmpxLLZoVtX8Cd+3U8o1MaOl7qmqmXYCbrqb98LyHiaGObldxZ3wWt/+Xj9AoNGDqduVVXW2XQ81E6Ooipp31n5wne2BY4RFlrTKC+/LboDMPGJ7aGUv1ZWs9DYVQ/AyBJbfyW+zHXdi5M+1vFI5fEU9f/4q+Pyf291nOwdGNtdrVJFtqIyPkxjZInVVX+z/UDhwYSjBpaBHdPSKNmZN7mmhm08Z+9zfzirqFcAPEBiabJUkiaraoeZ1gMF7waNWCxPU5qaKucuCxL+lp3yc426y8zWaVGAn4gwAQC6VpokLaqgupsLLicCD3d6PsTL2vA9Gr1CH60uk+XeuNnQ0mk2y95jia8XX7+4Aa2pkKXnV6rbYaaTb5AfGrPqgRlZYgFAV39pWzjARIWWBYbFFQBYD/73SbdkHTuQ3ThLZGNJlUjOSiTZodu2BQt6VzRqsbx2ufRqBodqTCxWcRx5mKYy9ecs6Y03P97qSwBQLSplKwUAna0qJbC5I1QOHHaPRq/QV3L2yLEMFW4nEtqYa8qSj11N8/rjX7b69E7tKD9/JDpNgdkIhNZYY+rxAvkS+wf+Soyd8SUWALomNrSTSP1zkf3bfz3kywEAaK9MPHRc/EWSy95QITZWsTwAgI4SObFz3yYXCwCgqy/sP5iWkiL3DRNgLqvecxGcfTemwid8W5jgQXZo9I2SN7LLKIfgHTtX9f6oaKXRu+Mup1U/Gyo0AbpMHHtVZbtyx85XBTgA0CrJ558ktEzC5fETzVjvx3bVX9oWHpUx7MXmVCJYEebb31dsIQpdNR9vluVUwdjF8gAAQLh8pUtfejGhn7ctNNfWP0xX1lgb5fhu3n9wd19cAYAtfIYHzSqSBgC6JKtQw/YOG1gW4/m/utzW4DMUpJdRtrEAAMCe/9qqKV/ukTtHoH+XCHN0dIC82gYtuFJjFMsDAMAIQu8akoXjAEDTAOOumjdWhT4AAFpzq7K8RtHQ2Kxsbqz7VQFAQDcANCuVHdgckVD/0sBOIDSH4vHujXEy0sSyF35w5st3F4xYtWqqwO659p2OYwAU3Tl2sbzJMOZGqUrxsROXqzqwWTzh0zyutcgPp8T5esti04buHIahvqcHZIyJZUpcAaC1maSBP/hX3dRIAsaZNQNMzMYuljfhxqrQp7wqviwn/N/fEz6v7+RFnVral1gTYqYF0OpmNcDgWcNdrbp98nf7yWJ017HEIsbEFQCoX2QFg3/TdHW2TGnC93AyH7NYniEwoOnOB9qdMTaq+U0DbJHP3IFrDW1NFTm4rDMfamW5DYOLavKzytEN4QdkZIm1ee3oKcbEFQBwXCH+Z6K0TKFskOdeOn7sajPXJ6T3scUxiuWN6SkrLmjz/5OUm1+pNPiho9E36uBkj2tl4u+LaptIdUOlND7mXEXX4LL+QYstFEnHTlwulCsbFCUZZ6OTyZnM+beYIozsrBjnTtgz+iz2dACo/Pav23MMLcbTUqYFYOMPcDuDuzQiVJMYG51JAQDGFj4XsWmNqO8kGXeL+NNG/Etx0slD4t4P7BaFbVvrZ2C1PuuA8NfrYr5Lib2R7rX58NaFhl1QjrpR3Cd8c8OJ0/85GZUMABjhGrTWvzT2P/3LWniuj3zT7IxY/Pl1MQBYCII3hsO5o1LD9hfphd4EGDf1pS2rtiUP8yrAaGa4bon/ZrvngxXcojWkuh1mcDjDPas8arG8MfV0aNoAJ+5I9v9vovy+qaa84N1RocM9eDzaRnVaZZNmlP2hWlSt1LSZw9bvQ8aCEvswdIobZYqhb9uNxnS6tbOn0NCKtY8SrbxxvU5730WtCWHj4eaATlynEpRYBGESI+t5QhCGQ4lFECZBiUUQJkGJRRAmQYlFECZBiUUQJkGJRRAmQYlFECZBiUUQJkGJRRAmQYlFECZBiUUQJkGJRRAmMbI32icUqm2HPHrobbvxmuzado9Gj0JyUlzlFLbZnzfxK2/JizudxX15W7DzxK/baKE2drwmvbbdQ1GmHY/J40V8GCoc47qHUtZUlltMTnU5HVlbJb/TTgOgwSYmjJEl1mhq29EaUqkyR2UenzxGlljG1bbTyHN/kpU1Up0sjtPCJX6ufcOH0/JMcR4sfGWZsL8l1/tElftdRnahCnR0+teJZRjf5zVfB8N7GGmyPCc7v4q8gxGznTx9nhUQ+su2KwpyisrqyTtdZlzRIr9nRVz9U4kebe3PWdKKxtYu3Mk7wP8xl6p+MhlZYoFJte2oCvHBz9NrTXgujjzsdlaiNF3iv3H3WjccgLpZlHoVbAP1EltXlHqV5r64TIjRrU0qDQXQTWmaVIARDzAkcEtRXPQZKWnu4GRP9CiSstKTpCE7twU5sAAAaEV69FFx+V0roTOfgObc80dTfwza+WFI3z7oFJePHhFXAVfgaDOjWXL6UJmPCI1GPOGML7HAkNp2utLE0+lKXtDubSFCHABoZerRqIuJYs+ocOdRo2/CD9y8zeXC3igpP3RbhPsD3L/T5p5NkNLzN/8tYjEHAICSJ0UfTjrxg9v+V/kAdG1ekZK1aPNHfVPpqsSoT9OT8ldE+poDQO0PcWI57rf1zxEebACAlqLYgyeV3ZjNeL8AZFjGej92yte2owozc7S8wPDeuAIAZvvi2zs3hfr8btI2ScrSS8Fr1drF/WezuCAoZCFbmS+r7gEATPjqjs/2RwxMxWaL7KfRZCMJANAjl8pUuMeqMI/+XrVZnmtXCFCP04QzyjYWAKZ8bTvlrUbawtnVTu8jE45wwWReGtbV1XZ3cfMvJd4a/IxqpKFFRdLQd+pLkdUVldUKlbKJVNfLq3Uws5sGAGhTKFvA1l+kP1Iq4SjgmiomcYeNkpEmduoXy6LvUoCZP8o2itZ1ANCtpKpWv2S7mb2LM7/3e1JnxX3ydZ66x5zLt7fn8oTPekJqZl9dnR6avr8SH6pcNwmMMbFTP64AQPyOgDYVeReEw+6nKQCAfr8OTT9sLw9GELiplc9bI1Rt1xWJz+fdeSZs/+Zltr3tbU9p7EBicYKYBo2DVWQBAOjfSHU3oA7jiWV017FMqW1nO8+N21WZmUUOftSUFbv/UGJxBwDgFuZYd2NVTX/B9R5VTt7Q808TgG6a7n6QTTrOdTFvLrhWqncXl67NSpEUq2gAoLQaHTh4eNoO9k5X1g20xiyR6xxMWZhVPtg+d5TkVqIbwhPOyNpYm9eOnuJyp3xcAQAEK0I9ZLHfHT3WHRo0zwbTVEq+Fedq526dbQ4AmPMCd4vrufExZk1LXC07qq5llHcMqbzOfYqD6SpTvssCZ3sXD75BR8zyDHlJsO9CXLTJqpClIhuMqstPiU8unfGCyM8DgBAIrSFVckFivdLdeprmVl7Sd1lqgJl9C7P9Xl6SeiQz9hi+dpWn/XSqLjtJfBMjoGPUTSIPzMgSy6TaduzF67d0fp2QePFkwQUAANxuUfi2cK/epS0Wrd/YSJ1Jl144KzU1Fy4P32SdGfXN4Ikx7rNm/a/H46+ePXZVFP7JNn/Dtmm7YstOOBf3Q2J0BgAAYGyXFzZGvCbAAMCEH7IxTH1SnBCdBwCA8/zWrPL6NrGmf1nMOezPGyDufHrswRQAwPnL1r/tmfJpkmEHixgKvQkwbo+qtl1fqTiO7Szz+6bRlKYDcPaIReJ0Wg1tTtQkvHss7/4TVGxBxOfvLhpm0Z4OTRPZ2m3OHab8HE01qdQ6cy5vpMp0tKap+bWJDKIAAB//SURBVE4PzuWxUbfTZECJfRgMqW3XIi+oaKTvrwRtJVrsjDqGGAYlFkGYxOj6ihGE0VBiEYRJUGIRhElQYhGESVBiEYRJUGIRhElQYhGESVBiEYRJUGIRhElQYhGESVBiEYRJUGIRhElQYhGESYzsjfYJhWrbIY8eettuvB5Hbbvqfx8Xq+dHvO3L8F8EleRUYtns0K0r+GPPiwyF2tjxegy17WhNY2V5PZ/xpTF6KOWvldUsNGzbeBhZYo2mth3ypDKyxDKtth3dVCqVXq8iO804Iv9A73sn92irf5YV19Sp22HG0/N8fOcLZ/UNrkTLM8V503xemUfnpEmrNMC293kxwGUWaKqy0n+uVHeYcZ2WBCwX6A3YRqvLZLk3bja0dJrNsvdY4uvF1x9WitZUyNLzK9XtMNPRN2i5TW1aWq31suCFnMHFi7OlN2rUOpxrL1ro6+kwZPhGvcWdfIP8HmQEqBGq+41++AAAOrLkWnaxvLEVZtg6LQrwFRF6EylFkTT7l1tamGnNd312iTuPMYNSme7Zs+dx78Mj1JL39VdXfkqV3HIMCHR6uBIe2qJvvrrW+PR/bwidO8OwJabdzjz1bUn33JD/b8VsQ+bX5MdFRX+ffxtmsE2pW7IfslumT1Pc7BD4Py+yBABKLv70ky8yq9pZs3CzzvqCq5cl1dPdFwvZAADthd/H/Lv2rvrqDyVd06e1VObnSn5usvwvWdy/Su6am+mUZVnZmQVap+fdOaYAANqSs4cOnMtW6PCZliaam7k/JP+k4Dz7LL/3zL6j/PzhvWev1eqmW5p31RdeSZF33y1Nl/2fR5AHBwCgh5T+v4NHLl0nTYjp0FyRm/5DZq2lh7fAAoZZvOCKRGHCaq797anFfYuPjKoQ7/vkrOSmDmfjPU0lGSkS2R2+zzxrbKzDh/bShAPRXxeS0604ON1UkJFypdrS+9nZM/4LAOja1GP7Tl4pv4NZsnpul/30w39yVdYLF9o9yHB5j4+RtbG9GFHbrj0v/mzeHcfQve8H2GIAQNf+++i+72nor8RDVcgKmjn+W7aEz+vNaFFs1Mmk1FL/9W597UW3vGbaewf2uuEA9C1x1IH0hB/mb46KWjwLALQFp/5+LCej5DWRFwuAvJFdRjkE79i5qre2lVYavTvuclr1s6FCE6BviGOvqmxX7tj5qgAHAFol+fyThCYgnPv2RHnlTMINzO/9fX17oilN+PR44lfp7jsDuAB02XCLt8DY47GOWt1v9MNXX0uRNPHD9u4I5AEAUGWJ0ecqShqX+dsByJNOXJRzV+6IXCXAAaCHzD19KPbsufmumxZbTMi/3OQy1vuxDKhtl1XSwfNf0xtXAMAc/jvET28cRnxB2P7Du/r+XgHAwtnVDqjbqtaBOUz5fkFuvSenmL2bCxswZ2+vvjWw3d3ssS6tug0AADi+m/cf3L1qoBQdW/gMD5pVJA0AdElWoYbtHRYs6C+yx/P//XKHgQuBHoVUKse9Q8MG9oRwC13pBnJZQdMIi7+63NaA64jRq/uNfvh0Fw0mg+0R7hq2+2+b/O0AgC7JzFJaB4QP7I8JZ/HqFULdL9mFzBgM3SjbWACY+rXt6hppi3lDatthAid7TKJX1gN6OpQVpdV1jcpGUtmkqJYDOOivAycGL0UxAMD0S1eZAgANg0Oi0ppbleU1iobGZmVzY92vCgACugGgWdnYgc0RCfUv9GwEDubQ99NA1dU2AxDXE8+VYoPr0mDdpPI2gHWzUnnf4nYCoTkUj/kNjFndb+TDt/X2dbmSmPjx7mIPTw9nkYubyKHvKra5tq4DuhXS84mDe9TdTAFNDS0aNGUZaWKnfrEsmqYBm3ZPf4h+rTj6Vvqx40klLUDY8B3srLjOvjNpsXR8G6MqxcdOXK7qwGbxhE/zuNYiP5wS5wMAQA/d2QP37Yle9O920AC0plHZoD8L7uAqsp0B0EN3do26+MhGr+43xuFbL4v8q5U0LSu/LEuck06bmjv4rt3y5iIu0J1dABSpbBhyj4xwEhEcZnQ+GWNip35cobe2naZ5aG07jfq3gb8zbc53SSWm8zfvD19s3fun1iG9JZbeGc+2lFfFl+WE//t7Bk4y1amlfYk1IbizgFaqlAC2Awu0qZTt/f9tSRDTgF769s6Vw3YjETMtgFY3qwEGn/q4q1W3DzfvPUuOVt1v7MPHOG7+a938AYBSlaQmxCYnJDiKIn2JmRaAzQrYGuk7tf/9R2R017GMqW0nEnF7KjNleifBDXk5tf3/3aNRt9DYbE8v6/6WQVdTXT/ObWl+0wBb5DN34BpBW1M1sF22i4cIU2YkFQ5c89PVaRnlAz8dLJGHI1b7c3atXqNFVWRezqhU0wDAdnHmQ60st0Fvc/lZ5QY8BTJadb8xDp9WFqaLM+R9G8F57oFLhKY0eVsDwHaZy6drsqVNeltqKU1NzqrWjL1LU4GRtbEMqm3nHBAsksV9ezy2OzTImQO3S5MuZlED9xtNeE4C9uX8lMQcwt+JDS03pZcu5bQDjKtEiIOTPZ4lE38vClvKx+nmcolYXNE1MJXrFxqafyTx1N/JBZ4uVpjmVlExxRFaqPof0GT7vBIgOZQS/Rm9dqW3PQc0VTLxt+m11iFey0UAYOsftFh6MunYCXh9hddTGFmVKU4lZ+LQOeZujVLdb6zDp6oyLmdkqLvDQzxssI66kh9SysHKz5UHALYvhPhdOy4+eoJ+ZYWXPU6rKyXfiaXNoggfX+F4vrxHzcgSy6Tadhy/zVuo+ISkb47ndgOYst1/vymsPubYrd6pmPuaTaHauKTThyQAYGoufGFtKBaXOK6zYtwnfHPDidP/ORmVDAAY4Rq01r809j/9kzF+YOQu27TU9OvygjogZi/f+jY/Z3/lwCPVmCAkcit2+mxKbHR67wdcj6DIdUF9Z9EWnusj3zQ7IxZ/fl0MABaC4I3hcO6oAZfco1T3G/3wMeGrWyLa4xK/OZp7DgAAIwQ+68LDnDEAANwt4k8b8S/FSScPiaFvtWHb1vo9+npI44LeBBi3R1XbjiKVzV2YFW/YUwNao1K20Lg1fwJOHPqK6PFsZ43VB9NTGhd5vHzhjkNvDinnTpEqdQfMtOIRw+0M1aJqpabNvKdeXnHc2HX3Rq7uN8bh9y7IIrjWwxTao9tJdUuHQcc7laDEPgyG1LZ7SE1FCedk3FcjAvl9f9mawri/nrju8Id9kX4PfXsM1d17QCixyFg0RXGfnpGSbJcFbg5soJrk+aUKcAjZuSPIgUmN0xMCJRYxgE5V8mNGdqWCvAOYpZVwnq+fr4iL4vo4oMQiCJMY3f1YBGE0lFgEYRKUWARhEpRYBGESlFgEYRKUWARhEpRYBGESlFgEYRKUWARhEpRYBGESlFgEYRIje6N9QqHadsijh94EGK/HUdtucrXkxZ3O4r68Ldh57HmRxwW1seP1GGrbTTIdWVslv9NO9w5ujExNRpZYVNsOYTgjSyyTa9v5BfoSFUkSUhAU6DYwuFt/jbbOGbPsPZb6uvOGjoTUXxgOzDkOC4YWhgOAHm3tz1nSisbWLtzJO8AfDdLCBEaWWADQTWyZLBYYFlcAYD3gyaZGFrfvTF4rzhfOJuBG0sHim/42ham3wa8vsXRt8vGDlyrBWiS0wcjCZElamvvaDyKX83oXp8rEB2PTlRhf6GiFqWU5GempPuG71y/qS7tOcfnoEXEVcAWONjOaJacPlfmIGF9L2ggYX2KBIbXtNMPWtusYqG1Hy5NOXJLPXL5t91oRDgCgLTjzybHzcZeddgXbAVCl8afT1byQ3duDHFgAAGrp8X3/Soh1nLNzOQcAan+IE8txv61/jvBgAwC0FMUePKnsxmwey8EiBjPW+7FTvradpiirRDdKbTu6/McspYV32Kui/nE/2V6vrfLCFFKpHACoosyCdiu/N/riCgBcvzVBArr8Wp4SAHrkUpkK91gV5tHfCTbLc+0KAepxmvqMNbFTv7ZdfSNt4Xh/bbv+/2mure/AZotc9HukLUSudqBuUGh6S+OZO7va66+S4+7Mg4a6RhqgTaFsAVsnkf4ov4SjwMALcuQxMtLEMqBY1ui17Xprxk2/ZwbzGdMBOunO3sJw06fdc3wYC4eeLpoG6KFpAIw1jopzyGNmjIllQFwBCC4HNCplm/5nzcrb/X1DJsRMAmh189DyTqqG3wCzJGb2FYZrJocOfk42kWBOENMBcIKYBpom/Vq0QP9Gqrsn4UiQCWV0iWVMbTsPN9ueytRU+UCFC6o4XaocmM52d+VDrUyqGFyErsrKVWHCeSJsoDBcjl4mqaLMYi0+d66DCQBL5DoHUxZmlesGJneU5FbeX00DmWqMrK+YQbXt+CvCXyiKTjsa1eDtNZsNzZUFv2I2fEzd38pyl4f6XzsqPn4cXg/xehqj6mTic5mtvKBNvmwAAMGKUE9Z7IXjsRAaNJeHtVZKvxPn0oKwYE8cAIDt9/KS1COZscfwtas87adTddlJ4psYAR2P7XgRw6DnisdL/e0ffHdlz/IMXPq04bXtUjNq2G99I4vyNGwBWilLSc2prCUp4Ij8V62ckbb7WH3A/r0hfWXjyKLEeLGkrJkGAFNzW7fl4etCXAaerqBV0nMJ4hy5hgYAwPmLQt5YG+g0+IiFOj8x7nx2eQsNADh/2fo3OCmfJhEbDm9diK5npy6U2HF7VLXtBtG5x7bH/ha0PyrIVv/TdlKt6Zoxy4rAh0uaTqsmKcCtuMNXcKM1Tc13enAub5jqb8gUZGRnxROJuyrmxwWTV9tOp5KeTax2fTPCp//pQVKWXUPjc3n3vBWEWXBsLUZeD4vNtRvlJhZGWPMMLGiLTAUosQ+DxZ/nyZ+kdWPTzOhG6emPq3Pmu9gR0K4oL65UYm7hwZ6oMTRm6Kx4KuuolWVI8ytrW2lsOpvr6Oa33FeIGkTjhhKLIExidPdjEYTRUGIRhElQYhGESVBiEYRJUGIRhElQYhGESVBiEYRJUGIRhElQYhGESVBiEYRJUGIRhEnQuzvjN7Vq2+k6aMwcQ7/ATzr0JsB4Tanadi2ZB6MSa2eHHYhc9lDv9vQoJCfFVU5hm/15E7VrBqKKxcckELAx1GuUd30R1MaO35SqbcfiCe35YM976FdnKWVNZbnF4xihrUVRXkkvRHVExmJkiX1Sa9vhotA/7ZrgdSJTkpEllkG17TSlqaly7rIg+9uZkvy6VozjunSFn8CcJiulGXlVZOcMm3l+KxY59I0LSRZcylTylwUv6BtiRiPPk/5c2aC5Y0bYeyxd7sXvG5BNmSOWUp4hS9nVkvTsOsqMsHH18V08e8RGn1aVSn+urG0iO6dxnBb4+njwhgxESZPlOdn5VeQdwO2cvf18BIT+hfRAZT22jXDeIp97KutRqgJpVrGC7GTZzPdf4W7AF4iA0SUWmFPbrl0uvZpBaBXKXzUO9rjmVl5uTlHtGm/l5QzKzp6gGwvy86TXG3f/b4iDCUBPc9m19HwPz97EKtOO7rtQidm6udhOU5elHZPK/Lf+OdzVHIBuLM5MJWmsWJbaZONih5M30qSStMxXP4hcyb9/79Q5Jz758norm+/iaIX9ViT+PD3V972969z6QttSFBd9Rtpk7iCy54AqPT4zJTMocnuIkAUAQFWID36ersR4wtkcUGbkpKVIVmzcuaZ/WVVm9KHEEort4GRP/CaLP1jpt/BBvhwjZnyJBYbUtgMA6KhW8nbufU+IA1ClcR8fl5zL8tuyJ2KeOQCoM45GncuSVoSEuw5diC5N/aES837vwHo3HAB6SMnx4zk3aijX/rTcysx9duOn2zwJEwDQlsR/En0pLmleVOg9I1b1KApyFOAatvfdZb3VupT/3h91OUka6BZoDQDa3LMJ0jZR+F83+tthAEBViQ9GpySkeu9dxQNdaeLpdPXs0L1b+wrzKSXH932TkOi6L2IeBkBKvhKXmMzf/LdNizkAAFRZ4r7PMgEEk/llPiGM9W7AlK9t10u4bKWwN2e4yGM2Bmw3v7l957dcNzdb0Kpb7u+roe/QYIZBX5tpwvHfGrV7oHEDAEwU+HvP/tNXtvvvV3mxVLnZ8ntXY8IPjNx36P1l/cX1wFYkmAmk8jYAAJCy9NIu4UtreuMKALhTyJb3N4bMwwGAKszMaReErBsszGf7fKi/tTZfVkkDgCpPKqddAtcu7h8lEnddFeo5tFY1MgKjbGMBYMrXtgMAAAy30PsHMh1azKr3bLy7C+CeglfOAT5W0Rkn/1Q3d+E8Z1fRXJdnOLj+LzNHMGR4N3yOEw8KGhopENxfLIEm5eWV8tp6sqFF1VgjV3dPc+wBAIC6ulqwCnTWr+uOcZ09e+9pKW810j1QlprYOnjJ0FVLA3Vb1QpuM+vrlMALfEb/yze3d7SBIoO+FCNnpIllRLGs8TJ3efMvux3TJLLSEkmi5DJgHLfQ9RGD1QCmYUMftDDDzQDorvsaa23B2ZjTGQoKt3Kwt7Gx5i98FmtNq+mdRnd1AGAzRhgpnb5LQTeQKtWQdXJE7jzCDADoLgDMbOjvjBmGAaB7O2MzxsQ+0XHtZe7gExLhEwJAa+TZ575ITDyT7LIv1KE3qC3NJA22g4UtSeVvgNmz7/0+qpITf1LZBu+IXNXf9srF0v7EYmwrHOqUt2mwHqY/jfgdATg/7P0I92E72wgChxq1mga9+8etJAmARnYdm9FdxzKltt34aeTSSykFfUXtMEKwLMjDClrIxoFKk+03sm8MVsSiK2QFzZjQ2fGecNEtmlbgeSwcPFVW/ypvHVjJHJGLuTb/p+uD5TB7FKnH9h+8JAcAW1cRV1eama/XTdCjKkhOL1B0AADMnuvC6ijOKh18UIOW5xQ2P+yBGwcja2MZVNtu3Hoa8yVJ1RUUrFkmJEBdlZmY04w5rXAZSKQF1HwTk9gR4jcbp+pk4guZauuATT73XtJjsx0dTK5LL6U7BM93YHXUFqYlpioG/2BYniEvCUrOJ0SfoUKfF3GALElNFJeCnz8fAMBpZahHUezZI7HtIQGufJxWlaQmiotoHztfLz4A7hn0Ir/g+4Tos1ToMkfibmNOsrgApnifwlRhZInFuRP2uC+LPR0AKr/96/Ycw2vbaQHY+CSf+83yXb+hOfZf6cf2pQP01rwLiVyn97zxLN/wl7Ti+KOpFABghHPA1j+GCu8/BuuATW+rYr4WR+8VAwBmPT/s1SWp/5INTLddsSWyOz4uOTE6CwAAsxD4rX873LX3h4G9eMMHnecSxBdO5vY2ywTfb11EuEfftbTDy1u2dickXDl7MAMAMNtn12x56fq+eFS/dmzoTYBxe/S17R4ITTU1q3Uw04pHDJ5T0AWx24/dDtofFWSr0yqbKIxtxSVGfbCjp0PdSFKmhO1Ixe96OtSNJG1KDF8dT6dVNmmARXCth5tKd6ibSBrn2Q5fdw8ZhpG1sRNpkmvbPSwMt+Y5jDKdxbblG3AiamLOtRu1GNjoM4y+FWyslSP3QYl9GJNZ2w5BhoMSa1QwjusSf3v+jMe9H8i4oetYBGESo7sfiyCMhhKLIEyCEosgTIISiyBMghKLIEyCEosgTIISiyBMghKLIEyCEosgTIISiyBMghKLIExirG8C6GouHYn+plA95E057OnADw9smPcIXl41DCpXh9zHSN8EUMS9vmJfke7+CbN8dn15akqEdqLK1SFPFiNtY6sra4aJKwC05Ox/fckpLnv6/ZPYwuffjdprYBkBujRhn/iO/web/cY7fNGElatDnihGmtjR6EYqTFcfv8vSZ3l0oCEDu/V0qFUqTXvn+HcDlatDhmPMieWu+9ePe30MOwHuVse/vSQqt17xG8BYiaUq0pNkpY0ArTniBA2H67YicB6blmeK86b5BIs00vRsucbuhYhgZwwAoF1RkFNUVk/e6TLjihb5PSvi9u3RkHJ1fTXpfPDyqxl59ZQZYePht9zLDlW+MDpMSCylVqiHP4cFFtuaxx7/RSdm8KKmYPhW6HZS2aS50w10W7OysQtmdwIAdbMo9SqlbEgqr8MdbIiZNAAArUiPPiouv2sldOYT0Jx7/mjqj0E7PwwRsu4pV0c3Fmem3tZQ10rLTe3tCajLyZNKZcGRu0Kd0FmzcWFCYrvqL+1453D+fWeq055edTjhaPCUG+eWWBgWOS8v+n/iNC9u3LlSrzJNt6IWj9h/aBG3L2V0bV6RkrVo80cRvTWj6KrEqE/Tk/JXRPoO13gqSlvX/nm/Pw8DgJasY3vPpibLgt73fbJHX0buwYRbB2zPLV98sX3h0GT2xXWKl5McypQf8MpAXAEAE76647P9EQMl3rDZIvtpNNlIDr84sSDIr78japb3snnmdKNC2TO5u4xMNUxoY6EvtPBOf0vLxLgCAODE/W0nRVZXVFYrVMomUl0vr9bBzO4RCkaxrfSGFsZwFgbdqLaU0WFIYkEvtNfZzIzrMNRZcZ98nafuMefy7e25POGznpCaOUILiyAATEos9IY2Ye4v3Od9JqwWx+OkKxKfz7vzTNj+zctse/u1ekpjUWKRUTEqsQDAdn3e53HvgyF6+wd6ukabh9JqdODg4Wnb3w1N11XWjdApjiC9mNDzxESmVrZWUJt9KTWnqLpphItNQiC0hmrJBUmZSk2S1fkpx05mPWAZH8ToMK2NnSAEzgLQZn8euc3QKjg6RSUATDf05q+JIGRdSO3plMTT14nl2z57UzTcPPyQjWHqk+KE6DwAAJznt2aV17eJNQbuEWKUjPRNAF3RkdB1n/9y58GW4q6M/iEm+EGuoWlK0wE4Gx/tMQeaalKpdeZcHmfU2RAEwGgTCwA6dc0v1U13u8ees9d0gj933tNT4KUexKgZb2IRhIlQzxOCMAlKLIIwCUosgjAJSiyCMAlKLIIwCUosgjAJSiyCMAlKLIIwCUosgjAJSiyCMAlKLIIwCUosgjAJSiyCMImRvtE+IbT5p/efyKzSDKmPR7i/c3D3i0/EOFTIVITethsvXcaHfhvODzPKC0v4WvTXBxkY2pa8uNNZ3Je3BTs/7j1BRoba2PFS11S1DDtBV/3tewEZTxPDvPzO4i547S8fr18w5coYAACAjqytkt9ppwHQWBhTl5Eltv5KfJnruhcnfazjkcrjKer/8VfH5f/e6jjZO4A8qYwssbrqb7YfKDyYcNTAMrBjWholO/Mm19Swjefsfe4PZxX1CgBDE0s3lUql16vITjOOyC/Ql6hIkpCCoEC3gRrQlKJImv3LLW3njFn2Hkt93XlDiw5o5Lk/ycoaKTDnOCxY4ufKGdJ69mhrf86SVjS2duFO3gH+HECmPiNLLADo6i9tCweYqNCywLC4AgDrAU82NbK4fWfyWnG+cDYBN5IOFt/0tylMvQ1+fYmla5OPH7xUCdYioQ1GFiZL0tLc134QuZzXuzhVJj4Ym67E+EJHK0wty8lIT/UJ371+UV/adYrLR4+Iq4ArcLSZ0Sw5fajMR4Rqgkx9xpdYAOia2NBODk1e/Nm8O46he98PsMUAgK7999F933eAXd90Wp504pJ85vJtu9eKcAAAbcGZT46dj7vstCvYDoAqjT+druaF7N4e5MACAFBLj+/7V0Ks45ydyzkAUPtDnFiO+239c4QHGwCgpSj24EllN2bzWA4WMZix3o/tqr+0LTwqY9iLzSlBU5RVouP5r+mNKwBgDv8d4jc4ujJd/mOW0sI77FVRfzVKttdrq7wwhVQqBwCqKLOg3crvjb64AgDXb02QgC6/lqcEgB65VKbCPVaFefR3gs3yXLtCgHqcpj5jTSwAe/5rq7ynZqctAICyvpG2cHS10/sIEzjZD2Squba+A5stctHvkbYQudqBukGhAVDWNdLmzq72+qvkuDvzoKGukQZoUyhbwNZJpF97lnAUGHhBjjxGRppY9sIPznz57oKpXCyZpgGbdk+jhw38fw/d2QUw/Z4ZzGdMB+ikOwHouxRMn3bP8WEsHHq6aBqgh6YBsHsurDEMtbFTnzEmlgFxBSC4HNColG36nzUrb/f3DZkQMwmg1c2aIQupGn4DzJKYCUD8joC2ZnLI41hANpFgThDTAXCCmAaapiFl9OjfSLXB460jj4vRJZZYxIC4AoCth5ttT2Vqqpzq/4QqTpcqB6az3V35UCuTKgYXoauyclWYcJ4IA7Cd58btqszM0cskVZRZrMXnznUwAWCJXOdgysKs8sFSeh0luZUUIFOdkfUV27x29BSXO+XjCgDAXxH+QlF02tGoBm+v2Wxoriz4FbPhY+r+Vpa7PNT/2lHx8ePweojX0xhVJxOfy2zlBW3yZQMACFaEespiLxyPhdCguTystVL6nTiXFoQFe+IAAGy/l5ekHsmMPYavXeVpP52qy04S38QI6Hhsx4sYBj1XPF7qb//guyt7lmfgUoOL8bSUpWbUsN/6RhbladgCtFKWkppTWUtSwBH5r1o5I233sfqA/XtDbHunk0WJ8WJJWTMNAKbmtm7Lw9eFuAw8XUGrpOcSxDlyDQ0AgPMXhbyxNtBp8BELdX5i3Pns8hYaAHD+svVvcFI+TSI2HN66EF3PTl0oseOmvrRl1bbkByz4OsN1S/w32z3HV3CLzj22Pfa3oP1RQbb6n7aTak3XjFlWxLC18XRaNUkBbsWdNWwOaU1T850enMtjo5gygpGdFU8k7qqYHxfcKFMMfdtuNKbTrZ09hQZWrNWppGcTq13fjPDpf3qQlGXX0Phc3j1vBWEWHFuLkdfDYnPtRrmJhRHWPGLkychUgxL7MFj8eZ78SVo3Ns2MbpSe/rg6Z76LHQHtivLiSiXmFh7siRpDY4bOiqeyjlpZhjS/sraVxqazuY5ufst9hahBNG4osQjCJEZ3PxZBGA0lFkGYBCUWQZgEJRZBmAQlFkGYBCUWQZgEJRZBmOT/BxAuMTjCznNOAAAAAElFTkSuQmCC)\n",
        "\n",
        "In the example above, `transistor` is the dataset root. It will contain a `train` folder and a `test` folder.\n",
        "\n",
        "In the `train` folder, it only contains `good` folder. Inside of `good` folder, there are normal images (OK).\n",
        "\n",
        "In the `test` folder, it contains `good` and other anomaly folders. Since, we don't care about these anomaly classes. We can specify only a `anomaly` folder, or whatever the name that you want. In short, `test` will contain `good` and `anomaly` folder. Inside of `good`, there are normal images. Inside of `anomaly` folder, there are abnormal (NG) images."
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import random\n",
        "from random import sample\n",
        "import argparse\n",
        "import numpy as np\n",
        "import os\n",
        "import pickle\n",
        "import glob\n",
        "from tqdm import tqdm\n",
        "from collections import OrderedDict\n",
        "from sklearn.metrics import roc_auc_score, accuracy_score\n",
        "from sklearn.metrics import roc_curve\n",
        "from sklearn.metrics import precision_recall_curve\n",
        "from sklearn.covariance import LedoitWolf\n",
        "from scipy.spatial.distance import mahalanobis\n",
        "from scipy.ndimage import gaussian_filter\n",
        "from skimage import morphology\n",
        "from skimage.segmentation import mark_boundaries\n",
        "import matplotlib.pyplot as plt\n",
        "import matplotlib\n",
        "import torchvision\n",
        "import pandas as pd\n",
        "from PIL import Image\n",
        "from dotmap import DotMap\n",
        "import yaml\n",
        "import torch\n",
        "from torch.utils.data import DataLoader, Dataset\n",
        "import torch.nn.functional as F\n",
        "from torchvision.models import wide_resnet50_2, resnet18, ResNet18_Weights, Wide_ResNet50_2_Weights\n",
        "from torchvision import transforms\n",
        "\n",
        "device = 'cuda' if torch.cuda.is_available() else 'cpu'"
      ],
      "metadata": {
        "id": "zrLcj1Nm9c2b"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OD9Br8QiGGxk"
      },
      "source": [
        "### Import, define model"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "58a8jN_BSsex"
      },
      "outputs": [],
      "source": [
        "def denormalization(x):\n",
        "    mean = np.array([0.485, 0.456, 0.406])\n",
        "    std = np.array([0.229, 0.224, 0.225])\n",
        "    x = (((x.transpose(1, 2, 0) * std) + mean) * 255.).astype(np.uint8)\n",
        "\n",
        "    return x\n",
        "\n",
        "\n",
        "def embedding_concat(x, y):\n",
        "    B, C1, H1, W1 = x.size()\n",
        "    _, C2, H2, W2 = y.size()\n",
        "    s = int(H1 / H2)\n",
        "    x = F.unfold(x, kernel_size=s, dilation=1, stride=s)\n",
        "    x = x.view(B, C1, -1, H2, W2)\n",
        "    z = torch.zeros(B, C1 + C2, x.size(2), H2, W2).to(x.device)\n",
        "    for i in range(x.size(2)):\n",
        "        z[:, :, i, :, :] = torch.cat((x[:, :, i, :, :], y), 1)\n",
        "    z = z.view(B, -1, H2 * W2)\n",
        "    z = F.fold(z, kernel_size=s, output_size=(H1, W1), stride=s)\n",
        "\n",
        "    return z"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ogaQkNcLW6Ce"
      },
      "source": [
        "#### Load train and test dataset"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ljIhalqcSw5Q"
      },
      "outputs": [],
      "source": [
        "class TrainDataset(Dataset):\n",
        "    def __init__(self, root, tfms=None):\n",
        "        super(TrainDataset, self).__init__()\n",
        "        self.tfms = transforms.Compose(\n",
        "            [\n",
        "                transforms.Resize([224, 224], Image.ANTIALIAS),\n",
        "                transforms.ToTensor(),\n",
        "                transforms.Normalize(\n",
        "                    mean=[0.485, 0.456, 0.406],\n",
        "                    std=[0.229, 0.224, 0.225]\n",
        "                )\n",
        "            ]\n",
        "        ) if tfms is None else tfms\n",
        "\n",
        "        self.datas = self.read_data(root)\n",
        "\n",
        "    def __getitem__(self, idx):\n",
        "        img = Image.open(self.datas[idx]).convert('RGB')\n",
        "        img = self.tfms(img)\n",
        "        return img\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self.datas)\n",
        "\n",
        "    def get_labels(self):\n",
        "        return np.arange(len(self.datas)).tolist()\n",
        "\n",
        "    def read_data(self, root):\n",
        "        imgs = glob.glob(os.path.join(root, 'train', 'good', '*'))\n",
        "        return imgs\n",
        "\n",
        "class TestDataset(Dataset):\n",
        "    def __init__(self, root, tfms=None):\n",
        "        super(TestDataset, self).__init__()\n",
        "        self.tfms = transforms.Compose(\n",
        "            [\n",
        "                transforms.Resize([224, 224], Image.ANTIALIAS),\n",
        "                transforms.ToTensor(),\n",
        "                transforms.Normalize(\n",
        "                    mean=[0.485, 0.456, 0.406],\n",
        "                    std=[0.229, 0.224, 0.225]\n",
        "                )\n",
        "            ]\n",
        "        ) if tfms is None else tfms\n",
        "\n",
        "        self.datas = self.read_data(root)\n",
        "\n",
        "    def __getitem__(self, idx):\n",
        "        img = Image.open(self.datas[idx][0]).convert('RGB')\n",
        "        img = self.tfms(img)\n",
        "        label = self.datas[idx][1]\n",
        "        return img, label\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self.datas)\n",
        "\n",
        "    def read_data(self, root):\n",
        "        ims, labels = [], []\n",
        "        cls_idx = None\n",
        "        for cls in os.listdir(os.path.join(root, 'test')):\n",
        "            im_paths = sorted(glob.glob(os.path.join(root, 'test', cls, '*')))\n",
        "            if cls == 'good': cls_idx = 0\n",
        "            else: cls_idx = 1\n",
        "            all_labels = [tuple([imp, cls_idx]) for imp in im_paths]\n",
        "            ims.extend(all_labels)\n",
        "            # if cls == 'good': labels.extend([0] * len(im_paths))\n",
        "            # else: labels.extend([1] * len(im_paths))\n",
        "        return ims"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "E0FBzs6bW6Cf"
      },
      "source": [
        "#### Padim"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Llg7kCUg_xtr"
      },
      "outputs": [],
      "source": [
        "class PaDiM():\n",
        "    def __init__(self, args) -> None:\n",
        "        self.input_size = (args.MODEL.INPUT_SIZE, args.MODEL.INPUT_SIZE)\n",
        "        self.device = args.TRAIN.DEVICE\n",
        "        self.save_dir = args.TRAIN.SAVE_DIR\n",
        "        self.checkpoint_path = args.INFERENCE.CHECKPOINT_PATH\n",
        "\n",
        "        if args.TRAIN.PRETRAINED:\n",
        "            self.backbone = resnet18(weights=ResNet18_Weights.IMAGENET1K_V1).to(self.device)\n",
        "        else:\n",
        "            self.backbone = resnet18().to(self.device)\n",
        "\n",
        "        self.t_d = 448\n",
        "        # random pick features\n",
        "        self.d = args.INFERENCE.REDUCE_FEATURES\n",
        "        self.backbone.eval()\n",
        "        self.idx = torch.tensor(sample(range(0, self.t_d), self.d)).to(self.device)\n",
        "\n",
        "        self.output_layers = list()\n",
        "\n",
        "        self.backbone.layer1[-1].register_forward_hook(self.hooks)\n",
        "        self.backbone.layer2[-1].register_forward_hook(self.hooks)\n",
        "        self.backbone.layer3[-1].register_forward_hook(self.hooks)\n",
        "\n",
        "        self.distribution = None\n",
        "        self.threshold = None\n",
        "        self.max_score = None\n",
        "        self.min_score = None\n",
        "\n",
        "    def predict(self, data):\n",
        "        '''\n",
        "            data [torch.Tensor]: input data which has shape (batch, C, H, W)\n",
        "                H, W    = (224, 224)\n",
        "                C       = 3\n",
        "                batch   = 1\n",
        "        '''\n",
        "        self.backbone.eval()\n",
        "\n",
        "        outputs = OrderedDict([('layer1', []), ('layer2', []), ('layer3', [])])\n",
        "\n",
        "        with torch.no_grad():\n",
        "            _ = self.backbone(data.to(self.device))\n",
        "\n",
        "        for k, v in zip(outputs.keys(), self.output_layers):\n",
        "            outputs[k].append(v.detach())\n",
        "\n",
        "        self.output_layers.clear()\n",
        "\n",
        "        for k, v in outputs.items():\n",
        "            outputs[k] = torch.cat(v, 0)\n",
        "\n",
        "        # Embedding concat\n",
        "        embedding_vectors = outputs['layer1']\n",
        "        for layer_name in ['layer2', 'layer3']:\n",
        "            embedding_vectors = embedding_concat(embedding_vectors, outputs[layer_name])\n",
        "\n",
        "        # randomly select d dimension\n",
        "        embedding_vectors = torch.index_select(embedding_vectors, 1, self.idx)\n",
        "        # calculate distance matrix\n",
        "        B, C, H, W = embedding_vectors.size()\n",
        "        embedding_vectors = embedding_vectors.view(B, C, H * W)\n",
        "        dist_list = []\n",
        "        for i in range(H * W):\n",
        "            mean = self.distribution[0][:, i]\n",
        "            conv_inv = torch.linalg.inv(self.distribution[1][:, :, i])\n",
        "            dist = [self.mahalanobis_torch(sample[:, i], mean, conv_inv) for sample in embedding_vectors]\n",
        "            dist_list.append(dist)\n",
        "\n",
        "        dist_list = torch.tensor(dist_list).transpose(1, 0).reshape(B, H, W)\n",
        "\n",
        "        # upsample\n",
        "        score_map = F.interpolate(dist_list.unsqueeze(1), size=data.size(2), mode='bilinear',\n",
        "                                    align_corners=False).squeeze(1).numpy()\n",
        "\n",
        "        # apply gaussian smoothing on the score map\n",
        "        for i in range(score_map.shape[0]):\n",
        "            score_map[i] = gaussian_filter(score_map[i], sigma=4)\n",
        "\n",
        "        # Normalization\n",
        "        # self.max_score = score_map.max()\n",
        "        # self.min_score = score_map.min()\n",
        "        scores = (score_map - self.min_score) / (self.max_score - self.min_score)\n",
        "\n",
        "        return scores\n",
        "\n",
        "    def train(self, dataloader):\n",
        "        self.backbone.eval()\n",
        "        train_outputs = OrderedDict([('layer1', []), ('layer2', []), ('layer3', [])])\n",
        "\n",
        "        for img in dataloader:\n",
        "            img = img.to(self.device)\n",
        "\n",
        "            with torch.no_grad():\n",
        "                _ = self.backbone(img)\n",
        "\n",
        "            for k, v in zip(train_outputs.keys(), self.output_layers):\n",
        "                train_outputs[k].append(v.detach())\n",
        "\n",
        "            self.output_layers.clear()\n",
        "\n",
        "        for k, v in train_outputs.items():\n",
        "            train_outputs[k] = torch.cat(v, 0)\n",
        "\n",
        "        # Embedding concat\n",
        "        embedding_vectors = train_outputs['layer1']\n",
        "        for layer_name in ['layer2', 'layer3']:\n",
        "            embedding_vectors = embedding_concat(embedding_vectors, train_outputs[layer_name])\n",
        "\n",
        "        # randomly select d dimension\n",
        "        embedding_vectors = torch.index_select(embedding_vectors, 1, self.idx)\n",
        "        # calculate multivariate Gaussian distribution\n",
        "        B, C, H, W = embedding_vectors.size()\n",
        "        embedding_vectors = embedding_vectors.view(B, C, H * W)\n",
        "        mean = torch.mean(embedding_vectors, dim=0)\n",
        "        cov = torch.zeros(C, C, H * W).to(self.device)\n",
        "        I = torch.eye(C).to(self.device)\n",
        "        for i in range(H * W):\n",
        "            # cov[:, :, i] = LedoitWolf().fit(embedding_vectors[:, :, i].numpy()).covariance_\n",
        "            cov[:, :, i] = torch.cov(embedding_vectors[:, :, i].T) + 0.01 * I\n",
        "        # save learned distribution\n",
        "        self.distribution = [mean, cov]\n",
        "\n",
        "    def evaluate(self, dataloader):\n",
        "        self.backbone.eval()\n",
        "        test_outputs = OrderedDict([('layer1', []), ('layer2', []), ('layer3', [])])\n",
        "\n",
        "        gt_list = list()\n",
        "\n",
        "        for img, label in dataloader:\n",
        "            img = img.to(self.device)\n",
        "\n",
        "            with torch.no_grad():\n",
        "                _ = self.backbone(img)\n",
        "\n",
        "            for k, v in zip(test_outputs.keys(), self.output_layers):\n",
        "                test_outputs[k].append(v.detach())\n",
        "\n",
        "            gt_list.extend(label.cpu().detach().numpy())\n",
        "\n",
        "            self.output_layers.clear()\n",
        "\n",
        "        for k, v in test_outputs.items():\n",
        "            test_outputs[k] = torch.cat(v, 0)\n",
        "\n",
        "        # Embedding concat\n",
        "        embedding_vectors = test_outputs['layer1']\n",
        "        for layer_name in ['layer2', 'layer3']:\n",
        "            embedding_vectors = embedding_concat(embedding_vectors, test_outputs[layer_name])\n",
        "\n",
        "        # randomly select d dimension\n",
        "        embedding_vectors = torch.index_select(embedding_vectors, 1, self.idx)\n",
        "        # calculate distance matrix\n",
        "        B, C, H, W = embedding_vectors.size()\n",
        "        embedding_vectors = embedding_vectors.view(B, C, H * W)\n",
        "        dist_list = []\n",
        "        for i in range(H * W):\n",
        "            mean = self.distribution[0][:, i]\n",
        "            conv_inv = torch.linalg.inv(self.distribution[1][:, :, i])\n",
        "            dist = [self.mahalanobis_torch(sample[:, i], mean, conv_inv) for sample in embedding_vectors]\n",
        "            dist_list.append(dist)\n",
        "\n",
        "        dist_list = torch.tensor(dist_list).transpose(1, 0).reshape(B, H, W)\n",
        "\n",
        "        # upsample\n",
        "        score_map = F.interpolate(dist_list.unsqueeze(1), size=self.input_size[0], mode='bilinear',\n",
        "                                    align_corners=False).squeeze().numpy()\n",
        "\n",
        "        # apply gaussian smoothing on the score map\n",
        "        for i in range(score_map.shape[0]):\n",
        "            score_map[i] = gaussian_filter(score_map[i], sigma=4)\n",
        "\n",
        "        # Normalization\n",
        "        self.max_score = score_map.max()\n",
        "        self.min_score = score_map.min()\n",
        "        scores = (score_map - self.min_score) / (self.max_score - self.min_score)\n",
        "\n",
        "        # calculate image-level ROC AUC score\n",
        "        img_scores = scores.reshape(scores.shape[0], -1).max(axis=1)\n",
        "        gt_list = np.asarray(gt_list)\n",
        "        img_roc_auc = roc_auc_score(gt_list, img_scores)\n",
        "        # self.threshold = self.find_optimal_threshold(gt_list, img_scores)\n",
        "        # print(\"Optimal threshold is:\", self.threshold)\n",
        "        return img_roc_auc\n",
        "\n",
        "    def mahalanobis_torch(self, u, v, cov):\n",
        "        delta = u - v\n",
        "        m = torch.dot(delta, torch.matmul(cov, delta))\n",
        "        return torch.sqrt(m)\n",
        "\n",
        "    # def find_optimal_threshold(self, gt_list, img_scores):\n",
        "    #     precision, recall, thresholds = precision_recall_curve(gt_list, img_scores)\n",
        "    #     a = 2 * precision * recall\n",
        "    #     b = precision + recall\n",
        "    #     f1 = np.divide(a, b, out=np.zeros_like(a), where=b != 0)\n",
        "    #     threshold = thresholds[np.argmax(f1)]\n",
        "    #     return threshold\n",
        "\n",
        "    def save_checkpoint(self, filename):\n",
        "        ckp = {\n",
        "            \"max_score\": self.max_score,\n",
        "            \"min_score\": self.min_score,\n",
        "            \"threshold\": self.threshold,\n",
        "            \"idx\": self.idx,\n",
        "            \"dist\": self.distribution\n",
        "        }\n",
        "        path = os.path.join(self.save_dir, filename)\n",
        "        torch.save(ckp, path)\n",
        "        # with open(path, 'wb') as f:\n",
        "        #     pickle.dump(ckp, f)\n",
        "\n",
        "    def load_checkpoint(self):\n",
        "        # with open(self.checkpoint_path, 'rb') as f:\n",
        "        #     ckp = pickle.load(f)\n",
        "        ckp = torch.load(self.checkpoint_path, map_location=self.device)\n",
        "        self.max_score = ckp['max_score']\n",
        "        self.min_score = ckp['min_score']\n",
        "        self.threshold = ckp['threshold']\n",
        "        self.idx = ckp['idx']\n",
        "        self.distribution = ckp['dist']\n",
        "\n",
        "    def hooks(self, module, input, output):\n",
        "        self.output_layers.append(output)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4Qi6_ylmGPPy"
      },
      "source": [
        "### Config\n",
        "\n",
        "INPUT_SIZE: size of image data\n",
        "\n",
        "EPOCH: number of epoch\n",
        "\n",
        "BATCH_SIZE: number of batchsize\n",
        "\n",
        "PRETRAINED (bool): use pretrained vgg to extract features\n",
        "\n",
        "DEVICE: \"cpu\" or \"cuda\"\n",
        "\n",
        "DATA_DIR: path to your dataset\n",
        "\n",
        "SAVE_DIR: path of directory to save checkpoint file (weight file)\n",
        "\n",
        "CHECKPOINT_PATH: path to checkpoint file so model can load and run inference\n",
        "\n",
        "REDUCE_FEATURE: reduce number of features to this number"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GZZQ-ENpX_vo",
        "outputId": "2d0e40d4-0fce-452e-954e-c2376266bf06"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4UsC33sLAc4q",
        "outputId": "760cc232-e55e-42a5-9d84-e4d8b1dd5f66"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Writing /content/config.yaml\n"
          ]
        }
      ],
      "source": [
        "%%writefile /content/config.yaml\n",
        "MODEL:\n",
        "  INPUT_SIZE: 224\n",
        "TRAIN:\n",
        "  EPOCH: 5\n",
        "  BATCH_SIZE: 16\n",
        "  PRETRAINED: True\n",
        "  DEVICE: \"cpu\"\n",
        "\n",
        "\n",
        "  DATA_DIR: \"/content/drive/MyDrive/hazelnut\"\n",
        "  SAVE_DIR: \"/content/drive/MyDrive/hazelnut\"\n",
        "  SAVE_DIR: \"/content\"\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "INFERENCE:\n",
        "  CHECKPOINT_PATH: \"/content/hazelnut.pt\"\n",
        "  REDUCE_FEATURES: 100"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "1JYdYoTTAum5"
      },
      "outputs": [],
      "source": [
        "def read_args(filename):\n",
        "    with open(filename) as f:\n",
        "        cf = yaml.safe_load(f)\n",
        "    f.close()\n",
        "    args = DotMap(cf)\n",
        "    return args\n",
        "\n",
        "args = read_args(\"/content/config.yaml\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aDqLI9n0S9Cm",
        "outputId": "4932fb85-2876-4263-9343-8c4168409c85"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Size of training set:  300\n",
            "Size of testing set:  162\n"
          ]
        }
      ],
      "source": [
        "tfms = transforms.Compose(\n",
        "            [\n",
        "                transforms.Resize([224, 224], Image.ANTIALIAS),\n",
        "                transforms.ToTensor(),\n",
        "                transforms.Normalize(\n",
        "                    mean=[0.485, 0.456, 0.406],\n",
        "                    std=[0.229, 0.224, 0.225]\n",
        "                )\n",
        "            ]\n",
        ")\n",
        "\n",
        "train_set = TrainDataset(root=args.TRAIN.DATA_DIR, tfms=tfms)\n",
        "test_set = TestDataset(root=args.TRAIN.DATA_DIR, tfms=tfms)\n",
        "\n",
        "train_dl = DataLoader(train_set, batch_size=args.TRAIN.BATCH_SIZE, num_workers=os.cpu_count(),\n",
        "                      shuffle=True, pin_memory=True, drop_last=False)\n",
        "\n",
        "test_dl = DataLoader(test_set, batch_size=args.TRAIN.BATCH_SIZE, num_workers=os.cpu_count(),\n",
        "                     shuffle=False, pin_memory=True)\n",
        "\n",
        "print('Size of training set: ', len(train_set))\n",
        "print('Size of testing set: ', len(test_set))  # solo deje damaged case"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "S2k-fpaOTd9c",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "79221dc4-3206-45c3-b702-663606e86731"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Downloading: \"https://download.pytorch.org/models/resnet18-f37072fd.pth\" to /root/.cache/torch/hub/checkpoints/resnet18-f37072fd.pth\n",
            "100%|██████████| 44.7M/44.7M [00:00<00:00, 65.5MB/s]\n"
          ]
        }
      ],
      "source": [
        "model = PaDiM(args)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "tv55IUl0CQfD"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "tj3xiPbZEMe1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8c32d30e-f32f-467d-d195-5272c69b037b"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "ROC AUC score: 0.7666615830410248\n",
            "Max score: 31.810404 Min score 0.1631401\n"
          ]
        }
      ],
      "source": [
        "# train y salva modelo entrenado como hazelnut.pt\n",
        "model.train(train_dl)\n",
        "\n",
        "# test\n",
        "roc_auc = model.evaluate(test_dl)\n",
        "\n",
        "print(\"ROC AUC score:\", roc_auc)\n",
        "\n",
        "#model.save_checkpoint(filename=f'train_transistor_{roc_auc:.2f}.pt')  # train_transistor_0.92.pt\n",
        "\n",
        "model.save_checkpoint(filename=f'hazelnut.pt')  # hazelnut.pt  roc_auc agnostico.\n",
        "# /content/drive/MyDrive/transistor/hazelnut.pt\n",
        "\n",
        "print('Max score:', model.max_score, 'Min score', model.min_score)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "h_ytRThwm6zs"
      },
      "source": [
        "### Test"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "uSRLyQcftwdE"
      },
      "outputs": [],
      "source": [
        "test_model = PaDiM(args)\n",
        "test_model.load_checkpoint()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "WuGZZAQ5Sri2",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 379
        },
        "outputId": "459c02a8-71df-4c98-c1f4-df50ef6e2804"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Anomaly:  True\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1500x1500 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "threshold = 0.4\n",
        "\n",
        "path = '/content/drive/MyDrive/hazelnut/test/bad/0 (28).PNG'\n",
        "\n",
        "infer_tfms = transforms.Compose(\n",
        "            [\n",
        "                transforms.Resize([224, 224]),\n",
        "                transforms.ToTensor(),\n",
        "                transforms.Normalize(\n",
        "                    mean=[0.485, 0.456, 0.406],\n",
        "                    std=[0.229, 0.224, 0.225]\n",
        "                )\n",
        "            ]\n",
        ")\n",
        "\n",
        "img_ = Image.open(path).convert('RGB')\n",
        "img = tfms(img_)\n",
        "img = img.unsqueeze(0)\n",
        "\n",
        "scores = test_model.predict(img)\n",
        "\n",
        "pred = np.any(scores > threshold)\n",
        "print(\"Anomaly: \", pred)\n",
        "\n",
        "mask = np.where(scores > threshold, 1, 0)\n",
        "\n",
        "vis_img = img_.resize((224, 224))\n",
        "\n",
        "f, axarr = plt.subplots(1,2, figsize=(15, 15))\n",
        "axarr[0].imshow(vis_img)\n",
        "axarr[1].imshow(mask.squeeze(0))\n",
        "axarr[1].imshow(vis_img, alpha = 0.75)\n",
        "# axarr[2].imshow(true_mask)\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!python --version"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CvGSSkEdUwI3",
        "outputId": "9317c527-6e67-4a8e-96b2-05b647c017ba"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Python 3.10.12\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "95Bf86UYxgmh"
      },
      "outputs": [],
      "source": []
    }
  ],
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "T4",
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}