History

leestott e4050807fb 🌐 Update translations via Co-op Translator		2 weeks ago
..
solution	🌐 Update translations via Co-op Translator	3 weeks ago
README.md	🌐 Update translations via Co-op Translator	2 weeks ago
assignment.md	🌐 Update translations via Co-op Translator	3 weeks ago
notebook.ipynb	🌐 Update translations via Co-op Translator	3 weeks ago

README.md

Introdução à classificação

Nestas quatro lições, você explorará um dos focos fundamentais do aprendizado de máquina clássico - classificação. Vamos utilizar vários algoritmos de classificação com um conjunto de dados sobre as brilhantes culinárias da Ásia e da Índia. Espero que você esteja com fome!

Celebre as culinárias pan-asiáticas nestas lições! Imagem por Jen Looper

Classificação é uma forma de aprendizado supervisionado que tem muito em comum com técnicas de regressão. Se o aprendizado de máquina é sobre prever valores ou nomes para coisas usando conjuntos de dados, então a classificação geralmente se divide em dois grupos: classificação binária e classificação multiclasse.

🎥 Clique na imagem acima para assistir a um vídeo: John Guttag do MIT apresenta a classificação

Lembre-se:

Regressão linear ajudou você a prever relações entre variáveis e fazer previsões precisas sobre onde um novo ponto de dados se encaixaria em relação a essa linha. Por exemplo, você poderia prever qual seria o preço de uma abóbora em setembro vs. dezembro.
Regressão logística ajudou você a descobrir "categorias binárias": neste ponto de preço, essa abóbora é laranja ou não-laranja?

A classificação utiliza vários algoritmos para determinar outras formas de identificar o rótulo ou a classe de um ponto de dados. Vamos trabalhar com esses dados de culinária para ver se, ao observar um grupo de ingredientes, conseguimos determinar sua origem culinária.

Quiz pré-aula

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

Introdução

A classificação é uma das atividades fundamentais do pesquisador de aprendizado de máquina e do 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 complexas de imagens usando visão computacional, é sempre útil poder organizar dados em classes e fazer perguntas sobre eles.

Para descrever o processo de forma mais científica, seu método de classificação cria um modelo preditivo que permite mapear a relação entre variáveis de entrada e variáveis de saída.

Problemas binários vs. multiclasse para algoritmos de classificação lidarem. Infográfico por Jen Looper

Antes de começar o processo de limpar nossos dados, visualizá-los e prepará-los para nossas tarefas de aprendizado de máquina, vamos aprender um pouco sobre as várias formas de usar aprendizado de máquina para classificar dados.

Derivada da estatística, a classificação usando aprendizado de máquina clássico utiliza características, como fumante, peso e idade, para determinar a probabilidade de desenvolver X doença. 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 aprendizado de máquina usam esses rótulos para classificar e prever classes (ou 'características') de um conjunto de dados e atribuí-las a um grupo ou resultado.

✅ Tire um momento para imaginar um conjunto de dados 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 culinária provavelmente usaria feno-grego? E se você quisesse ver se, dado um presente de uma sacola de supermercado cheia de anis-estrelado, alcachofras, couve-flor e raiz-forte, você poderia criar um prato típico indiano?

🎥 Clique na imagem acima para assistir a um vídeo. Todo o conceito do programa 'Chopped' é a 'cesta misteriosa', onde os chefs têm que fazer um prato com uma escolha aleatória de ingredientes. Certamente um modelo de aprendizado de máquina teria ajudado!

Olá 'classificador'

A pergunta que queremos fazer sobre este conjunto de dados de culinária é, na verdade, uma pergunta multiclasse, já que temos várias possíveis culinárias nacionais para trabalhar. Dado um lote de ingredientes, a qual dessas muitas classes os dados se encaixarão?

O Scikit-learn oferece vários algoritmos diferentes para classificar dados, dependendo do tipo de problema que você deseja resolver. Nas próximas duas lições, você aprenderá sobre alguns desses algoritmos.

Exercício - limpar e balancear seus dados

A primeira tarefa, antes de começar este projeto, é limpar e balancear seus dados para obter melhores resultados. Comece com o arquivo em branco notebook.ipynb na raiz desta pasta.

A primeira coisa a instalar é o imblearn. Este é um pacote do Scikit-learn que permitirá que você balanceie melhor os dados (você aprenderá mais sobre essa tarefa em um minuto).

Para instalar o imblearn, execute pip install, assim:
```
pip install imblearn
```

Importe os pacotes necessários para importar seus dados e visualizá-los, e também importe SMOTE do imblearn.

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 importar os dados.

A próxima tarefa será importar os dados:
```
df  = pd.read_csv('../data/cuisines.csv')
```
Usar read_csv() lerá o conteúdo do arquivo csv cusines.csv e o colocará na variável df.

Verifique o formato dos dados:

df.head()

As primeiras cinco linhas se parecem com isto:

|     | 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        |

Obtenha informações sobre esses dados chamando info():

df.info()

Sua saída será semelhante a:

<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 culinárias

Agora o trabalho começa a ficar mais interessante. Vamos descobrir a distribuição dos dados por culinária.

Plote os dados como barras chamando barh():
```
df.cuisine.value_counts().plot.barh()
```
Há um número finito de culinárias, mas a distribuição dos dados é desigual. Você pode corrigir isso! Antes de fazer isso, explore um pouco mais.

Descubra quanto dado está disponível por culinária e imprima:

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}')

A saída se parece com isto:

thai df: (289, 385)
japanese df: (320, 385)
chinese df: (442, 385)
indian df: (598, 385)
korean df: (799, 385)

Descobrindo ingredientes

Agora você pode se aprofundar nos dados e aprender quais são os ingredientes típicos por culinária. Você deve limpar dados recorrentes que criam confusão entre as culinárias, então vamos aprender sobre esse problema.

Crie uma função create_ingredient() em Python para criar um dataframe de ingredientes. Esta função começará removendo uma coluna inútil e classificará os ingredientes por sua contagem:

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

Agora você pode usar essa função para ter uma ideia dos dez ingredientes mais populares por culinária.

Chame create_ingredient() e plote chamando barh():

thai_ingredient_df = create_ingredient_df(thai_df)
thai_ingredient_df.head(10).plot.barh()

Faça o mesmo para os dados japoneses:

japanese_ingredient_df = create_ingredient_df(japanese_df)
japanese_ingredient_df.head(10).plot.barh()

Agora para os ingredientes chineses:

chinese_ingredient_df = create_ingredient_df(chinese_df)
chinese_ingredient_df.head(10).plot.barh()

Plote os ingredientes indianos:

indian_ingredient_df = create_ingredient_df(indian_df)
indian_ingredient_df.head(10).plot.barh()

Finalmente, plote os ingredientes coreanos:

korean_ingredient_df = create_ingredient_df(korean_df)
korean_ingredient_df.head(10).plot.barh()

Agora, remova os ingredientes mais comuns que criam confusão entre culinárias distintas, chamando drop():

Todo mundo ama arroz, alho e gengibre!
```
feature_df= df.drop(['cuisine','Unnamed: 0','rice','garlic','ginger'], axis=1)
labels_df = df.cuisine #.unique()
feature_df.head()
```

Balancear o conjunto de dados

Agora que você limpou os dados, use o SMOTE - "Técnica de Sobreamostragem de Minoria Sintética" - para balanceá-los.

Chame fit_resample(), esta estratégia gera novas amostras por interpolação.
```
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 maior parte dos seus dados pertence a uma classe, um modelo de aprendizado de máquina vai prever essa classe com mais frequência, apenas porque há mais dados para ela. Balancear os dados corrige esse desequilíbrio.

Agora você pode verificar os números de rótulos por ingrediente:

print(f'new label count: {transformed_label_df.value_counts()}')
print(f'old label count: {df.cuisine.value_counts()}')

Sua saída será semelhante a:

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 estão limpos, balanceados e muito deliciosos!

O último passo é salvar seus dados balanceados, incluindo rótulos e características, em um novo dataframe que pode ser exportado para um arquivo:
```
transformed_df = pd.concat([transformed_label_df,transformed_feature_df],axis=1, join='outer')
```
Você pode dar mais uma olhada nos dados usando transformed_df.head() e transformed_df.info(). Salve uma cópia desses dados para uso em lições futuras:
```
transformed_df.head()
transformed_df.info()
transformed_df.to_csv("../data/cleaned_cuisines.csv")
```
Este novo CSV pode agora ser encontrado na pasta de dados raiz.

🚀Desafio

Este currículo contém vários conjuntos de dados interessantes. Explore as pastas data e veja se alguma contém conjuntos de dados que seriam apropriados para classificação binária ou multiclasse. Que perguntas você faria a esse conjunto de dados?

Quiz pós-aula

Revisão e Autoestudo

Explore a API do SMOTE. Para quais casos de uso ele é mais adequado? Que problemas ele resolve?

Tarefa

Explore métodos de classificação

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