asl-classification-using-cnns-keras-99-89-acc.ipynb

{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"pygments_lexer":"ipython3","nbconvert_exporter":"python","version":"3.6.4","file_extension":".py","codemirror_mode":{"name":"ipython","version":3},"name":"python","mimetype":"text/x-python"}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"![image.png](attachment:1ab55413-4202-4bf2-9d8d-7dcb61ddc21c.png) \n\nThe American Sign Language consists of 29 different signs for the 26 alphabets, space, delete and nothing. This notebook performs image classification on these 29 classes and is trained on the ASL dataset consisting of over 70,000 sign language images. ","metadata":{},"attachments":{"1ab55413-4202-4bf2-9d8d-7dcb61ddc21c.png":{"image/png":"iVBORw0KGgoAAAANSUhEUgAAAU8AAACWCAIAAADR6Z32AAAMO2lDQ1BJQ0MgUHJvZmlsZQAASImVVwdYU8kWnltSIbRABKSE3gQB6UgJoQUQkCrYCEmAUGIMBBU7sqjAWlARARtWxLYWQNaK2FkUe18QUVHWRV3s5U0K6LKvfG++79z575kz/zlz7pQ7AKif5IrF2agGADmiPElMSABzQlIyk/QEkAEJUIEG0ODycsWs6OgIAMtg/ffy9iZAZPU1exnXP9v/a9HkC3J5ACDREKfyc3k5EB8CAK/hiSV5ABBlerMZeWIZhgK0JTBAiJfIcLoC18hwqgLvl9vExbAhbgWArMrlStIBULsC9cx8XjrkUOuH2FHEF4oAUGdC7JuTM40PcQrE1tBGDLGM3yP1B570v3GmDnFyuelDWDEWeSEHCnPF2dxZ/2c6/nfJyZYO+rCEopohCY2RjRnm7XbWtHAZVoW4T5QaGQWxFsTvhXy5PcQoNUMaGq+wRw14uWyYM8CA2JHPDQyH2ADiYFF2ZIRSn5omDOZADGcIOlOYx4mDWBfiJYLcoFilzSbJtBilL7QhTcJmKfXnuRK5X5mvh9KseJaS/3WGgKPkx9QKMuISIaZCbJ4vTIiEWA1ih9ys2HClzdiCDHbkoI1EGiOL3xziGIEoJEDBj+WnSYJjlPYlObmD48U2ZQg5kUp8IC8jLlSRH6yVx5XHD8eCXRGIWPGDPILcCRGDY+ELAoMUY8eeCUTxsUqe9+K8gBhFX5wqzo5W2uOmguwQmd4UYpfc/FhlXzwhD05IBT+eJs6LjlPEiRdkcsOiFfHgK0AEYINAwARSKKlgGsgEwva+xj74pmgJBlwgAelAAOyVmsEeifIWEXzGggLwB0QCkDvUL0DeKgD5UP9lSKt42oM0eWu+vEcWeAJxDggH2fBdKu8lGvKWAB5DjfAf3rlQeDDebCiy9n+vH9R+17CgJkKpkQ56ZKoPWhKDiIHEUGIw0QbXx31xbzwCPv2hOOMeuOfgOL7bE54QOgiPCDcInYQ7U4WFkmFRjgOdkD9YmYvUH3OBW0JOVzwA94HskBln4PrAHneBfli4H/TsCrVsZdyyrDCHcf9tBD98DaUdxZGCUkZQ/CnWw3uq2aq5DrHIcv1jfhSxpg7lmz3UMtw/+4fs82EdPtwSW4IdxM5hp7AL2FGsETCxE1gT1oYdk+Gh2fVYPrsGvcXI48mCPMJ/+Bv8srJM5jrWO/Y6fla05QlmyvZowJ4mniURpmfkMVnwRBAwOSKewyims6OzMwCy80Wxfb1hyM8NhHHxu05UBrddAlx7K7/ruPcAaOyGR0XBd50l3Ls14Po7YcqTSvIVOlz2IMBdQh2uND1gBMyANRyPM3AD3sAfBIEwEAXiQBKYAqPPgPNcAmaAOWAhKAalYAVYA6rARrAF7AR7wAHQCI6CU+AsuASugBvgHpw9PeAF6AdvwScEQUgIDaEjeogxYoHYIc6IB+KLBCERSAyShKQg6YgIkSJzkEVIKVKOVCGbkTrkF+QIcgq5gHQgd5AupBd5jXxEMVQV1UYNUUt0NOqBstBwNA6djKaj09ECtAhdhlaitehutAE9hV5Cb6Cd6At0AAOYCsbATDB7zANjY1FYMpaGSbB5WAlWgdVie7Fm+J2vYZ1YH/YBJ+J0nInbwxkcisfjPHw6Pg8vw6vwnXgD3opfw7vwfvwrgUYwINgRvAgcwgRCOmEGoZhQQdhOOEw4A9dSD+EtkUhkEK2I7nAtJhEzibOJZcT1xH3Ek8QOYjdxgEQi6ZHsSD6kKBKXlEcqJq0j7SadIF0l9ZDek1XIxmRncjA5mSwiF5IryLvIx8lXyU/JnygaFAuKFyWKwqfMoiynbKU0Uy5TeiifqJpUK6oPNY6aSV1IraTupZ6h3qe+UVFRMVXxVBmvIlRZoFKpsl/lvEqXygdVLVVbVbbqJFWp6jLVHaonVe+ovqHRaJY0f1oyLY+2jFZHO017SHuvRldzUOOo8dXmq1WrNahdVXupTlG3UGepT1EvUK9QP6h+Wb1Pg6JhqcHW4GrM06jWOKJxS2NAk67ppBmlmaNZprlL84LmMy2SlqVWkBZfq0hri9ZprW46Rjejs+k8+iL6VvoZeo82UdtKm6OdqV2qvUe7XbtfR0vHRSdBZ6ZOtc4xnU4GxrBkcBjZjOWMA4ybjI8jDEewRghGLB2xd8TVEe90R+r66wp0S3T36d7Q/ajH1AvSy9Jbqdeo90Af17fVH68/Q3+D/hn9vpHaI71H8kaWjDww8q4BamBrEGMw22CLQZvBgKGRYYih2HCd4WnDPiOGkb9RptFqo+NGvcZ0Y19jofFq4xPGz5k6TBYzm1nJbGX2mxiYhJpITTabtJt8MrUyjTctNN1n+sCMauZhlma22qzFrN/c2Hyc+RzzevO7FhQLD4sMi7UW5yzeWVpZJloutmy0fGala8WxKrCqt7pvTbP2s55uXWt93YZo42GTZbPe5ootautqm2FbbXvZDrVzsxParbfrGEUY5TlKNKp21C17VXuWfb59vX2XA8MhwqHQodHh5Wjz0cmjV44+N/qro6tjtuNWx3tOWk5hToVOzU6vnW2dec7VztfH0MYEj5k/pmnMKxc7F4HLBpfbrnTXca6LXVtcv7i5u0nc9rr1upu7p7jXuN/y0PaI9ijzOO9J8AzwnO951PODl5tXntcBrz+97b2zvHd5PxtrNVYwduvYbh9TH67PZp9OX6Zviu8m304/Ez+uX63fI38zf77/dv+nLBtWJms362WAY4Ak4HDAO7YXey77ZCAWGBJYEtgepBUUH1QV9DDYNDg9uD64P8Q1ZHbIyVBCaHjoytBbHEMOj1PH6Q9zD5sb1hquGh4bXhX+KMI2QhLRPA4dFzZu1bj7kRaRosjGKBDFiVoV9SDaKnp69K/jieOjx1ePfxLjFDMn5lwsPXZq7K7Yt3EBccvj7sVbx0vjWxLUEyYl1CW8SwxMLE/snDB6wtwJl5L0k4RJTcmk5ITk7ckDE4MmrpnYM8l1UvGkm5OtJs+cfGGK/pTsKcemqk/lTj2YQkhJTNmV8pkbxa3lDqRyUmtS+3ls3lreC74/fzW/V+AjKBc8TfNJK097lu6Tviq9N8MvoyKjT8gWVglfZYZmbsx8lxWVtSPrW3Zi9r4cck5KzhGRlihL1DrNaNrMaR1iO3GxuHO61/Q10/sl4ZLtuUju5NymPG34I98mtZb+JO3K982vzn8/I2HGwZmaM0Uz22bZzlo662lBcMG22fhs3uyWOSZzFs7pmsuau3keMi91Xst8s/lF83sWhCzYuZC6MGvhb4WOheWFfy1KXNRcZFi0oKj7p5Cf6ovViiXFtxZ7L964BF8iXNK+dMzSdUu/lvBLLpY6llaUfi7jlV382ennyp+/LUtb1r7cbfmGFcQVohU3V/qt3FmuWV5Q3r1q3KqG1czVJav/WjN1zYUKl4qNa6lrpWs7KyMqm9aZr1ux7nNVRtWN6oDqfTUGNUtr3q3nr7+6wX/D3o2GG0s3ftwk3HR7c8jmhlrL2ootxC35W55sTdh6bpvHtrrt+ttLt3/ZIdrRuTNmZ2ude13dLoNdy+vReml97+5Ju6/sCdzTtNd+7+Z9jH2l+8F+6f7nv6T8cvNA+IGWgx4H9x6yOFRzmH64pAFpmNXQ35jR2NmU1NRxJOxIS7N38+FfHX7dcdTkaPUxnWPLj1OPFx3/dqLgxMBJ8cm+U+mnulumttw7PeH09dbxre1nws+cPxt89vQ51rkT533OH73gdeHIRY+LjZfcLjW0ubYd/s31t8Ptbu0Nl90vN13xvNLcMbbj+FW/q6euBV47e51z/dKNyBsdN+Nv3r416Vbnbf7tZ3ey77y6m3/3070F9wn3Sx5oPKh4aPCw9neb3/d1unUe6wrsansU++heN6/7xePcx597ip7QnlQ8NX5a98z52dHe4N4rzyc+73khfvGpr/gPzT9qXlq/PPSn/59t/RP6e15JXn17XfZG782Ov1z+ahmIHnj4Nuftp3cl7/Xe7/zg8eHcx8SPTz/N+Ez6XPnF5kvz1/Cv97/lfPsm5kq48l8BDAqalgbA6x0A0JIAoMP7GXWi4v4nL4jizipH4D9hxR1RXtwA2LYAgLiTAETCeiMUSyjq/gDIfuHj/AE6ZsyQDN7V5PdKWSHCe8AmTxm64aL5EgwrijvnD3EPr4GM1QUMr/8FzSV3eTMDwGEAAAA4ZVhJZk1NACoAAAAIAAGHaQAEAAAAAQAAABoAAAAAAAKgAgAEAAAAAQAAAU+gAwAEAAAAAQAAAJYAAAAASvxvRwAAOu9JREFUeAHtnQv0b1PV93/uRJySVK7H5SS36kHhuJWQnp4y8hLlkhol1dPoMrq+KUZUMmiklC5vvMQgw6siuT2lohsqFEIuUS7pSiGV9/M/8/Q901p7r7327Xf5/3+/ccb/rL32XHPNNfe8rbnWXnupxx57bDD9TTkw5cAc4MDSc2CM0yFOOTDlwAwHpto+lYMpB+YKB6baPlee9HScUw5MtX0qA1MOzBUOTLV9rjzp6TinHFh2yoIpB6YcaMaBm2666ZJLLvnxj39M86c97Wl77bXXdttt1wzVcFotNV2BGw6jp73MMg4cfvjhRx11VDCoF7zgBV/5ylee8pSnBPVjcjnV9jF5EFMyJokD++2331lnnVVG8a233jp//vyyuyOsn2r7CJk/vK6JOW+88cY777wTQfS9brDBBuuss86Tn/zkpz71qQsWLPC3puUyDpx00kmHHXYYd4nev/nNb2600UYPP/zwRRdddMABB1iTZz3rWddcc81yyy1XhmFk9UTy09/s5sA73vGOTPFad911P/7xj//yl7+c3QxpOToxE1X3qH7zm9/AQLsLz/2tMSkPxoSOKRk9ceB73/uepDO/8IY3vOGBBx7oiaSJRvv9739fbPzd734XjOWnP/2p7qL8wd2RX87dSP5vf/vbvffea89mjTXWWGWVVfScZlOBKP2Pf/yjjehJT3rS9ttvv/rqqz/yyCN//vOfr7/++l//+tdlg8VNEY7OmzevDGBu1l966aW77babjR3tjZlwxBFHHHnkkdS/+93vPuaYY2KAUdaM3N4MmQDC1De/+c3Ifcx0Hs8sc2hf/vKXNUxyxTGr//rXv8IQ/P+nP/1p2PKc5zxH8BRe+cpXxk3meA1LbsYirGEhKxAhA0DGYG8hzKgq51YkLy8nmSahojKFWSbfGt2XvvSlHAn7+9//TnT62c9+VjyZZeYvhwlpmEptpzluwxiIGU1jG/LdObSX7tFHH2U5VHKMTGN6iWZxelRyyZQMR/fggw8KZqILl19++Q033MAQ8EKHHHJIzlhII7NW/MY3vlHAT3ziEw8++OATTzzx5JNPPvvss4ljSe//6U9/gpmCmRYCDuy///5WQ6I+uDXiyyFblxF296EPfch4TbzKQpQoIQtN0GWXhL5jmFwRqbUKROY2XgZYqyHAlUIJD8FPUnrcgtW6I60Ln+PbCZEsqnrxi19cF3+v8HMlksdpmwQTq/MwPE//c9HPavDzOC5/d0LLjFEaS6I4GIVN1wM+eBi1zSlgRpki+eazuJyj7QyfRQ1jXYLJw+fSXInkUXK4z98zzzzTb3sgM/+Nb3xj55131rN5whOekCPiYwWDhSLA/vqiHwVou+uuu4xCwni/beZnP/vZS1/60pVXXvmZz3zm8ssvf+yxx8KBYCxg8zVgQHZZQOYvZX/LyqSgCY6I8+Nbs69mxRVXtEF5exoPEw9ilXoQMcwIaoZvYIbfo83MYW6cc7K8HQG8UYWbGj55jXtk0kH6DcEKlhh4N4MY0oTJ5x19+k2ihgL7eQ3EKA4ChrjAeyeCAjqFXZJm4aEgNjYe0fg39OvtCWq1zWGsEnXjGMn/4x//QKr4m+Bm/i3l4Qu3NyG7iKlWp3Bf+ZhHCIkSSp+9vsVl2S9m7/Fd1XihVLDK5DMxRp4R6q20v6FCGRJNZsEtbwoTw5G2S7QSwEO7NV5vvJ5++unnnXceWz5uu+02xIjN26utthp/N9lkk8022yxYDZakpgvHHXecARx44IEx5H333UflCiuswN9//vOf47/HBiJZ4Dn++OPjsRTWrLfeetT/4Ac/0LIQl5TNpQvPjjvuSMrNLIjs4zbbbFOI0yqZ8rz61a/m/RBPz9FHH33++ecnWs21W+mAf8jcGBdtZ/bImwannnqqxn/PPfeobAUE9Gtf+1qg80wymXgHkLqE1/ZaIrYjaCgYCmw44+9111238cYb+/pxK7PuRYoB1fWEsay45557rr/++mazvvOd70iHAbMRoZPWhCCf2b1eyWRbGG3tFgU80g477HDttddazS677GKFxN9lllnG7Kl1mngWCSQTdAvfI2rZj4g30qUvaB1Xm2383ZGVhxZFJDqCI34lnFeL+KGfiCaFIDPkY0XFnJXsKwzjIQnzQVuLY4l1uUzQOdpbTG2C2TLz8MIVBB/kE/PbGBkmnIznR0Tjnnvy8FTC3swhY1V5UoZndufnfQoz3icvdmneROCjypEXRj9vR9Wlz0ybmUgzIeSHANkE3i5JR0koTeFRYNVUFsqmT6YJ3LXsizclI382AQEHHXSQH2aQWvPAUm/gGZFsRJn2BpjVS6IL352VZWJqtYrxjHmN13bm8FCLxOIt4C2Gkh8MR27F0g984APjM6J+tR3HYktfJkCYf5JGXhrQZAXYlZtA0EkJYpCFhrlwHO7zo1PjPn0JvkzQeTCYGIElrPXIn5nPh5UNx4j0c0XPf7hdNgqPXNxAsvnBE35xUBCgkrYj/cGt2XQJQ8QfJI2hBcGR7lphrNYpetR2r5wBC9BDpAcZkqpnBjyABai4LBN9NF/A9mDKxA4DbJA0KYMZeb14hWZW6l58QBoGMTEETLB4VVig9zQP1WOil1lwy2u7RYLoM26M4WNY+WlGY2ycE9pOSFMoNKr0TEGScEc5ouC9lqFKRARe2ysdDs8JhOwGzSFjJDDS9hzLyDttYrUVrBXzprLZCsocNIkvy/IaPBdNx0bCnKF16rW97F0j7+cS8jk0mtVRL77dyw1aBFMYv/0YvJyAhAnTIIIqC34CD4ZEdErsoC4qtV3AY5tk0uQFTa7kEvGOxm4FiR35jrLJZNwqQMJlYSQFew0Sna+kbaIBJCeMNyG3CkLL0sMjYUL32o6Zl1xKwoKxBRpbqYq+uffYZPL9rbgsf5jThc3zywx2jHzINVK8HG33QmkNfUQA37C5wMRDkMLDOiw1doHueI7qnYItYfi2eijp+YJvMqFljRQ+lEVJDA0WGceYdo3PSLvXdqXK01ZNb2jBlIR/jjnl2V0p90qN5mi7hSRIedzpaGuYpfuMI+VKemCpSZv+BnpoERYBV4CK+sJZVbDrNmjIpXVUZt+DXib3Eg0XSxHFsoF4a0vwXwY25PqOtV0xPEKTziTJh8C7WmP2GQG6S7dVEFEJaXjsQSZsdrq7zu9CNj5ZU2IjL21GjQaYb/os0aTg1ZgJiwU+/EVXydLxoy+W68pG4S0O2LhUdCATP1ZJqbKBtKmX04YDJEESqMT5TNlLoOrqVj1NS/fq9TBh9gwJLBA70miDu3Iy5PnS7KahLHEcfAZo7dJiASLYwrvDrISZhatiMK3SkhqdlncUkykEOTb8f9xFWl3FfKHFOmBSNXerfO7D5GEffeV7KW0YC9jeB1WZOJtoO06Ap86MDnkiIMfGE79pCwdyUJYE8jT5gNzXV5YlxEFoWtbQ5DKT44AZvLxWGdr+6mGvBMWIwXPidf0qRg55mit5bEHAhcJrsmN90Xt6aNhNT4m10t8cwtL4x/yutB0DlyZVoVDlfDONp8O79bSd8C8QDj1mX8iZh4NKTWqNR62CqWMZEts8g3kqA/D1BAuGf1RPSBNgIwNFlf7AMbniHOOFgTAk3rBS6cdrZSQYA82TLbwbw/N8Jcp6HBSYFATWJG476TXSdh5NeiyaRcKrNOTQ7tbQdi80/hkH5Uw9QSzUMH+0WumhbaUXMrTmrvODc7MO6NXwBTdQoTio1qQxJ3oCxjiMvdCMhppMK1n5UEDrAzow5zO5EvnYAugRMPY0kbILk6ftXtWJ27Fb9kO3udS0jUcuX5TmBXdNFvlbCSkAL7WqTBfMQKC9aTC7S/pUKbEhJ1cUeMMQ/EbZIkI+05Q5syci5QdD+6FhCrG2/LRhFrTjI9Y5z7oZDCbYHkFlrhTmGOT4sCVL08jlGt38jR0OXEOeBJDp22klG5HPdyyLdYRuZLZSLgqDVdnEy26O/6xEmAng9+qnhUNpizJzoB4NJ9G1UvF+Al/ZXHjigvwbz0KZDsqJ3SYxkgmtUZ6yUtu16y5zFjkEhmSdS/fe977XdAy6OcDAyv4v70srIf+Wt7wlPurMA6vM6cUqZxauvvpqg9x9990zm3Dogp3owGcP0004s+3CCy8UDMcqq9xr4Z3vfOfnP/956wIO87GRRHd651xvoZcB33zzzdzi/Dmdw3fuuecKeK211vrtb3+ry/wCB41w9IXBo+ove9nL1LbsZW8BzIKChYq1BtJAzmvhzweu1nZONbSDCvCr/qTxoA+8ohZ4M/Vkww03DJCkLznLQRMKvnCUBvZ3TQrPOOMMXxmUORPmTW96k68kK4Zk+5o+ynwwVIdPoOoJDlvvfNfJCj/84Q8T9GBwv/3tbwOw1VZbCQw++IVPFP7+++/X3cyCuAQqU3UfEGUimVywTE/GADnnY9yGWa3tOunp5S9/eZr6U045xQBI7eaIkT8GJI3Z7nJUCO6XMtGpZgGVDWUj+OD2UksthSUq9GnkVIIzYcDMaTaV+NsA0KN9GxgkaWOqXp7+9KdbOW2J9Ik7mWBrBeuUPaKGD+DZGbXCny5wlBjhD6kN5m6gMuDnP//5VuB7Fenms+Buvm9feumlbanSgqxxGHuFtjP3UJCZ+EKgjYSTjJWkTXzLXsPGt6icU/jDH/5gYAsXLsw3nMzbzUZYWyYa9BtHy4VRKB88zyGsGQxeQuwiDfGud70rB49MpJ2oV9bkqquusluCF+SLXvQiv85HqJ95ODR20z5RznxKZ12B1iZKFDgkS73M1oKOoFp22WXTY4RddtpajudLo+rqboW2c/q6evJrZqoMCnYIHJVf/OIXiY2Du8FlYpNGAGmXV1xxhRW07FwIFlRaxIsjIr9F4o0cGInGbbfdNgDDB7LKEFT67GNwq/0lEZBtOqDrj33sY5kI7Qg9gO+4445EVCltLzxXc5999lFuGVT77rsvB9cpq1RGiTVhMuVVHWAd5seKCfFXWfNZVs/JqJkjuv322zMhewdLZwJ99yhDGtjuyl9V5sClXTlogVHiGqnKbAKYJaIriTGEqLcWrhg70XV+R7UglYCgF4JDWIExovdKJIQqeigJeKXf0eEynD6dbjghQwn8uBUwhUt3fqNUJp9j5GNVA9MWLS/eGqxc4PA0f6lUB289YdE4DDDl2/nEnwSLQsKTeLC3ve1tdunnhx5AZb5VonJOQQFnflDAEEhWAe+/l5LoC69FhlwAz33uc1XutiCbgkF5xjOeASuY+7zmNa+p7EUJdiC186+yVSEAOTbsps+AvPa1r91oo41IHMapDcJRVF2y7hGSc1a09a1vfcvfmrgyWQy+nzN//vwNFv2Y9CEDzP5MF5g/enbljy4nLs7H1hwyYXKUa7UNJ+l1YI/HqEHHfGVcVjAZ3yqsMbQQA+8KAeJKozx/CwAY/GIyjjTG2b5Ge4QQHfOlYkXCFVu/jF2qhT0tI0a+PfBOMTzMKZSeWkyT8SL+iruYlJoyVog/REPa71DLt9eKRvtjV6lvx8jZ4jNzXaaIDPjiiy/WsNMFC7lJUaTzE7XWIYWKiWtmio6Mt2UWX/KSl6QJ9neVmceP9fRNuE9+8pPW40c+8hHvq6nkSXti4jJj33LLLa3eTwcCSM2l08k8WtlXn4PmWMnMj0BbQ+VBlNMNEI7/5Xve8x58uNGJrSRviuRrWmr1LEspE1k3Mh0HDpTmFU844QTowz9b+pph82GAxHH5fjAkgeypY9L87gsPQ7mWLunreQRXfP+ApWmW6wm8SQiTiMJwEHlR4w3BBRdcQC88OQKzoOvE5c9//nO7+6pXvSoB1vgWK2dasNBHHYSNjE5htCwACtLkQkU1SAJyKzz00EO+bVAmb3zOOedYJYGGZuCf+tSnaj2drbfeWpjxE5nzJjUZeYGVRaZUkMGrQSw5B2lI1nTQfPswhj5qoo0PZcRjxzGa5m9WWmmlMrCh1heGDUowQK4BWKiZn7WyaDMd12liX0hDUKkAG5xEv35XufhFZsW3sqCL5+Qr02Uwa2LWU8LJpAqaPWGK5HNeWREwSMqGQ5xpbPHRPhMT5t7U8Nd4Ja6yLqCyHnoZ8sJ6GSnIKwQY20pJO1PXBJGwRZJGAXYlgLmFLGnOlcinppF0e7dYXPwEhrkKXSohZPPMSiIQZTiCBCTm2Fr1zZkea2eu0gc4ImIHyEOycfWBcoLT9Lbyqfix8FTsiWIpfH2HZUmAt01SYGKoyr58AF+W7FW+XdNvugvkFQ1XDTZIZqhyRlpIoZr3x7rCfhtUwkBMHj+Yg+Qo6eCfSIzWKwVCkqPAyp7kAMc9dl5ToO3ev5noww50xsQ0RxQwDRKjOEsEfqwp7kVyr9QUTAE/lgKJ0V1MBsOW+CJVOVyQwaajHHiDkQHK8bH5aAUpRUUOVElB2g7DK82TT9SZLfaorKxEoL0+JCtmDzT+S6dyzjy+GGFlDXwW2kyXUImzWwBEEVchIoNC5bv9enbWMGeMFl0CP77azoMPGOEvcZiFrhgRpB6GBkcsKRvJXVQI4ZNUCa20XQ5ctyhgfXnqWAGrTM8OJB8SPh6SKisLPHLrpVarSrQCYCyGPzCaMEeCSK5EDFHDoCA6TZmDu1zyIKwj87S4cS4xwTwCbiF8sFoWmVtiFxPXGFtmjfVo2DKbDAcMzZQDNyJhsqZsVgNbKonRAOFnJTAAmm+WhWA5SDqEKfDtCsk0tqCgWFp0SFIDSC4l1kF600N64VbvPA8UW55Z9TQkpiIMQ3BxiWWeUNZBGERtokCnRlgCps0tRmT4C4PGfJWTRUZkC+lBvq0j5NI6je2CnBVhlGKBNkGNxEDTh0Lahl+piBqeUDYPpMkplTFzConUmrRCs8REFQxmYhCqZuFSIQ1tKgu0XX4DhUEoUbPACsKdwBB6L4F4MUjF4TIN3rgCA1qb24PNa7sNJuaO9AT44KfwwTNCD7jMHHhgdWqYcybPcfPKGjRQjCoz9jDWWIfv9Qh5EOihMQ0b54MgLtEu5JUh05aHRYEI3/Do2cX2RdqO/9dUIgbzZKTLslY9MTDde9ldyTMPN7BlMk+FIhQj9DJsES5MJlbluTD2QClobl0DkBP2x911XlOg7Qo/NNlgYEiPJiFwDd3zpDAYgPmht2bt5CsYsEFSDzuQMATdYOSgYm33yK3sezed5FEZ92Vo1QqEBsNfBRe6W1YQzTZ3KANrXM/AjSpExGQlRgWMskEmIqhfPHaNLlFQnAIMOh/3KG2Hk9YpxigmqVYNdtxIiu11LTxdAXuzyHgDtOJAZgAo66DsPTGmKhk4io0P09jtEEd4kg4BAqr6uyzVduQjVkJkUeYt5p2nkgGbtCXMvHgdd+RRWVm+Gp5iSgVgDA1ss8J4gGVu1KSsoFY8wjKYNvWyJjz+QjzKRJrC4G/FIqtJ/IXPWE8weEZ5eJ5d0KnooSMz8bHdDJpUXoqHUFIJ3DcA3kUciB0vvSvaygwApdheAsEDcvivvijATwFjrPseaSb+Um1PhB/mByrTOSZ24CkjRaKcEz2Cx7gZMNoCBGyQ70UehlY5yK2tGQ56IUjx2LoqE0baEHChMVWMy+7yF/nA2kK8xeH8hef4HzgGEsRIA7QmcjVGamA1DIa2wUCUMkTbTVjzLWOASpewzrpD3FU5tALxC1yyKQ9jkcwEzsDTY2YuMwCUAhf6A3SeUIJ+fVQFNyo1xdPTa7lU28v8DwxlPPZE0xZR1q4sjDFFBVUsiPGYbRYKcIANeowYNVHwFuiAAAoLmHkJh4XQhWBtKhWiG8HwByFD05BOGRoU20TTonfqEaxgyEaDIbG/adthMHGwqvFCg5UDS9pssHruzZo3aMXzwsCVzXfKJNk6soeCGuf0K22vlFg0X8+0vQ3NoS0HpnTnLDsu2TDIPsG7776bPep/+ctfOIJDO89NgNgVqxMmvPBRpknZLUE+/PDDKlPgfXg2J/7kJz+hR3YdsiWWM/B4P4xbbPC0SS9e0e+N5dYKK6xgSHhty4Df9773Wc1pp51mhZy/OCU79AJhDfau5zTPgQk2ujJYfr4hykaQYgO0cXHSTuEL6jpTgeZIebw1mB3dMsrWhd9CC6vf//73+0M+7FWI9ddf39PTrExOx8Y1hC20PHT2aB955JEJUhFaxhuIjeA5zINy+iAgAatQ+FB0lwKiuPfee5966qmU89+E9xh6KccmwWKbzM4wjQEGauQ0DEk8Y7QmimzNUsa2Gd223BJ/LaYFYdAddt16Md+leDgmLGgYXIqY/iyxZtSoNFG0LqGfTgP/bHfL5hQ4fBs1f6E8GAuXCnkERnBE1EM8hSdXoMRdOhIPO5lsK5inu5iwDmsKJyxwkgEiUSSDtOgTxzUig1swAdlTTaJgvp1A3cQyAcktxZjpEDiNpNu7ofKA3Ws7+oY0+B+CEkxLvET6tpIzH/aQvUP5qeFRKeSD4/bkqFE2BRgwWIhFpbAFUyalhShI1QGuG40r+5g5hWvwGGCjjaJSqaSrnre+R28ZPXs9TODbxUBfkGnLJMzjT5QRGxAKeQKy8S1v7+gLhhROzm1chQbRujYxwz/lCIxpO8A5ZMsYJWxNDp4OYVLaDvtiGwZT0FhuSedNIaFJ614w1y+Pm23Dd0m97RnoL9jMTAR8MXgw01bASJJy+HLIuqtC3SmoYodCoemE4zIoOJ80QmiwgQQO31p52weY1nsCnPItmkCKORSYzXqfY7cqzVDQRdml9cjjKwNoWa/wwchOBBEmVxLRuF8TLYS5jI2+iWk7VttXlpXlh8pMdlnD/upL329H8RCI+LVH5rRMWrgliWTWZKeR2QmtcIQ3Xj/xiU/IHNgk83Wve10wTZXw8b6hvb6+9tprq5KCnWPPvIt5u+p5hZDeTz75ZA6Z5kA11QcFHAsvxgaVZZeYD8sLAFD5JmMZksp6valaeQipvasLwl/96lcxWv8OOaFW2RwS8bW2b3/725FpRe8IK3rO49thhx0C5GoS1Ne9NN8eWKW6SBLwBx54oN3FRjM0bXGLmyAqVCam5ZYfeeSRRyqPURTy+GBP3fIFnfUUvD/rYYZcLtX2YO4dk0VmSHE7zgoA02oOLaaMmdh5552tFTKEMtvx5jwYpqxIm9oCQy6KV76xDgFftthiC+5ec801hkd/SXdxppKOnVB9UCBTVQljTXz+rEx5AuQNLpUDSwifodUZktjcoCM4mU5KCV4HznOcLg/r+uuvBxsayGFSsZ5bq0ozJOTpguFBhbyZTjfJv4sR10c+SATGGUqPaptttuEycXbwvHnzMBmWWvINE2WdsZuA4RZCzl9N39LAw7lbqu053euE2cMPPxxVN0ekKEsHSHPLzqLA0BJ08YEEpI0sWjCxVCygrm36iujITOpWWUEezADw//ERa3FbHZUBDauuumoM0EmNzpypPE9Gx13DIot6RIA/No9K7FRwfKBBEq3ooxQ6IwgLbssWwqaCeWNZGdU3K+Qfc9QAv07vY+oeuIcYmx3RG6z+eDDckvHHW3wP4Msrr7wyl2n7InhjgpkbVY62UKDtNoPFalZShl20eB7TCMvQeZrYXBoZ1byR02DscOjXv/71Hucxxxzjs03x+R4WDoBKZ0tbcyhEq/XDiGBBmSVCDB4MYnxgsvnmmwcK42mw8vnnn28FHmR/vh12WS8QaXFQTInVYAp1i1iJ2AftJSI49NBDbVGHu0pJ7rbbbkyFMIiKRSm/4hWvMAxwuFIlgLSZNlOt9kdEIzk2LWK8na9l4tgNObEhB+OLS2UFlBkLnp5TmA6Le2WoVK8YTTWFBaNTJr4QZtiVcUrAXG5+atqLplFvkyWNBHajmVwG6XS6thyJQeJePDHE/2Z30GTl/FBjwlH4SLJQP9/KyoovDDO9AxyDWQ17V6wjgBH6MrBO6mXdkL80wjiGt7HYX1SdEYlsq4RR9vOQZRn7oHdlYepmNwM8XCoZiULGd1vWSLQqGaiO4EkgWrplBcOJKAb18aWJeiIpqCYS7MRygICHVijIyZvTQC7ziQhici9tvowExzh5GIJBmUkBkBmW49ItK+Q8EutC4msNE/lhW4MxsMpseUx/rRpL6tJXTvYbwizANtr0VyYJh2/LFroVFHzWvZJOocpncozTe1EeQQzQpkbIkZl8PEgyZjEBbxKYYz4sP4XOJ7DZLZu08zj6lqhKSjxAgbabAYNBCJMHTZe1kyEQOH9Z6GfM7XuwsjJdpGkI7gYmo2wZRtvF6bfQHgVo21xqlbiMmAA5DlxxDeSR44wVGFcT8xC/miO+vjuyJObl4hDMg6XLcuxpd5pGUnZXT6qWChkDE8JsAVcOu0zb8W1lFKpey2+1SFXzngoF2q5F7Lo2ngCbEJofBXgXZ91iSVXAU6bhqueZ1WUBIXpAQ0wAOBVd01fdLurCK44gislvSyukJ/E4GCkqijLw7DBYTILykXtI8CR68ZCFZY0OThayurBVfqXCQGkmnomQBLITSEzbCz2NtbKcBXKbQGK3TDVyRBFra6KbPyP2vTMiGEh3eAW6Q0QZu/2wp415WyDfemZ05imoW8ZXBMoWO+fA/Uq3fYEoo7GBjGe/wQQew6S+4GndMTaAV3Ce8DYN0I5DE8TRmKm5RodUyTEQgJh6a7KW0GQIQGGgKjHZNs3M0XbUDFQ5b1uJFXWVCEOWEyZDBrojq5fJ54KcvPKoLb9WRzqUj4Ha47e/rNj5VD+p8sIJP48Te8ZDwnKjrmyn4fUYjye/jAs1064mRx99tMoU/JrTHnvs4W/1VN50000N85VXXtlTFyNBS7bc1lDoXV8B75CSiy66yLDtuuuu9oqLfEmwZFPYaWLjUOb6udCyj0DlwgJrIoXbogqBVcneENZcWLfWwrZuFRbQHYD54kXl9o0lzWOrIHeXY8Pi5kEN5mdJZ4s+R2GWGDXW0zIA1DvHvgb4Ky/BafiJEaxHBqhWiriASbsINWlZsLQI3THelqiC5vE25wCgv0sxmXHV9WaZVCkM9HEsz5Qe06GE+Xaal3VkMpATall8gTcqQ2X1XuYrU5WwjtA1zrwwLsJA4k396FeBIXf9jzGmpzNGWEEkzw31nR5V5l0Gb0/F0xeUEznzzF4SYJYywXjBevjlbYrIIArI4Veil8xbFg3Sb62peyVyTFjOfLISTzMAJNI4SaEZhspW0nb8hIBRAOtXNXGhUttt3p6j7abG+Iy0YfW2rywPAirEUusgkkMrQDMA8ViooWs4EAfFCHaluyrWds06yrospCNRiSxKIIKB2WWlCUwgz7llXp3heJWGayImYftz8OfDKHSiax9l5GMohCRFx1MrvNV3pV72YkTeknbbb6G2KzRLJCatIfpTRk++tkuNK/VC88fABKP8KDmOR4IXFKCzUmltIBCjFRAh8aYwHm+xtstyJHIbMa7KGiKWQidfGRpVYq4EMMUOHrlkBWaV2eBKzA0AxIT0s6mFmSH0Gh+VEYPcS9TaLN2V4Vd9obZb1AYBCW+B1AGAYghVUMjXdvyqxdJphfQ8oWv8HHRKp8QuFcAJeYkhBAT7S/oK/GiCtoIsHURou5+91iayWhZItrEjXdGLIojGSbh8egibUXWmlGrCCxvnnXeeXWJrMzc/q3mbgr4nqRdX2mCjrZ1C09+e3wR5vNpod5HXnK2sCVQNbmnI6GFZc0vCBRpYBqx6Xq8gbQZj+ZFattd7SDzzZVHBlBXWXHNN771544uXuGStfCtMAErOFn3ympqVeIDKMi8+nHnmmT680ttocdtibVeW8txzz43btKmBX/Y9UFID2mqycOHCNjgz28LZt771rQImbLHvb1LzwQ9+UPVDKLB133rp6p0z+/Bo+y3udcd+7LHH2utoGNNCaa6LsC68zim75ZZbytraC6p8ibns3Soz9DpYDTC+7ky6m1eqnrvox2lWfL+Z7De3DFv6vSaWDNDAMnrw5PDKwjpeFUHJUYoy4Mx6zoyzDCLwCAP0Fzf0UYHKMoTEnOmEhJrkF8zs4WaZQhtN+W07hERArfdus2U5FNq0gt4xecH6f07zGMY0DWw+KxGDdVujdCMDSUSPXXUqa+KnP3IYmPKyjiRmZTkFC/VtM4icJBEo4TeOl+7IiZi0wGGT3pyNz3rKJmbMF+io1wmjiKfHwo6K5+0wzkjs/EGS+TTMpFUUfZU9p/7qeYoaYK+zzcIhKNkDDTmp4EIkvtKyNciir+y17HONCHGvfRnyQm2XxSEFk6DBguSypUGZDJvAA1xovJR446nl5LNAAiSteNydu8zCwWpxl34L7VHpmbOM2Y6C4DCJBQsW0L6TnyUCsJrMuCyysifRCfJ8JHpLnN6HP9vkFVRyFrYXBYaUnS2RPxyDZPqXOFy1LrY0vN6oRZqHkHaBGN6bjkkqPEYGA4oCszeMCNmCZDtvFxfNe9nse+EFZ52HgYmU1+FtYlw3mhx3RA37svypQYUwvpJTQ7ikI85xMjL83W7LqNJHP/pRvy1np512irso1fbdd9/dtP3aa6/l5Km4ZbMaEmPMDg455BCam59fccUVm6Fq3Iq8iw0NDPIYjbE1a8ipVabtTN3ba/uyyy5+jv/617/KjlJuRmdhqyOOOMKIZwrax7a5wk4LK+2wCm5Zpgmh54Ha2T6suaLJ2t4HDGV+1H/uc5/7zGc+Qw1TXCJeHoGOAyKdVtgRlTnHBPi2lhImhu1P1UklshmUlMQZZ5xhuRsjALumwxQ8SaWRvE1mAO12vwQ+TWshFuqg/IVhSX+VWrEY1QI1Q9PSUSfsVQhHwqU/vhlmxb3Ihp9C992vhdlxpybNcMCiejScgieGQFptuVuYKDEk/AXStw3KNmMCrDBODoANZ9n0IQCue4nuaFAingKxCapehq1U25XiA0WHsw5I1KRIEVQZcX3U+9yJKOmjozROT0YaMueu0jN95yC8VGCwcmjrCkbCHaxL+5kgsUZhd0rTlNlWrzCJjTrmnwCutKqW54a2QnraVDIWrWF7sllgrqSqVNsJs7UJpDC/14Ziayttr6SyfV/CYDlV2JTI4gq4v4JP1LXfUadkVcKudzIWfKNJ2PB38kjbA7+quAbCysy3rCFPv5APXn8SeVOjIcdd2xMJSC3sOr8SnNqi4vWcDCXilIOnVNtprIi3p6QrMZUZlL49khghj0q/hRGdIIdQ0AMLnFWDrs2TgLBXJZS+MfVNOMAG9Oc0Ue9BTIHPwKUbM5HYQs/h3yGtBGCxTTAICSPlEg23XoLtmGWU23ynEzcJAbJWkhkrkCIVqWWU+PqUtmtuCaN9mw7LZlA0k+8QcyEqmfAc81yIocPKbo2p5KAnKyZhoKP25qkBG6Xt8SkJKJXiUMiDsVCLZccZ4vnV0FhUuFaHDouBVsCL8tOmDKvMjwdt7tCYUewRgH68bEC8kcFgSUY2MCUpbdcshT4aPJ6cJpYSx2p2mBoo69fL6zB3oVTSUyh/Za3K6iUWSEkZTON6k10TNR5ZYzxtGmqAODTDg9PjZ2VmQzLlRmfiL/YC2UZb+ItFwPQbMHJIGB9rvt1FfvLpN93B1uQ3ARKS6KVsICg5lLd5vhVqLJa16SMxYNBaF30H895yNTCKiSE0vmXBHsPHhzRGooYS2U5sh9BSsIVSe0y9zhR8p3FZ2k7qCy2S1+XJChgmKLMg0bUC8aM398Fdu9Q0G2cAWh4QCHGwWASZFfVVWUA5ZZjSwMy66QUxKKSK8WKAOlHACm0ndDEK+rPoNh0i+kpzpM1dHp4ivTgObIO5TdtuE3V+c1u3gZJ3NbVmiW2YE7eVtnuVQBsDSIuByVbyoJFe7AK7ZaSr8FyraB4P5c6tpO3SSUSRPDLo9+z1JGG2GAWeKYEhGHvlZYW2y//0sZZgxPE8bJDeSFfSXQsAEys+JjKutXC2B1aSEto6CTc0zA6zqjbVMu7lbBdtz5YyDIG24+7aZCiYm8AlNB8lxy40nmCXUWv1PFYZGg+JntOpZFIFAhbqUToAPHxX5Qpt1yIZBPVk1+XieJxdjcrjwXyKm/1FKL7H/LISdYoh89vGkH52Hd9tUKN5Fgzs6enkU+W1vRN25XfdLSQeWwKpAkanP28n+iu0HTglLeKoSVhaFhiqDbsTF+eJAaEYSqHQ0Hr4IZdl4LsyQ5rNtnfvBJB24A98Yx40ctaJV92G3HhRYpY2YUK+zGA947QCjx6Hl4+kDWS1tvfte6FeOtmtAyFol7wismPoEBR3dJW2IJ8k69ZShjTDAiFo2whZJ201p+gwUyg3O4QBin49ILKGw7Ey4n+1tgPKpN1IbClA6jUuyL13GM/4/EfZJqqYkmHWMFg9+676VWq3zS4Gn4fv1gQ3Hqa0BffYlZJoY2W38UIwRqbAeij2uEkfjiRWytJ2wkKjso0ABSwILuGIdUGKPrjV7FJTYkPbU9KhGW1qpbgJIruypH6y3TivJtUihu82w6+x1y349bOuVEU4mQF1ZUGCcRFRmgTaXxxn59PVoMfEZZa2M4UTxf3R2uFqn7LTRjYPNcGC0d5S3NRYM2P6xUmG38CI+NTs+Ex/tDzEoDpZfIZv3jJ27g8I3AKXw8QhfljDrMnSdgjSDKerGWY8SB89Ns4IYvV9AI9k9EdwPIQGNVr+7TBu8tYZa1J3wVaOvZNtPw14UthE0R/PtCvzjT9XZqd9XlNk4xE1M4VafrifBmZXCLsq5Go79l4bVHpanGRIiqxgEGsBdWNI3OMi3j7uT09Ll109AEV6XU1hjDDvtWpNvL1S9RfHNeAemqmEdodmSKn+TrxCrOfg7zxqaMA9a5Kr7UDLvWMOG/dX2dDnM7Av+JlKZuHP0RnfUOren2GqHEgmgI9outUun1SPFR7DWjh3kPT3mrjKZE4A5mcodT1BgEqXPlHaxv1iXoO4nctK0RUZwynU0HYIsl2u5nh7oo+nqEyplJYC8or4IqP2w/RgCKj0MEG58XSgp6GVoZWd6lzBpLrGGVjHUhMhq55jYA0xN+LhuEkq3PMBS4eBt7S0Af+JOPA02uYg7o2n7NXTdp8p6XU8im/FvroFbEGZdo1bvR9s54mcYAIZsJFZveeGspuYCV8/PmXZqQ6XVL17x39kRli0YrKp6a1nLFZpfDjmKamn7bT0ObDCUNBjb1kutJqerWXlOHBtSUmvzf2MlBHhajIFLpMqH9IHHENehcQ79jYxrRD2UcDHaAgdcilgEfJDEMRziYdAp1jk2JmLqiBcijGMsKa2tntDyAhbKnxOuAj7cFDK0IitZYUOd18M7cEQYwfDQecJVpGtuhn1QprxNsGsBydJpx5YAS3TY18/VmU0UIzqNnwDmzCrAE+o50FgDtJRkjUZZ9bxHGtrO20CvjRTeB6bLT5l2kLgMQ2Ydi1Z6ZEEBaYbYyWgOcTAhGAUusR4IWeZXEr3RToTtYc/mOzAcXkj3qHPTNPT7K4Xv2YYylr5wEH8Txe0XcLAcrxXWe9DqG+i7ZCl6ZMNkgeQ74JYElN6n+bNJjkIKwqAxQ3YDUKy3ENgXLddwATjZOIv0WNXe8hi4uX5x38SxCxDXOp8fzvCWelOEDlmQGZ/sYwiZvxZtxQPXuTmF/jqJZ/C8/C4II7gJ71cdsj+bbfdhgPhM5L+gxtwjU8ReDwNyi984Qv5KoAaYgiWW245XU5EgQ9a8H1BI5UM2SabbMKHAViegGmXXXaZvk6Jkw9mmJ2Mjl422GADQ4X+tP+aRSdUJZAceuihJkWkFfkURAKy2a37778fifrFL35x99138y1NPvXBNzlYeN522235Og2fVRXak0466bDDDrNLgqbhf3dIlOQUGmo7qE8++eTCD2vg9jF+xiDA4Bff4kCasZoBQSTh+DZlUNng8uyzz953332tITlSfayzAapRNfHajp8PkkB87wmvDgP5pKkXta6olfIg0FiW8beVl19++Y477mjDJ6gcwudxyli955576iNTzRxnGeZe6uOgLr9Guw5rUYZC4qC62h0BtT6agpJ8+scH0kfyQ5770Z0en0/Rjw9zCikRzZ1kNAq7qKycONYVf79drEwX+FZcGiC4S4aTaOeuu+4iIu3w41h8yi/oaKIvV1555WHSf/rpp6u7gw8+WOUxL2glmK+SjorUK664Ql3vtddeKo9toZW2P+95z6scGDN5pTT4hD0Tmw713HpfbbXV8tfnKgkeCYDnCcMZGg3MEcikWHfwcP78+UPrumVHW2+9tWEgkc43PB988MEEQr4G+fWvf51PRC611FJMmhKQtW7xrViDh3VbbLFFrbYjAS79xmsONcH3dHHdZ511Fg0ZPBNpFJtsU1nSLgd/JgzzTCa0mcDjCTaqqTK5AH3u1j68O578ialSBEQ6bfvttwcA8dtll11IpK299tpYTzScDA5pCMLJL3zhC0obpe1C3FGihi9A212kfYS5gwSFwa1W2h6E0KeddhoTclLifWSSArqDS21gVCEAmF4WcsA7ut12260QZjwr48+542nM2ZQRTPL4lFNOWbBgQRlArXpZSVrtsccetdqOCriVtvuY09RsCJ48zSlM+KOPPjoqV5mmbQzv3nLLLUYVKyldqcFwhnnllVdaR0wVjz/++K9+9as/+tGPlB73NLDAQYJp//33D1Y6PEyDMusC1grJ17SiAZ5hNmml7SuttJJoDfy86odfeOSRR6bansl2FkcNkpdMfO4gs/kIwW644QbrnX0KqLFpMhurbr/99nvuuYcFSyZ3a6yxBpNKYv4+5EH5DkxJH/j74G0rbffzdlIgSy/dKufXZniTJanxSOFeXDmEGnY9Wy877bTTELrrqgvCN6Hyy8Dz5s0ztdfdngpsv1Ekv/fee/fUS+doW+nnmmuuKYLWWmutESYqVlllFVEyiYVRsU4ecrPNNpsgvrH5T9QGezpV32uBVWThf/azn63ymBdaafuoZHTMeTqJ5E3WpP2+++4Tk4NXNlTfa4E8v/BPEOtaabsGPFYFtlKOFT05xIxkEkQ4arQxuZ2sqZDfHM16Ww6Hu4XRioDeJuoWf0/YWs3be6KpAVrmEWpFWp75my4notBM2R54YPCr2wZ//NPgoYcWj3L1Jw+eNG+w7jqDFVesHrd0hteKqqHHCeLOO+80cnDsw18GImtw3nnnGQGbb775ODGmgpa22k5SxK/ZVvRWfvsXNwz+7+mD5ZefgXjykwbv+O9y0OmdweBHVw7O+MrgjjsHvOy3/HJLOPL3RdkrcljzVhts97zBC3YaLNh4yd2g9Pvf/95qttpqq+DWmF/yop5RGL/vPATKeStOe3UmYgudeNJW21nuEq42hYsuHfzmtzOyy++XNw9uujklpnFH47P+F9OWWUM4rZxZosnDDw8+dvwA47jyE2ZUGsVGw/nL5V//tpiBlPldetnM34S2s212BmIwmLgcp87eYPPcohEM9c+NN96o/kaSI1TvdQtttZ33onNkNE3WvfcNfvDjGXm1H87qgotTYhpjY2U1rpzQGhaNEzOR9xw+uP/3M7xCw5+y+mCv/xpsugmFf1rGFE7efc/gmusGV/xw8Kc/VzDgYSzHot9Ipr4VxJXf5s1/hZMbbbRROWBfd/ze28lyM221vRO3cOEli8PRtdca3LfoYBKE9XUHDfLfbfPzXgKtvp5zn3i33HJLs5ts8C7T9gsuGvz2nsVu/JADBi9Zsl9zGSNtzacO+PecLQcHv3rG/xszy6i+99577dZ6661XBjOG9f4F57qr69i3z3xhZkx/eWBw0KsGG6zfdnzsE2+LYojtxyInf/H/zISgBKKvPWjwjKfPeC3c+yXfqsGGddZZpwb0WIJy/ofR5V1HQOn3f7Q4Anrmxl7VA6jFl5s9a2benvix4czuTlZkdOmllxrZzVJ01/58cPVPBz+7dklqM8GiWXZr9Nr+7e/OzDz5PeNpM7Z2r5fOXKL8X79glrG6Yji8L2gQSp4FDfBLFpxjDf+jiw0dmrcHHY3zJTSfcMIJRmGz1S8ywUiXZYiajdTv3muGYVSt2mq7XjVtLDrfvHhxaMoUlB9RqCWZcfVknjN/K+asOGXiGhGYdrNxqk8ZCQobH0i9zV3WOqy3kJgXRSdlmzcDuO6665QP32abbcIhDeXabxi/4447htJnN5201Xadf7Dhhhs2oOimmwe3/ZtdrBjZb++XL04yf/OSXJQ+ffCQVp9zW48FHFNQe49Qi8kBWRg0kvD88EvkNRqbV6Elw0ow3Mexluqi88I555wjnKN682zVVVcVDT4/r8qxLbTVdg1MTl41OQVy73hyQtMX7bJkQ8jC7RY3Jc905105aAY+S5fVYCyB7Dxzn4UKyNz6uTO84of7//Axy8CfNr8DDjiAN16HvzulDc1HHXWUNcc4Dv8YBesaUVcwr/2IbQY1tLadaXsDikkS4aPwVEzUd9t1CQKyylstEmsMAVnonJ/eIWMD80h2XOQQWQnDaT8cL33VVVeVQb7sPwccWofCw7Tb7xgc8ZHBuz8w+Nz/GZD7uPX2wb8X1Mpah/UcTzBBMTzU67UzyjmnpIUD7ugapu28886G7Oqrr+4I6zDQdKbtDbwrWXeboj9z43AtZI8XLc7VEcznCDEOikP/2SE/5gd6Vz7SD3/4w5tuumkZGMH8cR8ZzF9/Zv0CnWfVnTW2714x+OIpA9bh93vN4A3/PbMl8aabyxBMdr0/MHOfffYZ4WC0gJI+LWeEFBZ23VbbdTyYYpvCbgorybrjoxDcXXcJ77N6xH5vfgj0t74T3i28Pu6442bHO3kMpHCAVskehKM+OPjf7xpsvNEM6/hnPxjFrJ40HsuZ7z58xue3jPMTNIzkFpuOTjzxRHU9qhSdEbBw4UJRMkGFtrtr9IWTulsIybcjqcgo7n2nhWzhXCbgGktxp581Yw7YVOu2kQRQc/SSlQv+EfXceNPg1tsGt/96psBknjmRqT0+nzj/8TtwJptXBG6cvUE6FpuOa/GnpA1/YJx1aZ2O5H3bxuNtq+1EznzXku/A1d3VRIiOXBKO7rRwUOiTd9x+cPKXZ7Sd3WPshUC4p7+AAwT2pvZWz7bZm381OPv/Ld5vB3s/f/Jgi80G64zgldCA0g4umaxxnFYHiLpAwWZH9iaxHDiqdYFmg2gbydPrMcccQxq5VmqXTLvFmfgiW2aPqSdkJVGPOcD5ZwbzMZI5VUN2c4ftBp88drD//1oc4aPwZy8+LX5OcWIYgyXKIB88WWnOtr7d+KpV90w2k2m3/BziePiHU43w7fx4ZwbHhTRPfzkceMXLB9f+YiZpD/fYKMraR/4bBzn4pzATyoEOfHvdkTPb5GVMU2NcN7PNxD9Djmm48JK6/cxp+OdtNRMW8SM58rd/n3UxpzkyHfxg0I1vr8VJwnJz7LTaZqvBv/5V2pozbNkZbj6KVPMB+y1+r7O0wfTGvzngzv7+d9X0/znPgRFoO/vncOx4nt13nXkxM/1jf+h+r1mGgJ8Z/nevWCb9Ulca1Zy6yyvu9mMhc7UlGz3nFA+mgw05MOxInuQcM3B+RJgv3i2kJr4mXb9w2xnTgML/z2Xx/TlUg+E7/lMzyxOVP2BskyJ82+o5S7YkVzacAsxuDgzbt7N4bmH85pvmZt3YLmqy2+AEq9n08DB899w7s4qO4SMs2vo/BuuuPRMl6fU/EiKsVn71vMcdBFQZPc0mFtUay3LDlv1a1PUCPNQR49XtRCoc+3/tmTueDdYfzF9vZosoZqLuCVa5fUwIHIcAoupoOFmM8y+cYchTVp/Jty+77IBjtWER589SCQxenbnP0R9cYgsmZIhDIhMu8XLBz69PdQdLd94x1yelEI3NvaFq+4WL8uoIIpPJZ29Rgwe77Diz04YndNn36p1gVaOPSQA95MAZDvhgnjPq+KcfLELJ+bFn6VX7ThfexJglBTYXI4FYTN4vMF4tuff4EmCbZUegj286pldD1XZeZbeX2DdZUM/nsK+OnaH8OE7s+hsHzx/NKQajf4TaOUeUxFLFHb+eceYESvbDpbNtbr11BxvOr8fe0Q9siBSsv95MHJTzwy7MsqWNpR577LGckU9hphyYcmDSOTDsnPyk82tK/5QDk8uBqbZP7rObUj7lQD0OTLW9Hr+m0FMOTC4Hpto+uc9uSvmUA/U4MNX2evyaQk85MLkc+P+3lXIrkJqueQAAAABJRU5ErkJggg=="}}},{"cell_type":"markdown","source":"This notebook is divided into the following sections.\n\n0. [Importing required Libraries](#0)\n1. [Loading the dataset](#1)\n2. [Data Visualization](#2)\n3. [Performing Data Preprocessing](#3)\n4. [Defining custom Convolutional Neural Network](#4)\n5. [Training the model on the data](#5)\n6. [Model evaluation](#6)","metadata":{}},{"cell_type":"markdown","source":"Let's get started!","metadata":{}},{"cell_type":"markdown","source":"## 0. Import Libraries\n<div id=\"0\">\n</div>","metadata":{}},{"cell_type":"markdown","source":"Before starting with the dataset, we require to import certain libraries to aid us in data preprocessing, visualisation and training. They are imported as shown below.","metadata":{}},{"cell_type":"code","source":"# To check if GPU is active\nfrom tensorflow.python.client import device_lib\n\n# Load Data\nimport os\nimport cv2\nimport numpy as np\n\n# Data Visualisation\nimport matplotlib.pyplot as plt\n\n# Model Training\nfrom tensorflow.keras import utils\nfrom tensorflow.keras.optimizers import Adam\nfrom tensorflow.keras.models import Sequential\nfrom tensorflow.keras.layers import Dense, Dropout, Flatten, Conv2D, MaxPooling2D, BatchNormalization\nfrom sklearn.model_selection import train_test_split","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","execution":{"iopub.status.busy":"2022-11-10T17:26:40.513913Z","iopub.execute_input":"2022-11-10T17:26:40.51435Z","iopub.status.idle":"2022-11-10T17:26:40.533607Z","shell.execute_reply.started":"2022-11-10T17:26:40.514311Z","shell.execute_reply":"2022-11-10T17:26:40.532212Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"As we would be training a CNN model, a GPU would speed up the training process by manifolds whereas the model would take hours to train on a CPU. Hence, let's verify the presence of a GPU below. \n\nIf the GPU is not available, you can turn it on by clicking at the three dots on the top right, going to Accelerators and clicking on your preferred GPU option.","metadata":{}},{"cell_type":"code","source":"print(device_lib.list_local_devices())","metadata":{"execution":{"iopub.status.busy":"2022-11-10T17:43:21.338995Z","iopub.execute_input":"2022-11-10T17:43:21.339352Z","iopub.status.idle":"2022-11-10T17:43:21.349087Z","shell.execute_reply.started":"2022-11-10T17:43:21.339323Z","shell.execute_reply":"2022-11-10T17:43:21.346856Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## 1. Load Data\n<div id=\"1\">\n</div>","metadata":{}},{"cell_type":"markdown","source":"The ASL Dataset contains 29 classes of images, including all the alphabets, delete, space and nothing. The data is divided into two folders for test and training purposes. \n\nHere, we would use the training data for training and validation purposes. The test data would be used later for model evaluation.","metadata":{}},{"cell_type":"markdown","source":"Let us define the data directories now.","metadata":{}},{"cell_type":"code","source":"train_dir = '../input/asl-alphabet/asl_alphabet_train/asl_alphabet_train'\ntest_dir = '../input/asl-alphabet/asl_alphabet_test/asl_alphabet_test'","metadata":{"execution":{"iopub.status.busy":"2022-11-10T17:27:05.212471Z","iopub.execute_input":"2022-11-10T17:27:05.213431Z","iopub.status.idle":"2022-11-10T17:27:05.219138Z","shell.execute_reply.started":"2022-11-10T17:27:05.213376Z","shell.execute_reply":"2022-11-10T17:27:05.217991Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"To obtain image data, let us read the folders of all classes and store them inside single arrays of images (X)and their corresponding labels (y). Since we are reading and storing 87,000 images, this step would require some time to finish.","metadata":{}},{"cell_type":"code","source":"def get_data(data_dir) :\n    images = []\n    labels = []\n    \n    dir_list = os.listdir(data_dir)\n    for i in range(len(dir_list)):\n        print(\"Obtaining images of\", dir_list[i], \"...\")\n        for image in os.listdir(data_dir + \"/\" + dir_list[i]):\n            img = cv2.imread(data_dir + '/' + dir_list[i] + '/' + image)\n            img = cv2.resize(img, (32, 32))\n            images.append(img)\n            labels.append(i)\n    \n    return images, labels\n        \nX, y = get_data(train_dir)","metadata":{"execution":{"iopub.status.busy":"2022-11-10T17:27:08.742965Z","iopub.execute_input":"2022-11-10T17:27:08.743343Z","iopub.status.idle":"2022-11-10T17:37:40.607633Z","shell.execute_reply.started":"2022-11-10T17:27:08.74331Z","shell.execute_reply":"2022-11-10T17:37:40.606531Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Before moving forward, let us verify the size of both X and y, to ensure all the data is read.","metadata":{}},{"cell_type":"code","source":"print(len(X), len(y))","metadata":{"execution":{"iopub.status.busy":"2022-11-10T17:37:40.609585Z","iopub.execute_input":"2022-11-10T17:37:40.609978Z","iopub.status.idle":"2022-11-10T17:37:40.619892Z","shell.execute_reply.started":"2022-11-10T17:37:40.609942Z","shell.execute_reply":"2022-11-10T17:37:40.614963Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## 2. Data Visualisation\n<div id=\"2\">\n</div>","metadata":{}},{"cell_type":"markdown","source":"Before preprocessing our data, let us explore and gain insight into the images we are dealing with. For simplicity, let us load one sample image from each class.","metadata":{}},{"cell_type":"code","source":"classes = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', \n           'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', \n           'W', 'X', 'Y', 'Z', 'del', 'nothing', 'space']","metadata":{"execution":{"iopub.status.busy":"2022-11-10T17:37:40.621868Z","iopub.execute_input":"2022-11-10T17:37:40.622308Z","iopub.status.idle":"2022-11-10T17:37:40.628935Z","shell.execute_reply.started":"2022-11-10T17:37:40.622271Z","shell.execute_reply":"2022-11-10T17:37:40.627808Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def plot_sample_images():\n    figure = plt.figure()\n    plt.figure(figsize=(16,5))\n\n    for i in range (0,29):\n        plt.subplot(3,10,i+1)\n        plt.xticks([])\n        plt.yticks([])\n        path = train_dir + \"/{0}/{0}1.jpg\".format(classes[i])\n        img = plt.imread(path)\n        plt.imshow(img)\n        plt.xlabel(classes[i])\n        \nplot_sample_images()","metadata":{"execution":{"iopub.status.busy":"2022-11-10T17:37:40.631729Z","iopub.execute_input":"2022-11-10T17:37:40.632121Z","iopub.status.idle":"2022-11-10T17:37:42.208175Z","shell.execute_reply.started":"2022-11-10T17:37:40.632086Z","shell.execute_reply":"2022-11-10T17:37:42.203791Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"We can observe various sign language images as seen above. These denote different alphabets and symbols that our model would be trained to recognize. ","metadata":{}},{"cell_type":"markdown","source":"## 3. Data Preprocessing\n<div id=\"3\">\n</div>","metadata":{}},{"cell_type":"markdown","source":"Before feeding the data to our model, we convert into numpy arrays and normalise the values by dividing the image pixel values by 255. \n\nThen, we divide our training data into training and testing sets to be used by the model. ","metadata":{}},{"cell_type":"code","source":"def preprocess_data(X, y):\n    np_X = np.array(X)\n    normalised_X = np_X.astype('float32')/255.0\n    \n    label_encoded_y = utils.to_categorical(y)\n    \n    x_train, x_test, y_train, y_test = train_test_split(normalised_X, label_encoded_y, test_size = 0.1)\n    \n    return x_train, x_test, y_train, y_test\n\nx_train, x_test, y_train, y_test = preprocess_data(X, y)","metadata":{"execution":{"iopub.status.busy":"2022-11-10T17:37:42.209277Z","iopub.execute_input":"2022-11-10T17:37:42.209661Z","iopub.status.idle":"2022-11-10T17:37:43.062511Z","shell.execute_reply.started":"2022-11-10T17:37:42.209617Z","shell.execute_reply":"2022-11-10T17:37:43.061393Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Let us confirm the size of training and testing data.","metadata":{}},{"cell_type":"code","source":"print(\"Training data:\", x_train.shape)\nprint(\"Test data:\", x_test.shape)","metadata":{"execution":{"iopub.status.busy":"2022-11-10T17:37:43.064492Z","iopub.execute_input":"2022-11-10T17:37:43.065348Z","iopub.status.idle":"2022-11-10T17:37:43.07177Z","shell.execute_reply.started":"2022-11-10T17:37:43.065301Z","shell.execute_reply":"2022-11-10T17:37:43.070563Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## 4. Define CNN Model\n<div id=\"4\">\n</div>","metadata":{}},{"cell_type":"markdown","source":"Next, we define the architecture of our custom CNN Model. ","metadata":{}},{"cell_type":"markdown","source":"I have trained the model for 15 epochs, with the standard batch size of 32. Feel free to experiment with them for your use cases.","metadata":{}},{"cell_type":"code","source":"classes = 29\nbatch = 32\nepochs = 15\nlearning_rate = 0.001","metadata":{"execution":{"iopub.status.busy":"2022-11-10T17:43:33.614726Z","iopub.execute_input":"2022-11-10T17:43:33.615115Z","iopub.status.idle":"2022-11-10T17:43:33.619986Z","shell.execute_reply.started":"2022-11-10T17:43:33.615083Z","shell.execute_reply":"2022-11-10T17:43:33.6188Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"For our model, let us initialize a Keras Sequential model. \n\nThe defined model is a 4 layer deep CNN model. Batch normalisation and dropout layers have been added to avoid overfitting on the training set and perform regularization. Max pooling is also applied.\n\nThe three CNN layers have been flattened out and connected to a dense layer before performing classification using the softmax activation function.\n\nThis model is created by experimenting with various layers to achieve the maximum validation accuracy.","metadata":{}},{"cell_type":"code","source":"model = Sequential()\n\nmodel.add(Conv2D(64, (3, 3), padding='same', input_shape=(32, 32, 3), activation='relu'))\nmodel.add(MaxPooling2D(pool_size=(2, 2)))\nmodel.add(BatchNormalization())\n\nmodel.add(Conv2D(128, (3, 3), padding='same', input_shape=(32, 32, 3), activation='relu'))\nmodel.add(MaxPooling2D(pool_size=(2, 2)))\nmodel.add(BatchNormalization())\nmodel.add(Dropout(0.2))\n\nmodel.add(Conv2D(256, (3, 3), padding='same', input_shape=(32, 32, 3), activation='relu'))\nmodel.add(MaxPooling2D(pool_size=(2, 2)))\nmodel.add(BatchNormalization())\n\nmodel.add(Flatten())\nmodel.add(Dropout(0.2))\nmodel.add(Dense(1024, activation='relu'))\nmodel.add(Dense(classes, activation='softmax'))","metadata":{"execution":{"iopub.status.busy":"2022-11-10T17:43:36.585159Z","iopub.execute_input":"2022-11-10T17:43:36.585642Z","iopub.status.idle":"2022-11-10T17:43:36.746059Z","shell.execute_reply.started":"2022-11-10T17:43:36.585572Z","shell.execute_reply":"2022-11-10T17:43:36.744948Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Adam is used as the optimizer here with 0.001 as its learning rate.\n\nSince this is a multiclass classification, categorical crossentropy is chosen as the loss function. The model is trained on the metric of accuracy.","metadata":{}},{"cell_type":"code","source":"adam = Adam(lr=learning_rate)\nmodel.compile(optimizer=adam, loss='categorical_crossentropy', metrics=['accuracy'])","metadata":{"execution":{"iopub.status.busy":"2022-11-10T17:43:40.842898Z","iopub.execute_input":"2022-11-10T17:43:40.843271Z","iopub.status.idle":"2022-11-10T17:43:40.855807Z","shell.execute_reply.started":"2022-11-10T17:43:40.843242Z","shell.execute_reply":"2022-11-10T17:43:40.854685Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"The summary of our CNN architecture can be seen below. \nOverall it contains 4,596,765 trainable parameters.","metadata":{}},{"cell_type":"code","source":"model.summary()","metadata":{"execution":{"iopub.status.busy":"2022-11-10T17:43:47.666375Z","iopub.execute_input":"2022-11-10T17:43:47.666833Z","iopub.status.idle":"2022-11-10T17:43:47.680889Z","shell.execute_reply.started":"2022-11-10T17:43:47.666771Z","shell.execute_reply":"2022-11-10T17:43:47.679718Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## 5. Train Model\n<div id=\"5\">\n</div>","metadata":{}},{"cell_type":"markdown","source":"Now, let us train the model on our training data. \nI have used the standard validation split of 80:20 for training here.\n\nThis step can take several minutes to train the model.","metadata":{}},{"cell_type":"code","source":"history = model.fit(x_train, y_train, batch_size=batch, epochs=epochs, validation_split=0.2, shuffle = True, verbose=1)","metadata":{"execution":{"iopub.status.busy":"2022-11-10T17:43:55.58646Z","iopub.execute_input":"2022-11-10T17:43:55.587597Z","iopub.status.idle":"2022-11-10T17:46:39.781935Z","shell.execute_reply.started":"2022-11-10T17:43:55.587555Z","shell.execute_reply":"2022-11-10T17:46:39.780872Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## 6. Evaluate Model\n<div id=\"6\">\n</div>","metadata":{}},{"cell_type":"markdown","source":"After completing the training of the model, let us evaluate its efficiency on the test data.","metadata":{}},{"cell_type":"code","source":"  test_loss, test_acc = model.evaluate(x_test, y_test)\n  print('Test accuracy:', test_acc)\n  print('Test loss:', test_loss)","metadata":{"execution":{"iopub.status.busy":"2022-11-10T17:46:39.784458Z","iopub.execute_input":"2022-11-10T17:46:39.785176Z","iopub.status.idle":"2022-11-10T17:46:40.891538Z","shell.execute_reply.started":"2022-11-10T17:46:39.785131Z","shell.execute_reply":"2022-11-10T17:46:40.890661Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"It reports **0.99885** Test accuracy which is very commendable. \n\nNow let us plot accuracy and loss over the training epochs to better understand the training of our model.","metadata":{}},{"cell_type":"code","source":"def plot_results(model):\n\n  plt.figure(figsize=(12, 12))\n  plt.subplot(3, 2, 1)\n  plt.plot(history.history['accuracy'], label = 'train_accuracy')\n  plt.plot(history.history['val_accuracy'], label = 'val_accuracy')\n  plt.xlabel('epoch')\n  plt.ylabel('accuracy')\n  plt.legend()\n  plt.subplot(3, 2, 2)\n  plt.plot(history.history['loss'], label = 'train_loss')\n  plt.plot(history.history['val_loss'], label = 'val_loss')\n  plt.xlabel('epoch')\n  plt.ylabel('accuracy')\n  plt.legend()\n  plt.show()\n\n\n    \nplot_results(model)","metadata":{"execution":{"iopub.status.busy":"2022-11-10T17:46:40.893398Z","iopub.execute_input":"2022-11-10T17:46:40.894043Z","iopub.status.idle":"2022-11-10T17:46:41.23742Z","shell.execute_reply.started":"2022-11-10T17:46:40.894005Z","shell.execute_reply":"2022-11-10T17:46:41.236501Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"As you can observe, the training and validation loss decreases with epochs while the training and validation accuracy increases. Our training and validation metrics continue to be relative, indicating that the model is generalised and not overfitting. ","metadata":{}}]}