{"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":"code","source":"import numpy as np # linear algebra\nimport pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\nimport cv2\nimport matplotlib.pyplot as plt","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","execution":{"iopub.status.busy":"2021-06-13T12:16:17.981033Z","iopub.execute_input":"2021-06-13T12:16:17.981662Z","iopub.status.idle":"2021-06-13T12:16:17.986552Z","shell.execute_reply.started":"2021-06-13T12:16:17.981595Z","shell.execute_reply":"2021-06-13T12:16:17.98514Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# 1. Processamento de Imagem\n\nComo estamos tratando de problemas que envolvem _o escopo das imagens_, vamos utilizar bastante o módulo de python `cv2`, oriundo da biblioteca [OpenCV](https://opencv.org/). Com ele conseguimos carregar imagens, salvar imagens, aplicar transformações, convoluções e outros processos nos quais veremos alguns no nosso curso. Começaremos pelo básico que é o processo de carregar imagens.","metadata":{}},{"cell_type":"markdown","source":"### 1.1 Carregar uma Imagem\n\nPara essa parte do notebook, abra a aba de Dados pela seta que aponta para baixo ao lado de \"Add Data\": </br>\n![image.png](attachment:2590dc96-7daa-4d5e-9ac5-53d78051b059.png) </br>\nVocê irá observar dois diretórios, um escrito *input* e outro de *output*, como deve imaginar pelo nome, o de input representa dados de entrada e o de output representa os dados de saída, se nós salvarmos uma imagem por um comando do notebook essa imagem ficará dentro dessa pasta. </br>\n![Captura de Tela 2021-05-23 às 16.58.48.png](attachment:28adb364-e639-454f-b7ef-9ab65bb580bf.png)","metadata":{},"attachments":{"2590dc96-7daa-4d5e-9ac5-53d78051b059.png":{"image/png":"iVBORw0KGgoAAAANSUhEUgAAASgAAADlCAYAAADgBmrHAAAgAElEQVR4Ae2daVRVV5r3/dD9oVd3+lNXutfqVHcllUqvN1WV9EoqVdaq6U3Wa2I6pnzNa1IpozFxiMZoHOIQUcsRERFFjYoMTiCoOIsooqAIDogTEJFJUUQGBQEZHPO867/x2Z47cLlc7oVzD89e63DO2fP+73t+99nPOdzTiySIAqKAaRS4crXUNH0xQ0d6maET0gdRQBRoVcB0gGppIcrJIdq9m2j1aqKQEKJ581r3OEc80pHPB0EA5QNRpUpRwFMFuh1Qjx8TZWQQTZ5M9OtfE/393xP16tX+hnzIj3Ioj3q8EHpBENlEA/kM9OzPwLWsLKqdOIke/uu/tg8jN4D18N/+TdVXmnWmU3xRgPIC6KQKUUAU8EcFamqIpkwh+od/8AqYHKwt1Iv60U4Hw/6kgySA6qBokl0UsIwCcXFEP/qRb8Bkb2WhHbTXgSCA6oBYklUUsIwCTU1Egwa5D6Yf/5jo7beJRo5stYZmzWrd4xzxSLcHUlvnaBftuxEEUG6IJFlEAUspUFFB9OqrroHyd39H1L8/0YYNRDdvujd85EN+lEP5tgCFeLSPfrQTBFDtCCTJooClFCgrI/rZz9qGxz/9E9H06e5DqS1xACvUg/raAhX6gf64CAIoF+JIkihgKQXq64l++cu2gfHxx0SVld4dMupDvW1BCv1Bv9oIAqg2hJFoUcByCvTr5xwU//iPHXZed1ibzZuJ0I4zUKFfbQQBVBvCSLQoYCkF1qxxDod/+ReiM2e6ZqhoB+05gxT65yQIoJyIIlGigKUUqK4m+ud/dgTDM88QnT/ftUNFe2jXHlLoH/ppFwRQdoLIqShgOQXGjnUEAgCxZ0/3DBXt2gMK5+inXRBA2Qkip6KApRSorXX+hPiIEd07TLRvDyk8cY7+GoIAyiCGHLatwA8//ECPvfTPn223IileV2DZMkcQYDl165bXm+pQhW0tO8PCbKoRQNnIISdtKbBy5Sr66Yv/1VayR/GPHj2i5ORDajt0KIUAwfZCTm6uyp+fn99m1qNHj6k8lZVVbeYxJrhTpzG/Xx3/6U+OgJo0yRxDQD/srSj01xA8AlRaWhrt2rVLbYmJiVTWzsNWhvbk0E8V8AWgTp06TT95/kW9nTvXvsP2q7Ffq/yBgUFtKvnzX7yq8hw+fKTNPMYEd+o05i8ru0EzZs5S2/37941J5jpubHT+RHdenjn6mZvrCCg8gY5+PwkeAerll1+mXr160bPPPkvPPPOMOn7uuedo586dXK9b++TkZJo7d65beSVT9yrgC0DNmjVbwwmgWrBgYbuDdAcmvgZUTk6O7ndTU3O7fe62DKdOOQLgP//T7e7ExG6mGjd+gQB5kNejgP7YW1Ho95PgMaBm4Z8Fn4SKigqaNGmSAlVKSgpHt7sPCQkhwE6C+RXwNqAePHhADJK+7/ZTF/zrv/oNYdlnDCkph2nYsBGEPKvXhNOYr8apvGxBwS8WERFJAz4YSAMH/oVgNXG9bVlQ7dX58OFD2rotgQDDN9/qQyO/GE2ZJ06obmFp2eftvhpQf+7/Ae3Zu0+nhYSEUr/3+6v+BAeHUJOb/xRrHLPXjvF/cfYX/4ABblUP4OBL452+77mEFOCEPMjrEaTQH/s+ot9PglcAxZUNGTLEBjg3b96kcePGqbiXXnqJvvnmG2pubv3GWbhwIcHqgiXWu3dvio+PV9W4KsPtyL7rFfA2oOAn4uVdXt73+vjkyaffnhkZmTqe8/KeAbUsbHmbeZwByp06ly9fqesENLnNrKwzdCY7W59z/IYNG+nWrVsajAxIpA8aNKTrJ4tbXLrU8eKfMIFTXe6N4GkLUu7kcdkIEtEfe0Ch30+CVwF18uRJBZyGhgbC2vy1116jF154gcLCwig0NFQtB2FpIWRlZdHgwYPVMnH79u1UVFTUbhnutOx9q8C8+QvUhYWLi7c//ulNdWHyuXEPwHQ0TJ4yVdU3eMhQVRTWDy7omTP/pquC5YI4WE/FxSUEy4ehAEDB2uLzCRO/oYqKSgpdukzHOQOUO3UuCl5M6B874mEloZ2FQYtU35wt8TIyMwlL1rCwFcrZn5Z2VPejtvaOHlOXHsyf73jxz5zpdhdcAchVmtsNICP6Yw8o9PtJ8CqgsNSDRZSZmak+PKmpqXTlyhVui6ZMmUKvvPKKPrdf4uED114ZXVgOfKYAAPXJJ5/abAwo+3icdxRQsKIZLFgSXb16lebPD1RxsD6w/ENg6yUqep0eK5ZPKAtAoRzXA2gg1NXV6ThngGqvTtTR2NhIm2Ji6dvpM9SykdsAtBCcAQrx2WfPEsYDCHI7KFt67Zoq1+V/OmFBcV+dgchZHOfv8L4rLaji4mIFqEuXLql+Yv0N6yggIIA++ugjZUHBsc7BHlCIb68Ml5V91yrgzSUeHi3gi97ZHtYHHjngpVJ8/BY92I//+okG1KVL+bqeoqJilaelpUXH2QPKnToBx96//b2uA/4v+KHQT1eAgs+KxwIf1ajRY/R5twGqEz4oLTjhl3qf+pmw3GOfU1tLP2PZdo+70ge1bds2BShYQvgmg98Jd/mGDRtGixcvps8++0wt6bjT9oBypwyXlX3XKuBNQPGdOIBg/PiJemOrg0GAZSQu+s8+H04AD27vMwRgQcGNwOfwGwFA+/Yl6jh7QEGx9uqEn4nrxOcRgZef3C+jBYWL11gvlpgIcKpzPd0GqE7exVMDefLHCCmMyytwQt3/8R+OSzxv38VDOwyX/vg1PSLCIwRY7sEM54A7f/YWFCDGwZ0ynFf2XauAtwB19+5dfeFu3BRjM4i1ayN1GpaBmzfH63O2pviiZyc5ww7xDDjO4wxQ7dV5+/Zt3ea0adPVHUSujwGFRwu4P1j6wuILWhSsysHamjN3nk1fug1QbT0HheePPAgMKa/ByZfPQeGOHXxNgAqc4Lgjh0cGap/8Lw2WeQDUsmXL1IOceEYK50ZAxcXFqbgDBw5QVVUVuVPGA12liBcU8Bag9u9P0gAoLy+36VlJyRWdBoc4Anw6DANYUuzkZkDBJWBcTiE/g8oZoNypMyIySteB5do3k1sd+gAWh9jYOJ1nSehSZd2xdQagGe8uXr/u+lcjuU6f7L38JDkgxVZjp/vrqyfJ+UFNAAdbnz59aN68eQQnuTHMnj1bpTOYBg0aZAOo+vp6euedd1Qe5EVor4yxfjnuOgW8BShPegyXAe4MuwqwuO7du+cqi01ae3Xi+ao7d1qXeDYFDSfIgy9k47/ooJ94jso0Qf4Xz/VU4INz7do1hwfwjKUwqXznBvHulDGWl2PfK4CLUP5Z2Pc6e70F+TUDr0sqFYoCooA3FZDfg/KmmlKXKCAKeFWBtn7aRH5R06syS2WigCjgqQKrVzvezscT3PKb5J4qKuVEAVHAqwp051td8MpzeauLV6dTKhMFrKWAvBfPWvMpoxEFLKeAvFnYclMqAxIFrKUAnld89VXnPin+ZQH8siX+KwT/z4fXmLsTkA/5UQ7luS5ne7Rv99yksyY8+jUDZxVJnCggCviRAvghvUGDXEPECJYf/5jo7beJRo4kmjKFCD9YiT3OEY90Y35Xx2jXzR/yE0D50WdKuioKeF0BOK9/9CP34eIKPO2loR2014EggOqAWJJVFLCkAvhFBlhDeC9de5DxJB31on43ft/cXl8BlL0ici4K9FQF4BOaN4/o3//dO6B67rnW+iorPVZUA+rK1VKSTTSQz4B8Bq6UXKHyhO10Z+RIuvfKK/RDew7vJ1YV8iE/yqE86uns50kDymPESUFRQBSwtgItLfidY6Ldu4nwRHpISKtlhD3OEY905PNyEEB5WVCpThQQBbyngADKe1pKTaKAKOBlBQRQXhZUqhMFRAHvKSCA8p6WUpMoIAp4WQEBlJcFlepEAVHAewoIoLynpdQkCogCXlZAAOVlQaU6UUAU8J4CAijvaSk1iQKigJcVEEB5WVCpThQQBbyngADKe1pKTaKAKOBlBQRQXhZUqhMFRAHvKeAxoO7evUtHjhyh1atXE15dzq88917XWmvCa9UTEhK8Xa3UJwqIAn6ggEeAys3NpRdeeEG9spz3zzzzDGVmZro95OTkZJo7d65N/pKSEho9erTNa65feuklGjBggE0+OREFRIHuUaCmpoawdVXwCFDvvvsuvfLKK1RVVaX6WVdXR71791Zx7nY8JCSEXn75ZZvsp06dUtCrxosGnwS8515euc1qyF4U6D4FAKZ3+r6ntq6ClEeAgrUUHBxso9TVq1dp27Zt9OjRIx0fGRlJ7733ngLR2LFjicGzcOFCeu655xSMALb4+HiCRQVg9erVi1577TWagl/gI6KJEyfSypUr1XFMTIyysDZu3Eh/+MMf6J133qEtW7bo9nAAaE6dOlXBEnlg1f3ud7+jrKwsle/+/fs0Z84ceuONN1T8okWLCBCUIAqIAm0rwHD6yfMvEjaAqisg5RGgJkyYQM8++ywlJia2eXEDYIDNggULKCgoSOUHFAADwGLw4MEqbvv27VRUVEQAXGBgoCoTHR1NJ0+eVGr16dNHwwr1oE5YbytWrKBBgwap83Pnzqm8LS0tCjpYFiJ96NChBJiiDPxlCN98842Kg+9s1apVqg/oowRRQBRwroARTmxBdRWkPALUrVu3aNy4cerCBwAAipSUFD26pqYmlbZjxw4dB4gAFIcPH1Zx7i7xnAGquLhY1wsf2OzZs9V5UlKSagPA4xAaGqriGFCwpgAuDnl5eQTflwRRQBRwVMAeTjh3FudY0jsxHgGKm75x4wZFRETQW2+9pSDAyzJYP4ARHN5YomGD1YU4WC0IngIK1pExDB8+nD788EMVBUsI1pUxXLx40QZQ4eHh6hx9xtLRCDtjOTkWBXq6Aq5A5CrNm7p1ClDGjuBxAAAIjxvAn8SAArSMG9IQPAWUPYC++OILDSj4lmBRGcOlS5dsAIU0ABTl2A+2fv16YxE5FgV6vALuAMidPJ0VssOAKiwsVH4e9hFxB7DEA5TKy8upsrJSHcP5zeGHH36gy5cv86kClL01xHfxKgxvHLVf4rkC1L59+1S7xnbgi0K/eIkHX9edO3dUP+DQx3LPHmq6k3IgCvRQBWJiN7vlDDdCCmW8HToMqAcPHijLA3fcYA1hibRnzx4Vh7tvHN5//30CgGJjY5UTfNq0aQoU8PkgxMXFqXM85MmPK1y7dk3FwboCCBE6Aig8PIo+wC8WEBBAw4YNs3GSo+/oN56rgp/qzJkzakmIu4ESRAFRwFYBAAcAai8gjy/ghHY7DCgUgoXy5ZdfqjtgsE6w9e/fn+A859DY2Egff/yxSkM6wIDHEDjU19erxwSQxk5upGE5iDg4sxE6Aijkh/WGO3W4Y4jntWA5oT62oLKzsxXEEIcNjzkYneqqUfkjCogCplDAI0Bxz/EAZWlpaZuPGiAfHiswgovL8r6hoYFg2RhDc3Mz4U6gJ8G4vEP5Y8eOKRDBWW4M8JWhbQmigChgXgU6BSizDQt3FWEVYWmXnp6uHuLEkg/PbMnT6GabLemPKNC+ApYCFIZ79OhRtbQDqOCLgi9MnnNq/4MgOUQBMypgOUCxyLhrKEEUEAX8WwHLAsq/p0V6LwqIAlBAACWfA1FAFDCtAgIo006NdEwUEAUEUPIZEAVEAdMqIIAy7dRIx0QBUUAAJZ8BUUAUMK0CAijTTo10TBQQBQRQ8hkQBUQB0yoggDLt1EjHRAFRQAAlnwFRQBQwrQICKNNOjXRMFBAFBFDyGRAFRAHTKiCAMu3USMdEAVFAACWfAVFAFDCtAgIo006NdEwUEAUEUPIZEAVEAdMqIIAy7dRIx0QBUUAAJZ8BUUAUMK0CAijTTo10TBQQBQRQ8hkQBUQB0yoggDLt1EjHRAFRQAAlnwFRQBQwrQICKNNOjXRMFBAFBFA99DOA174nJx+y2XJycuj+/fudVuTq1auq3uyzZztdl1TQsxXwCFAXLuZSaem1nq2cn4/+8uXL9JPnX3S67d27z+3RpacfpxkzZ9GaNWt1mYjIKFXvsGEjdJwciAKeKOARoMZNmEobYuI8aU/KmEQBI6AAmOkBM+nnv3hVAysv73u3ehoVvU6VGfDBQJ1fAKWlkINOKiCA6qSA/lrcCKjKyio1DCz72KoCZBYsWEgAz/LlK/UwYV0h7tOhn9P27Tuo929/r8sgvrCwiIyA2rVrN3340cf02efD6dChFDK+kj4/P5/mzV9Afd/tp9IjIiLp3r17uq2BA/+i2jp9OoumTv1W5UNfuL86oxxYVgGfAKqmppZWh0cRLK0x4ydTRPQG/cG7crWUJk+bRVgmzgsMpomTA2jXnkRqamrWIj9+/Ji279xN0wLm0PhJ39KB5BQKj1xH+w8kqzyHU4/SkmVPLxpEboqNp/it23UdhUXFFLhoiWp/0pQZtG//AZ2Gg6LiElq2fJVKD14SRlnZZ1W/Hj58qPMlHTxEs+ctVONYFR5Jd+rqdJq/HzgDFHR//Ve/UcAJDg6hmNjN6hhxDJbhI75QcdOmTafw8AgNJwYb/FgMKKNFxunnz19Q0qF9Z+lffvkVPXr0SOXhMvb5Ro0e47H8mSdO0JLQpU43pEkwlwJeBxQucEBn1NhJtHP3Ptq+cw8NG/kVrY1ar0ae930+fTr8S5UeE7eVotZvUue79yZqZQA05EE6lpIor843b1F5tmzbocClCxBR0OJQBRzE3ayoUPm/nTFXwS1q3UZ1fuLkaVUE6agzYPYCBS6AEPVjYyfx1oSd6jxuSwKhveGjvyaA7tHjx8Zm/fbYCKiMzEw6d+68smYYCkeOpFJ1dbUGEPI3Nzfr84yMTDV2V0s81LVvXyIVFBTQH//0piobGBikyo35apw6h9VVUVFJR1LTHOrmvgweMpTgeF+6LEznqa+v90h7WGiw/rhu3iPOaL15VLkU8roCXgcUvoXPX8xRHzrubWT0Bg0UBlTK4VROphWrwmnq9FnqvLGxUYEBVhKHywWFKi7GTUC13LtHxzNP2nzgYIkBfAiAIiw7hhHiYCkxoFAex6iDAywuxJ19YgFwvL/ujYDii5T3gMeDBw/U0PhiBogAJeSBRcNWjitAvflWHy1P0KJgVRb1IbClFhv71JfZ5+2+Ks93q1arPNyfpKRW69cITHd9ZLoDhgN7SAmcDOKY7NDrgML4cIGnZ5yg9RtjlWUDawUWCAIDqqa2VksBGCEPQk5ungJBQ8NdnQ7oId1dQKEg6uelIcMnNKx1WRgway4BmsawNzFJA+pSfoE6BjixtMS2JiJaxSGfFYIRULjbBigBIkkHDmr4YJw7d+5S0IAVA+sH0Jg/P1BL4ApQ8CFxgO8IZQEDwI3hAx8VB1hTiF8UvFhFcR621u7evavLdQZQqJwhJXBi9c259zqgYAHBOgFQli7/jrZt30kAgz2gjABKTTumAXX+wkUFgupbt7Ri8H+0B6j5CxfrJR78T7B20I/Va6Noz74ktTxjQMFaA3yMAf4ttqCyz55Tx8gDkBk3pFkhGAHlyumMpRSDgq0eLAc5MKBg/XBgH1RbgEI+AA/1fjX2awWsiooK3c7Bg62+Rm7XF4BCHwApWdbxrJlz73VA8cVdUVmpRww/kruAqm9oUHCA9cOBl1dsQSWnHFF5WlpaVBYADPXD6Y0Ayw0+MF6GIA6OeQYUgIP8sMw4wGHPgKqtvaOO044d52TlJC4ru6HP/f3AXUBhnHBcMyxw144d5kgDrDit3/v9qaqqWjvJXQHqwMFkXY79U6gHy0L2L3G9vgKUv89hT+i/x4AKWbpcLdewZOOtsamJrl0vUxf3jl17CVYQ/Di48N0FFESH5YIyAApgA+sJ5wwoBgj6cDormxaHhql0BhRbQ7DGKquqlZOb60P9pdeuqzphYcUn7CAs+ZCOjf1Sc+YHKQsMy88b5Te1M98qD6gWFBZqQLiyoKCXESZwVNsH3NFjmODBTbaqnAEKjxtwwPKR/U4oj7SbN29ysq6T7641NTXpuM4u8XQjcmBqBTwGFF/Qxj0eHUDALX+OB5hwG78jgMKdMtxFw901LMfgUIcFxIBCG7hDOGrMBNXOd6sjaEFQiLag8MgCW0ToB+4qoi62oFC+oLBILUGRBtCxVcaAgnW2KGSpHgcemTianqHG15P+4M4d+6EAEYDNWYBubPk4S3cVhy8cdsq7yidpPU8BjwDljkxY21dVV9sso9wphzy3a2psnouCZQbQwJdkDACZ8bklYxqO4ecyOuON6dftlmuxW7Ypq8q4fEF+LBPr6jy7pW1szx+PMXbjM0h44lyCKNCVCvgMUJ4OAoCAVQOLCQ9PwqeFZ5wAqOvXyzyt1qYcnodCfbDSLuVfpr2JBxScYElJeKoAfG5/7v8BDRo0hCKjogk3QCSIAl2pgOkAhcHD8sKykH1PgJW3nz9KTEpWd/YAKiwV8aR4c3Or070rJ0DaEgVEgbYVMCWguLv2yy2O9+a+K9rwZn+lLlGgJylgakD1pImQsYoCooCjAgIoR00kRhQQBUyigADKJBMh3RAFRAFHBQRQjppIjCggCphEAQGUSSZCuiEKiAKOCgigHDWRGFFAFDCJAgIok0yEdEMUEAUcFRBAOWoiMaKAKGASBQRQJpkI6YYoIAo4KiCActREYkQBUcAkCgigTDIR0g1RQBRwVEAA5aiJxIgCooBJFBBAmWQipBuigCjgqIAAylETiREFRAGTKCCAMslESDdEAVHAUQEBlKMmEiMKiAImUUAAZZKJkG6IAqKAowICKEdNJEYUEAVMooAAyiQTId0QBUQBRwUEUI6aSIwoIAqYRAEBlEkmoqu70dDQQMnJh2y2nJwc/WblzvYHL+PEq6o+/usnNGzYCI9f6tnZfkh5/1bAI0DhDcIZmScdtvLyp6+t9lQWvPAzMnoDFZdc8bQKKeeGApcvX9avEefXlvN+7959btTgOgte8sn14eWf8vYc13pJqnMFPAIUXgOO98nhdebG7UByivNWOhBbWVX95C3C+ztQyj+y4t17RcUlpuisEVCAyfSAmTZvEc7L+97jfgJGDKdNMbFUV1fncV1SsGcr4DGgNsTE+Uw5V68z91mjXVAxoA7L0wzBCKjKyirVJSz7GCwRkVFUXFxCAz4YSB9+9DEdOpRC/d7vT4hHyM/Ppzlz51Hfd/vRZ58Pp42bYpSVVF9fr8pwPW++1YdmzZqtyuBV6siHJV+ft/vSzJl/o6KiYpWGPwMH/kWV3b8/iT4d+jmNGj1GpdXU1NCysOU6ffHiJYS+InAfBw8ZStlnz9LIL0arOuLjt1Bzc7PKgz+1tbW0fPlKNRaMY/aceXTr1i2d3l7f0IeNGzepvmPMi4IXU05uri4vB75RwCeACo9cR3sTk2j9xlgaP+lbCg1bqV4xjiFcuVqqXmtufI05vnFnz1tIeNsvjqdOn0W5eZfUiA+nHqUVq8Jpx649BMtt/4FkFY83DeNV5YhDutEy4TawFJ0XGKxepb5rTyI1NbV+YLmN9IwT6rXqqCNq/SZquXdP7dHnpcu/o5IrV21UTzp4SPUT+WEN3TFYBq7GXFNbq8as3mI8dhJNC5hjU293nDgD1OPHj+n1X/1GQSo4OIQuXLiogcXAARwKCgpsrC1OA7BgLWFJx3HYAzbQ3Ljs43TkBWQQOI73eO363bt3FRg5jvcAJ+bT2Ef7dgEUhLbq6P3b3yvfWHt9gy54/TvaRhsox8diHSqJffbHJ4AKmL1ALdMAHYAKry7Ha8xhGT16/FgtC2PitupB5V8uVPkLCovUBxkX8snTWSp9y7YdKm3M+MmUsGO3AhzAgzxLlq0khgbqv152Q5XJ+z5fpY8aO4nQDuCD/Lv3Jqp0fCBxjjJbE3bSptj41vxjJtD8hYtp3/4DCqzfzpir+4h8KBO3JYHQJyxtJ02ZocaDTK7G3NLSQoAhysO/duLkaV1vdx0YAZWRmUnnzp2nefMXaEgcOZJqc/GPHz+RCguL6Pbt2zTmq3Eq38RJkwljgzXF4Lhzp45gjfB5VtYZNURjntzcPOWMnzxlqsoXGBik8nAZWCiwhm7evElYIiIelhjahvMdx4g7fPiITR9h1ZSWliorB+mAGALXAbicP3+BYDEyiPftS7Tpv7O+YUzct6QDB1Wd361arSxI6CbBdwp4DChc3LhAjRsmEgEX66gxExRscF5V3epXgtWDEL0hhgAPDhHRGwgAQmB42APq1q3bnF1ZWMFLwvQ5Lgj0Y9nyVSqOAZVyOFXngZUFywyB24g1QBJgYogiT1b2WQUUWEmwrACX44blGSw2xPGY2hsz6kR+My7x+OLjPQD04MEDm4v/xo1W+GMcfHEDFLCOsHHZ9PTjTgG1dVuCzsNlsMxDOVhKCFzHrt171Dn+AIKIR5tcjtsPCQm16WNVVbUqB4hwXYiYMPEbdY5xcaioqKCCwkLC0s2dvmH5yXUCfIAq7npK8K0CHgNqxpxA2pt4wGZrbGpSvcXFujq81VfB3QewYE0hYAmGixUWE8xnWCOwjhAYHkZAYcnFAVYYymbaWSEoj6UXAgMKSysOWCoCQAi6jVOtVhrisEQLmPXUYsIdSbSDpeil/AJ1DMghH7Y1EdEqjsfU3pjRhlkBBZ8QLt6gRcGEixvARzAun9ifY7SOAJbhI76w2TIyMp0CKip6nb7A7cvAkkJgAKAODsiLeCyr7MuhTmd9TEs7qutCPVzH1KlPP0dcP/bu9A3wWxK6VMOZ+5qScthYlRx7WQGPAeXKSY6LFUsZYzACCvETJweopdfFnNblWvUTh6WGh2GJZwRUc3OLutCzz54zVq9ACdAhMKAaGu7qPKlpxxwB9aQNZHIFKLQFuABQGJdx4364M2azAoqd5FqsJwfOLn4ksT9m6bJWKxbQglM6IWEHwTIxQoyXeGfOnNHQgCMdAXcKN2+OpyOpaeqcL3ojoG2Eb9MAABKKSURBVLCUQjwsGHw2ELC027J1m3JSO+ujPaBWrV6j6oDlhbbxpQhHOerdsWMntdc3wAlWFnxaADWsSbb+2oKe6qj86bQC3QaoPfuSlOW0/Ls1BGuMQ3uAQj5YSvAbGUPQ4lAKXLRERXkbUPB7AC5px47rJtHPsic+L0S6Cyj4oswQjD6ojgIKd9kYJngQE0senMPKgUPaGaDgq2IowBcEi42d2vARIXCdRkCVlFzR+bCkxF06zgfAuQMo+KW4Lez/+Kc3dR3l5eXKj+aqb/fv39d+L4x12rTpuvy2hO1mmE7L9sFjQOEOGkBg3PAME4I7Fyv8VbjosaUeTdcCuwMo3JFDuZQjaQoSWN7h/NTpVoestwGFzs2ZH6T8ZFgq3ii/qR3vpaXX3B4zrEj4zrC07e4A/wtf6O4ACoAxBlhL7KxGPXgkAA5mBCOgzmRn62K41W8EDKyQsLAV2jLi/mSesIU4IGT0AeGxBzi3EYyA4j7CD8Z1ceMXL9rWgb7DcuLQXt9Q3th3gA7WHcYqwXcKeAwohotxz3fm3AEUhoRHAFCeP1iIcwdQyBezeYuywFAeF77xIVFPALU2ar1THxRbSejjopClqr9oE1bc0fQMPTPujJnv5Kkx37uny/rzAb5o4FDvSMBFDed0RwOWV7DQOhNQBy8xndXTXt/gAzU+P+WsDonzngIeAcp7zXeuJsDM+CxS52pzrzQ+wHV1rT4U90rY5oL/o7Gx0TZSzkQBUcCpAn4NKKcjkkhRQBSwjAICKMtMpQxEFLCeAgIo682pjEgUsIwCAijLTKUMRBSwngICKOvNqYxIFLCMAgIoy0ylDEQUsJ4CAijrzamMSBSwjAICKMtMpQxEFLCeAgIo682pjEgUsIwCAijLTKUMRBSwngICKOvNqYxIFLCMAgIoy0ylDEQUsJ4CAijrzamMSBSwjAICKMtMpQxEFLCeAgIo682pjEgUsIwCAijLTKUMRBSwngICKOvNqYxIFLCMAgIoy0ylDEQUsJ4CAijrzamMSBSwjAICKMtMpQxEFLCeAgIo682pjEgUsIwCAijLTKUMRBSwngICKOvNqYxIFLCMAgIoy0xlxwbS0NBAycmH6MiRVP1mX67h1KnTKu3q1ascJXtRoFsU6BSgHj1+TBmZJ+n69bIu7zzeHnzlammXt2uVBi9fvqxfDx4XF28zrH7v91dpkVHRNvFyIgp0tQKdAtTZ8xfUq8Dx2u+uDs5eNe7tPuxNTKKjx457u1pT1GcE1E+ef5FKS5/CXgBliimSThBRpwC1ZNlKGjbyKwWpqurqLhW0KwD1t7mBFB65rkvH1VWN2QNq4MC/EF7rjuAMUFgKTp4yld58qw+NHz+R9u7dp7taXFxCAz4YSIOHDKXss2dp5Bej1Xl8/BZqbm7W+fLz82nO3HnU991+9Nnnw2njphiH5aXOLAeiQGcA1djUpMCUnHKEho/+mrZt3+kgaNmNcloTEU3jJ31LuNixHDQGWGAhS5fTuAlTKWhxqMOSLengIZo9b6FKXxUeSXfq6nRxe0BxW6grYNZcm7awFJw8bRadOHmapk6fRaFhK1U9NTW1tDo8StU/ZvxkiojeQPfu3VNp8xcuVuMDgFH22pNlbFNTM8XEbVVxaGfHrj2EpS4HAG3n7n20YlU4jRozgUqumNOPYw8oWFFr10aqYdgDatfuPXo5iHy8RUW3wvvChYs67ue/eFUfI9/GjZtUnQUFBWSfhnQAy9OQeeIELQld6nRDmgT/V8BjCyrlSJq6gAGqqPWbCBe4MdTU1qoLFBfp9p17aPl3a1T+k6eyVLaLOXnqHMDAUgrA+XT4l3T7do1K35qwU53HbUmgLdt2KAhOmjJDw8AIKG4LcYDagqAQm7bgr0LdAGn0hhgCGB8+fEgTJwfQqLGTFFDQR8BobdR61f7prGwN1vSME9TY2KgsDICWxxQbt1WVATw58Diw37f/ANXX13OSqfZGQMGSYejAyjEC6vHjxxosM2f+TY1n6bIwnR/ANgJqUfBitVwcNmyEygPLCmHMV+PU+cRJk6mlpYXQDrd5587TL56OiIQvk0+Hfq7r4foQx180HalP8ppPAY8BBethUchSNaKi4hIFgILCIj3CTbHx6uK9f/++jovfup32H0hW5wATrCMOLffuKasD4MIxgHLcYHFxG4ALghFQMZu3KNgAOhxgAaENBAZU+vFMTiZceOcv5lBFRaWOi4zeoKDEEfZLPPa5GZ3zJ09nqb5WVLbWg34B1j/88ANXY8q9EVCVlVU0deq36kLH8gvLOFzscJKXlFzRAIAVhHDr1i0dd+bMGRtAVVW1LvWTDhzUeVDm9V/9Rp2jbgDECJb0dM/9fPaQEjiZ8uPmcac8AhT8TQDI7r2JVFlVTbg4YZ0Y/TUz5gRS8JIwpx0DSFAe1o6zcCm/QKVjmYQ6sWGpiDKwthCMgAJIsLTjvNhjWQaLCIEBVd/QoM75D0AI62j9xli1xER+jIODPaBg1aEdY8DyzghT9AtLRbMHe0DhsYPev/29hgoDKic3V8eVld1Qw2pqatJxaWlHbQDFPifEs0UD3xYf/7n/BzR8xBc2W0bG0y8OT3RjSAmcPFHP3GU8AhQvv3BhGjdc4GzFABDGpY9RhubmFlXuWHqGMVofZ589p9IBKFg1xg1pCEZAYekHcBjz8TEsJQZUQ8Nd3QaWbLB00Oely79TPjT4plwBasOmzQp8upInB6gj5XCqOjP2yz6fmc7tAYW+nT6dpUHCgIIFzHDBUhBh//4kHXf79u12AYUygwYNUWWwPEQAtOBET0jYQRUVFSquM38AKVnWdUZBc5b1CFC4sJctX0W3a2r0ln+5UEEFSx6E1Wuj1MVuXOpczMklLOEQUAc7q3GOfADW9bIbVFt7R9WVZrjFj3T+Bkd+IwjQFnxJxrbgy4J/BMEZoBiCvDRDvg0xcQ6AghOdA5z8AHLD3aegKy29puJ42WfsF5cz494ZoNDPoEXBGj78HNT8+YE6rs/bffXxuK8nqKEZfVDOLChkMkLt479+ou7yAXyw2u4a9DSjVtKn7lOgw4C6XNAKoty8Sw69htUUuGiJis+/3LpMw126wqJigv8HF/euPYkqHXucw1eFO2TwI+EcviaEOfODFMQOpx6lG+U3lSMe6QACghEEvCQETIpLrlBObp4CDdpGcAYotIn6duzaS9W3bil/F86NFhQc+wApxopvZ1hgcJCjb/C3IR6Odoyb7+QZ+6UaN+mfgsJCDRr4oDhgnAyh6OjWGwawdgAu9iPhbtyMmbOI/YtGQMEBjgC/ElteXDesJfZvIW3U6DGUm9v6hcV5ZC8KGBXoMKBwlwsXsdFa4Qpx1woX+d27jSoK/h1c4IjDhiUfLwGRAXBCXUjDMulAcgpXpe70wAnPZbGEO2pYEtqDANaNsS2A0pUFxe1z/egHfGZGQJVeu64sM+Rh5zwsPDjfuRz8VK4ef9ADsshBdXW107nvyPBw1+7BgwcdKSJ5e6gCHQaUJzrV1dXbgMlYB0CHJZ0z4CEfvr1R3t2A2/pGCLZXDhYDnP7wVbUVsKSz7x/gBye7BFFAFPCdAl0CKN91X2oWBUQBKysggLLy7MrYRAE/V0AA5ecTKN0XBaysgADKyrMrYxMF/FwBAZSfT6B0XxSwsgICKCvProxNFPBzBQRQfj6B0n1RwMoKCKCsPLsyNlHAzxUQQPn5BEr3RQErKyCAsvLsythEAT9XQADl5xMo3RcFrKyAAMrKsytjEwX8XAEBlJ9PoHRfFLCyAgIoK8+ujE0U8HMFBFB+PoHSfVHAygoIoKw8uzI2UcDPFRBA+fkESvdFASsrIICy8uzK2EQBP1dAAOXnE9hd3cdPIONnkrHhZ5mNG8fb/0xyd/VV2vVfBQRQ/jt33dJzBhNeeoBXTOGVUXghal1dndpwjDi83QV5ACsBVbdMlSUaFUBZYhq7ZhAADV5I0djYREeOpNL48RPp93/43/TTF/9Lv2IKx4hDWmpqGuEtxCgjkOqaObJaKwIoq82oj8YDwDx48FC9Yefr8RM0kPjdd23tx0+YqMqgrEDKR5Nj4WoFUBaeXG8NjS2nuvp6GvjhX9yGE0MLZfjVYwIpb81Kz6jHI0Cdv3BRvQ24Z0hk/VFezL1EO/YlU9SmrbR2Q7zDFr4+jr6L3ETv/fmDDsOJIQWrq7Gx0eX7B62vtIywowp4BCi85XdDTJzbbWWfPUcxcVvdzu/LjHi7Mb9e3Zft+EPd9Q13FZicQckYtzo6liYHzO0wnH720v+iX/zyv3W5w4ePqNelixXlD58Oc/SxSwCVsGM3AWpmCHhlOV6TLoHcglOr9bSR/uf9ARo0bBW52gNOKSmHKT39uC43dux4saLkg9chBToNqCtXS2nytFl04WIuzQsMpomTA2jXnkTCq8ER4rdup1FjJhDAgHypR9N1B5MOHqLZ8xYqeMGyuVNXp9LwDTt1+ixKTTum6kR5hPDIdbQ3MYnWb4yl8ZO+pdCwlXQp/7KuDwdlN8ppTUS0qjNg1lwNo5raWtU++jFq7CSaFjDHplxPO8GyzmgltXUMQC0PX0ev/PfrGjSuwIQ0hlNDQwP93wH/T5f71Ru9qba2Vj0z1dP0lvF6pkCnAZX3fb6CDy56LOOi1m9S57v3JqoeXS4opMWhYTR89NeUnnGCystvqvitCTtVvrgtCbRl2w6VPmnKDHr05LkZgAQbIJRyOFWVCZi9QMUBagAVgDds5FfqNjYyAEKAGfIBfguCQlT+k6ey1HM5aB91RkZvoBMnT6s6e+of+JzagpIxfs26zbR0VRS98NOXNGhcAaotOKEM6qiqrlbPR/VU3WXcHVPAa4BiiKD5FavClQXEXbFf4rXcu6dAcdyw1IJfCPA4e/6Cuh2NY1hVxgDwAEDsw8CHncsgX8zmLcqCw3M3HOYvXGzTF+SXJR616RA3wgnHa9bFUujKtZ2GE0Ot/OZNARR/OGXfrgJeAxSsFw6HU48qy4bP7QF1Kb9AgQUgw7ING5ZlgAcsIwAIx7B8jAGAWh0eZYxSwEIZhL/NDVRLO64Te7ayuJAAqlWJtu7YOQPUkhXhNoAaPuILSko6oJZyDB5XlhPnwb6srEw5ynk+ZC8KuFLAa4BqaLir24HvCEsvDvaAwl09gAKAwnLLuCFNA+q0I6CQ1xhgUTGgsESEM95YHx/jXy4QBFCt6rm/xIulkBVr6fkXni7x4FeCfwlOcIDJXThhiXf9xg0BlPEDLMcuFegyQI0ZP1l3pLb2jgJF2rHjOg5QKiu7oc49BdTqtVHKAY7yHG7frtEOe8QBUPBF9fTgrpMcS7wlKyPol6++ZmNFGSEFUNk7xI1WEx+/9vqv6UZ5uSzxevqHrwPj7xJAwaICGLKyz9KdO6136ubMDyJAC8vBG+U3tXO9tPSaxxYULx2xDCwuuUI5uXnK+R6ydLmWBBZX8JIwKigs0nE99cAdK6rVSR5Jffq+ZwMoQIch5Q6ckP/zYSOoqkqc5D318+bJuLsEUI1NTTRjTqCC1KbYeNVP/Lf7opClKg7wwtLsaHqGSvPUgkJhOMABPtSJLXDREhsLiu/kIQ3O+p4c3HlQE48ZhK1ZR2PGT3UAFEPK+CgBW0vO9vHxW9SjJPhpFgmigDsKeAQodyp2lgfPRhnvsCEPPqz4Py1vh/r6eoe2uA34o/BvFxJaFXD1ry78oGZQ6Hf0f97u5xRSzmBkHzf0s2FUWFSkft2A/YGivyjQngJdCqj2OiPp5lMA1uz9+/epsrKKsrPP0bv/03FIocyZ7HNUVVVF9x880I+JmG+00iOzKSCAMtuMmLA/bHFeLb1GJ06eosFDPnPbkkJelEFZ+WdhE06uybskgDL5BJmhe7CisDTHUry4uIROZ52h8LWR9MngT+mNX//W5ilzPEqAOKStjYhSeVFGfm7FDDPpf30QQPnfnHVLjwEp/sG6a9evU05uLp06nUXpxzMo7egxOpKaqjYcIw4Qy83LI+QFnOQH67pl2vy+UQGU309h1w2ALSn8jG919S26du06FRYWUd73lxSwAC0cIw5pt2/flp/87brpsWRLAihLTqvvBgVIwSclL03wncZS81MFBFBPtZCjDijAoAKsjK+cwjHisCGPBFGgMwoIoDqjnpQVBUQBnyoggPKpvFK5KCAKdEYBAVRn1JOyooAo4FMFBFA+lVcqFwVEgc4oIIDqjHpSVhQQBXyqgADKp/JK5aKAKNAZBQRQnVFPyooCooBPFRBA+VReqVwUEAU6o4AAqjPqSVlRQBTwqQICKJ/KK5WLAqJAZxQQQHVGPSkrCogCPlUAgPr/F9eDdch1olcAAAAASUVORK5CYII="},"28adb364-e639-454f-b7ef-9ab65bb580bf.png":{"image/png":"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"}}},{"cell_type":"markdown","source":"Com isso, abra o diretório do `chessman-image-dataset`, nele teremos um diretório para cada peça, ache o arquivo `00000007.jpg` da pasta `King` e copie o seu caminho, com isso teremos o caminho para acessar a imagem, a função usada para processar a imagem pelo caminho do seu arquivo é a função `imread` do módulo `cv2`, que tem a sintaxe `cv2.imread(\"path/to/file.extension\")`, tanto imagens jpg quanto png e (outros tipos de imagem)[https://docs.opencv.org/master/d4/da8/group__imgcodecs.html#ga288b8b3da0892bd651fce07b3bbd3a56] podem ser abertos com essa função, ela carrega a imagem como um array numpy com 3 dimensões: (altura, largura, 3), esse três se refere aos canais de cor, mesmo imagens preto e branco serão abertas com esses três canais de cor. Cada valor dentro da imagem é o valor de intensidade de luz do pixel (entre o range ` 0-255`) para cada canal de cor.\n\n#### Tarefa 01: Abra a imagem usando essa função e carregando numa variável chamada `king`, com isso, imprima as dimensões de king. \n##### Dica: Em python conseguimos obter as dimensões de um array numpy com o atributo `.shape`:\n```python3\nx = np.array([1,2,3,4,5])\nprint(x.shape) # tem a saída (5,), o retorno desse atributo sempre será uma tupla\n```","metadata":{}},{"cell_type":"code","source":"","metadata":{"execution":{"iopub.status.busy":"2021-06-13T12:16:17.991642Z","iopub.execute_input":"2021-06-13T12:16:17.992261Z","iopub.status.idle":"2021-06-13T12:16:18.047005Z","shell.execute_reply.started":"2021-06-13T12:16:17.992175Z","shell.execute_reply":"2021-06-13T12:16:18.046051Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### 1.2 Mostrar uma imagem \n\nUma parte importante no processamento de imagens a visualização do que estamos fazendo com ela, dentre os módulos de visualização gráfica em python um dos mais usados é o `matplotlib.pyplot`, utilizaremos ele bastante nos notebooks do curso, para que usemos ele devemos importá-lo com o comando\n```python3\nimport matplotlib.pyplot as plt\n```\n","metadata":{}},{"cell_type":"markdown","source":"Após o import desse módulo, utilizaremos a função `imshow` para podermos ver a imagem que temos, a sinaxe desse comando é `plt.imshow(img)`, ele tem outros argumentos mas não serão importantes no momento.\n\n#### Tarefa 02: Mostre a imagem `king` na tela","metadata":{}},{"cell_type":"code","source":"","metadata":{"execution":{"iopub.status.busy":"2021-06-13T12:16:18.048516Z","iopub.execute_input":"2021-06-13T12:16:18.048833Z","iopub.status.idle":"2021-06-13T12:16:18.36178Z","shell.execute_reply.started":"2021-06-13T12:16:18.048803Z","shell.execute_reply":"2021-06-13T12:16:18.360767Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## 1.3 Salvar uma imagem\n \n Assim como ler uma imagem, salvar uma imagem é bem simples com o `cv2`, utilizaremos a função `imwrite` de sintaxe:\n ```python3\n cv2.imwrite('path/to/file/', img)\n ```\n A imagem pode ser salvo em qualquer formato aceito pelo opencv, mas é importante que a extensão (ex. `.png` para imagens PNG) esteja no nome da imagem a ser salvo.\n \n #### Tarefa 03: Salve a imagem `king` com um nome de arquivo de sua preferência.","metadata":{}},{"cell_type":"code","source":"","metadata":{"execution":{"iopub.status.busy":"2021-06-13T12:16:18.36376Z","iopub.execute_input":"2021-06-13T12:16:18.3643Z","iopub.status.idle":"2021-06-13T12:16:18.457583Z","shell.execute_reply.started":"2021-06-13T12:16:18.364253Z","shell.execute_reply":"2021-06-13T12:16:18.456265Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Vemos que essa função teve um retorno em forma de booleano, basicamente quando temos o valor `True` a imagem foi salva com sucesso, e quando temos `False` ela não foi. \n#### Tarefa 04: Baixe a imagem no diretório `/kaggle/working/` dentro de `output` e veja como ela ficou","metadata":{}},{"cell_type":"markdown","source":"Se você compara a imagem que você salvou com a imagem que você mostrou com o `plt` verá que as duas tem *cores diferentes!*, como isso aconteceu? </br>\n\nO que acontece é que o módulo `plt` trabalha com imagens no padrão de cor RGB (Red, Green, Blue) e o OpenCV (por questões dos padrões que eram usados na época que ele começou a ser desenvolvido)[https://learnopencv.com/why-does-opencv-use-bgr-color-format/#:~:text=The%20reason%20the%20early%20developers,use%20the%20BGR%20format%200x00bbggrr.&text=In%20other%20words%2C%20BGR%20is%20the%20horse's%20ass%20in%20OpenCV.] usa BGR (Blue, Green, Red), então ficamos com as cores com as faixas de vermelho e azul invertidas. Por questões de conveniência, pois atualmente grande parte dos softwares utiliza mais o padrão RGB converteremos nossa imagem para esse padrão. </br>\n\nCom o `cv2`, a conversão para os padrões de cor é bem tranquila, temos a função já implementada chamada de `cvtColor` que faz isso pela gente, ela tem a sintaxe de `cv2.cvtColor(image, code)`, com `image` sendo a imagem que queremos converter e `code` sendo o código de conversão do espaço de cor, parece complicado mas é tranquilo, temos constantes no opencv que indicam qual conversão iremos fazer, elas são esse código, geralmente apresentam a sintaxe `COLOR_[COLOR SPACE 1]2[COLOR SPACE 2]`, por exemplo, se queremos converter uma image `RGB` em grayscale (escala de cinza), usaremos\n```python3\ncv2.cvtColor(image, cv2.COLOR_RGB2GRAY)\n```\n\n#### Tarefa 05: converta a variável `king` para o espaço de cor `RGB` e veja como ficou a nova imagem mostrando ela na tela","metadata":{}},{"cell_type":"code","source":"","metadata":{"execution":{"iopub.status.busy":"2021-06-13T12:16:18.459565Z","iopub.execute_input":"2021-06-13T12:16:18.459988Z","iopub.status.idle":"2021-06-13T12:16:18.466933Z","shell.execute_reply.started":"2021-06-13T12:16:18.459945Z","shell.execute_reply":"2021-06-13T12:16:18.465909Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"","metadata":{"execution":{"iopub.status.busy":"2021-06-13T12:16:18.468447Z","iopub.execute_input":"2021-06-13T12:16:18.468774Z","iopub.status.idle":"2021-06-13T12:16:18.780877Z","shell.execute_reply.started":"2021-06-13T12:16:18.468747Z","shell.execute_reply":"2021-06-13T12:16:18.779733Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Para a próxima parte do tutorial utilizaremos a escala de cor cinza, pois ela deixa a imagem num formato bidimensional e portanto mais simples, e a cor não será tão importante no momento.\n\n#### Tarefa 06: Converta a imagem para a escala de cor cinza a mostre ela na tela","metadata":{}},{"cell_type":"code","source":"","metadata":{"execution":{"iopub.status.busy":"2021-06-13T12:16:18.782195Z","iopub.execute_input":"2021-06-13T12:16:18.782496Z","iopub.status.idle":"2021-06-13T12:16:19.259662Z","shell.execute_reply.started":"2021-06-13T12:16:18.782468Z","shell.execute_reply":"2021-06-13T12:16:19.258386Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Como você pode ver, a imagem não está cinza e sim em tons de azul/verde, isso porque o `plt` por padrão deixa as cores de escala cinza nesse colormap, para vermos no format preto e branco utilizaremos, além da imagem no começo o argumento `cmap='gray'` na função `imshow`\n\n#### Tarefa 07: Mostre a imagem com a visualização preto e branco:","metadata":{}},{"cell_type":"code","source":"","metadata":{"execution":{"iopub.status.busy":"2021-06-13T12:16:19.261447Z","iopub.execute_input":"2021-06-13T12:16:19.261887Z","iopub.status.idle":"2021-06-13T12:16:19.582457Z","shell.execute_reply.started":"2021-06-13T12:16:19.261841Z","shell.execute_reply":"2021-06-13T12:16:19.581294Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## 1.4 Indexação aplicada em imagens\n\n\nAgora que vimos as formas de visualização vamos começar a fazer um leve processamento das imagens que estamos carregando, apenas mostrar e salvar imagens não é extamente a coisa mais empolgante a se fazer.\n\nMas o que é a indexação em geral?\n\nFalando em termos práticos, quando temos uma lista\n```python3\nlista = ['a', 'b', 'c']\n``` \n\nE obtemos parte dos seus elementos como\n```python3\n\nlista[2] # retorna 'c'\n\nlista [1:] # retorna ['b', 'c']\n``` \nEstamos fazendo indexação. O que isso ajuda em processamento de imagens? \n\nComo toda imagem é um array podemos fazer indexação nas imagens também, isso permite que façamos cortes na imagem de uma forma mais prática e outras formas de transformação\n","metadata":{}},{"cell_type":"markdown","source":"Em numpy temos novas formas de indexação que ajudam bastante nesse tipo de processamento:","metadata":{}},{"cell_type":"code","source":"x = np.arange(10) # numpy array com os valores [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\nx","metadata":{"execution":{"iopub.status.busy":"2021-06-13T12:16:19.585774Z","iopub.execute_input":"2021-06-13T12:16:19.586213Z","iopub.status.idle":"2021-06-13T12:16:19.593215Z","shell.execute_reply.started":"2021-06-13T12:16:19.586163Z","shell.execute_reply":"2021-06-13T12:16:19.592223Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"y = x > 5 # array de booleanos para cada elemento de x, se for > 5 será True, se não sera False\ny","metadata":{"execution":{"iopub.status.busy":"2021-06-13T12:16:19.59506Z","iopub.execute_input":"2021-06-13T12:16:19.595378Z","iopub.status.idle":"2021-06-13T12:16:19.60888Z","shell.execute_reply.started":"2021-06-13T12:16:19.595344Z","shell.execute_reply":"2021-06-13T12:16:19.607682Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Podemos usar o array de booleano como forma de indexação\nx[y] # Todos os valores de x que são maiores que 5","metadata":{"execution":{"iopub.status.busy":"2021-06-13T12:16:19.610823Z","iopub.execute_input":"2021-06-13T12:16:19.611305Z","iopub.status.idle":"2021-06-13T12:16:19.623009Z","shell.execute_reply.started":"2021-06-13T12:16:19.611236Z","shell.execute_reply":"2021-06-13T12:16:19.621857Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Não obstante também podemos redefinir esses valores \nx[y] = 0 # Todos os valores maiores que 5 agora serão iguais a zero\nx","metadata":{"execution":{"iopub.status.busy":"2021-06-13T12:16:19.624503Z","iopub.execute_input":"2021-06-13T12:16:19.62489Z","iopub.status.idle":"2021-06-13T12:16:19.636389Z","shell.execute_reply.started":"2021-06-13T12:16:19.624857Z","shell.execute_reply":"2021-06-13T12:16:19.635302Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Veremos mais sobre numpy durante o curso, mas se você quiser se adiantar lendo um pouco mais sobre o módulo pode ler [por aqui](https://towardsdatascience.com/the-ultimate-beginners-guide-to-numpy-f5a2f99aef54)","metadata":{}},{"cell_type":"markdown","source":"","metadata":{}},{"cell_type":"markdown","source":"### Como podemos aplicar isso numa imagem?\n\nSendo que cada valor na imagem é um valor de intensidade de luz, podemos manipular e indetificar valores de intensidade mais facilmente utilizando esses atributos de indexação pois as imagens do OpenCV são carregadas como numpy arrays.","metadata":{}},{"cell_type":"markdown","source":"#### Tarefa 08: Use a indexação booleana para zerar todos os valores da imagem (variável `treshold_king`) que são do tabuleiro. \n##### Obs: Perceba que eles são mais escuros que o da peça","metadata":{}},{"cell_type":"code","source":"# treshold_king = king.copy()","metadata":{"execution":{"iopub.status.busy":"2021-06-13T12:16:19.637781Z","iopub.execute_input":"2021-06-13T12:16:19.638204Z","iopub.status.idle":"2021-06-13T12:16:19.651203Z","shell.execute_reply.started":"2021-06-13T12:16:19.638152Z","shell.execute_reply":"2021-06-13T12:16:19.650086Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"","metadata":{"execution":{"iopub.status.busy":"2021-06-13T12:16:19.652589Z","iopub.execute_input":"2021-06-13T12:16:19.652921Z","iopub.status.idle":"2021-06-13T12:16:19.972389Z","shell.execute_reply.started":"2021-06-13T12:16:19.652877Z","shell.execute_reply":"2021-06-13T12:16:19.97141Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Convoluções\n\nEm processamento de imagem, convolução é o processo de alterar os valores de intesidade dos pixels com base nos pesos do kernel com os valores dos pixels vizinhos. De uma forma prática, podemos utilizá-la para alterar a imagem de uma forma para extrair as informações mais importantes dela. Como exemplo, podemos usar um kernel de blur para borrar a imagem: (Em opencv muitas convoluções com kernels muito usados já tem suas funções próximas)","metadata":{}},{"cell_type":"code","source":"# gaussian_king = cv2.blur(king, (21,21))","metadata":{"execution":{"iopub.status.busy":"2021-06-13T12:16:19.97376Z","iopub.execute_input":"2021-06-13T12:16:19.974041Z","iopub.status.idle":"2021-06-13T12:16:19.980752Z","shell.execute_reply.started":"2021-06-13T12:16:19.974014Z","shell.execute_reply":"2021-06-13T12:16:19.979648Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"##### Obs: O kernel utilizado tem um tamanho 21x21, quanto maior você usar o kernel de blur mais borrada fica a imagem:","metadata":{}},{"cell_type":"code","source":"# plt.imshow(gaussian_king, cmap='gray')","metadata":{"execution":{"iopub.status.busy":"2021-06-13T12:16:19.982066Z","iopub.execute_input":"2021-06-13T12:16:19.982352Z","iopub.status.idle":"2021-06-13T12:16:20.301016Z","shell.execute_reply.started":"2021-06-13T12:16:19.982325Z","shell.execute_reply":"2021-06-13T12:16:20.299982Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Para simplificar a aplicação de kernels customizados, criei a função `apply_kernel(imagem, kernel)` que retorna a imagem após aplicar a convolução com determinado kernel:\n##### Obs: o kernel sendo um numpy array 2D com dimensões NxN com N sendo o tamanho do kernel","metadata":{}},{"cell_type":"code","source":"def apply_kernel(image: np.ndarray, kernel: np.ndarray) -> np.ndarray:\n    '''\n    Applies a convolutional kernel on a input image\n    Args:\n        image: input image\n        kernel: convolutional kernel\n    Returns:\n        image with the input kernel convolution\n    '''\n    return cv2.filter2D(image, -1, kernel)","metadata":{"execution":{"iopub.status.busy":"2021-06-13T12:16:20.30234Z","iopub.execute_input":"2021-06-13T12:16:20.302654Z","iopub.status.idle":"2021-06-13T12:16:20.307741Z","shell.execute_reply.started":"2021-06-13T12:16:20.302623Z","shell.execute_reply":"2021-06-13T12:16:20.306661Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"#### Tarefa 09:\nSabendo que temos filtros passa alta nos formatos </br>\n![Filtros](https://homepages.inf.ed.ac.uk/rbf/HIPR2/figs/sobmasks.gif) </br>\nEm que o Gx aplica filtros passa alta em bordas horizontais e Gy para bordas verticais, aplique os dois filtros separadamente na imagem (`king`):","metadata":{}},{"cell_type":"code","source":"","metadata":{"execution":{"iopub.status.busy":"2021-06-13T12:16:20.308994Z","iopub.execute_input":"2021-06-13T12:16:20.3093Z","iopub.status.idle":"2021-06-13T12:16:20.322594Z","shell.execute_reply.started":"2021-06-13T12:16:20.309268Z","shell.execute_reply":"2021-06-13T12:16:20.321333Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"","metadata":{"execution":{"iopub.status.busy":"2021-06-13T12:16:20.324086Z","iopub.execute_input":"2021-06-13T12:16:20.324419Z","iopub.status.idle":"2021-06-13T12:16:20.65326Z","shell.execute_reply.started":"2021-06-13T12:16:20.324388Z","shell.execute_reply":"2021-06-13T12:16:20.652317Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"","metadata":{"execution":{"iopub.status.busy":"2021-06-13T12:16:20.654607Z","iopub.execute_input":"2021-06-13T12:16:20.654891Z","iopub.status.idle":"2021-06-13T12:16:20.968086Z","shell.execute_reply.started":"2021-06-13T12:16:20.654864Z","shell.execute_reply":"2021-06-13T12:16:20.9669Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"#### Tarefa 10: Some a saída das duas aplicações de kernel e mostre na tela, e obtenha as bordas da imagem:","metadata":{}},{"cell_type":"code","source":"","metadata":{"execution":{"iopub.status.busy":"2021-06-13T12:16:20.969674Z","iopub.execute_input":"2021-06-13T12:16:20.970099Z","iopub.status.idle":"2021-06-13T12:16:21.29177Z","shell.execute_reply.started":"2021-06-13T12:16:20.970053Z","shell.execute_reply":"2021-06-13T12:16:21.290788Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# 2. Classificação","metadata":{}},{"cell_type":"markdown","source":"Vamos trabalhar com o uso de modelos de classificação com uma task bastante conhecida no início do estudo de redes neurais, que é o uso do dataset MNIST de dígitos escritos à mão.\n\nPara simplificar a tarefa, carreguei as imagens com a função load data (não se preocupe com o funcionamento dela no momento) e filtrei as imagens para apenas usarmos imagens com os números 0, 1 e 2 (Vendo pela segunda célula você consegue identificar o uso da indexação booleana).","metadata":{}},{"cell_type":"code","source":"def load_data():\n    DF_PATH = '../input/digit-recognizer/train.csv'\n    df = pd.read_csv(DF_PATH)\n    labels, pixels = df.iloc[:, 0], df.iloc[:, 1:]\n    images = pixels.values.reshape(-1, 28, 28)\n    return labels, images","metadata":{"execution":{"iopub.status.busy":"2021-06-13T12:16:21.293069Z","iopub.execute_input":"2021-06-13T12:16:21.293351Z","iopub.status.idle":"2021-06-13T12:16:21.298992Z","shell.execute_reply.started":"2021-06-13T12:16:21.293324Z","shell.execute_reply":"2021-06-13T12:16:21.297971Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"labels, images = load_data()\nlabels_lt3 = (labels < 3)\nimages, y = images[labels_lt3], labels[labels_lt3] \nX = images.mean(axis=1)","metadata":{"execution":{"iopub.status.busy":"2021-06-13T12:16:21.300281Z","iopub.execute_input":"2021-06-13T12:16:21.300593Z","iopub.status.idle":"2021-06-13T12:16:24.072696Z","shell.execute_reply.started":"2021-06-13T12:16:21.300563Z","shell.execute_reply":"2021-06-13T12:16:24.071661Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Por enquanto vamos focar nas variáveis `X` e `y`. Por convenção, se usa `X` para os dados e `y` para as anotações desses dados, nesse caso, em vez de imagens, nosso X será um conjunto de vetores com cada elemento sendo relacionado à média de intensidade de uma coluna da imagem e o `y` será a anotação daquela imagem.","metadata":{}},{"cell_type":"markdown","source":"#### Tarefa 11: Para entender o que nosso X está representando, chame a função `show_image_data_by_number(number: int)` com um número entre 0 e 2 (pois são os números que iremos classificar) para ver um exemplo a partir de uma imagem (a função escolhe uma imagem aleatoriamente então chame mais de uma vez para ver mais exemplos)","metadata":{}},{"cell_type":"code","source":"def show_image_data_by_number(number: int):\n    assert number < 3, \"Número fora da base de dados!\"\n    images_with_number = images[y == number]\n    X_with_number = X[y == number]\n    index = np.random.randint(images_with_number.shape[0])    \n    ax = plt.figure(figsize=(4,4))\n    plt.imshow(images_with_number[index])\n    plt.show()\n    ax = plt.figure(figsize=(4,4))\n    plt.plot(X_with_number[index])\n    plt.show()\n\nshow_image_data_by_number(1)","metadata":{"execution":{"iopub.status.busy":"2021-06-13T12:16:24.075866Z","iopub.execute_input":"2021-06-13T12:16:24.076194Z","iopub.status.idle":"2021-06-13T12:16:24.342493Z","shell.execute_reply.started":"2021-06-13T12:16:24.076162Z","shell.execute_reply":"2021-06-13T12:16:24.341476Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Separação de dados de Treinamento e de Teste\n\nComo vimos nas aulas anteriores, usar os dados de teste para o treinamento do modelo levará ao overfitting, para fazermos essa divisão de uma forma mais rápida e justa (você vai entender essa parte depois) nós usamos a função train_test_split do módulo sklearn.model_selection","metadata":{}},{"cell_type":"code","source":"from sklearn.model_selection import train_test_split","metadata":{"execution":{"iopub.status.busy":"2021-06-13T12:16:24.344211Z","iopub.execute_input":"2021-06-13T12:16:24.344514Z","iopub.status.idle":"2021-06-13T12:16:24.348936Z","shell.execute_reply.started":"2021-06-13T12:16:24.344482Z","shell.execute_reply":"2021-06-13T12:16:24.347931Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"* A sintaxe do train_test_split é simples, o primeiro argumento é o X do dataset, o segundo o y, declaramos qual a quantidade do dataset original queremos usar para teste com o argumento test_size (essa quantidade vai de 0 a 1) e o random_state, que será explicado posteriormente. A função no retorna uma tupla (X_train, X_test, y_train, y_test), que representam, respectivamente, o X de treinamento, X de teste, y do treinamento e y do teste (usado apenas para validação do modelo).\n* A separação é simples, de forma aleatória,(1 - test_size) dos samples do dataset (X,y) vai para o treinamento e test_size dos samples vai para o teste. Por questões de probabilidade, como é aleatória a distribuição, se o seu dataset tiver dados balanceados você terá dados de treinamento e teste balanceados, geralmente como a proporção para o treinamento é maior, teremos dados com valores mais equilibrados no caso do treinamento.\n* Em relação ao random_state tempos que primeiro entender como funciona a escolha aleatória para o computador. Para uma explicação simplificada: O seu computador não joga dados. Todos os números \"aleatórios\" que são gerados são na verdade pseudoaleatórios, gerados a partir de uma função numérica complexa que recebe um número a e retorna um número b ou um conjunto de números B. O número a, a entrada dessa função é chamado de seed, é ela que alimenta a função para gerar um número pseudoaleatório, se o mesmo número for colocado na função, os mesmos números serão gerados. Se você já se aventurou usando números aleatórios, seja em python ou outra linguagens, geralmente a parte do seed é \"escondida\" de você, o seed utilizado é um número que muda com o tempo, uma prática muito comum em C é usar o tempo atual da máquina em segundos como seed, assim, sempre que o programa rodar teremos resultados diferentes. O problema é que nem sempre queremos isso, às vezes queremos replicar exatamente o mesmo resultado para quando formos rodar de novo nosso código. Assim, poder controlar a seed de funções que utilizam artifícios randomicos (alguns modelos do sklearn, train_test_split, etc) é algo que ajuda muito. No caso, colocamos a seed da função usando o argumento random_state, que recebe um número inteiro (a seed).\n* Não existe seed certa e errada, o importante é manter a seed que você usou para replicar seus resultados. </br>\nFinalmente, veja um exemplo do uso do train_test_split e as proporções de cada label no dataset, no treinamento e no teste:","metadata":{}},{"cell_type":"code","source":"from sklearn.datasets import make_blobs # Função para gerar pontos aleatórios para demonstração\n\nX_, y_ = make_blobs(1000,random_state=42) # Criando 100 pontos separados em 3 labels\nX_train_, X_test_, y_train_, y_test_ = train_test_split(X_, y_, test_size=0.1, random_state=42)\n_, c = np.unique(y_,return_counts=True) # Np.unique -> retorna uma tupla (valores únicos da lista, contagem de cada valor)\n_, c_Train = np.unique(y_train_,return_counts=True)\n_, c_Test  = np.unique(y_test_,return_counts=True)\nprint(100*c/c.sum()) # Porcentagem da frequência de cada label no dataset \nprint(100*c_Train/c_Train.sum()) # Porcentagem da frequência de cada label no dataset de treinamento\nprint(100*c_Test/c_Test.sum()) # Porcentagem da frequência de cada label no dataset de teste\n","metadata":{"execution":{"iopub.status.busy":"2021-06-13T12:16:24.350607Z","iopub.execute_input":"2021-06-13T12:16:24.351041Z","iopub.status.idle":"2021-06-13T12:16:24.383481Z","shell.execute_reply.started":"2021-06-13T12:16:24.350994Z","shell.execute_reply":"2021-06-13T12:16:24.382336Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"#### Tarefa 11: Use a `train_test_split` no nosso dataset, com um `test_size` de `0.2` e um `random_state` igual a `42`. (Vamos escolher o `random_state` desse treinamento para termos resultados iguais). Retorne a função nas variáveis `X_train, X_test, y_train, y_test`","metadata":{}},{"cell_type":"code","source":"X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state=42)","metadata":{"execution":{"iopub.status.busy":"2021-06-13T12:16:24.384682Z","iopub.execute_input":"2021-06-13T12:16:24.385222Z","iopub.status.idle":"2021-06-13T12:16:24.396509Z","shell.execute_reply.started":"2021-06-13T12:16:24.385188Z","shell.execute_reply":"2021-06-13T12:16:24.395457Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Sintaxe básica de um modelo do Sklearn\nOs modelos de Machine Learning clássico que veremos em seguida no curso seguem em base a mesma sintaxe. Para exemplificar, vamos usar o `DummyClassifier` do módulo `sklearn.dummy`, um modelo de treinamento usado apenas para demonstrações, que não faz nenhum cálculo complexo e usa estratégias como escolher sempre a label mais presente no treinamento, não se preocupe com ele.","metadata":{}},{"cell_type":"code","source":"from sklearn.dummy import DummyClassifier\ndummy = DummyClassifier()\ndummy","metadata":{"execution":{"iopub.status.busy":"2021-06-13T12:16:24.398087Z","iopub.execute_input":"2021-06-13T12:16:24.398497Z","iopub.status.idle":"2021-06-13T12:16:24.408365Z","shell.execute_reply.started":"2021-06-13T12:16:24.398452Z","shell.execute_reply":"2021-06-13T12:16:24.407721Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### Treinamento \n(Descomente essas células após já ter o `X_Train`, `X_test`, `y_train` e `y_test`)\nUsaremos a função `MODELO.fit`, que recebe, no caso de modelos de aprendizado supervisionado, um `X` e um `y`, que no caso são os relativos aos **dados de treinamento**.","metadata":{}},{"cell_type":"code","source":"# dummy.fit(X_train, y_train)","metadata":{"execution":{"iopub.status.busy":"2021-06-13T12:16:24.409473Z","iopub.execute_input":"2021-06-13T12:16:24.409786Z","iopub.status.idle":"2021-06-13T12:16:24.421148Z","shell.execute_reply.started":"2021-06-13T12:16:24.409757Z","shell.execute_reply":"2021-06-13T12:16:24.419902Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### Previsão\n\nA previsão do nosso modelo é feita usando a função `MODELO.predict` e vai receber um argumento `X`, com vários samples sem label e retornar um `y_pred`, com cada elemento sendo a label prevista correspondente ao sample de mesma posição em `X`.","metadata":{}},{"cell_type":"code","source":"# y_pred = dummy.predict(X_test) # conseguindo predição com base no X_test\n# for i in range(10):\n#    print(f\"valor real: {y_test.iloc[i]}\")\n#    print(f\"valor previsto: {y_pred[i]}\")\n","metadata":{"execution":{"iopub.status.busy":"2021-06-13T12:16:24.422198Z","iopub.execute_input":"2021-06-13T12:16:24.422484Z","iopub.status.idle":"2021-06-13T12:16:24.433853Z","shell.execute_reply.started":"2021-06-13T12:16:24.422443Z","shell.execute_reply":"2021-06-13T12:16:24.432693Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### Validação\nComo vimos na última aula, existem várias métricas para validar o nosso modelo. A mais simples é a acurácia. Para conseguirmos a acurácia do nosso modelo usando a função `MODELO.score`, que recebe um `X` e um `y`, no caso relativos aos dados de teste.","metadata":{}},{"cell_type":"code","source":"# dummy.score(X_test, y_test)","metadata":{"execution":{"iopub.status.busy":"2021-06-13T12:16:24.435173Z","iopub.execute_input":"2021-06-13T12:16:24.435488Z","iopub.status.idle":"2021-06-13T12:16:24.450503Z","shell.execute_reply.started":"2021-06-13T12:16:24.435456Z","shell.execute_reply":"2021-06-13T12:16:24.449309Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## K-Nearest Neighbors (KNN)","metadata":{}},{"cell_type":"markdown","source":"Por ser um modelo mais simples e não precisar de nenhum componente aleatório, o KNN não precisa de um `random_state` quando instanciado, o único argumento adicional que usaremos é o `n_neighbors`, que escolhe o número de K vizinhos que ele usará para fazer a votação na hora de prever um novo ponto. A classe usada é a `KNeighborsClassifier` do módulo `sklearn.neighbors`","metadata":{}},{"cell_type":"markdown","source":"#### Tarefa 12: Instancie o `KNeighborsClassifier` na variável `knn` sem argumentos adicionais (o `n_neighbors` padrão é 5), treine com os dados de treinamento e obtenha a acurácia com os dados de teste.","metadata":{}},{"cell_type":"code","source":"from sklearn.neighbors import KNeighborsClassifier\n","metadata":{"execution":{"iopub.status.busy":"2021-06-13T12:24:20.948004Z","iopub.execute_input":"2021-06-13T12:24:20.948679Z","iopub.status.idle":"2021-06-13T12:24:21.967005Z","shell.execute_reply.started":"2021-06-13T12:24:20.948582Z","shell.execute_reply":"2021-06-13T12:24:21.966031Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"","metadata":{"execution":{"iopub.status.busy":"2021-06-13T12:16:24.464353Z","iopub.execute_input":"2021-06-13T12:16:24.464703Z","iopub.status.idle":"2021-06-13T12:16:25.07555Z","shell.execute_reply.started":"2021-06-13T12:16:24.464673Z","shell.execute_reply":"2021-06-13T12:16:25.07464Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"#### Tarefa 13: Crie uma lista de neighbors com os 5 valores entre 1 e 10000 e veja a variação da acurácia entre os K valores","metadata":{}},{"cell_type":"code","source":"","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"","metadata":{},"execution_count":null,"outputs":[]}]}