16 KiB

Raw Permalink Blame History

Comece com Python e Scikit-learn para modelos de regressão

Sketchnote por Tomomi Imura

Questionário pré-aula

Esta lição está disponível em R!

Introdução

Nessas quatro aulas, você irá descobrir como construir modelos de regressão. Em breve discutiremos para que eles servem. Mas antes de fazer qualquer coisa, certifique-se de ter as ferramentas certas para iniciar o processo!

Nesta aula, você vai aprender a:

Configurar seu computador para tarefas locais de machine learning.
Trabalhar com Jupyter Notebooks.
Usar Scikit-learn, incluindo a instalação.
Explorar regressão linear com um exercício prático.

Instalações e configurações

🎥 Clique na imagem acima para um vídeo curto explicando como configurar seu computador para ML.

Instale o Python. Garanta que o Python esteja instalado no seu computador. Você usará Python para muitas tarefas de ciência de dados e machine learning. A maioria dos sistemas já inclui uma instalação do Python. Também existem úteis Pacotes de Codificação em Python disponíveis para facilitar a configuração para alguns usuários.

Alguns usos do Python, no entanto, requerem uma versão do software, enquanto outros requerem uma versão diferente. Por isso, é útil trabalhar dentro de um ambiente virtual.
Instale o Visual Studio Code. Certifique-se de que o Visual Studio Code está instalado no seu computador. Siga estas instruções para instalar o Visual Studio Code na instalação básica. Você vai usar Python no Visual Studio Code neste curso, então pode querer se familiarizar com como configurar o Visual Studio Code para desenvolvimento em Python.

Fique confortável com Python passando por esta coleção de módulos Learn

🎥 Clique na imagem acima para um vídeo: usando Python dentro do VS Code.

Instale o Scikit-learn, seguindo estas instruções. Como é necessário garantir o uso do Python 3, é recomendado usar um ambiente virtual. Note que, se você está instalando essa biblioteca em um Mac M1, há instruções especiais na página mencionada acima.
Instale o Jupyter Notebook. Você precisará instalar o pacote Jupyter.

Seu ambiente para desenvolvimento de ML

Você vai usar notebooks para desenvolver seu código Python e criar modelos de machine learning. Esse tipo de arquivo é uma ferramenta comum para cientistas de dados, e eles podem ser identificados pela sua extensão .ipynb.

Notebooks são um ambiente interativo que permite ao desenvolvedor tanto codificar quanto adicionar notas e escrever documentações ao redor do código, o que é bastante útil para projetos experimentais ou orientados à pesquisa.

🎥 Clique na imagem acima para um vídeo curto explicando este exercício.

Exercício - trabalhe com um notebook

Nesta pasta, você encontrará o arquivo notebook.ipynb.

Abra notebook.ipynb no Visual Studio Code.

Um servidor Jupyter será iniciado com Python 3+. Você encontrará áreas do notebook que podem ser executadas — partes de código. Você pode executar um bloco de código selecionando o ícone que parece um botão de play.
Selecione o ícone md e adicione um pouco de markdown, e o texto seguinte # Bem-vindo ao seu notebook.

Em seguida, adicione algum código Python.
Digite print('hello notebook') no bloco de código.
Selecione a seta para executar o código.

Você deverá ver a declaração impressa:
```
hello notebook
```

Você pode intercalar seu código com comentários para auto-documentar o notebook.

✅ Pense por um minuto em como é diferente o ambiente de trabalho de um desenvolvedor web versus o de um cientista de dados.

Configurando e usando Scikit-learn

Agora que o Python está configurado no seu ambiente local, e você está confortável com Jupyter Notebooks, vamos ficar igualmente à vontade com o Scikit-learn (pronuncia-se sci como em science). O Scikit-learn oferece uma API extensa para ajudar você a realizar tarefas de ML.

Segundo o site oficial, "Scikit-learn é uma biblioteca de machine learning de código aberto que suporta aprendizado supervisionado e não supervisionado. Também fornece várias ferramentas para ajuste de modelos, pré-processamento de dados, seleção e avaliação de modelos, além de muitas outras utilidades."

Neste curso, você usará o Scikit-learn e outras ferramentas para construir modelos de machine learning para realizar o que chamamos de tarefas de 'machine learning tradicional'. Deliberadamente evitamos redes neurais e deep learning, pois esses temas são melhor abordados em nosso futuro currículo 'IA para iniciantes'.

O Scikit-learn facilita a construção e avaliação de modelos para uso. Ele é focado principalmente em dados numéricos e contém diversos conjuntos de dados prontos para usar como ferramentas de aprendizado. Inclui também modelos pré-construídos para os estudantes experimentarem. Vamos explorar o processo de carregar dados predefinidos e usar um estimador embutido — o primeiro modelo de ML com Scikit-learn — com dados básicos.

Exercício - seu primeiro notebook Scikit-learn

Este tutorial foi inspirado pelo exemplo de regressão linear no site do Scikit-learn.

🎥 Clique na imagem acima para um vídeo curto explicando este exercício.

No arquivo notebook.ipynb associado a esta aula, limpe todas as células pressionando o ícone da 'lixeira'.

Nesta seção, você trabalhará com um pequeno conjunto de dados sobre diabetes, embutido no Scikit-learn para fins de aprendizado. Imagine que você queira testar um tratamento para pacientes diabéticos. Modelos de Machine Learning podem ajudar a determinar quais pacientes responderiam melhor ao tratamento, com base em combinações de variáveis. Mesmo um modelo de regressão bastante básico, quando visualizado, pode mostrar informações sobre variáveis que ajudariam a organizar seus supostos ensaios clínicos.

✅ Existem muitos tipos de métodos de regressão, e qual você escolhe depende da resposta que procura. Se quiser prever a altura provável de uma pessoa de determinada idade, usará regressão linear, já que está buscando um valor numérico. Se estiver interessado em descobrir se um tipo de comida deve ser considerada vegana ou não, estará procurando uma atribuição de categoria, então usaria regressão logística. Você aprenderá mais sobre regressão logística mais adiante. Pense um pouco sobre algumas perguntas que você pode fazer aos dados e qual desses métodos seria mais apropriado.

Vamos começar essa tarefa.

Importar bibliotecas

Para esta tarefa, vamos importar algumas bibliotecas:

matplotlib. É uma útil ferramenta de gráficos e vamos usá-la para criar um gráfico de linha.
numpy. O numpy é uma biblioteca útil para manipular dados numéricos em Python.
sklearn. Esta é a biblioteca Scikit-learn.

Importe algumas bibliotecas para ajudar nas suas tarefas.

Adicione as importações digitando o seguinte código:
```
import matplotlib.pyplot as plt
import numpy as np
from sklearn import datasets, linear_model, model_selection
```
Acima você está importando matplotlib, numpy e importando datasets, linear_model e model_selection do sklearn. model_selection é usado para dividir dados em conjuntos de treino e teste.

O conjunto de dados de diabetes

O conjunto de dados diabetes incluído possui 442 amostras relacionadas ao diabetes, com 10 variáveis características, algumas das quais incluem:

age: idade em anos
bmi: índice de massa corporal
bp: pressão arterial média
s1 tc: Células T (tipo de glóbulos brancos)

✅ Este conjunto de dados inclui o conceito de 'sexo' como uma variável característica importante para pesquisas sobre diabetes. Muitos conjuntos médicos incluem esse tipo de classificação binária. Pense um pouco sobre como categorias como essa podem excluir certas partes da população de tratamentos.

Agora, carregue os dados X e y.

🎓 Lembre-se, este é aprendizado supervisionado, e precisamos de um alvo chamado 'y'.

Em uma nova célula de código, carregue o conjunto de dados diabetes chamando load_diabetes(). O parâmetro return_X_y=True indica que X será uma matriz de dados, e y será o alvo da regressão.

Adicione alguns comandos print para mostrar a forma da matriz de dados e seu primeiro elemento:
```
X, y = datasets.load_diabetes(return_X_y=True)
print(X.shape)
print(X[0])
```
O que você está recebendo como resposta é uma tupla. O que você está fazendo é atribuir os dois primeiros valores da tupla para X e y respectivamente. Saiba mais sobre tuplas.

Você pode ver que esses dados têm 442 itens organizados em arrays de 10 elementos:
```
(442, 10)
[ 0.03807591  0.05068012  0.06169621  0.02187235 -0.0442235  -0.03482076
-0.04340085 -0.00259226  0.01990842 -0.01764613]
```
✅ Pense um pouco sobre a relação entre os dados e o alvo da regressão. A regressão linear prevê relações entre a característica X e a variável alvo y. Você consegue encontrar o alvo no conjunto diabetes na documentação? O que esse conjunto demonstra, dado esse alvo?
Em seguida, selecione uma parte desse conjunto para plotar, escolhendo a 3ª coluna do conjunto. Você pode usar o operador : para selecionar todas as linhas, e então selecione a terceira coluna pelo índice (2). Você também pode remodelar os dados para um array 2D — conforme exigido para plotagem — usando reshape(n_linhas, n_colunas). Se um dos parâmetros for -1, a dimensão correspondente será calculada automaticamente.
```
X = X[:, 2]
X = X.reshape((-1,1))
```
✅ A qualquer momento, imprima os dados para checar sua forma.
Agora que você tem os dados prontos para plotar, veja se uma máquina pode ajudar a determinar uma divisão lógica entre os números deste conjunto. Para isso, você precisa dividir tanto os dados (X) quanto o alvo (y) em conjuntos de teste e treino. O Scikit-learn tem uma forma simples de fazer isso; você pode dividir seus dados de teste em um ponto dado.
```
X_train, X_test, y_train, y_test = model_selection.train_test_split(X, y, test_size=0.33)
```
Agora você está pronto para treinar seu modelo! Carregue o modelo de regressão linear e treine-o com seus conjuntos X e y de treino usando model.fit():
```
model = linear_model.LinearRegression()
model.fit(X_train, y_train)
```
✅ model.fit() é uma função que você verá em muitas bibliotecas de ML como TensorFlow
Depois, crie uma predição usando os dados de teste, usando a função predict(). Isso será usado para desenhar uma linha entre os grupos de dados.
```
y_pred = model.predict(X_test)
```
Agora é hora de mostrar os dados em um gráfico. Matplotlib é uma ferramenta muito útil para essa tarefa. Crie um gráfico de dispersão de todos os dados X e y do teste, e use a predição para desenhar uma linha no lugar mais apropriado, entre os agrupamentos de dados do modelo.
```
plt.scatter(X_test, y_test,  color='black')
plt.plot(X_test, y_pred, color='blue', linewidth=3)
plt.xlabel('Scaled BMIs')
plt.ylabel('Disease Progression')
plt.title('A Graph Plot Showing Diabetes Progression Against BMI')
plt.show()
```
✅ Pense um pouco sobre o que está acontecendo aqui. Uma linha reta está passando por muitos pequenos pontos de dados, mas o que exatamente ela está fazendo? Você consegue ver como deveria poder usar essa linha para prever onde um novo ponto de dados, ainda não visto, deve encaixar em relação ao eixo y do gráfico? Tente colocar em palavras a utilidade prática desse modelo.

Parabéns, você construiu seu primeiro modelo de regressão linear, criou uma previsão com ele e a exibiu em um gráfico!

🚀Desafio

Plote uma variável diferente desse conjunto de dados. Dica: edite esta linha: X = X[:,2]. Considerando o alvo deste conjunto de dados, o que você consegue descobrir sobre a progressão do diabetes como doença?

Quiz pós-aula

Revisão & Autoestudo

Neste tutorial, você trabalhou com regressão linear simples, ao invés de regressão linear univariada ou múltipla. Leia um pouco sobre as diferenças entre esses métodos, ou dê uma olhada neste vídeo

Leia mais sobre o conceito de regressão e pense sobre que tipos de perguntas podem ser respondidas por essa técnica. Faça este tutorial para aprofundar sua compreensão.

Tarefa

Um conjunto de dados diferente

Aviso Legal: Este documento foi traduzido usando o serviço de tradução por IA Co-op Translator. Embora nos esforcemos pela precisão, por favor, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte autorizada. Para informações críticas, recomenda-se tradução profissional humana. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações incorretas decorrentes do uso desta tradução.

16 KiB Raw Permalink Blame History