Lab_Guide_01.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Lab Guide 01.ipynb",
      "private_outputs": true,
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "TPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/thalisreboucas/Python-codes-ML/blob/main/Lab_Guide_01.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jsLqqUd8escA"
      },
      "source": [
        "# Lab Guide 01 - Configuração do Ambiente\n",
        "O **Google Colaboratory**, que também é conhecido como **Google Colab** ou simplesmente **Colab** é uma plataforma/serviço para trabalhar com ciência de dados e aprendizagem de máquina. Isso permite (re)usar configurações e compartilhar um ambiente com suporte a comandos *bash* e *Python* sobre uma série de bibliotecas, todas pré-instaladas e prontas para uso. Além disso, o Colab também provê aceleração por GPU e TPU.\n",
        "\n",
        "Nesse exemplo configuraremos um ambiente para lidar com matrizes.\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nL-GiiYwmzef"
      },
      "source": [
        "## [Passo 01] Conhecendo o **Colab**\n",
        "\n",
        "Cada documento do Colab é um **notebook**, formado por código e .\n",
        "\n",
        "O código está dividido em partes que podem ser executadas individualmente, chamadas de **células**. As células podem ser intercadadas com textos e imagens, permitindo documentar fartamente o processo desenvoldido, incluindo imagens, links, diagramas, etc."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "co7Z2IFweqXo"
      },
      "source": [
        "import sys\n",
        "import numpy as np\n",
        "\n",
        "if \"__main__\" == __name__ :\n",
        "  \"\"\" Ponto de entrada para um programa standalone, mas geralmente irrelevante\n",
        "      no contexto do Colab. Use Ctrl + Enter para executar a célula atual.\n",
        "  \"\"\"\n",
        "  print(f\"Olá Python {sys.version}\");"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YS0q7RUVjyTF"
      },
      "source": [
        "Uma vez que a célula anterior foi executada, é possível acessar os objetos existentes, sejam variáveis, pacotes, classes ou funções. Por exemplo, podemos acessar a versão do pacote *numpy*, importado anteriormente como *np*:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OTx0zt3wh_Bv"
      },
      "source": [
        "# Essa célula continua a execução a partir da anterior\n",
        "print( \"versão do numpy: \" + np.__version__ )"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TAdcDDwgkyps"
      },
      "source": [
        "Uma das principais vantagens do Colab é abolir a complexidade de instalar a maior parte das bibliotecas, drivers e outras configurações complexas, demoradas e propensas ao erro. Comandos de terminal *bash* podem ser usados para configurações pontuais, devendo começar com o prefixo **!**:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AtIo4xiQku36"
      },
      "source": [
        "!pwd\n",
        "!ls -la"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XWW6jAsx5yyC"
      },
      "source": [
        "## [Passo 02] Multiplicação de Matrizes\n",
        "A multiplicação de matrizes em *numpy* utiliza o método *dot()* ou *matmul()*. Por padrão, as matrizes são ordenadas de maneira *row-major*, ou seja, o primeiro índice identifica uma linha da matriz.\n",
        "\n",
        "Isso significa que, para definir uma matriz-coluna, é necessário usar vários arrays aninhados em um array externo. Vejamos um exemplo a seguir:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VB7IPhh466Az"
      },
      "source": [
        "# matriz linha: 1x2\n",
        "A = np.array( [[1.0 ,  2.0 ]] )\n",
        "# matriz coluna: 2x1\n",
        "B = np.array( [[3.0], [4.0]] )\n",
        "\n",
        "print(f'A = {A}, with shape = {A.shape}')\n",
        "print(f'B = {B}, with shape = {B.shape}')\n",
        "\n",
        "# resultado: 1x1\n",
        "C = A.dot(B)\n",
        "# resultado: 2x2\n",
        "D = B.dot(A)\n",
        "\n",
        "print(f'C = {C}, with shape = {C.shape}')\n",
        "print(f'D = {D}, with shape = {D.shape}')\n",
        "\n",
        "print(f'trace(C) = { np.trace(C) }')\n",
        "print(f'trace(D) = { np.trace(D) }')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "V69QxgqhT1yC"
      },
      "source": [
        "## [Passo 03] Regressão Linear\n",
        "Agora que você tem noções básicas de como funciona a configuração do ambiente, que tal ajustar um modelo simples? Começaremos pela Regressão Linear. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ehom36WgUPyv"
      },
      "source": [
        "Primeiro vamos importar as bibliotecas necessárias:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cEV6AZyFUTJr"
      },
      "source": [
        "# operações de álgebra linear\n",
        "import numpy as np\n",
        "# visualização/plotagem\n",
        "import matplotlib.pyplot as plt\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Y1T3mmfaUc1Y"
      },
      "source": [
        "Definamos o nosso conjunto de dados em duas dimensões, formado por dois arrays, **x** e **y**:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EGClxsZAUm5v"
      },
      "source": [
        "x = np.array( [3,21,22,34,54,34,55,67,89,99] )\n",
        "y = np.array( [1,10,14,34,44,36,22,67,79,90] )"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RUqpkGtyU5EP"
      },
      "source": [
        "Vejamos como é simples visualizar nosso dataset usando um gŕafico de dispersão (*scatter plot*) usando a biblioteca **matplotlib**."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qoWjenb6U1Xu"
      },
      "source": [
        "plt.scatter(  x, y)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "83uilR8i8RTN"
      },
      "source": [
        "Usaremos o método `polyfit` da biblitoeca numpy para estimar uma reta que melhor representa os dados obtidos de `x` e `y`:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "B-6WMIny7kEr"
      },
      "source": [
        "fit = np.polyfit(x,y,1)\n",
        "fit_fn = np.poly1d(fit)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "C8HOgP5K8mxa"
      },
      "source": [
        "Enquanto `fit` contém os coeficientes de regressão de ordem 1 - linear, `fit_fn` pode ser utiliada com a sintaxe `fit_fn(x)` para apresentar o valor de `y` estimado com a reta de regressão. Consulte mais detalhes sobre o método `polyfit` [na documentação](https://numpy.org/doc/stable/reference/generated/numpy.polyfit.html)\n",
        "\n",
        "Por fim, exibimos os dados originais acrescidos da reta de regressão obtida, como a seguir:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zrKBCQEK75OB"
      },
      "source": [
        "plt.plot(x,y, 'bo', x, fit_fn(x), 'k')"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}