Angel Mendez
4 years ago
commit
92d6c93a4a
@ -0,0 +1,27 @@
|
||||
# This workflow warns and then closes issues and PRs that have had no activity for a specified amount of time.
|
||||
#
|
||||
# You can adjust the behavior by modifying this file.
|
||||
# For more information, see:
|
||||
# https://github.com/actions/stale
|
||||
name: Mark stale issues and pull requests
|
||||
|
||||
on:
|
||||
schedule:
|
||||
- cron: '35 8 * * *'
|
||||
|
||||
jobs:
|
||||
stale:
|
||||
|
||||
runs-on: ubuntu-latest
|
||||
permissions:
|
||||
issues: write
|
||||
pull-requests: write
|
||||
|
||||
steps:
|
||||
- uses: actions/stale@v3
|
||||
with:
|
||||
repo-token: ${{ secrets.GITHUB_TOKEN }}
|
||||
stale-issue-message: 'This issue has not seen any action for a while! Closing for now, but it can be reopened at a later date.'
|
||||
stale-pr-message: 'This PR has not seen any action for a while! Closing for now, but it can be reopened at a later date.'
|
||||
stale-issue-label: 'no-issue-activity'
|
||||
stale-pr-label: 'no-pr-activity'
|
||||
|
Before Width: | Height: | Size: 16 KiB After Width: | Height: | Size: 19 KiB |
@ -0,0 +1,299 @@
|
||||
# Introdução à classificação
|
||||
|
||||
Nestas quatro lições, você explorará um foco fundamental da aprendizagem de máquina clássica - _classificação_. Usaremos vários algoritmos de classificação com um _datset_ (conjunto de dados) sobre todas as cozinhas brilhantes da Ásia e da Índia. Espero que esteja com fome!
|
||||
|
||||
|
||||
|
||||
> Celebre a cozinha pan-asiática nestas aulas! Imagem por [Jen Looper](https://twitter.com/jenlooper).
|
||||
|
||||
A classificação é uma forma de [aprendizado supervisionado](https://wikipedia.org/wiki/Supervised_learning) que tem muito em comum com as técnicas de regressão. O aprendizado de máquina tem tudo a ver com prever valores ou nomes para coisas usando _datasets_. A classificação geralmente se divide em dois grupos: _classificação binária_ e _classificação de multiclasse_.
|
||||
|
||||
[](https://youtu.be/eg8DJYwdMyg "Introdução à classificação")
|
||||
|
||||
> 🎥 Clique na imagem acima para ver o vídeo: John Guttag do MIT introduz classificação (vídeo em inglês).
|
||||
|
||||
Lembre-se:
|
||||
|
||||
- **A regressão linear** ajudou a prever relações entre variáveis e fazer previsões precisas sobre onde um novo ponto de dados cairia em relação a uma linha. Então, você poderia prever _que preço teria uma abóbora em setembro vs. dezembro_, por exemplo.
|
||||
- **A regressão logística** ajudou a descobrir "categorias binárias": em uma faixa de preço, _essa abóbora é laranja ou não_?
|
||||
|
||||
A classificação usa vários algoritmos para determinar outras maneiras de determinar o rótulo ou a classe de um ponto de dados ou objeto. Vamos trabalhar com dados sobre culinária para ver se, observando um grupo de ingredientes, podemos determinar sua culinária de origem.
|
||||
|
||||
## [Questionário inicial](https://white-water-09ec41f0f.azurestaticapps.net/quiz/19/?loc=ptbr)
|
||||
|
||||
> ### [Esta lição está disponível em R!](../solution/R/lesson_10-R.ipynb)
|
||||
|
||||
### Introdução
|
||||
|
||||
Classificação é uma das atividades fundamentais do pesquisador de aprendizado de máquina e cientista de dados. Desde a classificação básica de um valor binário ("este e-mail é spam ou não?"), até a classificação e segmentação de imagens complexas usando visão computacional, é sempre útil ser capaz de classificar os dados em classes e fazer perguntas sobre eles.
|
||||
|
||||
Para declarar o processo de uma maneira mais científica, seu método de classificação cria um modelo preditivo que permite mapear o relacionamento entre as variáveis de entrada e as variáveis de saída.
|
||||
|
||||
|
||||
|
||||
> Problemas binários vs. multiclasse para algoritmos de classificação lidarem. Infográfico por [Jen Looper](https://twitter.com/jenlooper).
|
||||
|
||||
Antes de iniciar o processo de limpar, visualizar e preparar nossos dados para tarefas de ML, vamos aprender um pouco sobre as várias maneiras pelas quais o aprendizado de máquina pode ser usado ao classificar dados.
|
||||
|
||||
Derivado da [estatística](https://wikipedia.org/wiki/Statistical_classification), a classificação no aprendizado de máquina clássico usa características como `fumante`,` peso` e `idade` para determinar a _possibilidade de desenvolver a doença X_. Como uma técnica de aprendizado supervisionado semelhante aos exercícios de regressão que você realizou anteriormente, seus dados são rotulados e os algoritmos de ML usam esses rótulos para classificar e prever classes (ou 'características') de um _dataset_ e atribuí-los a um grupo ou resultado.
|
||||
|
||||
✅ Imagine um _dataset_ sobre culinárias. O que um modelo multiclasse seria capaz de responder? O que um modelo binário seria capaz de responder? E se você quisesse determinar se uma determinada cozinha usaria [feno-grego](https://pt.wikipedia.org/wiki/Feno-grego)? E se você quisesse ver se usando uma sacola de supermercado cheia de anis estrelado, alcachofras, couve-flor e raiz-forte, você poderia criar um prato típico indiano?
|
||||
|
||||
[](https://youtu.be/GuTeDbaNoEU "Cestas de mistério malucas")
|
||||
|
||||
> 🎥 Clique na imagem acima para assistir a um vídeo (em inglês). O foco de cada episódio do programa 'Chopped' é a 'cesta misteriosa' onde os chefs têm que fazer um prato a partir de uma escolha aleatória de ingredientes. Certamente um modelo de ML teria ajudado!
|
||||
|
||||
## Olá 'classificador'
|
||||
|
||||
A pergunta que queremos fazer sobre este _dataset_ de culinária é, na verdade, uma **questão multiclasse**, pois temos várias cozinhas nacionais em potencial para trabalhar. Dado um lote de ingredientes, em qual dessas muitas classes os dados se encaixam?
|
||||
|
||||
Dependendo do tipo de problema que você deseja resolver, o Scikit-learn oferece vários algoritmos diferentes para classificar dados. Nas próximas tarefas, você aprenderá sobre esses algoritmos.
|
||||
|
||||
## Exercício - limpe e balanceie seus dados
|
||||
|
||||
A primeira tarefa, antes de iniciar este projeto, é limpar e **balancear** seus dados para obter melhores resultados. Comece com o arquivo _notebook.ipynb_ na raiz da pasta desta tarefa.
|
||||
|
||||
A primeira coisa a instalar é o [imblearn](https://imbalanced-learn.org/stable/). O imblearn é um pacote Scikit-learn que permitirá que você balanceie melhor os dados (vamos aprender mais sobre isso já já).
|
||||
|
||||
1. Para instalar o `imblearn`, rode `pip install`:
|
||||
|
||||
```python
|
||||
pip install imblearn
|
||||
```
|
||||
|
||||
1. Importe os pacotes que você precisa para obter seus dados e visualizá-los, importe também a classe `SMOTE`.
|
||||
|
||||
```python
|
||||
import pandas as pd
|
||||
import matplotlib.pyplot as plt
|
||||
import matplotlib as mpl
|
||||
import numpy as np
|
||||
from imblearn.over_sampling import SMOTE
|
||||
```
|
||||
|
||||
Agora você está pronto para obter os dados do _dataset_.
|
||||
|
||||
1. O próximo passo é obter os dados do _dataset_ a ser usado:
|
||||
|
||||
```python
|
||||
df = pd.read_csv('../data/cuisines.csv')
|
||||
```
|
||||
|
||||
Usando o método `read_csv()`, leremos o conteúdo do arquivo csv _cusines.csv_ e colocaremos na variável `df`.
|
||||
|
||||
1. Vamos observar o formato dos dados:
|
||||
|
||||
```python
|
||||
df.head()
|
||||
```
|
||||
|
||||
As primeiras cinco linhas são assim:
|
||||
|
||||
```output
|
||||
| | Unnamed: 0 | cuisine | almond | angelica | anise | anise_seed | apple | apple_brandy | apricot | armagnac | ... | whiskey | white_bread | white_wine | whole_grain_wheat_flour | wine | wood | yam | yeast | yogurt | zucchini |
|
||||
| --- | ---------- | ------- | ------ | -------- | ----- | ---------- | ----- | ------------ | ------- | -------- | --- | ------- | ----------- | ---------- | ----------------------- | ---- | ---- | --- | ----- | ------ | -------- |
|
||||
| 0 | 65 | indian | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
|
||||
| 1 | 66 | indian | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
|
||||
| 2 | 67 | indian | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
|
||||
| 3 | 68 | indian | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
|
||||
| 4 | 69 | indian | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 |
|
||||
```
|
||||
|
||||
1. Conseguimos informações sobre esses dados chamando `info()`:
|
||||
|
||||
```python
|
||||
df.info()
|
||||
```
|
||||
|
||||
O resultado será mais ou menos assim:
|
||||
|
||||
```output
|
||||
<class 'pandas.core.frame.DataFrame'>
|
||||
RangeIndex: 2448 entries, 0 to 2447
|
||||
Columns: 385 entries, Unnamed: 0 to zucchini
|
||||
dtypes: int64(384), object(1)
|
||||
memory usage: 7.2+ MB
|
||||
```
|
||||
|
||||
## Exercício - aprendendo sobre cozinhas
|
||||
|
||||
Agora o trabalho começa a ficar mais interessante. Vamos descobrir a distribuição de dados por cozinha.
|
||||
|
||||
1. Plote os dados como gráfico de barras chamando o método `barh()`:
|
||||
|
||||
```python
|
||||
df.cuisine.value_counts().plot.barh()
|
||||
```
|
||||
|
||||
|
||||
|
||||
Há um número finito de cozinhas, mas a distribuição de dados é desigual. Você pode consertar isso! Mas antes, explore um pouco mais.
|
||||
|
||||
1. Descubra quantos dados estão disponíveis por cozinha e imprima-os:
|
||||
|
||||
```python
|
||||
thai_df = df[(df.cuisine == "thai")]
|
||||
japanese_df = df[(df.cuisine == "japanese")]
|
||||
chinese_df = df[(df.cuisine == "chinese")]
|
||||
indian_df = df[(df.cuisine == "indian")]
|
||||
korean_df = df[(df.cuisine == "korean")]
|
||||
|
||||
print(f'thai df: {thai_df.shape}')
|
||||
print(f'japanese df: {japanese_df.shape}')
|
||||
print(f'chinese df: {chinese_df.shape}')
|
||||
print(f'indian df: {indian_df.shape}')
|
||||
print(f'korean df: {korean_df.shape}')
|
||||
```
|
||||
|
||||
O resultado será mais ou menos assim:
|
||||
|
||||
```output
|
||||
thai df: (289, 385)
|
||||
japanese df: (320, 385)
|
||||
chinese df: (442, 385)
|
||||
indian df: (598, 385)
|
||||
korean df: (799, 385)
|
||||
```
|
||||
|
||||
## Descobrindo ingredientes
|
||||
|
||||
Vamos nos aprofundar nos dados e aprender quais são os ingredientes típicos de cada cozinha. Para isso, devemos limpar os dados recorrentes que criam confusão entre cozinhas.
|
||||
|
||||
1. Crie uma função em Python chamada `create_ingredient()` para criar um _dataframe_ de ingredientes. Esta função começará eliminando uma coluna inútil ("Unnamed: 0") e classificando os ingredientes por quantidade:
|
||||
|
||||
```python
|
||||
def create_ingredient_df(df):
|
||||
ingredient_df = df.T.drop(['cuisine','Unnamed: 0']).sum(axis=1).to_frame('value')
|
||||
ingredient_df = ingredient_df[(ingredient_df.T != 0).any()]
|
||||
ingredient_df = ingredient_df.sort_values(by='value', ascending=False,
|
||||
inplace=False)
|
||||
return ingredient_df
|
||||
```
|
||||
|
||||
Você pode usar essa função para ter uma ideia dos dez ingredientes mais populares de uma culinária.
|
||||
|
||||
1. Chame a função `create_ingredient()` usando os dados de cozinha tailandesa, e plote-os usando o método `barh()`:
|
||||
|
||||
```python
|
||||
thai_ingredient_df = create_ingredient_df(thai_df)
|
||||
thai_ingredient_df.head(10).plot.barh()
|
||||
```
|
||||
|
||||
|
||||
|
||||
1. Faça o mesmo para cozinha japonesa:
|
||||
|
||||
```python
|
||||
japanese_ingredient_df = create_ingredient_df(japanese_df)
|
||||
japanese_ingredient_df.head(10).plot.barh()
|
||||
```
|
||||
|
||||
|
||||
|
||||
1. E para cozinha chinesa:
|
||||
|
||||
```python
|
||||
chinese_ingredient_df = create_ingredient_df(chinese_df)
|
||||
chinese_ingredient_df.head(10).plot.barh()
|
||||
```
|
||||
|
||||
|
||||
|
||||
1. Plote os ingredientes indianos:
|
||||
|
||||
```python
|
||||
indian_ingredient_df = create_ingredient_df(indian_df)
|
||||
indian_ingredient_df.head(10).plot.barh()
|
||||
```
|
||||
|
||||
|
||||
|
||||
1. Por fim, os ingredientes da cozinha coreana:
|
||||
|
||||
```python
|
||||
korean_ingredient_df = create_ingredient_df(korean_df)
|
||||
korean_ingredient_df.head(10).plot.barh()
|
||||
```
|
||||
|
||||
|
||||
|
||||
1. Agora, remova os ingredientes mais comuns que criam confusão entre cozinhas distintas, chamando `drop()`:
|
||||
|
||||
Todo mundo adora arroz, alho e gengibre!
|
||||
|
||||
```python
|
||||
feature_df = df.drop(['cuisine','Unnamed: 0','rice','garlic','ginger'], axis=1)
|
||||
labels_df = df.cuisine #.unique()
|
||||
feature_df.head()
|
||||
```
|
||||
|
||||
## Balanceie o _dataset_
|
||||
|
||||
Agora que você limpou os dados, use a [SMOTE](https://imbalanced-learn.org/dev/references/generated/imblearn.over_sampling.SMOTE.html) - "Técnica de sobreamostragem de minoria sintética" - para balancear.
|
||||
|
||||
1. Chame o método `fit_resample()`, esta estratégia gera novas amostras por interpolação.
|
||||
|
||||
```python
|
||||
oversample = SMOTE()
|
||||
transformed_feature_df, transformed_label_df = oversample.fit_resample(feature_df, labels_df)
|
||||
```
|
||||
|
||||
Ao balancear seus dados, você terá melhores resultados ao classificá-los. Pense em uma classificação binária. Se a maioria dos seus dados for uma classe, um modelo de ML vai prever essa classe com mais frequência, simplesmente porque há mais dados para ela. O balanceamento de dados pega todos os dados distorcidos e ajuda a remover esse desequilíbrio.
|
||||
|
||||
1. Verifique o número de rótulos por ingrediente:
|
||||
|
||||
```python
|
||||
print(f'new label count: {transformed_label_df.value_counts()}')
|
||||
print(f'old label count: {df.cuisine.value_counts()}')
|
||||
```
|
||||
|
||||
O resultado será mais ou menos assim:
|
||||
|
||||
```output
|
||||
new label count: korean 799
|
||||
chinese 799
|
||||
indian 799
|
||||
japanese 799
|
||||
thai 799
|
||||
Name: cuisine, dtype: int64
|
||||
old label count: korean 799
|
||||
indian 598
|
||||
chinese 442
|
||||
japanese 320
|
||||
thai 289
|
||||
Name: cuisine, dtype: int64
|
||||
```
|
||||
|
||||
Os dados são bons e limpos, equilibrados e muito deliciosos!
|
||||
|
||||
1. A última etapa é salvar seus dados balanceados, incluindo rótulos e características, em um novo _dataframe_ que pode ser exportado para um arquivo:
|
||||
|
||||
```python
|
||||
transformed_df = pd.concat([transformed_label_df,transformed_feature_df],axis=1, join='outer')
|
||||
```
|
||||
|
||||
1. Você pode dar mais uma olhada nos dados usando o método `transform_df.head()` e `transform_df.info()`. Salve uma cópia desses dados para usar nas próximas tarefas:
|
||||
|
||||
```python
|
||||
transformed_df.head()
|
||||
transformed_df.info()
|
||||
transformed_df.to_csv("../data/cleaned_cuisines.csv")
|
||||
```
|
||||
|
||||
Este novo csv pode ser encontrado na pasta raiz, onde estão todos os arquivos com os dados dos _datasets_.
|
||||
|
||||
---
|
||||
|
||||
## 🚀Desafio
|
||||
|
||||
Esta lição contém vários _datasets_ interessantes. Explore os arquivos da pasta `data` e veja quais _datasets_ seriam apropriados para classificação binária ou multiclasse. Quais perguntas você faria sobre estes _datasets_?
|
||||
|
||||
## [Questionário para fixação](https://white-water-09ec41f0f.azurestaticapps.net/quiz/20?loc=ptbr)
|
||||
|
||||
## Revisão e Auto Aprendizagem
|
||||
|
||||
Explore a API do SMOTE. Para quais casos de uso ela é melhor usada? Quais problemas resolve?
|
||||
|
||||
## Tarefa
|
||||
|
||||
[Explore métodos de classificação](assignment.pt-br.md)
|
||||
@ -0,0 +1,11 @@
|
||||
# Explore métodos de classificação
|
||||
|
||||
## Instruções
|
||||
|
||||
Na [documentação do Scikit-learn](https://scikit-learn.org/stable/supervised_learning.html), você encontrará uma grande lista de maneiras de classificar dados. Faça uma pequena caça ao tesouro nesses documentos: seu objetivo é procurar métodos de classificação e combinar um _dataset_, uma pergunta que você pode fazer sobre ele e uma técnica de classificação. Crie uma planilha ou tabela em um arquivo .doc e explique como o _dataset_ funcionaria com o algoritmo de classificação.
|
||||
|
||||
## Critérios de avaliação
|
||||
|
||||
| Critério | Exemplar | Adequado | Precisa melhorar |
|
||||
| -------- | ----------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|
||||
| | O documento é apresentado com uma visão geral de 5 algoritmos e uma técnica de classificação. A visão geral é bem explicada e detalhada. | O documento é apresentado com uma visão geral de 3 algoritmos e uma técnica de classificação. A visão geral é bem explicada e detalhada. | O documento é apresentado com uma visão geral de menos de três algoritmos e uma técnica de classificação. A visão geral não é bem explicada nem detalhada. |
|
||||
@ -0,0 +1,243 @@
|
||||
# Classificadores de culinária 1
|
||||
|
||||
Nesta lição, você usará o _dataset_ balanceado e tratado que salvou da última lição cheio de dados sobre cozinhas diferentes.
|
||||
|
||||
Você usará este _dataset_ com uma variedade de classificadores para _prever uma determinada culinária nacional com base em um grupo de ingredientes_. Enquanto isso, você aprenderá mais sobre algumas das maneiras como os algoritmos podem ser aproveitados para tarefas de classificação.
|
||||
|
||||
## [Questionário inicial](https://white-water-09ec41f0f.azurestaticapps.net/quiz/21?loc=ptbr)
|
||||
|
||||
# Preparação
|
||||
|
||||
Assumindo que você completou [lição 1](../../1-Introduction/translations/README.pt-br.md), certifique-se de que existe o arquivo _cleaned_cuisines.csv_ na pasta `/data`, pois será usado para todas as lições de classificação.
|
||||
|
||||
## Exercício - prevendo uma culinária nacional
|
||||
|
||||
1. Usando o _notebook.ipynb_ que está na pasta desta lição, importe a biblioteca Pandas:
|
||||
|
||||
```python
|
||||
import pandas as pd
|
||||
cuisines_df = pd.read_csv("../../data/cleaned_cuisines.csv")
|
||||
cuisines_df.head()
|
||||
```
|
||||
|
||||
Os dados estarão mais ou menos assim:
|
||||
|
||||
| | Unnamed: 0 | cuisine | almond | angelica | anise | anise_seed | apple | apple_brandy | apricot | armagnac | ... | whiskey | white_bread | white_wine | whole_grain_wheat_flour | wine | wood | yam | yeast | yogurt | zucchini |
|
||||
| --- | ---------- | ------- | ------ | -------- | ----- | ---------- | ----- | ------------ | ------- | -------- | --- | ------- | ----------- | ---------- | ----------------------- | ---- | ---- | --- | ----- | ------ | -------- |
|
||||
| 0 | 0 | indian | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
|
||||
| 1 | 1 | indian | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
|
||||
| 2 | 2 | indian | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
|
||||
| 3 | 3 | indian | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
|
||||
| 4 | 4 | indian | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 |
|
||||
|
||||
|
||||
1. Agora importe algumas bibliotecas:
|
||||
|
||||
```python
|
||||
from sklearn.linear_model import LogisticRegression
|
||||
from sklearn.model_selection import train_test_split, cross_val_score
|
||||
from sklearn.metrics import accuracy_score,precision_score,confusion_matrix,classification_report, precision_recall_curve
|
||||
from sklearn.svm import SVC
|
||||
import numpy as np
|
||||
```
|
||||
|
||||
1. Divida as coordenadas X e y em dois _dataframes_ para treinamento. `cuisine` pode ser o rótulo do _dataframe_:
|
||||
|
||||
```python
|
||||
cuisines_label_df = cuisines_df['cuisine']
|
||||
cuisines_label_df.head()
|
||||
```
|
||||
|
||||
O resultado será mais ou menos assim:
|
||||
|
||||
```output
|
||||
0 indian
|
||||
1 indian
|
||||
2 indian
|
||||
3 indian
|
||||
4 indian
|
||||
Name: cuisine, dtype: object
|
||||
```
|
||||
|
||||
1. Remova as colunas `Unnamed: 0` e `cuisine`, chamando o método `drop()`. Salve o restante dos dados como características treináveis:
|
||||
|
||||
```python
|
||||
cuisines_feature_df = cuisines_df.drop(['Unnamed: 0', 'cuisine'], axis=1)
|
||||
cuisines_feature_df.head()
|
||||
```
|
||||
|
||||
As características serão mais ou menos assim:
|
||||
|
||||
| | almond | angelica | anise | anise_seed | apple | apple_brandy | apricot | armagnac | artemisia | artichoke | ... | whiskey | white_bread | white_wine | whole_grain_wheat_flour | wine | wood | yam | yeast | yogurt | zucchini |
|
||||
| ---: | -----: | -------: | ----: | ---------: | ----: | -----------: | ------: | -------: | --------: | --------: | ---: | ------: | ----------: | ---------: | ----------------------: | ---: | ---: | ---: | ----: | -----: | -------: |
|
||||
| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
|
||||
| 1 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
|
||||
| 2 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
|
||||
| 3 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
|
||||
| 4 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 |
|
||||
|
||||
Já podemos treinar nosso modelo!
|
||||
|
||||
## Escolhendo um classificador
|
||||
|
||||
Agora que seus dados estão tratados e prontos para treinamento, você deve decidir qual algoritmo usar para o trabalho.
|
||||
|
||||
O Scikit-learn agrupa classificação em apredizagem supervisionada e, nessa categoria, você encontrará muitas maneiras de classificar. [A variedade](https://scikit-learn.org/stable/supervised_learning.html) é bastante desconcertante à primeira vista. Todos os métodos a seguir incluem técnicas de classificação:
|
||||
|
||||
- Modelos Lineares
|
||||
- Máquinas de vetor de suporte (SVM)
|
||||
- Descida do gradiente estocástico (SGD)
|
||||
- Vizinhos mais próximos
|
||||
- Processos Gaussianos
|
||||
- Árvores de decisão
|
||||
- Métodos de conjunto (classificador de votação, _ensemble_)
|
||||
- Algoritmos de multiclasse e saída múltipla (classificação multiclasse e multilabel, classificação multiclasse-saída múltipla)
|
||||
|
||||
> Você também pode usar [redes neurais para classificar dados](https://scikit-learn.org/stable/modules/neural_networks_supervised.html#classification), mas isso está fora do escopo desta lição.
|
||||
|
||||
### Qual classificador escolher?
|
||||
|
||||
Então, qual classificador você deve escolher? Freqüentemente, percorrer vários e procurar um bom resultado é uma forma de testar. Scikit-learn oferece uma [comparação lado a lado](https://scikit-learn.org/stable/auto_examples/classification/plot_classifier_comparison.html) em um _dataset_ criado, comparando com KNeighbors, SVC de duas maneiras, GaussianProcessClassifier, DecisionTreeClassifier, RandomForestClassifier, MLPClassifier, AdaBoostClassifier, GaussianNB e QuadraticDiscrinationAnalysis, mostrando os resultados visualizados:
|
||||
|
||||
|
||||
> Plots gerados na documentação do Scikit-learn
|
||||
|
||||
> O AutoML resolve esse problema perfeitamente executando essas comparações na nuvem, permitindo que você escolha o melhor algoritmo para seus dados. Teste-o [aqui](https://docs.microsoft.com/learn/modules/automate-model-selection-with-azure-automl/?WT.mc_id=academic-15963-cxa).
|
||||
|
||||
### Uma abordagem melhor
|
||||
|
||||
Melhor do que adivinhar, é seguir as ideias nesta [planilha com dicas de ML](https://docs.microsoft.com/azure/machine-learning/algorithm-cheat-sheet?WT.mc_id=academic-15963-cxa). Aqui, descobrimos que para o nosso problema multiclasse, temos algumas opções:
|
||||
|
||||
|
||||
> Uma planilha com dicas de algoritmo da Microsoft, detalhando as opções de classificação multiclasse.
|
||||
|
||||
✅ Baixe esta planilha, imprima e pendure na parede!
|
||||
|
||||
### Raciocinando
|
||||
|
||||
Vamos ver se podemos raciocinar através de diferentes abordagens, dadas as restrições que temos:
|
||||
|
||||
- **Redes neurais são muito pesadas**. Dado que nosso _dataset_ está tratado mas é pequeno, e o fato de estarmos executando o treinamento localmente por meio de _notebooks_, redes neurais são muito pesadas para essa tarefa.
|
||||
- **Nenhum classificador de duas classes**. Não usamos um classificador de duas classes, isso exclui o esquema um versus todos (one-vs-all).
|
||||
- **Árvore de decisão ou regressão logística podem funcionar**. Árvore de decisão pode funcionar, ou regressão logística para dados multiclasse.
|
||||
- **Árvores de decisão impulsionadas à multiclasse resolvem um problema diferente**. Árvore de decisão impulsionada à multiclasse é mais adequada para tarefas não paramétricas, por exemplo, tarefas destinadas a construir _rankings_, por isso não são úteis para nós.
|
||||
|
||||
### Usando Scikit-learn
|
||||
|
||||
Usaremos o Scikit-learn para analisar nossos dados. No entanto, existem muitas maneiras de usar a regressão logística no Scikit-learn. Dê uma olhada nos [possíveis parâmetros](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html?highlight=logistic%20regressio#sklearn.linear_model.LogisticRegression).
|
||||
|
||||
Essencialmente, existem dois parâmetros importantes - `multi_class` e `solver` -, que precisamos especificar quando pedimos ao Scikit-learn para realizar uma regressão logística. O valor de `multi_class` aplica um certo comportamento. O valor de `solver` é o algoritmo a ser usado. Nem todos os valores de `solver` podem ser combinados com os valores de `multi_class`.
|
||||
|
||||
De acordo com a documentação, no caso de multiclasse, o algoritmo de treinamento:
|
||||
|
||||
- **Usa o esquema one-vs-rest (OvR, ou "um contra o resto")**, se a opção `multi_class` estiver definida como `ovr`.
|
||||
- **Usa a perda de entropia cruzada**, se a opção `multi_class` estiver definida como `multinomial` (atualmente, a opção `multinomial` é compatível apenas com os "_solvers_" (ou solucionadores): `lbfgs`, `sag`, `saga` e `newton-cg`).
|
||||
|
||||
> 🎓 O 'esquema' aqui pode ser 'ovr' ou 'multinomial'. Uma vez que a regressão logística é realmente projetada para oferecer suporte à classificação binária, esses esquemas permitem um melhor tratamento das tarefas de classificação multiclasse. [Fonte](https://machinelearningmastery.com/one-vs-rest-and-one-vs-one-for-multi-class-classification/).
|
||||
|
||||
> 🎓 O 'solucionador' é definido como "o algoritmo a ser usado no problema de otimização". [Fonte](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html?highlight=logistic%20regressio#sklearn.linear_model.LogisticRegression).
|
||||
|
||||
O Scikit-learn oferece esta tabela para explicar como os solucionadores lidam com diferentes desafios apresentados por diferentes tipos de estruturas de dados:
|
||||
|
||||
|
||||
|
||||
## Exercício - dividindo os dados
|
||||
|
||||
Podemos nos concentrar na regressão logística para nosso primeiro teste de treinamento, uma vez que você aprendeu recentemente sobre o último em uma lição anterior.
|
||||
Divida seus dados em grupos de treinamento e teste chamando o método `train_test_split()`:
|
||||
|
||||
```python
|
||||
X_train, X_test, y_train, y_test = train_test_split(cuisines_feature_df, cuisines_label_df, test_size=0.3)
|
||||
```
|
||||
|
||||
## Exercício - aplicando regressão logística
|
||||
|
||||
Já que estamos usando um caso multiclasse, você precisa escolher qual _scheme_ usar e qual _solver_ definir. Use LogisticRegression com uma configuração multiclasse e o solucionador **liblinear** para treinar.
|
||||
|
||||
1. Crie uma regressão logística com multi_class definido como `ovr` e solver definido como `liblinear`:
|
||||
|
||||
```python
|
||||
lr = LogisticRegression(multi_class='ovr',solver='liblinear')
|
||||
model = lr.fit(X_train, np.ravel(y_train))
|
||||
|
||||
accuracy = model.score(X_test, y_test)
|
||||
print ("Accuracy is {}".format(accuracy))
|
||||
```
|
||||
|
||||
✅ Teste diferentes _solvers_ como o `lbfgs`, que já é definido como padrão.
|
||||
|
||||
> Use a função Pandas chamada [`ravel`](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.Series.ravel.html) para nivelar seus dados quando necessário.
|
||||
|
||||
A acurácia está boa quando é maior que **80%**!
|
||||
|
||||
1. Você pode ver este modelo em ação testando dessa forma (linha #50):
|
||||
|
||||
```python
|
||||
print(f'ingredients: {X_test.iloc[50][X_test.iloc[50]!=0].keys()}')
|
||||
print(f'cuisine: {y_test.iloc[50]}')
|
||||
```
|
||||
|
||||
O resultado será:
|
||||
|
||||
```output
|
||||
ingredients: Index(['cilantro', 'onion', 'pea', 'potato', 'tomato', 'vegetable_oil'], dtype='object')
|
||||
cuisine: indian
|
||||
```
|
||||
|
||||
✅ Tente um número de linha diferente e verifique os resultados.
|
||||
|
||||
1. Indo mais fundo, você pode verificar a precisão desta previsão:
|
||||
|
||||
```python
|
||||
test= X_test.iloc[50].values.reshape(-1, 1).T
|
||||
proba = model.predict_proba(test)
|
||||
classes = model.classes_
|
||||
resultdf = pd.DataFrame(data=proba, columns=classes)
|
||||
|
||||
topPrediction = resultdf.T.sort_values(by=[0], ascending = [False])
|
||||
topPrediction.head()
|
||||
```
|
||||
|
||||
A culinária indiana é seu melhor palpite, com boa probabilidade:
|
||||
|
||||
| | 0 |
|
||||
| -------: | -------: |
|
||||
| indian | 0.715851 |
|
||||
| chinese | 0.229475 |
|
||||
| japanese | 0.029763 |
|
||||
| korean | 0.017277 |
|
||||
| thai | 0.007634 |
|
||||
|
||||
✅ Você pode explicar por que a modelo tem certeza de que se trata de uma culinária indiana?
|
||||
|
||||
1. Obtenha mais detalhes imprimindo um relatório de classificação, como você fez nas aulas de regressão:
|
||||
|
||||
```python
|
||||
y_pred = model.predict(X_test)
|
||||
print(classification_report(y_test,y_pred))
|
||||
```
|
||||
|
||||
| | precision | recall | f1-score | support |
|
||||
| ------------ | --------- | ------ | -------- | ------- |
|
||||
| chinese | 0.73 | 0.71 | 0.72 | 229 |
|
||||
| indian | 0.91 | 0.93 | 0.92 | 254 |
|
||||
| japanese | 0.70 | 0.75 | 0.72 | 220 |
|
||||
| korean | 0.86 | 0.76 | 0.81 | 242 |
|
||||
| thai | 0.79 | 0.85 | 0.82 | 254 |
|
||||
| accuracy | 0.80 | 1199 | | |
|
||||
| macro avg | 0.80 | 0.80 | 0.80 | 1199 |
|
||||
| weighted avg | 0.80 | 0.80 | 0.80 | 1199 |
|
||||
|
||||
## 🚀Desafio
|
||||
|
||||
Nesta lição, você usou seus dados para construir um modelo de aprendizado de máquina que pode prever uma culinária nacional com base em uma série de ingredientes. Reserve algum tempo para ler as opções que o Scikit-learn oferece para classificar dados. Aprofunde-se no conceito de 'solucionador' para entender o que acontece nos bastidores.
|
||||
|
||||
## [Questionário para fixação](https://white-water-09ec41f0f.azurestaticapps.net/quiz/22?loc=ptbr)
|
||||
|
||||
## Revisão e Auto Aprendizagem
|
||||
|
||||
Aprofunde-se um pouco mais na matemática por trás da regressão logística [nesta lição](https://people.eecs.berkeley.edu/~russell/classes/cs194/f11/lectures/CS194%20Fall%202011%20Lecture%2006.pdf).
|
||||
|
||||
## Tarefa
|
||||
|
||||
[Estudando solucionadores](assignment.pt-br.md).
|
||||
@ -0,0 +1,11 @@
|
||||
# Estudando solucionadores
|
||||
|
||||
## Instruções
|
||||
|
||||
Nesta lição, você aprendeu sobre os vários solucionadores que combinam algoritmos com um processo de aprendizado de máquina para criar um modelo preciso. Percorra os solucionadores listados na lição e escolha dois. Em suas próprias palavras, compare e contraste esses dois solucionadores. Que tipo de problema eles abordam? Como eles funcionam com várias estruturas de dados? Por que você escolheria um em vez do outro?
|
||||
|
||||
## Critérios de avaliação
|
||||
|
||||
| Critério | Exemplar | Adequado | Precisa melhorar |
|
||||
| -------- | ---------------------------------------------------------------------------------------------- | ------------------------------------------------ | ---------------------------- |
|
||||
| | Um arquivo .doc foi apresentado com dois parágrafos, um em cada solucionador, comparando-os cuidadosamente. | Um arquivo .doc é apresentado com apenas um parágrafo. | A tarefa está incompleta. |
|
||||
@ -0,0 +1,235 @@
|
||||
# Classificadores de culinária 2
|
||||
|
||||
Nesta segunda lição de classificação, você explorará outras maneiras de classificar dados numéricos. Você também aprenderá sobre as ramificações para escolher um classificador em vez de outro.
|
||||
|
||||
## [Questionário inicial](https://white-water-09ec41f0f.azurestaticapps.net/quiz/23?loc=ptbr)
|
||||
|
||||
### Pré-requisito
|
||||
|
||||
Presumimos que você tenha concluído as lições anteriores e tenha um arquivo com o _dataset_ em sua pasta `data` chamado _cleaned_cuisines.csv_.
|
||||
|
||||
### Preparação
|
||||
|
||||
Carregando o arquivo _notebook.ipynb_ com o _dataset_ e o dividimos em dataframes X e y, estamos prontos para o processo de construção do modelo.
|
||||
|
||||
## Um mapa de classificação
|
||||
|
||||
Anteriormente, você aprendeu sobre as várias opções para classificar dados usando a planilha da Microsoft. O Scikit-learn oferece uma planilha semelhante, com mais informações, que pode ajudar ainda mais a restringir seus estimadores (outro termo para classificadores):
|
||||
|
||||
|
||||
> Dica: [visite este site](https://scikit-learn.org/stable/tutorial/machine_learning_map/) para ler a documentação.
|
||||
|
||||
### O plano
|
||||
|
||||
Este mapa é muito útil, uma vez que você tenha uma compreensão clara de seus dados, pois você pode 'andar' no mapa ao longo dos caminhos para então, tomar uma decisão:
|
||||
|
||||
- Temos mais que 50 amostras
|
||||
- Queremos prever uma categoria
|
||||
- Nós rotulamos os dados
|
||||
- Temos menos de 100 mil amostras
|
||||
- ✨ Podemos escolher um SVC linear
|
||||
- Se isso não funcionar, já que temos dados numéricos:
|
||||
- Podemos tentar um classificador KNeighbors ✨
|
||||
- Se não funcionar, tente o ✨ SVC e ✨ Classificadores de conjunto (ensemble)
|
||||
|
||||
Esta é uma trilha muito útil a seguir.
|
||||
|
||||
## Exercício - dividindo os dados
|
||||
|
||||
Seguindo este caminho, devemos começar importando algumas bibliotecas.
|
||||
|
||||
1. Importe essas bibliotecas:
|
||||
|
||||
```python
|
||||
from sklearn.neighbors import KNeighborsClassifier
|
||||
from sklearn.linear_model import LogisticRegression
|
||||
from sklearn.svm import SVC
|
||||
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier
|
||||
from sklearn.model_selection import train_test_split, cross_val_score
|
||||
from sklearn.metrics import accuracy_score,precision_score,confusion_matrix,classification_report, precision_recall_curve
|
||||
import numpy as np
|
||||
```
|
||||
|
||||
1. Divida os dados em dados de treinamento e teste:
|
||||
|
||||
```python
|
||||
X_train, X_test, y_train, y_test = train_test_split(cuisines_feature_df, cuisines_label_df, test_size=0.3)
|
||||
```
|
||||
|
||||
## Classificador linear SVC
|
||||
|
||||
O Clustering de Vetores de Suporte (SVC, ou no inglês, Support-Vector clustering) é um filho da família de máquinas de vetores de suporte de técnicas de ML. Neste método, você pode escolher um 'kernel' para decidir como agrupar os rótulos. O parâmetro 'C' refere-se à 'regularização' que regula a influência dos parâmetros. O kernel pode ser um de [vários](https://scikit-learn.org/stable/modules/generated/sklearn.svm.SVC.html#sklearn.svm.SVC); aqui, nós o definimos como 'linear' para garantir impulsionar o classificador. O padrão de probabilidade é 'false'; aqui, nós o definimos como 'true' para reunir estimativas de probabilidade. Definimos random_state como '0' para embaralhar os dados e obter probabilidades.
|
||||
|
||||
### Exercício - aplicando um SVC linear
|
||||
|
||||
Comece criando um array de classificadores. Você adicionará itens progressivamente a este array enquanto testamos.
|
||||
|
||||
1. Comece com um SVC linear:
|
||||
|
||||
```python
|
||||
C = 10
|
||||
# Create different classifiers.
|
||||
classifiers = {
|
||||
'Linear SVC': SVC(kernel='linear', C=C, probability=True,random_state=0)
|
||||
}
|
||||
```
|
||||
|
||||
2. Treine seu modelo usando o SVC e imprima um relatório:
|
||||
|
||||
```python
|
||||
n_classifiers = len(classifiers)
|
||||
|
||||
for index, (name, classifier) in enumerate(classifiers.items()):
|
||||
classifier.fit(X_train, np.ravel(y_train))
|
||||
|
||||
y_pred = classifier.predict(X_test)
|
||||
accuracy = accuracy_score(y_test, y_pred)
|
||||
print("Accuracy (train) for %s: %0.1f%% " % (name, accuracy * 100))
|
||||
print(classification_report(y_test,y_pred))
|
||||
```
|
||||
|
||||
O resultado é bom:
|
||||
|
||||
```output
|
||||
Accuracy (train) for Linear SVC: 78.6%
|
||||
precision recall f1-score support
|
||||
|
||||
chinese 0.71 0.67 0.69 242
|
||||
indian 0.88 0.86 0.87 234
|
||||
japanese 0.79 0.74 0.76 254
|
||||
korean 0.85 0.81 0.83 242
|
||||
thai 0.71 0.86 0.78 227
|
||||
|
||||
accuracy 0.79 1199
|
||||
macro avg 0.79 0.79 0.79 1199
|
||||
weighted avg 0.79 0.79 0.79 1199
|
||||
```
|
||||
|
||||
## Classificador K-Neighbors
|
||||
|
||||
K-Neighbors faz parte da família "neighbors" de métodos de ML, que podem ser usados para aprendizado supervisionado e não supervisionado. Neste método, um número predefinido de pontos é criado e os dados são reunidos em torno desses pontos de modo que rótulos generalizados podem ser previstos para os dados.
|
||||
|
||||
### Exercício - aplicando o classificador K-Neighbors
|
||||
|
||||
O classificador anterior era bom e funcionou bem com os dados, mas talvez possamos obter uma melhor acurácia. Experimente um classificador K-Neighbors.
|
||||
|
||||
1. Adicione uma linha ao seu array de classificadores (adicione uma vírgula após o item do SVC):
|
||||
|
||||
```python
|
||||
'KNN classifier': KNeighborsClassifier(C),
|
||||
```
|
||||
|
||||
O resultado é um pouco pior:
|
||||
|
||||
```output
|
||||
Accuracy (train) for KNN classifier: 73.8%
|
||||
precision recall f1-score support
|
||||
|
||||
chinese 0.64 0.67 0.66 242
|
||||
indian 0.86 0.78 0.82 234
|
||||
japanese 0.66 0.83 0.74 254
|
||||
korean 0.94 0.58 0.72 242
|
||||
thai 0.71 0.82 0.76 227
|
||||
|
||||
accuracy 0.74 1199
|
||||
macro avg 0.76 0.74 0.74 1199
|
||||
weighted avg 0.76 0.74 0.74 1199
|
||||
```
|
||||
|
||||
✅ Aprenda mais sobre [K-Neighbors](https://scikit-learn.org/stable/modules/neighbors.html#neighbors)
|
||||
|
||||
## Classificador de Vetores de Suporte
|
||||
|
||||
Os Classificadores de Vetores de Suporte (SVM, ou no inglês, Support-Vector Machine) fazem parte da família [Classificadores de Vetores de Suporte](https://wikipedia.org/wiki/Support-vector_machine) de métodos de ML que são usados para tarefas de classificação e regressão. Os SVMs "mapeiam exemplos de treinamento para pontos no espaço" para maximizar a distância entre duas categorias. Os dados subsequentes são mapeados neste espaço para que sua categoria possa ser prevista.
|
||||
|
||||
### Exercício - aplicando o Classificador de Vetores de Suporte
|
||||
|
||||
Vamos tentar aumentar a acurácia com um Classificador de Vetores de Suporte.
|
||||
|
||||
1. Adicione uma vírgula após o item K-Neighbors e, em seguida, adicione esta linha:
|
||||
|
||||
```python
|
||||
'SVC': SVC(),
|
||||
```
|
||||
|
||||
O resultado é muito bom!
|
||||
|
||||
```output
|
||||
Accuracy (train) for SVC: 83.2%
|
||||
precision recall f1-score support
|
||||
|
||||
chinese 0.79 0.74 0.76 242
|
||||
indian 0.88 0.90 0.89 234
|
||||
japanese 0.87 0.81 0.84 254
|
||||
korean 0.91 0.82 0.86 242
|
||||
thai 0.74 0.90 0.81 227
|
||||
|
||||
accuracy 0.83 1199
|
||||
macro avg 0.84 0.83 0.83 1199
|
||||
weighted avg 0.84 0.83 0.83 1199
|
||||
```
|
||||
|
||||
✅ Aprenda mais sobre [Vetores de Suporte](https://scikit-learn.org/stable/modules/svm.html#svm)
|
||||
|
||||
## Classificadores de conjunto (ensemble)
|
||||
|
||||
Vamos seguir o caminho até o fim, embora o teste anterior tenha sido muito bom. Vamos tentar alguns 'Classificadores de conjunto, especificamente Random Forest (Árvores Aleatórias) e AdaBoost:
|
||||
|
||||
```python
|
||||
'RFST': RandomForestClassifier(n_estimators=100),
|
||||
'ADA': AdaBoostClassifier(n_estimators=100)
|
||||
```
|
||||
|
||||
O resultado é muito bom, especialmente para Random Forest:
|
||||
|
||||
```output
|
||||
Accuracy (train) for RFST: 84.5%
|
||||
precision recall f1-score support
|
||||
|
||||
chinese 0.80 0.77 0.78 242
|
||||
indian 0.89 0.92 0.90 234
|
||||
japanese 0.86 0.84 0.85 254
|
||||
korean 0.88 0.83 0.85 242
|
||||
thai 0.80 0.87 0.83 227
|
||||
|
||||
accuracy 0.84 1199
|
||||
macro avg 0.85 0.85 0.84 1199
|
||||
weighted avg 0.85 0.84 0.84 1199
|
||||
|
||||
Accuracy (train) for ADA: 72.4%
|
||||
precision recall f1-score support
|
||||
|
||||
chinese 0.64 0.49 0.56 242
|
||||
indian 0.91 0.83 0.87 234
|
||||
japanese 0.68 0.69 0.69 254
|
||||
korean 0.73 0.79 0.76 242
|
||||
thai 0.67 0.83 0.74 227
|
||||
|
||||
accuracy 0.72 1199
|
||||
macro avg 0.73 0.73 0.72 1199
|
||||
weighted avg 0.73 0.72 0.72 1199
|
||||
```
|
||||
|
||||
✅ Aprenda mais sobre [Classificadores de conjunto](https://scikit-learn.org/stable/modules/ensemble.html)
|
||||
|
||||
Este método de arendizado de máquina "combina as previsões de vários estimadores de base" para melhorar a qualidade do modelo. Em nosso exemplo, usamos Random Forest e AdaBoost.
|
||||
|
||||
- [Random Forest](https://scikit-learn.org/stable/modules/ensemble.html#forest), um método de média, constrói uma 'floresta' de 'árvores de decisão' infundidas com aleatoriedade para evitar _overfitting_. O parâmetro `n_estimators` define a quantidade de árvores.
|
||||
|
||||
- [AdaBoost](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.AdaBoostClassifier.html) ajusta um classificador a um _dataset_ e, em seguida, ajusta cópias desse classificador ao mesmo _dataset_. Ele se concentra nos pesos dos itens classificados incorretamente e corrige o ajuste para o próximo classificador.
|
||||
|
||||
---
|
||||
|
||||
## 🚀Desafio
|
||||
|
||||
Cada uma dessas técnicas possui um grande número de parâmetros. Pesquise os parâmetros padrão de cada um e pense no que o ajuste desses parâmetros significaria para a qualidade do modelo.
|
||||
|
||||
## [Questionário para fixação](https://white-water-09ec41f0f.azurestaticapps.net/quiz/24?loc=ptbr)
|
||||
|
||||
## Revisão e Auto Aprendizagem
|
||||
|
||||
Há muitos termos nessas lições, então reserve um minuto para revisar [esta lista útil](https://docs.microsoft.com/dotnet/machine-learning/resources/glossary?WT.mc_id=academic-15963-cxa) sobre terminologias!
|
||||
|
||||
## Tarefa
|
||||
|
||||
[Brincando com parâmetros](assignment.pt-br.md).
|
||||
@ -0,0 +1,11 @@
|
||||
# Brincando com parâmetros
|
||||
|
||||
## Instruções
|
||||
|
||||
Existem muitos parâmetros definidos por padrão ao trabalhar com classificadores. O Intellisense no VS Code pode ajudá-lo a se aprofundar neles. Adote uma das técnicas de classificação de ML nesta lição e retreine os modelos ajustando os parâmetros. Construa um _notebook_ explicando por que algumas mudanças ajudam na qualidade do modelo enquanto outras o degradam. Seja detalhado em sua resposta.
|
||||
|
||||
## Critérios de avaliação
|
||||
|
||||
| Critério | Exemplar | Adequado | Precisa melhorar |
|
||||
| -------- | ---------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------- | ----------------------------- |
|
||||
| | Um _notebook_ foi apresentado com um classificador totalmente construído e seus parâmetros ajustados e mudanças explicadas em caixas de texto | O _notebook_ foi parcialmente apresentado ou mal explicado | O _notebook_ está bugado |
|
||||
@ -0,0 +1,337 @@
|
||||
# Construindo uma aplicação Web para recomendar culinária
|
||||
|
||||
Nesta lição, você construirá um modelo de classificação usando algumas das técnicas que aprendeu nas lições anteriores e com o _dataset_ de cozinhas deliciosas usado ao longo desta série. Além disso, você construirá uma pequena aplicação Web para usar um modelo salvo, aproveitando o tempo de execução da web do Onnx.
|
||||
|
||||
Um dos usos práticos mais úteis do aprendizado de máquina é criar sistemas de recomendação, e você pode dar o primeiro passo nessa direção hoje!
|
||||
|
||||
[](https://youtu.be/17wdM9AHMfg "Applied ML")
|
||||
|
||||
> 🎥 Clique na imagem acima para ver um vídeo
|
||||
|
||||
## [Questionário inicial](https://white-water-09ec41f0f.azurestaticapps.net/quiz/25?loc=ptbr)
|
||||
|
||||
Nesta lição você aprenderá:
|
||||
|
||||
- Como construir um modelo e salvá-lo como um modelo Onnx
|
||||
- Como usar o Netron para visualizar o modelo
|
||||
- Como usar seu modelo em uma aplicação Web para inferência
|
||||
|
||||
## Construindo seu modelo
|
||||
|
||||
Construir sistemas aplicados de ML é uma parte importante para o aproveitamento dessas tecnologias voltadas para sistemas de negócios. Você pode usar modelos dentro de aplicações Web (e, portanto, usá-los em um contexto offline, se necessário) usando Onnx.
|
||||
|
||||
Em uma [lição anterior](../../../3-Web-App/1-Web-App/translations/README.pt-br.md), você construiu um modelo de regressão sobre avistamentos de OVNIs, aplicou "pickle" e o usou em uma aplicação Flask. Embora seja muito útil conhecer essa arquitetura, é uma aplicação full-stack Python e seus requisitos podem incluir o uso de JavaScript.
|
||||
|
||||
Nesta lição, você pode construir um sistema básico baseado em JavaScript para inferência. Mas primeiro, você precisa treinar um modelo e convertê-lo para uso através do Onnx.
|
||||
|
||||
## Exercício - treinando um modelo de classificação
|
||||
|
||||
Primeiro, treine um modelo de classificação usando o _dataset_ que usamos anteriormente.
|
||||
|
||||
1. Comece importando algumas bibliotecas:
|
||||
|
||||
```python
|
||||
!pip install skl2onnx
|
||||
import pandas as pd
|
||||
```
|
||||
|
||||
Você precisará da '[skl2onnx](https://onnx.ai/sklearn-onnx/)' para ajudar a converter seu modelo Scikit-learn para o formato Onnx.
|
||||
|
||||
1. Trabalhe com seus dados da mesma maneira que você fez nas lições anteriores, lendo um arquivo CSV usando `read_csv()`:
|
||||
|
||||
```python
|
||||
data = pd.read_csv('../data/cleaned_cuisines.csv')
|
||||
data.head()
|
||||
```
|
||||
|
||||
1. Remova as duas primeiras colunas desnecessárias e salve os dados restantes na variável 'X':
|
||||
|
||||
```python
|
||||
X = data.iloc[:,2:]
|
||||
X.head()
|
||||
```
|
||||
|
||||
1. Salve as categorias na variável 'y':
|
||||
|
||||
```python
|
||||
y = data[['cuisine']]
|
||||
y.head()
|
||||
|
||||
```
|
||||
|
||||
### Começando a rotina de treinamento
|
||||
|
||||
Usaremos a biblioteca 'SVC' que tem boa acurácia.
|
||||
|
||||
1. Importe as bibliotecas apropriadas do Scikit-learn:
|
||||
|
||||
```python
|
||||
from sklearn.model_selection import train_test_split
|
||||
from sklearn.svm import SVC
|
||||
from sklearn.model_selection import cross_val_score
|
||||
from sklearn.metrics import accuracy_score,precision_score,confusion_matrix,classification_report
|
||||
```
|
||||
|
||||
1. Separe os dados em dados de treinamento e teste:
|
||||
|
||||
```python
|
||||
X_train, X_test, y_train, y_test = train_test_split(X,y,test_size=0.3)
|
||||
```
|
||||
|
||||
1. Construa um modelo de classificação SVC como você fez na lição anterior:
|
||||
|
||||
```python
|
||||
model = SVC(kernel='linear', C=10, probability=True,random_state=0)
|
||||
model.fit(X_train,y_train.values.ravel())
|
||||
```
|
||||
|
||||
1. Agora teste seu modelo, chamando o método `predict()`:
|
||||
|
||||
```python
|
||||
y_pred = model.predict(X_test)
|
||||
```
|
||||
|
||||
1. Imprima um relatório de classificação para verificar a qualidade do modelo:
|
||||
|
||||
```python
|
||||
print(classification_report(y_test,y_pred))
|
||||
```
|
||||
|
||||
Como vimos antes, a acurácia é boa:
|
||||
|
||||
```output
|
||||
precision recall f1-score support
|
||||
|
||||
chinese 0.72 0.69 0.70 257
|
||||
indian 0.91 0.87 0.89 243
|
||||
japanese 0.79 0.77 0.78 239
|
||||
korean 0.83 0.79 0.81 236
|
||||
thai 0.72 0.84 0.78 224
|
||||
|
||||
accuracy 0.79 1199
|
||||
macro avg 0.79 0.79 0.79 1199
|
||||
weighted avg 0.79 0.79 0.79 1199
|
||||
```
|
||||
|
||||
### Convertendo seu modelo para o formato Onnx
|
||||
|
||||
Certifique-se de fazer a conversão adequada do número Tensor. Este _dataset_ tem 380 ingredientes listados, então você precisa anotar esse número usando a `FloatTensorType`:
|
||||
|
||||
1. Converta usando um número tensor de 380.
|
||||
|
||||
```python
|
||||
from skl2onnx import convert_sklearn
|
||||
from skl2onnx.common.data_types import FloatTensorType
|
||||
|
||||
initial_type = [('float_input', FloatTensorType([None, 380]))]
|
||||
options = {id(model): {'nocl': True, 'zipmap': False}}
|
||||
```
|
||||
|
||||
1. Crie a variável onx e armazene como um arquivo chamado **model.onnx**:
|
||||
|
||||
```python
|
||||
onx = convert_sklearn(model, initial_types=initial_type, options=options)
|
||||
with open("./model.onnx", "wb") as f:
|
||||
f.write(onx.SerializeToString())
|
||||
```
|
||||
|
||||
> Observe, você pode passar um dicionário em [options](https://onnx.ai/sklearn-onnx/parameterized.html) no seu script de conversão. Nesse caso, passamos 'nocl' como True e 'zipmap' como False. Por ser um modelo de classificação, você tem a opção de remover o ZipMap, que produz uma lista de dicionários (não é necessário). `nocl` refere-se às informações de classe incluídas no modelo. Reduza o tamanho do seu modelo configurando `nocl` para 'True'.
|
||||
|
||||
Executando o _notebook_ inteiro agora irá construir um modelo Onnx e salvá-lo nesta pasta.
|
||||
|
||||
## Visualizando seu modelo
|
||||
|
||||
Os modelos Onnx não são muito visíveis no código do Visual Studio, mas existe um software livre muito bom que muitos pesquisadores usam para visualizar o modelo e garantir que ele seja construído corretamente. Baixe o programa [Netron](https://github.com/lutzroeder/Netron) e abra seu arquivo model.onnx com ele. Você pode ver seu modelo simples com suas 380 entradas e suas possíveis saídas:
|
||||
|
||||
|
||||
|
||||
Netron é uma ferramenta útil para visualizar seus modelos.
|
||||
|
||||
Estamos prontos para usar este modelo bacana em uma aplicação Web. Vamos construir uma aplicação que será útil pra quando você olhar em sua geladeira e tentar descobrir qual combinação de seus ingredientes você pode usar para cozinhar um prato de uma determinada culinária específica, conforme determinado por seu modelo.
|
||||
|
||||
## Criando uma aplicação Web de recomendação
|
||||
|
||||
Você pode usar seu modelo diretamente em uma aplicação Web. Essa arquitetura também permite executá-lo localmente e até mesmo offline, se necessário. Comece criando um arquivo `index.html` na mesma pasta onde você armazenou seu arquivo` model.onnx`.
|
||||
|
||||
1. No arquivo _index.html_, adicione o seguinte _markup_:
|
||||
|
||||
```html
|
||||
<!DOCTYPE html>
|
||||
<html>
|
||||
<header>
|
||||
<title>Cuisine Matcher</title>
|
||||
</header>
|
||||
<body>
|
||||
...
|
||||
</body>
|
||||
</html>
|
||||
```
|
||||
|
||||
1. Trabalhando com a tag `body`, adicione um pequeno _markup_ para mostrar uma lista de caixas de seleção (input) refletindo alguns ingredientes:
|
||||
|
||||
```html
|
||||
<h1>Check your refrigerator. What can you create?</h1>
|
||||
<div id="wrapper">
|
||||
<div class="boxCont">
|
||||
<input type="checkbox" value="4" class="checkbox">
|
||||
<label>apple</label>
|
||||
</div>
|
||||
|
||||
<div class="boxCont">
|
||||
<input type="checkbox" value="247" class="checkbox">
|
||||
<label>pear</label>
|
||||
</div>
|
||||
|
||||
<div class="boxCont">
|
||||
<input type="checkbox" value="77" class="checkbox">
|
||||
<label>cherry</label>
|
||||
</div>
|
||||
|
||||
<div class="boxCont">
|
||||
<input type="checkbox" value="126" class="checkbox">
|
||||
<label>fenugreek</label>
|
||||
</div>
|
||||
|
||||
<div class="boxCont">
|
||||
<input type="checkbox" value="302" class="checkbox">
|
||||
<label>sake</label>
|
||||
</div>
|
||||
|
||||
<div class="boxCont">
|
||||
<input type="checkbox" value="327" class="checkbox">
|
||||
<label>soy sauce</label>
|
||||
</div>
|
||||
|
||||
<div class="boxCont">
|
||||
<input type="checkbox" value="112" class="checkbox">
|
||||
<label>cumin</label>
|
||||
</div>
|
||||
</div>
|
||||
<div style="padding-top:10px">
|
||||
<button onClick="startInference()">What kind of cuisine can you make?</button>
|
||||
</div>
|
||||
```
|
||||
|
||||
Observe que cada caixa de seleção recebe um valor. Este valor reflete o índice onde o ingrediente é encontrado de acordo com o _dataset_. O ingrediente "apple", por exemplo, ocupa a quinta coluna, então seu valor é '4' já que começamos a contar em 0. Você pode consultar a [planilha de ingredientes](../../data/ingredient_indexes.csv) para descobrir um determinado índice do ingrediente.
|
||||
|
||||
Continuando seu trabalho no arquivo _index.html_, vamos adicionar um bloco de script onde o modelo é chamado após o fechamento final `</div>`.
|
||||
|
||||
1. Primeiro, importe o [Onnx Runtime](https://www.onnxruntime.ai/):
|
||||
|
||||
```html
|
||||
<script src="https://cdn.jsdelivr.net/npm/onnxruntime-web@1.9.09/dist/ort.min.js"></script>
|
||||
```
|
||||
|
||||
> Onnx Runtime é usado para permitir a execução de seus modelos Onnx em uma ampla gama de plataformas de hardware, incluindo otimizações e uma API.
|
||||
|
||||
1. Assim que o Runtime estiver pronto, você pode chamá-lo:
|
||||
|
||||
```javascript
|
||||
<script>
|
||||
const ingredients = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
|
||||
|
||||
const checks = [].slice.call(document.querySelectorAll('.checkbox'));
|
||||
|
||||
// use an async context to call onnxruntime functions.
|
||||
function init() {
|
||||
|
||||
checks.forEach(function (checkbox, index) {
|
||||
checkbox.onchange = function () {
|
||||
if (this.checked) {
|
||||
var index = checkbox.value;
|
||||
|
||||
if (index !== -1) {
|
||||
ingredients[index] = 1;
|
||||
}
|
||||
console.log(ingredients)
|
||||
}
|
||||
else {
|
||||
var index = checkbox.value;
|
||||
|
||||
if (index !== -1) {
|
||||
ingredients[index] = 0;
|
||||
}
|
||||
console.log(ingredients)
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
function testCheckboxes() {
|
||||
for (var i = 0; i < checks.length; i++)
|
||||
if (checks[i].type == "checkbox")
|
||||
if (checks[i].checked)
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
async function startInference() {
|
||||
|
||||
let checked = testCheckboxes()
|
||||
|
||||
if (checked) {
|
||||
|
||||
try {
|
||||
// create a new session and load the model.
|
||||
|
||||
const session = await ort.InferenceSession.create('./model.onnx');
|
||||
|
||||
const input = new ort.Tensor(new Float32Array(ingredients), [1, 380]);
|
||||
const feeds = { float_input: input };
|
||||
|
||||
// feed inputs and run
|
||||
|
||||
const results = await session.run(feeds);
|
||||
|
||||
// read from results
|
||||
alert('You can enjoy ' + results.label.data[0] + ' cuisine today!')
|
||||
|
||||
} catch (e) {
|
||||
console.log(`failed to inference ONNX model: ${e}.`);
|
||||
}
|
||||
}
|
||||
else alert("Please check an ingredient")
|
||||
|
||||
}
|
||||
init();
|
||||
|
||||
</script>
|
||||
```
|
||||
|
||||
Neste código, várias coisas acontecem:
|
||||
|
||||
1. Existe uma matriz de 380 valores possíveis (1 ou 0) para serem definidos e enviados ao modelo para inferência, dependendo se a caixa de seleção de um ingrediente está marcada.
|
||||
2. Existe um array de caixas de seleção e uma maneira de determinar se elas foram verificadas é usando a função `init` que é chamada quando a aplicação é iniciada. Quando uma caixa de seleção é marcada, o array `ingredients` é atualizado para refletir o ingrediente escolhido.
|
||||
3. Existe uma função `testCheckboxes` que verifica se alguma caixa de seleção foi marcada.
|
||||
4. Você usa essa função quando o botão é pressionado e, se alguma caixa de seleção estiver marcada, você inicia a inferência.
|
||||
5. A rotina de inferência inclui:
|
||||
1. Carregar o modelo de forma assíncrona
|
||||
2. Criar uma estrutura de Tensores para enviar ao modelo
|
||||
3. Criar 'feeds' que refletem a entrada `float_input` que você criou ao treinar seu modelo (você pode usar o Netron para verificar esse nome)
|
||||
4. Enviar esses 'feeds' para a modelo e aguardar uma resposta
|
||||
|
||||
## Testando sua aplicação
|
||||
|
||||
Abra uma sessão de terminal (prompt, cmd) no Visual Studio Code na pasta onde está o arquivo _index.html_. Certifique-se de ter o pacote [http-server](https://www.npmjs.com/package/http-server) instalado globalmente e digite `http-server` no prompt. Um _localhost_ será aberto e você pode visualizar sua aplicação. Verifique qual cozinha é recomendada com base nos ingredientes:
|
||||
|
||||
|
||||
|
||||
Parabéns, você criou uma aplicação Web de 'recomendação' com alguns campos. Dedique algum tempo para aprimorar o sistema!
|
||||
|
||||
## 🚀Desafio
|
||||
|
||||
Sua aplicação é simples, portanto, adicione outros ingredientes observando seus índices na [planilha de ingredientes](../../data/ingredient_indexes.csv). Que combinações de sabores funcionam para criar um determinado prato?
|
||||
|
||||
## [Questionário para fixação](https://white-water-09ec41f0f.azurestaticapps.net/quiz/26?loc=ptbr)
|
||||
|
||||
## Revisão e Auto Aprendizagem
|
||||
|
||||
Embora esta lição tenha apenas abordado sobre a criação de um sistema de recomendação para ingredientes alimentícios, esta área de aplicações de ML é muito rica em exemplos. Leia mais sobre como esses sistemas são construídos:
|
||||
|
||||
- https://www.sciencedirect.com/topics/computer-science/recommendation-engine
|
||||
- https://www.technologyreview.com/2014/08/25/171547/the-ultimate-challenge-for-recommendation-engines/
|
||||
- https://www.technologyreview.com/2015/03/23/168831/everything-is-a-recommendation/
|
||||
|
||||
## Tarefa
|
||||
|
||||
[Construindo um recomendador](assignment.pt-br.md).
|
||||
@ -0,0 +1,11 @@
|
||||
# Construindo um recomendador
|
||||
|
||||
## Instruções
|
||||
|
||||
Dados os exercícios desta lição, agora você sabe como construir uma aplicação Web baseada em JavaScript usando Onnx Runtime e um modelo Onnx convertido. Experimente construir um novo recomendador usando dados dessas lições ou obtidos em outro lugar (dê crédito, por favor). Você pode criar um recomendador de animais de estimação com vários atributos de personalidade, ou um recomendador de gênero musical baseado no humor de uma pessoa. Use a criatividade!
|
||||
|
||||
## Critérios de avaliação
|
||||
|
||||
| Critério | Exemplar | Adequado | Precisa melhorar |
|
||||
| -------- | ---------------------------------------------------------------------- | ------------------------------------- | --------------------------------- |
|
||||
| | Uma aplicação Web e um _notebook_ foram apresentados, ambos bem documentados e funcionando | Um dos dois está faltando ou com bugs | Não possui nem uma aplicação Web e nem um _notebook_, ou ambos estão com bugs |
|
||||
@ -0,0 +1,27 @@
|
||||
# Começando com Classificação
|
||||
|
||||
## Tópico regional: Deliciosas cozinhas asiáticas e indianas 🍜
|
||||
|
||||
Na Ásia e na Índia, as tradições alimentares são extremamente diversificadas e deliciosas! Vamos observar dados sobre culinária regional para tentar entender seus ingredientes.
|
||||
|
||||
|
||||
> Foto por <a href="https://unsplash.com/@changlisheng?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Lisheng Chang</a> no <a href="https://unsplash.com/s/photos/asian-food?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Unsplash</a>
|
||||
|
||||
## O que você vai aprender
|
||||
|
||||
Você desenvolverá as habilidades que aprendeu nas lições sobre Regressão, para aprender sobre outros classificadores que o ajudarão a aprender mais sobre dados.
|
||||
|
||||
> Existem ferramentas _low-code_ (que não exigem o uso de código) úteis que podem ajudá-lo a aprender como trabalhar com modelos de classificação. Experimente a [Azure ML para esta tarefa](https://docs.microsoft.com/learn/modules/create-classification-model-azure-machine-learning-designer/?WT.mc_id=academic-15963-cxa).
|
||||
|
||||
## Lições
|
||||
|
||||
1. [Introdução à classificação](../1-Introduction/translations/README.pt-br.md)
|
||||
2. [Classificadores](../2-Classifiers-1/translations/README.pt-br.md)
|
||||
3. [Mais classificadores](../3-Classifiers-2/translations/README.pt-br.md)
|
||||
4. [ML aplicado: construindo uma aplicação web](../4-Applied/translations/README.pt-br.md)
|
||||
|
||||
## Créditos
|
||||
|
||||
"Começando com Classificação" foi escrito com ♥️ por [Cassie Breviu](https://www.twitter.com/cassieview) e [Jen Looper](https://www.twitter.com/jenlooper).
|
||||
|
||||
O conjunto de dados sobre deliciosas culinárias foi obtido a partir do [Kaggle](https://www.kaggle.com/hoandan/asian-and-indian-cuisines).
|
||||
@ -0,0 +1,29 @@
|
||||
# Modelos de agrupamiento en el aprendizaje automático
|
||||
|
||||
El agrupamiento es una tarea del aprendizaje automático en donde se buscan objetos que se parezcan a otros y estos se agrupan en elementos llamados clusters. Lo que hace diferente al clustering de otros enfoques en el aprendizaje automático, es que las cosas suceden de forma automática, de hecho, es justo decir que es lo opuesto al aprendizaje supervisado.
|
||||
|
||||
## Tema regional: modelos de clustering para los gustos musicales de la audiencia Nigeriana 🎧
|
||||
|
||||
La audiencia Nigeriana tiene diversos gustos musicales. Usando datos extraídos de Spotify (inspirados por [este artículo](https://towardsdatascience.com/country-wise-visual-analysis-of-music-taste-using-spotify-api-seaborn-in-python-77f5b749b421), daremos un vistazo a alguna música popular en Nigeria. Este conjunto de datos incluye datos acerca de varias canciones de acuerdo a la puntuación por 'bailables', 'acústica', 'volumen', 'habla', popularidad y energía. ¡Será interesante descubrir patrones en estos datos!
|
||||
|
||||
|
||||
|
||||
> Foto por <a href="https://unsplash.com/@marcelalaskoski?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Marcela Laskoski</a> en <a href="https://unsplash.com/s/photos/nigerian-music?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Unsplash</a>
|
||||
|
||||
En esta serie de lecciones, descubrirás nuevas formas de analizar datos usando técnicas de clustering. El clustering es particularmente útil cuando tu conjunto de datos carece de etiquetas. Si este sí tiene etiquetas, entonces las técnicas de clasificación como las que has aprendido en lecciones previas son más útiles. Pero en casos donde pretendes agrupar datos sin etiquetas, el clustering es una gran forma de descubrir patrones.
|
||||
|
||||
|
||||
> Existen herramientas low-code útiles que te pueden ayudar a trabajar con modelos de clustering. Prueba [Azure ML para esta tarea](https://docs.microsoft.com/learn/modules/create-clustering-model-azure-machine-learning-designer/?WT.mc_id=academic-15963-cxa)
|
||||
|
||||
## Lecciones
|
||||
|
||||
1. [Introducción al clustering](1-Visualize/README.md)
|
||||
2. [K-Means clustering](2-K-Means/README.md)
|
||||
|
||||
## Créditos
|
||||
|
||||
Éstas lecciones fueron escritas con 🎶 por [Jen Looper](https://www.twitter.com/jenlooper) con la útil ayuda de [Rishit Dagli](https://rishit_dagli) y [Muhammad Sakib Khan Inan](https://twitter.com/Sakibinan).
|
||||
|
||||
El conjunto de datos de las [Canciones Nigerianas](https://www.kaggle.com/sootersaalu/nigerian-songs-spotify) fue obtenido de Kaggle como raspado de datos de Spotify.
|
||||
|
||||
Algunos ejemplos útiles de K-means que ayudaron en la creación de esta lección son [exploración de iris](https://www.kaggle.com/bburns/iris-exploration-pca-k-means-and-gmm-clustering), este [notebook introductorio](https://www.kaggle.com/prashant111/k-means-clustering-with-python), y este [ejemplo hipotético de ONG](https://www.kaggle.com/ankandash/pca-k-means-clustering-hierarchical-clustering).
|
||||
@ -0,0 +1 @@
|
||||
Placeholder for translation file
|
||||
File diff suppressed because it is too large
Load Diff
Loading…
Reference in new issue