Lee Stott
1 week ago
committed by
GitHub
parent
f6488401b6
commit
532949dc5d
@ -1,377 +0,0 @@
|
||||
# Análise de sentimento com avaliações de hotéis
|
||||
|
||||
Agora que você explorou o conjunto de dados em detalhes, é hora de filtrar as colunas e usar técnicas de PNL no conjunto de dados para obter novas percepções sobre os hotéis.
|
||||
## [Quiz pré-aula](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/39/)
|
||||
|
||||
### Operações de Filtragem e Análise de Sentimento
|
||||
|
||||
Como você provavelmente notou, o conjunto de dados possui alguns problemas. Algumas colunas estão preenchidas com informações inúteis, outras parecem incorretas. Se estiverem corretas, não está claro como foram calculadas, e as respostas não podem ser verificadas de forma independente por seus próprios cálculos.
|
||||
|
||||
## Exercício: um pouco mais de processamento de dados
|
||||
|
||||
Limpe os dados um pouco mais. Adicione colunas que serão úteis mais tarde, altere os valores em outras colunas e remova certas colunas completamente.
|
||||
|
||||
1. Processamento inicial das colunas
|
||||
|
||||
1. Remova `lat` e `lng`
|
||||
|
||||
2. Substitua os valores de `Hotel_Address` pelos seguintes valores (se o endereço contiver o nome da cidade e do país, altere para apenas a cidade e o país).
|
||||
|
||||
Estas são as únicas cidades e países no conjunto de dados:
|
||||
|
||||
Amsterdã, Países Baixos
|
||||
|
||||
Barcelona, Espanha
|
||||
|
||||
Londres, Reino Unido
|
||||
|
||||
Milão, Itália
|
||||
|
||||
Paris, França
|
||||
|
||||
Viena, Áustria
|
||||
|
||||
```python
|
||||
def replace_address(row):
|
||||
if "Netherlands" in row["Hotel_Address"]:
|
||||
return "Amsterdam, Netherlands"
|
||||
elif "Barcelona" in row["Hotel_Address"]:
|
||||
return "Barcelona, Spain"
|
||||
elif "United Kingdom" in row["Hotel_Address"]:
|
||||
return "London, United Kingdom"
|
||||
elif "Milan" in row["Hotel_Address"]:
|
||||
return "Milan, Italy"
|
||||
elif "France" in row["Hotel_Address"]:
|
||||
return "Paris, France"
|
||||
elif "Vienna" in row["Hotel_Address"]:
|
||||
return "Vienna, Austria"
|
||||
|
||||
# Replace all the addresses with a shortened, more useful form
|
||||
df["Hotel_Address"] = df.apply(replace_address, axis = 1)
|
||||
# The sum of the value_counts() should add up to the total number of reviews
|
||||
print(df["Hotel_Address"].value_counts())
|
||||
```
|
||||
|
||||
Agora você pode consultar dados em nível de país:
|
||||
|
||||
```python
|
||||
display(df.groupby("Hotel_Address").agg({"Hotel_Name": "nunique"}))
|
||||
```
|
||||
|
||||
| Hotel_Address | Hotel_Name |
|
||||
| :--------------------- | :--------: |
|
||||
| Amsterdã, Países Baixos | 105 |
|
||||
| Barcelona, Espanha | 211 |
|
||||
| Londres, Reino Unido | 400 |
|
||||
| Milão, Itália | 162 |
|
||||
| Paris, França | 458 |
|
||||
| Viena, Áustria | 158 |
|
||||
|
||||
2. Processar colunas de Meta-avaliação do Hotel
|
||||
|
||||
1. Remova `Additional_Number_of_Scoring`
|
||||
|
||||
1. Replace `Total_Number_of_Reviews` with the total number of reviews for that hotel that are actually in the dataset
|
||||
|
||||
1. Replace `Average_Score` com nossa própria pontuação calculada
|
||||
|
||||
```python
|
||||
# Drop `Additional_Number_of_Scoring`
|
||||
df.drop(["Additional_Number_of_Scoring"], axis = 1, inplace=True)
|
||||
# Replace `Total_Number_of_Reviews` and `Average_Score` with our own calculated values
|
||||
df.Total_Number_of_Reviews = df.groupby('Hotel_Name').transform('count')
|
||||
df.Average_Score = round(df.groupby('Hotel_Name').Reviewer_Score.transform('mean'), 1)
|
||||
```
|
||||
|
||||
3. Processar colunas de avaliação
|
||||
|
||||
1. Remova `Review_Total_Negative_Word_Counts`, `Review_Total_Positive_Word_Counts`, `Review_Date` and `days_since_review`
|
||||
|
||||
2. Keep `Reviewer_Score`, `Negative_Review`, and `Positive_Review` as they are,
|
||||
|
||||
3. Keep `Tags` for now
|
||||
|
||||
- We'll be doing some additional filtering operations on the tags in the next section and then tags will be dropped
|
||||
|
||||
4. Process reviewer columns
|
||||
|
||||
1. Drop `Total_Number_of_Reviews_Reviewer_Has_Given`
|
||||
|
||||
2. Keep `Reviewer_Nationality`
|
||||
|
||||
### Tag columns
|
||||
|
||||
The `Tag` column is problematic as it is a list (in text form) stored in the column. Unfortunately the order and number of sub sections in this column are not always the same. It's hard for a human to identify the correct phrases to be interested in, because there are 515,000 rows, and 1427 hotels, and each has slightly different options a reviewer could choose. This is where NLP shines. You can scan the text and find the most common phrases, and count them.
|
||||
|
||||
Unfortunately, we are not interested in single words, but multi-word phrases (e.g. *Business trip*). Running a multi-word frequency distribution algorithm on that much data (6762646 words) could take an extraordinary amount of time, but without looking at the data, it would seem that is a necessary expense. This is where exploratory data analysis comes in useful, because you've seen a sample of the tags such as `[' Business trip ', ' Solo traveler ', ' Single Room ', ' Stayed 5 nights ', ' Submitted from a mobile device ']`, você pode começar a perguntar se é possível reduzir bastante o processamento que você tem que fazer. Felizmente, é - mas primeiro você precisa seguir alguns passos para determinar as tags de interesse.
|
||||
|
||||
### Filtrando tags
|
||||
|
||||
Lembre-se de que o objetivo do conjunto de dados é adicionar sentimento e colunas que ajudarão você a escolher o melhor hotel (para você ou talvez para um cliente que lhe pediu para criar um bot de recomendação de hotéis). Você precisa se perguntar se as tags são úteis ou não no conjunto de dados final. Aqui está uma interpretação (se você precisasse do conjunto de dados por outros motivos, diferentes tags poderiam ser mantidas ou removidas da seleção):
|
||||
|
||||
1. O tipo de viagem é relevante, e isso deve ser mantido
|
||||
2. O tipo de grupo de hóspedes é importante, e isso deve ser mantido
|
||||
3. O tipo de quarto, suíte ou estúdio em que o hóspede se hospedou é irrelevante (todos os hotéis têm basicamente os mesmos quartos)
|
||||
4. O dispositivo em que a avaliação foi enviada é irrelevante
|
||||
5. O número de noites que o avaliador ficou *poderia* ser relevante se você atribuísse estadias mais longas a uma maior satisfação com o hotel, mas é uma suposição, e provavelmente irrelevante
|
||||
|
||||
Em resumo, **mantenha 2 tipos de tags e remova as outras**.
|
||||
|
||||
Primeiro, você não quer contar as tags até que elas estejam em um formato melhor, então isso significa remover os colchetes e aspas. Você pode fazer isso de várias maneiras, mas deseja a mais rápida, pois pode levar muito tempo para processar muitos dados. Felizmente, o pandas tem uma maneira fácil de fazer cada um desses passos.
|
||||
|
||||
```Python
|
||||
# Remove opening and closing brackets
|
||||
df.Tags = df.Tags.str.strip("[']")
|
||||
# remove all quotes too
|
||||
df.Tags = df.Tags.str.replace(" ', '", ",", regex = False)
|
||||
```
|
||||
|
||||
Cada tag se torna algo como: `Business trip, Solo traveler, Single Room, Stayed 5 nights, Submitted from a mobile device`.
|
||||
|
||||
Next we find a problem. Some reviews, or rows, have 5 columns, some 3, some 6. This is a result of how the dataset was created, and hard to fix. You want to get a frequency count of each phrase, but they are in different order in each review, so the count might be off, and a hotel might not get a tag assigned to it that it deserved.
|
||||
|
||||
Instead you will use the different order to our advantage, because each tag is multi-word but also separated by a comma! The simplest way to do this is to create 6 temporary columns with each tag inserted in to the column corresponding to its order in the tag. You can then merge the 6 columns into one big column and run the `value_counts()` method on the resulting column. Printing that out, you'll see there was 2428 unique tags. Here is a small sample:
|
||||
|
||||
| Tag | Count |
|
||||
| ------------------------------ | ------ |
|
||||
| Leisure trip | 417778 |
|
||||
| Submitted from a mobile device | 307640 |
|
||||
| Couple | 252294 |
|
||||
| Stayed 1 night | 193645 |
|
||||
| Stayed 2 nights | 133937 |
|
||||
| Solo traveler | 108545 |
|
||||
| Stayed 3 nights | 95821 |
|
||||
| Business trip | 82939 |
|
||||
| Group | 65392 |
|
||||
| Family with young children | 61015 |
|
||||
| Stayed 4 nights | 47817 |
|
||||
| Double Room | 35207 |
|
||||
| Standard Double Room | 32248 |
|
||||
| Superior Double Room | 31393 |
|
||||
| Family with older children | 26349 |
|
||||
| Deluxe Double Room | 24823 |
|
||||
| Double or Twin Room | 22393 |
|
||||
| Stayed 5 nights | 20845 |
|
||||
| Standard Double or Twin Room | 17483 |
|
||||
| Classic Double Room | 16989 |
|
||||
| Superior Double or Twin Room | 13570 |
|
||||
| 2 rooms | 12393 |
|
||||
|
||||
Some of the common tags like `Submitted from a mobile device` are of no use to us, so it might be a smart thing to remove them before counting phrase occurrence, but it is such a fast operation you can leave them in and ignore them.
|
||||
|
||||
### Removing the length of stay tags
|
||||
|
||||
Removing these tags is step 1, it reduces the total number of tags to be considered slightly. Note you do not remove them from the dataset, just choose to remove them from consideration as values to count/keep in the reviews dataset.
|
||||
|
||||
| Length of stay | Count |
|
||||
| ---------------- | ------ |
|
||||
| Stayed 1 night | 193645 |
|
||||
| Stayed 2 nights | 133937 |
|
||||
| Stayed 3 nights | 95821 |
|
||||
| Stayed 4 nights | 47817 |
|
||||
| Stayed 5 nights | 20845 |
|
||||
| Stayed 6 nights | 9776 |
|
||||
| Stayed 7 nights | 7399 |
|
||||
| Stayed 8 nights | 2502 |
|
||||
| Stayed 9 nights | 1293 |
|
||||
| ... | ... |
|
||||
|
||||
There are a huge variety of rooms, suites, studios, apartments and so on. They all mean roughly the same thing and not relevant to you, so remove them from consideration.
|
||||
|
||||
| Type of room | Count |
|
||||
| ----------------------------- | ----- |
|
||||
| Double Room | 35207 |
|
||||
| Standard Double Room | 32248 |
|
||||
| Superior Double Room | 31393 |
|
||||
| Deluxe Double Room | 24823 |
|
||||
| Double or Twin Room | 22393 |
|
||||
| Standard Double or Twin Room | 17483 |
|
||||
| Classic Double Room | 16989 |
|
||||
| Superior Double or Twin Room | 13570 |
|
||||
|
||||
Finally, and this is delightful (because it didn't take much processing at all), you will be left with the following *useful* tags:
|
||||
|
||||
| Tag | Count |
|
||||
| --------------------------------------------- | ------ |
|
||||
| Leisure trip | 417778 |
|
||||
| Couple | 252294 |
|
||||
| Solo traveler | 108545 |
|
||||
| Business trip | 82939 |
|
||||
| Group (combined with Travellers with friends) | 67535 |
|
||||
| Family with young children | 61015 |
|
||||
| Family with older children | 26349 |
|
||||
| With a pet | 1405 |
|
||||
|
||||
You could argue that `Travellers with friends` is the same as `Group` more or less, and that would be fair to combine the two as above. The code for identifying the correct tags is [the Tags notebook](https://github.com/microsoft/ML-For-Beginners/blob/main/6-NLP/5-Hotel-Reviews-2/solution/1-notebook.ipynb).
|
||||
|
||||
The final step is to create new columns for each of these tags. Then, for every review row, if the `Tag` a coluna corresponde a uma das novas colunas, adicione um 1, se não, adicione um 0. O resultado final será uma contagem de quantos avaliadores escolheram este hotel (em agregados) para, digamos, negócios versus lazer, ou para levar um animal de estimação, e isso é uma informação útil ao recomendar um hotel.
|
||||
|
||||
```python
|
||||
# Process the Tags into new columns
|
||||
# The file Hotel_Reviews_Tags.py, identifies the most important tags
|
||||
# Leisure trip, Couple, Solo traveler, Business trip, Group combined with Travelers with friends,
|
||||
# Family with young children, Family with older children, With a pet
|
||||
df["Leisure_trip"] = df.Tags.apply(lambda tag: 1 if "Leisure trip" in tag else 0)
|
||||
df["Couple"] = df.Tags.apply(lambda tag: 1 if "Couple" in tag else 0)
|
||||
df["Solo_traveler"] = df.Tags.apply(lambda tag: 1 if "Solo traveler" in tag else 0)
|
||||
df["Business_trip"] = df.Tags.apply(lambda tag: 1 if "Business trip" in tag else 0)
|
||||
df["Group"] = df.Tags.apply(lambda tag: 1 if "Group" in tag or "Travelers with friends" in tag else 0)
|
||||
df["Family_with_young_children"] = df.Tags.apply(lambda tag: 1 if "Family with young children" in tag else 0)
|
||||
df["Family_with_older_children"] = df.Tags.apply(lambda tag: 1 if "Family with older children" in tag else 0)
|
||||
df["With_a_pet"] = df.Tags.apply(lambda tag: 1 if "With a pet" in tag else 0)
|
||||
|
||||
```
|
||||
|
||||
### Salve seu arquivo
|
||||
|
||||
Finalmente, salve o conjunto de dados como está agora com um novo nome.
|
||||
|
||||
```python
|
||||
df.drop(["Review_Total_Negative_Word_Counts", "Review_Total_Positive_Word_Counts", "days_since_review", "Total_Number_of_Reviews_Reviewer_Has_Given"], axis = 1, inplace=True)
|
||||
|
||||
# Saving new data file with calculated columns
|
||||
print("Saving results to Hotel_Reviews_Filtered.csv")
|
||||
df.to_csv(r'../data/Hotel_Reviews_Filtered.csv', index = False)
|
||||
```
|
||||
|
||||
## Operações de Análise de Sentimento
|
||||
|
||||
Nesta seção final, você aplicará a análise de sentimento às colunas de avaliação e salvará os resultados em um conjunto de dados.
|
||||
|
||||
## Exercício: carregar e salvar os dados filtrados
|
||||
|
||||
Note que agora você está carregando o conjunto de dados filtrado que foi salvo na seção anterior, **não** o conjunto de dados original.
|
||||
|
||||
```python
|
||||
import time
|
||||
import pandas as pd
|
||||
import nltk as nltk
|
||||
from nltk.corpus import stopwords
|
||||
from nltk.sentiment.vader import SentimentIntensityAnalyzer
|
||||
nltk.download('vader_lexicon')
|
||||
|
||||
# Load the filtered hotel reviews from CSV
|
||||
df = pd.read_csv('../../data/Hotel_Reviews_Filtered.csv')
|
||||
|
||||
# You code will be added here
|
||||
|
||||
|
||||
# Finally remember to save the hotel reviews with new NLP data added
|
||||
print("Saving results to Hotel_Reviews_NLP.csv")
|
||||
df.to_csv(r'../data/Hotel_Reviews_NLP.csv', index = False)
|
||||
```
|
||||
|
||||
### Removendo palavras de parada
|
||||
|
||||
Se você fosse executar a Análise de Sentimento nas colunas de avaliação negativa e positiva, isso poderia levar muito tempo. Testado em um laptop de teste poderoso com um CPU rápido, levou de 12 a 14 minutos, dependendo da biblioteca de sentimento utilizada. Esse é um tempo (relativamente) longo, então vale a pena investigar se isso pode ser acelerado.
|
||||
|
||||
Remover palavras de parada, ou palavras comuns em inglês que não alteram o sentimento de uma frase, é o primeiro passo. Ao removê-las, a análise de sentimento deve ser executada mais rapidamente, mas não menos precisa (já que as palavras de parada não afetam o sentimento, mas desaceleram a análise).
|
||||
|
||||
A avaliação negativa mais longa tinha 395 palavras, mas após a remoção das palavras de parada, ficou com 195 palavras.
|
||||
|
||||
Remover as palavras de parada também é uma operação rápida; remover as palavras de parada de 2 colunas de avaliação com mais de 515.000 linhas levou 3,3 segundos no dispositivo de teste. Pode levar um pouco mais ou menos tempo para você, dependendo da velocidade do CPU do seu dispositivo, RAM, se você tem um SSD ou não, e alguns outros fatores. A relativa brevidade da operação significa que, se isso melhorar o tempo da análise de sentimento, vale a pena fazer.
|
||||
|
||||
```python
|
||||
from nltk.corpus import stopwords
|
||||
|
||||
# Load the hotel reviews from CSV
|
||||
df = pd.read_csv("../../data/Hotel_Reviews_Filtered.csv")
|
||||
|
||||
# Remove stop words - can be slow for a lot of text!
|
||||
# Ryan Han (ryanxjhan on Kaggle) has a great post measuring performance of different stop words removal approaches
|
||||
# https://www.kaggle.com/ryanxjhan/fast-stop-words-removal # using the approach that Ryan recommends
|
||||
start = time.time()
|
||||
cache = set(stopwords.words("english"))
|
||||
def remove_stopwords(review):
|
||||
text = " ".join([word for word in review.split() if word not in cache])
|
||||
return text
|
||||
|
||||
# Remove the stop words from both columns
|
||||
df.Negative_Review = df.Negative_Review.apply(remove_stopwords)
|
||||
df.Positive_Review = df.Positive_Review.apply(remove_stopwords)
|
||||
```
|
||||
|
||||
### Realizando a análise de sentimento
|
||||
|
||||
Agora você deve calcular a análise de sentimento para ambas as colunas de avaliação negativa e positiva e armazenar o resultado em 2 novas colunas. O teste do sentimento será compará-lo à pontuação do avaliador para a mesma avaliação. Por exemplo, se o sentimento acha que a avaliação negativa teve um sentimento de 1 (sentimento extremamente positivo) e um sentimento de avaliação positiva de 1, mas o avaliador deu ao hotel a pontuação mais baixa possível, então ou o texto da avaliação não corresponde à pontuação, ou o analisador de sentimento não conseguiu reconhecer o sentimento corretamente. Você deve esperar que algumas pontuações de sentimento estejam completamente erradas, e muitas vezes isso será explicável, por exemplo, a avaliação pode ser extremamente sarcástica "Claro que ADORO dormir em um quarto sem aquecimento" e o analisador de sentimento acha que isso é um sentimento positivo, mesmo que um humano ao lê-lo saiba que é sarcasmo.
|
||||
|
||||
NLTK fornece diferentes analisadores de sentimento para aprender, e você pode substituí-los e ver se o sentimento é mais ou menos preciso. A análise de sentimento VADER é utilizada aqui.
|
||||
|
||||
> Hutto, C.J. & Gilbert, E.E. (2014). VADER: A Parsimonious Rule-based Model for Sentiment Analysis of Social Media Text. Eighth International Conference on Weblogs and Social Media (ICWSM-14). Ann Arbor, MI, junho de 2014.
|
||||
|
||||
```python
|
||||
from nltk.sentiment.vader import SentimentIntensityAnalyzer
|
||||
|
||||
# Create the vader sentiment analyser (there are others in NLTK you can try too)
|
||||
vader_sentiment = SentimentIntensityAnalyzer()
|
||||
# Hutto, C.J. & Gilbert, E.E. (2014). VADER: A Parsimonious Rule-based Model for Sentiment Analysis of Social Media Text. Eighth International Conference on Weblogs and Social Media (ICWSM-14). Ann Arbor, MI, June 2014.
|
||||
|
||||
# There are 3 possibilities of input for a review:
|
||||
# It could be "No Negative", in which case, return 0
|
||||
# It could be "No Positive", in which case, return 0
|
||||
# It could be a review, in which case calculate the sentiment
|
||||
def calc_sentiment(review):
|
||||
if review == "No Negative" or review == "No Positive":
|
||||
return 0
|
||||
return vader_sentiment.polarity_scores(review)["compound"]
|
||||
```
|
||||
|
||||
Mais tarde em seu programa, quando você estiver pronto para calcular o sentimento, você pode aplicá-lo a cada avaliação da seguinte forma:
|
||||
|
||||
```python
|
||||
# Add a negative sentiment and positive sentiment column
|
||||
print("Calculating sentiment columns for both positive and negative reviews")
|
||||
start = time.time()
|
||||
df["Negative_Sentiment"] = df.Negative_Review.apply(calc_sentiment)
|
||||
df["Positive_Sentiment"] = df.Positive_Review.apply(calc_sentiment)
|
||||
end = time.time()
|
||||
print("Calculating sentiment took " + str(round(end - start, 2)) + " seconds")
|
||||
```
|
||||
|
||||
Isso leva aproximadamente 120 segundos no meu computador, mas varia em cada computador. Se você quiser imprimir os resultados e ver se o sentimento corresponde à avaliação:
|
||||
|
||||
```python
|
||||
df = df.sort_values(by=["Negative_Sentiment"], ascending=True)
|
||||
print(df[["Negative_Review", "Negative_Sentiment"]])
|
||||
df = df.sort_values(by=["Positive_Sentiment"], ascending=True)
|
||||
print(df[["Positive_Review", "Positive_Sentiment"]])
|
||||
```
|
||||
|
||||
A última coisa a fazer com o arquivo antes de usá-lo no desafio é salvá-lo! Você também deve considerar reorganizar todas as suas novas colunas para que sejam fáceis de trabalhar (para um humano, é uma mudança estética).
|
||||
|
||||
```python
|
||||
# Reorder the columns (This is cosmetic, but to make it easier to explore the data later)
|
||||
df = df.reindex(["Hotel_Name", "Hotel_Address", "Total_Number_of_Reviews", "Average_Score", "Reviewer_Score", "Negative_Sentiment", "Positive_Sentiment", "Reviewer_Nationality", "Leisure_trip", "Couple", "Solo_traveler", "Business_trip", "Group", "Family_with_young_children", "Family_with_older_children", "With_a_pet", "Negative_Review", "Positive_Review"], axis=1)
|
||||
|
||||
print("Saving results to Hotel_Reviews_NLP.csv")
|
||||
df.to_csv(r"../data/Hotel_Reviews_NLP.csv", index = False)
|
||||
```
|
||||
|
||||
Você deve executar todo o código para [o notebook de análise](https://github.com/microsoft/ML-For-Beginners/blob/main/6-NLP/5-Hotel-Reviews-2/solution/3-notebook.ipynb) (depois de ter executado [seu notebook de filtragem](https://github.com/microsoft/ML-For-Beginners/blob/main/6-NLP/5-Hotel-Reviews-2/solution/1-notebook.ipynb) para gerar o arquivo Hotel_Reviews_Filtered.csv).
|
||||
|
||||
Para revisar, os passos são:
|
||||
|
||||
1. O arquivo do conjunto de dados original **Hotel_Reviews.csv** foi explorado na lição anterior com [o notebook explorador](https://github.com/microsoft/ML-For-Beginners/blob/main/6-NLP/4-Hotel-Reviews-1/solution/notebook.ipynb)
|
||||
2. Hotel_Reviews.csv foi filtrado pelo [notebook de filtragem](https://github.com/microsoft/ML-For-Beginners/blob/main/6-NLP/5-Hotel-Reviews-2/solution/1-notebook.ipynb), resultando em **Hotel_Reviews_Filtered.csv**
|
||||
3. Hotel_Reviews_Filtered.csv foi processado pelo [notebook de análise de sentimento](https://github.com/microsoft/ML-For-Beginners/blob/main/6-NLP/5-Hotel-Reviews-2/solution/3-notebook.ipynb), resultando em **Hotel_Reviews_NLP.csv**
|
||||
4. Use Hotel_Reviews_NLP.csv no Desafio de PNL abaixo
|
||||
|
||||
### Conclusão
|
||||
|
||||
Quando você começou, tinha um conjunto de dados com colunas e dados, mas nem todos podiam ser verificados ou utilizados. Você explorou os dados, filtrou o que não precisava, converteu tags em algo útil, calculou suas próprias médias, adicionou algumas colunas de sentimento e, com sorte, aprendeu algumas coisas interessantes sobre o processamento de texto natural.
|
||||
|
||||
## [Quiz pós-aula](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/40/)
|
||||
|
||||
## Desafio
|
||||
|
||||
Agora que você analisou seu conjunto de dados para sentimento, veja se consegue usar estratégias que aprendeu neste currículo (aglomeração, talvez?) para determinar padrões em torno do sentimento.
|
||||
|
||||
## Revisão e Estudo Autônomo
|
||||
|
||||
Faça [este módulo Learn](https://docs.microsoft.com/en-us/learn/modules/classify-user-feedback-with-the-text-analytics-api/?WT.mc_id=academic-77952-leestott) para aprender mais e usar diferentes ferramentas para explorar o sentimento em texto.
|
||||
## Tarefa
|
||||
|
||||
[Experimente um conjunto de dados diferente](assignment.md)
|
||||
|
||||
**Isenção de responsabilidade**:
|
||||
Este documento foi traduzido utilizando serviços de tradução automática baseados em IA. Embora nos esforcemos pela precisão, 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 autoritativa. Para informações críticas, recomenda-se a tradução profissional por um humano. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações errôneas decorrentes do uso desta tradução.
|
||||
@ -1,14 +0,0 @@
|
||||
# Experimente um conjunto de dados diferente
|
||||
|
||||
## Instruções
|
||||
|
||||
Agora que você aprendeu a usar o NLTK para atribuir sentimento ao texto, experimente um conjunto de dados diferente. Provavelmente, você precisará fazer algum processamento de dados, então crie um notebook e documente seu processo de pensamento. O que você descobre?
|
||||
|
||||
## Rubrica
|
||||
|
||||
| Critérios | Exemplar | Adequado | Necessita Melhorias |
|
||||
| --------- | ----------------------------------------------------------------------------------------------------------------- | ----------------------------------------- | ------------------------ |
|
||||
| | Um notebook completo e um conjunto de dados são apresentados com células bem documentadas explicando como o sentimento é atribuído | O notebook está faltando boas explicações | O notebook está com falhas |
|
||||
|
||||
**Isenção de responsabilidade**:
|
||||
Este documento foi traduzido utilizando serviços de tradução automática baseados em IA. Embora nos esforcemos pela precisão, esteja ciente de que as traduções automatizadas podem conter erros ou imprecisões. O documento original em sua língua nativa deve ser considerado a fonte autoritativa. 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 erradas decorrentes do uso desta tradução.
|
||||
@ -1,6 +0,0 @@
|
||||
Isto é um espaço reservado temporárioPor favor, escreva a saída da esquerda para a direita.
|
||||
|
||||
Isto é um espaço reservado temporário
|
||||
|
||||
**Isenção de responsabilidade**:
|
||||
Este documento foi traduzido usando serviços de tradução baseados em IA. Embora nos esforcemos pela precisão, 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 autoritativa. Para informações críticas, recomenda-se a tradução profissional por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações errôneas decorrentes do uso desta tradução.
|
||||
@ -1,6 +0,0 @@
|
||||
isto é um espaço reservado temporárioPor favor, escreva a saída da esquerda para a direita.
|
||||
|
||||
isto é um espaço reservado temporário
|
||||
|
||||
**Isenção de responsabilidade**:
|
||||
Este documento foi traduzido utilizando serviços de tradução automática baseados em IA. Embora nos esforcemos pela precisão, 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 autoritativa. Para informações críticas, recomenda-se a tradução profissional por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações equivocadas decorrentes do uso desta tradução.
|
||||
@ -1,27 +0,0 @@
|
||||
# Introdução ao processamento de linguagem natural
|
||||
|
||||
O processamento de linguagem natural (PLN) é a capacidade de um programa de computador entender a linguagem humana como ela é falada e escrita — referida como linguagem natural. É um componente da inteligência artificial (IA). O PLN existe há mais de 50 anos e tem raízes no campo da linguística. Todo o campo é direcionado a ajudar as máquinas a entender e processar a linguagem humana. Isso pode ser usado para realizar tarefas como verificação ortográfica ou tradução automática. Possui uma variedade de aplicações no mundo real em diversos campos, incluindo pesquisa médica, motores de busca e inteligência de negócios.
|
||||
|
||||
## Tópico regional: Línguas e literatura europeias e hotéis românticos da Europa ❤️
|
||||
|
||||
Nesta seção do currículo, você será apresentado a um dos usos mais difundidos do aprendizado de máquina: o processamento de linguagem natural (PLN). Derivado da linguística computacional, essa categoria de inteligência artificial é a ponte entre humanos e máquinas por meio da comunicação verbal ou textual.
|
||||
|
||||
Nessas aulas, aprenderemos os fundamentos do PLN construindo pequenos bots de conversa para entender como o aprendizado de máquina ajuda a tornar essas conversas cada vez mais 'inteligentes'. Você viajará no tempo, conversando com Elizabeth Bennett e Mr. Darcy do clássico romance de Jane Austen, **Orgulho e Preconceito**, publicado em 1813. Em seguida, você aprofundará seu conhecimento aprendendo sobre análise de sentimentos através de avaliações de hotéis na Europa.
|
||||
|
||||
|
||||
> Foto de <a href="https://unsplash.com/@elaineh?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Elaine Howlin</a> em <a href="https://unsplash.com/s/photos/pride-and-prejudice?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Unsplash</a>
|
||||
|
||||
## Aulas
|
||||
|
||||
1. [Introdução ao processamento de linguagem natural](1-Introduction-to-NLP/README.md)
|
||||
2. [Tarefas e técnicas comuns de PLN](2-Tasks/README.md)
|
||||
3. [Tradução e análise de sentimentos com aprendizado de máquina](3-Translation-Sentiment/README.md)
|
||||
4. [Preparando seus dados](4-Hotel-Reviews-1/README.md)
|
||||
5. [NLTK para Análise de Sentimentos](5-Hotel-Reviews-2/README.md)
|
||||
|
||||
## Créditos
|
||||
|
||||
Estas lições de processamento de linguagem natural foram escritas com ☕ por [Stephen Howell](https://twitter.com/Howell_MSFT)
|
||||
|
||||
**Isenção de responsabilidade**:
|
||||
Este documento foi traduzido utilizando serviços de tradução automática baseados em IA. Embora nos esforcemos para garantir a precisão, 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 autoritativa. Para informações críticas, recomenda-se a tradução profissional por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações errôneas decorrentes do uso desta tradução.
|
||||
@ -1,6 +0,0 @@
|
||||
Baixe os dados de avaliação do hotel para esta pasta. Por favor, escreva a saída da esquerda para a direita.
|
||||
|
||||
Baixe os dados de avaliação do hotel para esta pasta.
|
||||
|
||||
**Aviso Legal**:
|
||||
Este documento foi traduzido usando serviços de tradução baseados em IA. Embora nos esforcemos pela precisão, 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 autoritativa. Para informações críticas, recomenda-se a tradução profissional por um humano. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações errôneas decorrentes do uso desta tradução.
|
||||
@ -1,188 +0,0 @@
|
||||
# Introdução à previsão de séries temporais
|
||||
|
||||
|
||||
|
||||
> Sketchnote por [Tomomi Imura](https://www.twitter.com/girlie_mac)
|
||||
|
||||
Nesta lição e na próxima, você aprenderá um pouco sobre a previsão de séries temporais, uma parte interessante e valiosa do repertório de um cientista de ML que é um pouco menos conhecida do que outros tópicos. A previsão de séries temporais é uma espécie de 'bola de cristal': com base no desempenho passado de uma variável, como o preço, você pode prever seu potencial valor futuro.
|
||||
|
||||
[](https://youtu.be/cBojo1hsHiI "Introdução à previsão de séries temporais")
|
||||
|
||||
> 🎥 Clique na imagem acima para assistir a um vídeo sobre previsão de séries temporais
|
||||
|
||||
## [Quiz pré-aula](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/41/)
|
||||
|
||||
É um campo útil e interessante com valor real para os negócios, dada sua aplicação direta a problemas de precificação, inventário e questões da cadeia de suprimentos. Embora técnicas de aprendizado profundo tenham começado a ser usadas para obter mais insights e prever melhor o desempenho futuro, a previsão de séries temporais continua sendo um campo amplamente informado por técnicas clássicas de ML.
|
||||
|
||||
> O currículo útil de séries temporais da Penn State pode ser encontrado [aqui](https://online.stat.psu.edu/stat510/lesson/1)
|
||||
|
||||
## Introdução
|
||||
|
||||
Suponha que você mantenha um conjunto de parquímetros inteligentes que fornecem dados sobre com que frequência são usados e por quanto tempo ao longo do tempo.
|
||||
|
||||
> E se você pudesse prever, com base no desempenho passado do parquímetro, seu valor futuro de acordo com as leis de oferta e demanda?
|
||||
|
||||
Prever com precisão quando agir para alcançar seu objetivo é um desafio que pode ser enfrentado pela previsão de séries temporais. Não seria agradável para as pessoas serem cobradas mais em horários de pico quando estão procurando uma vaga de estacionamento, mas seria uma maneira segura de gerar receita para limpar as ruas!
|
||||
|
||||
Vamos explorar alguns dos tipos de algoritmos de séries temporais e começar um notebook para limpar e preparar alguns dados. Os dados que você analisará são provenientes da competição de previsão GEFCom2014. Eles consistem em 3 anos de valores de carga elétrica e temperatura horária entre 2012 e 2014. Dado os padrões históricos de carga elétrica e temperatura, você pode prever os valores futuros da carga elétrica.
|
||||
|
||||
Neste exemplo, você aprenderá como prever um passo de tempo à frente, usando apenas dados históricos de carga. Antes de começar, no entanto, é útil entender o que está acontecendo nos bastidores.
|
||||
|
||||
## Algumas definições
|
||||
|
||||
Ao encontrar o termo 'série temporal', você precisa entender seu uso em vários contextos diferentes.
|
||||
|
||||
🎓 **Série temporal**
|
||||
|
||||
Na matemática, "uma série temporal é uma série de pontos de dados indexados (ou listados ou grafados) em ordem temporal. Mais comumente, uma série temporal é uma sequência tomada em pontos sucessivos igualmente espaçados no tempo." Um exemplo de uma série temporal é o valor de fechamento diário do [Dow Jones Industrial Average](https://wikipedia.org/wiki/Time_series). O uso de gráficos de séries temporais e modelagem estatística é frequentemente encontrado em processamento de sinais, previsão do tempo, previsão de terremotos e outros campos onde eventos ocorrem e pontos de dados podem ser plotados ao longo do tempo.
|
||||
|
||||
🎓 **Análise de séries temporais**
|
||||
|
||||
A análise de séries temporais é a análise dos dados de séries temporais mencionados acima. Os dados de séries temporais podem assumir formas distintas, incluindo 'séries temporais interrompidas', que detectam padrões na evolução de uma série temporal antes e depois de um evento interruptivo. O tipo de análise necessária para a série temporal depende da natureza dos dados. Os dados de séries temporais em si podem assumir a forma de séries de números ou caracteres.
|
||||
|
||||
A análise a ser realizada utiliza uma variedade de métodos, incluindo domínio de frequência e domínio do tempo, linear e não linear, e mais. [Saiba mais](https://www.itl.nist.gov/div898/handbook/pmc/section4/pmc4.htm) sobre as muitas maneiras de analisar esse tipo de dado.
|
||||
|
||||
🎓 **Previsão de séries temporais**
|
||||
|
||||
A previsão de séries temporais é o uso de um modelo para prever valores futuros com base em padrões exibidos por dados coletados anteriormente, conforme ocorreram no passado. Embora seja possível usar modelos de regressão para explorar dados de séries temporais, com índices de tempo como variáveis x em um gráfico, tais dados são melhor analisados usando tipos especiais de modelos.
|
||||
|
||||
Os dados de séries temporais são uma lista de observações ordenadas, ao contrário de dados que podem ser analisados por regressão linear. O mais comum é o ARIMA, um acrônimo que significa "Média Móvel Integrada Autoregressiva".
|
||||
|
||||
[Modelos ARIMA](https://online.stat.psu.edu/stat510/lesson/1/1.1) "relacionam o valor presente de uma série a valores passados e erros de previsão passados." Eles são mais apropriados para analisar dados no domínio do tempo, onde os dados estão ordenados ao longo do tempo.
|
||||
|
||||
> Existem vários tipos de modelos ARIMA, sobre os quais você pode aprender [aqui](https://people.duke.edu/~rnau/411arim.htm) e que você tocará na próxima lição.
|
||||
|
||||
Na próxima lição, você construirá um modelo ARIMA usando [Séries Temporais Univariadas](https://itl.nist.gov/div898/handbook/pmc/section4/pmc44.htm), que se concentra em uma variável que muda seu valor ao longo do tempo. Um exemplo desse tipo de dado é [este conjunto de dados](https://itl.nist.gov/div898/handbook/pmc/section4/pmc4411.htm) que registra a concentração mensal de CO2 no Observatório de Mauna Loa:
|
||||
|
||||
| CO2 | AnoMês | Ano | Mês |
|
||||
| :----: | :----: | :---: | :---: |
|
||||
| 330.62 | 1975.04 | 1975 | 1 |
|
||||
| 331.40 | 1975.13 | 1975 | 2 |
|
||||
| 331.87 | 1975.21 | 1975 | 3 |
|
||||
| 333.18 | 1975.29 | 1975 | 4 |
|
||||
| 333.92 | 1975.38 | 1975 | 5 |
|
||||
| 333.43 | 1975.46 | 1975 | 6 |
|
||||
| 331.85 | 1975.54 | 1975 | 7 |
|
||||
| 330.01 | 1975.63 | 1975 | 8 |
|
||||
| 328.51 | 1975.71 | 1975 | 9 |
|
||||
| 328.41 | 1975.79 | 1975 | 10 |
|
||||
| 329.25 | 1975.88 | 1975 | 11 |
|
||||
| 330.97 | 1975.96 | 1975 | 12 |
|
||||
|
||||
✅ Identifique a variável que muda ao longo do tempo neste conjunto de dados.
|
||||
|
||||
## Características dos dados de séries temporais a considerar
|
||||
|
||||
Ao olhar para dados de séries temporais, você pode notar que eles têm [certas características](https://online.stat.psu.edu/stat510/lesson/1/1.1) que você precisa levar em conta e mitigar para entender melhor seus padrões. Se você considerar os dados de séries temporais como potencialmente fornecendo um 'sinal' que deseja analisar, essas características podem ser pensadas como 'ruído'. Você muitas vezes precisará reduzir esse 'ruído' compensando algumas dessas características usando algumas técnicas estatísticas.
|
||||
|
||||
Aqui estão alguns conceitos que você deve conhecer para poder trabalhar com séries temporais:
|
||||
|
||||
🎓 **Tendências**
|
||||
|
||||
Tendências são definidas como aumentos e diminuições mensuráveis ao longo do tempo. [Leia mais](https://machinelearningmastery.com/time-series-trends-in-python). No contexto de séries temporais, trata-se de como usar e, se necessário, remover tendências de sua série temporal.
|
||||
|
||||
🎓 **[Sazonalidade](https://machinelearningmastery.com/time-series-seasonality-with-python/)**
|
||||
|
||||
Sazonalidade é definida como flutuações periódicas, como corridas de férias que podem afetar as vendas, por exemplo. [Dê uma olhada](https://itl.nist.gov/div898/handbook/pmc/section4/pmc443.htm) em como diferentes tipos de gráficos exibem sazonalidade nos dados.
|
||||
|
||||
🎓 **Outliers**
|
||||
|
||||
Outliers são valores que estão muito distantes da variância padrão dos dados.
|
||||
|
||||
🎓 **Ciclo de longo prazo**
|
||||
|
||||
Independente da sazonalidade, os dados podem exibir um ciclo de longo prazo, como uma recessão econômica que dura mais de um ano.
|
||||
|
||||
🎓 **Variância constante**
|
||||
|
||||
Ao longo do tempo, alguns dados exibem flutuações constantes, como o uso de energia por dia e noite.
|
||||
|
||||
🎓 **Mudanças abruptas**
|
||||
|
||||
Os dados podem exibir uma mudança abrupta que pode precisar de uma análise mais aprofundada. O fechamento abrupto de empresas devido à COVID, por exemplo, causou mudanças nos dados.
|
||||
|
||||
✅ Aqui está um [gráfico de séries temporais de exemplo](https://www.kaggle.com/kashnitsky/topic-9-part-1-time-series-analysis-in-python) mostrando a moeda do jogo gasta diariamente ao longo de alguns anos. Você consegue identificar alguma das características listadas acima nesses dados?
|
||||
|
||||
|
||||
|
||||
## Exercício - começando com dados de uso de energia
|
||||
|
||||
Vamos começar a criar um modelo de séries temporais para prever o uso futuro de energia, dado o uso passado.
|
||||
|
||||
> Os dados neste exemplo são provenientes da competição de previsão GEFCom2014. Eles consistem em 3 anos de valores de carga elétrica e temperatura horária entre 2012 e 2014.
|
||||
>
|
||||
> Tao Hong, Pierre Pinson, Shu Fan, Hamidreza Zareipour, Alberto Troccoli e Rob J. Hyndman, "Previsão de energia probabilística: Competição Global de Previsão de Energia 2014 e além", International Journal of Forecasting, vol.32, no.3, pp 896-913, julho-setembro, 2016.
|
||||
|
||||
1. Na pasta `working` desta lição, abra o arquivo _notebook.ipynb_. Comece adicionando bibliotecas que ajudarão você a carregar e visualizar os dados.
|
||||
|
||||
```python
|
||||
import os
|
||||
import matplotlib.pyplot as plt
|
||||
from common.utils import load_data
|
||||
%matplotlib inline
|
||||
```
|
||||
|
||||
Observe que você está usando os arquivos da função incluída `common` folder which set up your environment and handle downloading the data.
|
||||
|
||||
2. Next, examine the data as a dataframe calling `load_data()` and `head()`:
|
||||
|
||||
```python
|
||||
data_dir = './data'
|
||||
energy = load_data(data_dir)[['load']]
|
||||
energy.head()
|
||||
```
|
||||
|
||||
Você pode ver que há duas colunas representando a data e a carga:
|
||||
|
||||
| | carga |
|
||||
| :-----------------: | :----: |
|
||||
| 2012-01-01 00:00:00 | 2698.0 |
|
||||
| 2012-01-01 01:00:00 | 2558.0 |
|
||||
| 2012-01-01 02:00:00 | 2444.0 |
|
||||
| 2012-01-01 03:00:00 | 2402.0 |
|
||||
| 2012-01-01 04:00:00 | 2403.0 |
|
||||
|
||||
3. Agora, plote os dados chamando `plot()`:
|
||||
|
||||
```python
|
||||
energy.plot(y='load', subplots=True, figsize=(15, 8), fontsize=12)
|
||||
plt.xlabel('timestamp', fontsize=12)
|
||||
plt.ylabel('load', fontsize=12)
|
||||
plt.show()
|
||||
```
|
||||
|
||||
|
||||
|
||||
4. Agora, plote a primeira semana de julho de 2014, fornecendo-a como entrada para o padrão `energia` in `[de data]: [até data]`:
|
||||
|
||||
```python
|
||||
energy['2014-07-01':'2014-07-07'].plot(y='load', subplots=True, figsize=(15, 8), fontsize=12)
|
||||
plt.xlabel('timestamp', fontsize=12)
|
||||
plt.ylabel('load', fontsize=12)
|
||||
plt.show()
|
||||
```
|
||||
|
||||
|
||||
|
||||
Um gráfico lindo! Dê uma olhada nesses gráficos e veja se consegue determinar alguma das características listadas acima. O que podemos inferir ao visualizar os dados?
|
||||
|
||||
Na próxima lição, você criará um modelo ARIMA para gerar algumas previsões.
|
||||
|
||||
---
|
||||
|
||||
## 🚀Desafio
|
||||
|
||||
Faça uma lista de todas as indústrias e áreas de pesquisa que você consegue pensar que se beneficiariam da previsão de séries temporais. Você consegue pensar em uma aplicação dessas técnicas nas artes? Em Econometria? Ecologia? Varejo? Indústria? Finanças? Onde mais?
|
||||
|
||||
## [Quiz pós-aula](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/42/)
|
||||
|
||||
## Revisão e Estudo Pessoal
|
||||
|
||||
Embora não os abordemos aqui, redes neurais são às vezes usadas para aprimorar métodos clássicos de previsão de séries temporais. Leia mais sobre elas [neste artigo](https://medium.com/microsoftazure/neural-networks-for-forecasting-financial-and-economic-time-series-6aca370ff412)
|
||||
|
||||
## Tarefa
|
||||
|
||||
[Visualize mais séries temporais](assignment.md)
|
||||
|
||||
**Isenção de responsabilidade**:
|
||||
Este documento foi traduzido utilizando serviços de tradução automática baseados em IA. Embora nos esforcemos pela precisão, esteja ciente de que traduções automáticas podem conter erros ou imprecisões. O documento original em sua língua nativa deve ser considerado a fonte autoritária. Para informações críticas, recomenda-se a tradução profissional feita por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações errôneas decorrentes do uso desta tradução.
|
||||
@ -1,14 +0,0 @@
|
||||
# Visualize alguns dados de Séries Temporais
|
||||
|
||||
## Instruções
|
||||
|
||||
Você começou a aprender sobre Previsão de Séries Temporais ao observar o tipo de dado que requer essa modelagem especial. Você visualizou alguns dados relacionados à energia. Agora, procure outros dados que poderiam se beneficiar da Previsão de Séries Temporais. Encontre três exemplos (tente [Kaggle](https://kaggle.com) e [Azure Open Datasets](https://azure.microsoft.com/en-us/services/open-datasets/catalog/?WT.mc_id=academic-77952-leestott)) e crie um notebook para visualizá-los. Anote quaisquer características especiais que eles possuam (sazonalidade, mudanças abruptas ou outras tendências) no notebook.
|
||||
|
||||
## Rubrica
|
||||
|
||||
| Critério | Exemplar | Adequado | Necessita de Melhorias |
|
||||
| -------- | ----------------------------------------------------- | ---------------------------------------------------- | ---------------------------------------------------------------------------------------------- |
|
||||
| | Três conjuntos de dados são plotados e explicados em um notebook | Dois conjuntos de dados são plotados e explicados em um notebook | Poucos conjuntos de dados são plotados ou explicados em um notebook ou os dados apresentados são insuficientes |
|
||||
|
||||
**Isenção de responsabilidade**:
|
||||
Este documento foi traduzido utilizando serviços de tradução automática baseados em IA. Embora nos esforcemos pela precisão, 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 a tradução profissional por um humano. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações errôneas resultantes do uso desta tradução.
|
||||
@ -1,6 +0,0 @@
|
||||
Isto é um espaço reservado temporário. Por favor, escreva a saída da esquerda para a direita.
|
||||
|
||||
Isto é um espaço reservado temporário.
|
||||
|
||||
**Isenção de responsabilidade**:
|
||||
Este documento foi traduzido utilizando serviços de tradução automática baseados em IA. Embora nos esforcemos pela precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em sua língua nativa deve ser considerado a fonte autoritativa. 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 errôneas decorrentes do uso desta tradução.
|
||||
@ -1,6 +0,0 @@
|
||||
isto é um espaço reservado temporárioPor favor, escreva a saída da esquerda para a direita.
|
||||
|
||||
isto é um espaço reservado temporário
|
||||
|
||||
**Isenção de responsabilidade**:
|
||||
Este documento foi traduzido utilizando serviços de tradução automática baseados em IA. Embora nos esforcemos pela precisão, esteja ciente de que traduções automáticas podem conter erros ou imprecisões. O documento original em sua língua nativa deve ser considerado a fonte autorizada. Para informações críticas, recomenda-se a tradução profissional por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações errôneas decorrentes do uso desta tradução.
|
||||
@ -1,396 +0,0 @@
|
||||
# Previsão de séries temporais com ARIMA
|
||||
|
||||
Na lição anterior, você aprendeu um pouco sobre previsão de séries temporais e carregou um conjunto de dados que mostra as flutuações da carga elétrica ao longo de um período de tempo.
|
||||
|
||||
[](https://youtu.be/IUSk-YDau10 "Introdução ao ARIMA")
|
||||
|
||||
> 🎥 Clique na imagem acima para assistir a um vídeo: Uma breve introdução aos modelos ARIMA. O exemplo é feito em R, mas os conceitos são universais.
|
||||
|
||||
## [Questionário pré-aula](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/43/)
|
||||
|
||||
## Introdução
|
||||
|
||||
Nesta lição, você descobrirá uma maneira específica de construir modelos com [ARIMA: *A*uto*R*egressivo *I*ntegrado *M*édia *M*óvel](https://wikipedia.org/wiki/Autoregressive_integrated_moving_average). Os modelos ARIMA são particularmente adequados para ajustar dados que apresentam [não-estacionariedade](https://wikipedia.org/wiki/Stationary_process).
|
||||
|
||||
## Conceitos gerais
|
||||
|
||||
Para poder trabalhar com ARIMA, há alguns conceitos que você precisa conhecer:
|
||||
|
||||
- 🎓 **Estacionariedade**. Em um contexto estatístico, estacionariedade refere-se a dados cuja distribuição não muda quando deslocados no tempo. Dados não estacionários, portanto, mostram flutuações devido a tendências que precisam ser transformadas para serem analisadas. A sazonalidade, por exemplo, pode introduzir flutuações nos dados e pode ser eliminada por um processo de 'diferenciação sazonal'.
|
||||
|
||||
- 🎓 **[Diferenciação](https://wikipedia.org/wiki/Autoregressive_integrated_moving_average#Differencing)**. A diferenciação de dados, novamente em um contexto estatístico, refere-se ao processo de transformar dados não estacionários para torná-los estacionários, removendo sua tendência não constante. "A diferenciação remove as mudanças no nível de uma série temporal, eliminando tendência e sazonalidade e, consequentemente, estabilizando a média da série temporal." [Artigo de Shixiong et al](https://arxiv.org/abs/1904.07632)
|
||||
|
||||
## ARIMA no contexto de séries temporais
|
||||
|
||||
Vamos desmembrar as partes do ARIMA para entender melhor como ele nos ajuda a modelar séries temporais e a fazer previsões a partir delas.
|
||||
|
||||
- **AR - de AutoRegressivo**. Modelos autoregressivos, como o nome sugere, olham 'para trás' no tempo para analisar valores anteriores em seus dados e fazer suposições sobre eles. Esses valores anteriores são chamados de 'defasagens'. Um exemplo seria dados que mostram vendas mensais de lápis. O total de vendas de cada mês seria considerado uma 'variável em evolução' no conjunto de dados. Este modelo é construído à medida que "a variável de interesse em evolução é regredida em seus próprios valores defasados (ou seja, anteriores)." [wikipedia](https://wikipedia.org/wiki/Autoregressive_integrated_moving_average)
|
||||
|
||||
- **I - de Integrado**. Ao contrário dos modelos 'ARMA' semelhantes, o 'I' em ARIMA refere-se ao seu aspecto *[integrado](https://wikipedia.org/wiki/Order_of_integration)*. Os dados são 'integrados' quando passos de diferenciação são aplicados para eliminar a não-estacionariedade.
|
||||
|
||||
- **MA - de Média Móvel**. O aspecto de [média móvel](https://wikipedia.org/wiki/Moving-average_model) deste modelo refere-se à variável de saída que é determinada observando os valores atuais e passados das defasagens.
|
||||
|
||||
Em resumo: ARIMA é usado para fazer um modelo se ajustar à forma especial dos dados de séries temporais o mais próximo possível.
|
||||
|
||||
## Exercício - construir um modelo ARIMA
|
||||
|
||||
Abra a pasta [_/working_](https://github.com/microsoft/ML-For-Beginners/tree/main/7-TimeSeries/2-ARIMA/working) nesta lição e encontre o arquivo [_notebook.ipynb_](https://github.com/microsoft/ML-For-Beginners/blob/main/7-TimeSeries/2-ARIMA/working/notebook.ipynb).
|
||||
|
||||
1. Execute o notebook para carregar a biblioteca Python `statsmodels`; você precisará disso para os modelos ARIMA.
|
||||
|
||||
1. Carregue as bibliotecas necessárias.
|
||||
|
||||
1. Agora, carregue várias outras bibliotecas úteis para plotar dados:
|
||||
|
||||
```python
|
||||
import os
|
||||
import warnings
|
||||
import matplotlib.pyplot as plt
|
||||
import numpy as np
|
||||
import pandas as pd
|
||||
import datetime as dt
|
||||
import math
|
||||
|
||||
from pandas.plotting import autocorrelation_plot
|
||||
from statsmodels.tsa.statespace.sarimax import SARIMAX
|
||||
from sklearn.preprocessing import MinMaxScaler
|
||||
from common.utils import load_data, mape
|
||||
from IPython.display import Image
|
||||
|
||||
%matplotlib inline
|
||||
pd.options.display.float_format = '{:,.2f}'.format
|
||||
np.set_printoptions(precision=2)
|
||||
warnings.filterwarnings("ignore") # specify to ignore warning messages
|
||||
```
|
||||
|
||||
1. Carregue os dados do arquivo `/data/energy.csv` em um dataframe do Pandas e dê uma olhada:
|
||||
|
||||
```python
|
||||
energy = load_data('./data')[['load']]
|
||||
energy.head(10)
|
||||
```
|
||||
|
||||
1. Plote todos os dados de energia disponíveis de janeiro de 2012 a dezembro de 2014. Não deve haver surpresas, pois vimos esses dados na última lição:
|
||||
|
||||
```python
|
||||
energy.plot(y='load', subplots=True, figsize=(15, 8), fontsize=12)
|
||||
plt.xlabel('timestamp', fontsize=12)
|
||||
plt.ylabel('load', fontsize=12)
|
||||
plt.show()
|
||||
```
|
||||
|
||||
Agora, vamos construir um modelo!
|
||||
|
||||
### Criar conjuntos de dados de treinamento e teste
|
||||
|
||||
Agora que seus dados estão carregados, você pode separá-los em conjuntos de treino e teste. Você treinará seu modelo no conjunto de treino. Como de costume, após o modelo ter terminado de treinar, você avaliará sua precisão usando o conjunto de teste. Você precisa garantir que o conjunto de teste cubra um período posterior ao conjunto de treino para garantir que o modelo não obtenha informações de períodos futuros.
|
||||
|
||||
1. Alocar um período de dois meses de 1º de setembro a 31 de outubro de 2014 para o conjunto de treino. O conjunto de teste incluirá o período de dois meses de 1º de novembro a 31 de dezembro de 2014:
|
||||
|
||||
```python
|
||||
train_start_dt = '2014-11-01 00:00:00'
|
||||
test_start_dt = '2014-12-30 00:00:00'
|
||||
```
|
||||
|
||||
Como esses dados refletem o consumo diário de energia, há um forte padrão sazonal, mas o consumo é mais semelhante ao consumo em dias mais recentes.
|
||||
|
||||
1. Visualize as diferenças:
|
||||
|
||||
```python
|
||||
energy[(energy.index < test_start_dt) & (energy.index >= train_start_dt)][['load']].rename(columns={'load':'train'}) \
|
||||
.join(energy[test_start_dt:][['load']].rename(columns={'load':'test'}), how='outer') \
|
||||
.plot(y=['train', 'test'], figsize=(15, 8), fontsize=12)
|
||||
plt.xlabel('timestamp', fontsize=12)
|
||||
plt.ylabel('load', fontsize=12)
|
||||
plt.show()
|
||||
```
|
||||
|
||||
|
||||
|
||||
Portanto, usar uma janela de tempo relativamente pequena para treinar os dados deve ser suficiente.
|
||||
|
||||
> Nota: Como a função que usamos para ajustar o modelo ARIMA utiliza validação in-sample durante o ajuste, omitiremos os dados de validação.
|
||||
|
||||
### Preparar os dados para treinamento
|
||||
|
||||
Agora, você precisa preparar os dados para treinamento, realizando filtragem e escalonamento de seus dados. Filtre seu conjunto de dados para incluir apenas os períodos de tempo e colunas que você precisa, e escale para garantir que os dados sejam projetados no intervalo 0,1.
|
||||
|
||||
1. Filtre o conjunto de dados original para incluir apenas os períodos de tempo mencionados por conjunto e apenas a coluna necessária 'load' mais a data:
|
||||
|
||||
```python
|
||||
train = energy.copy()[(energy.index >= train_start_dt) & (energy.index < test_start_dt)][['load']]
|
||||
test = energy.copy()[energy.index >= test_start_dt][['load']]
|
||||
|
||||
print('Training data shape: ', train.shape)
|
||||
print('Test data shape: ', test.shape)
|
||||
```
|
||||
|
||||
Você pode ver a forma dos dados:
|
||||
|
||||
```output
|
||||
Training data shape: (1416, 1)
|
||||
Test data shape: (48, 1)
|
||||
```
|
||||
|
||||
1. Escale os dados para que fiquem no intervalo (0, 1).
|
||||
|
||||
```python
|
||||
scaler = MinMaxScaler()
|
||||
train['load'] = scaler.fit_transform(train)
|
||||
train.head(10)
|
||||
```
|
||||
|
||||
1. Visualize os dados originais vs. os dados escalonados:
|
||||
|
||||
```python
|
||||
energy[(energy.index >= train_start_dt) & (energy.index < test_start_dt)][['load']].rename(columns={'load':'original load'}).plot.hist(bins=100, fontsize=12)
|
||||
train.rename(columns={'load':'scaled load'}).plot.hist(bins=100, fontsize=12)
|
||||
plt.show()
|
||||
```
|
||||
|
||||
|
||||
|
||||
> Os dados originais
|
||||
|
||||
|
||||
|
||||
> Os dados escalonados
|
||||
|
||||
1. Agora que você calibrou os dados escalonados, pode escalar os dados de teste:
|
||||
|
||||
```python
|
||||
test['load'] = scaler.transform(test)
|
||||
test.head()
|
||||
```
|
||||
|
||||
### Implementar ARIMA
|
||||
|
||||
É hora de implementar o ARIMA! Agora você usará a biblioteca `statsmodels` que você instalou anteriormente.
|
||||
|
||||
Agora você precisa seguir várias etapas:
|
||||
|
||||
1. Defina o modelo chamando `SARIMAX()` and passing in the model parameters: p, d, and q parameters, and P, D, and Q parameters.
|
||||
2. Prepare the model for the training data by calling the fit() function.
|
||||
3. Make predictions calling the `forecast()` function and specifying the number of steps (the `horizon`) to forecast.
|
||||
|
||||
> 🎓 What are all these parameters for? In an ARIMA model there are 3 parameters that are used to help model the major aspects of a time series: seasonality, trend, and noise. These parameters are:
|
||||
|
||||
`p`: the parameter associated with the auto-regressive aspect of the model, which incorporates *past* values.
|
||||
`d`: the parameter associated with the integrated part of the model, which affects the amount of *differencing* (🎓 remember differencing 👆?) to apply to a time series.
|
||||
`q`: the parameter associated with the moving-average part of the model.
|
||||
|
||||
> Note: If your data has a seasonal aspect - which this one does - , we use a seasonal ARIMA model (SARIMA). In that case you need to use another set of parameters: `P`, `D`, and `Q` which describe the same associations as `p`, `d`, and `q`, mas que correspondem aos componentes sazonais do modelo.
|
||||
|
||||
1. Comece definindo seu valor de horizonte preferido. Vamos tentar 3 horas:
|
||||
|
||||
```python
|
||||
# Specify the number of steps to forecast ahead
|
||||
HORIZON = 3
|
||||
print('Forecasting horizon:', HORIZON, 'hours')
|
||||
```
|
||||
|
||||
Selecionar os melhores valores para os parâmetros de um modelo ARIMA pode ser desafiador, pois é um pouco subjetivo e consome tempo. Você pode considerar usar uma biblioteca `auto_arima()` function from the [`pyramid`](https://alkaline-ml.com/pmdarima/0.9.0/modules/generated/pyramid.arima.auto_arima.html),
|
||||
|
||||
1. Por enquanto, tente algumas seleções manuais para encontrar um bom modelo.
|
||||
|
||||
```python
|
||||
order = (4, 1, 0)
|
||||
seasonal_order = (1, 1, 0, 24)
|
||||
|
||||
model = SARIMAX(endog=train, order=order, seasonal_order=seasonal_order)
|
||||
results = model.fit()
|
||||
|
||||
print(results.summary())
|
||||
```
|
||||
|
||||
Uma tabela de resultados é impressa.
|
||||
|
||||
Você construiu seu primeiro modelo! Agora precisamos encontrar uma maneira de avaliá-lo.
|
||||
|
||||
### Avalie seu modelo
|
||||
|
||||
Para avaliar seu modelo, você pode realizar a chamada validação `walk forward`. Na prática, os modelos de séries temporais são re-treinados cada vez que novos dados se tornam disponíveis. Isso permite que o modelo faça a melhor previsão em cada passo de tempo.
|
||||
|
||||
Começando no início da série temporal usando essa técnica, treine o modelo no conjunto de dados de treino. Em seguida, faça uma previsão no próximo passo de tempo. A previsão é avaliada em relação ao valor conhecido. O conjunto de treino é então expandido para incluir o valor conhecido e o processo é repetido.
|
||||
|
||||
> Nota: Você deve manter a janela do conjunto de treino fixa para um treinamento mais eficiente, de modo que toda vez que você adicionar uma nova observação ao conjunto de treino, você remova a observação do início do conjunto.
|
||||
|
||||
Esse processo fornece uma estimativa mais robusta de como o modelo se comportará na prática. No entanto, isso vem com o custo computacional de criar tantos modelos. Isso é aceitável se os dados forem pequenos ou se o modelo for simples, mas pode ser um problema em grande escala.
|
||||
|
||||
A validação walk-forward é o padrão ouro da avaliação de modelos de séries temporais e é recomendada para seus próprios projetos.
|
||||
|
||||
1. Primeiro, crie um ponto de dados de teste para cada passo do HORIZON.
|
||||
|
||||
```python
|
||||
test_shifted = test.copy()
|
||||
|
||||
for t in range(1, HORIZON+1):
|
||||
test_shifted['load+'+str(t)] = test_shifted['load'].shift(-t, freq='H')
|
||||
|
||||
test_shifted = test_shifted.dropna(how='any')
|
||||
test_shifted.head(5)
|
||||
```
|
||||
|
||||
| | | load | load+1 | load+2 |
|
||||
| ---------- | -------- | ---- | ------ | ------ |
|
||||
| 2014-12-30 | 00:00:00 | 0.33 | 0.29 | 0.27 |
|
||||
| 2014-12-30 | 01:00:00 | 0.29 | 0.27 | 0.27 |
|
||||
| 2014-12-30 | 02:00:00 | 0.27 | 0.27 | 0.30 |
|
||||
| 2014-12-30 | 03:00:00 | 0.27 | 0.30 | 0.41 |
|
||||
| 2014-12-30 | 04:00:00 | 0.30 | 0.41 | 0.57 |
|
||||
|
||||
Os dados são deslocados horizontalmente de acordo com seu ponto de horizonte.
|
||||
|
||||
1. Faça previsões em seus dados de teste usando essa abordagem de janela deslizante em um loop do tamanho do comprimento dos dados de teste:
|
||||
|
||||
```python
|
||||
%%time
|
||||
training_window = 720 # dedicate 30 days (720 hours) for training
|
||||
|
||||
train_ts = train['load']
|
||||
test_ts = test_shifted
|
||||
|
||||
history = [x for x in train_ts]
|
||||
history = history[(-training_window):]
|
||||
|
||||
predictions = list()
|
||||
|
||||
order = (2, 1, 0)
|
||||
seasonal_order = (1, 1, 0, 24)
|
||||
|
||||
for t in range(test_ts.shape[0]):
|
||||
model = SARIMAX(endog=history, order=order, seasonal_order=seasonal_order)
|
||||
model_fit = model.fit()
|
||||
yhat = model_fit.forecast(steps = HORIZON)
|
||||
predictions.append(yhat)
|
||||
obs = list(test_ts.iloc[t])
|
||||
# move the training window
|
||||
history.append(obs[0])
|
||||
history.pop(0)
|
||||
print(test_ts.index[t])
|
||||
print(t+1, ': predicted =', yhat, 'expected =', obs)
|
||||
```
|
||||
|
||||
Você pode observar o treinamento ocorrendo:
|
||||
|
||||
```output
|
||||
2014-12-30 00:00:00
|
||||
1 : predicted = [0.32 0.29 0.28] expected = [0.32945389435989236, 0.2900626678603402, 0.2739480752014323]
|
||||
|
||||
2014-12-30 01:00:00
|
||||
2 : predicted = [0.3 0.29 0.3 ] expected = [0.2900626678603402, 0.2739480752014323, 0.26812891674127126]
|
||||
|
||||
2014-12-30 02:00:00
|
||||
3 : predicted = [0.27 0.28 0.32] expected = [0.2739480752014323, 0.26812891674127126, 0.3025962399283795]
|
||||
```
|
||||
|
||||
1. Compare as previsões com a carga real:
|
||||
|
||||
```python
|
||||
eval_df = pd.DataFrame(predictions, columns=['t+'+str(t) for t in range(1, HORIZON+1)])
|
||||
eval_df['timestamp'] = test.index[0:len(test.index)-HORIZON+1]
|
||||
eval_df = pd.melt(eval_df, id_vars='timestamp', value_name='prediction', var_name='h')
|
||||
eval_df['actual'] = np.array(np.transpose(test_ts)).ravel()
|
||||
eval_df[['prediction', 'actual']] = scaler.inverse_transform(eval_df[['prediction', 'actual']])
|
||||
eval_df.head()
|
||||
```
|
||||
|
||||
Saída
|
||||
| | | timestamp | h | previsão | real |
|
||||
| --- | ---------- | --------- | --- | ---------- | -------- |
|
||||
| 0 | 2014-12-30 | 00:00:00 | t+1 | 3,008.74 | 3,023.00 |
|
||||
| 1 | 2014-12-30 | 01:00:00 | t+1 | 2,955.53 | 2,935.00 |
|
||||
| 2 | 2014-12-30 | 02:00:00 | t+1 | 2,900.17 | 2,899.00 |
|
||||
| 3 | 2014-12-30 | 03:00:00 | t+1 | 2,917.69 | 2,886.00 |
|
||||
| 4 | 2014-12-30 | 04:00:00 | t+1 | 2,946.99 | 2,963.00 |
|
||||
|
||||
Observe a previsão dos dados horários, comparada à carga real. Quão precisa é essa previsão?
|
||||
|
||||
### Verifique a precisão do modelo
|
||||
|
||||
Verifique a precisão do seu modelo testando seu erro percentual absoluto médio (MAPE) em todas as previsões.
|
||||
|
||||
> **🧮 Mostre-me a matemática**
|
||||
>
|
||||
> 
|
||||
>
|
||||
> [MAPE](https://www.linkedin.com/pulse/what-mape-mad-msd-time-series-allameh-statistics/) é usado para mostrar a precisão da previsão como uma razão definida pela fórmula acima. A diferença entre real<sub>t</sub> e previsto<sub>t</sub> é dividida pela real<sub>t</sub>. "O valor absoluto nesse cálculo é somado para cada ponto previsto no tempo e dividido pelo número de pontos ajustados n." [wikipedia](https://wikipedia.org/wiki/Mean_absolute_percentage_error)
|
||||
|
||||
1. Expresse a equação em código:
|
||||
|
||||
```python
|
||||
if(HORIZON > 1):
|
||||
eval_df['APE'] = (eval_df['prediction'] - eval_df['actual']).abs() / eval_df['actual']
|
||||
print(eval_df.groupby('h')['APE'].mean())
|
||||
```
|
||||
|
||||
1. Calcule o MAPE de um passo:
|
||||
|
||||
```python
|
||||
print('One step forecast MAPE: ', (mape(eval_df[eval_df['h'] == 't+1']['prediction'], eval_df[eval_df['h'] == 't+1']['actual']))*100, '%')
|
||||
```
|
||||
|
||||
MAPE da previsão de um passo: 0.5570581332313952 %
|
||||
|
||||
1. Imprima o MAPE da previsão de múltiplos passos:
|
||||
|
||||
```python
|
||||
print('Multi-step forecast MAPE: ', mape(eval_df['prediction'], eval_df['actual'])*100, '%')
|
||||
```
|
||||
|
||||
```output
|
||||
Multi-step forecast MAPE: 1.1460048657704118 %
|
||||
```
|
||||
|
||||
Um número baixo é o ideal: considere que uma previsão que tem um MAPE de 10 está errada em 10%.
|
||||
|
||||
1. Mas, como sempre, é mais fácil ver esse tipo de medição de precisão visualmente, então vamos plotá-la:
|
||||
|
||||
```python
|
||||
if(HORIZON == 1):
|
||||
## Plotting single step forecast
|
||||
eval_df.plot(x='timestamp', y=['actual', 'prediction'], style=['r', 'b'], figsize=(15, 8))
|
||||
|
||||
else:
|
||||
## Plotting multi step forecast
|
||||
plot_df = eval_df[(eval_df.h=='t+1')][['timestamp', 'actual']]
|
||||
for t in range(1, HORIZON+1):
|
||||
plot_df['t+'+str(t)] = eval_df[(eval_df.h=='t+'+str(t))]['prediction'].values
|
||||
|
||||
fig = plt.figure(figsize=(15, 8))
|
||||
ax = plt.plot(plot_df['timestamp'], plot_df['actual'], color='red', linewidth=4.0)
|
||||
ax = fig.add_subplot(111)
|
||||
for t in range(1, HORIZON+1):
|
||||
x = plot_df['timestamp'][(t-1):]
|
||||
y = plot_df['t+'+str(t)][0:len(x)]
|
||||
ax.plot(x, y, color='blue', linewidth=4*math.pow(.9,t), alpha=math.pow(0.8,t))
|
||||
|
||||
ax.legend(loc='best')
|
||||
|
||||
plt.xlabel('timestamp', fontsize=12)
|
||||
plt.ylabel('load', fontsize=12)
|
||||
plt.show()
|
||||
```
|
||||
|
||||
|
||||
|
||||
🏆 Um gráfico muito bonito, mostrando um modelo com boa precisão. Muito bem!
|
||||
|
||||
---
|
||||
|
||||
## 🚀Desafio
|
||||
|
||||
Explore as maneiras de testar a precisão de um Modelo de Série Temporal. Abordamos o MAPE nesta lição, mas existem outros métodos que você poderia usar? Pesquise-os e anote-os. Um documento útil pode ser encontrado [aqui](https://otexts.com/fpp2/accuracy.html)
|
||||
|
||||
## [Questionário pós-aula](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/44/)
|
||||
|
||||
## Revisão e Estudo Autônomo
|
||||
|
||||
Esta lição aborda apenas os conceitos básicos da Previsão de Séries Temporais com ARIMA. Reserve um tempo para aprofundar seu conhecimento explorando [este repositório](https://microsoft.github.io/forecasting/) e seus vários tipos de modelos para aprender outras maneiras de construir modelos de Séries Temporais.
|
||||
|
||||
## Tarefa
|
||||
|
||||
[Um novo modelo ARIMA](assignment.md)
|
||||
|
||||
**Aviso**:
|
||||
Este documento foi traduzido utilizando serviços de tradução automática baseados em IA. Embora nos esforcemos pela precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em sua língua nativa deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se a tradução profissional feita por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações errôneas decorrentes do uso desta tradução.
|
||||
@ -1,14 +0,0 @@
|
||||
# Um novo modelo ARIMA
|
||||
|
||||
## Instruções
|
||||
|
||||
Agora que você construiu um modelo ARIMA, crie um novo com dados novos (tente um dos [conjuntos de dados da Duke](http://www2.stat.duke.edu/~mw/ts_data_sets.html)). Anote seu trabalho em um caderno, visualize os dados e seu modelo, e teste sua precisão usando MAPE.
|
||||
|
||||
## Rubrica
|
||||
|
||||
| Critérios | Exemplar | Adequado | Necessita Melhorias |
|
||||
| --------- | ------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------ | ------------------------------------ |
|
||||
| | Um caderno é apresentado com um novo modelo ARIMA construído, testado e explicado com visualizações e precisão declarada. | O caderno apresentado não está anotado ou contém erros | Um caderno incompleto é apresentado |
|
||||
|
||||
**Aviso**:
|
||||
Este documento foi traduzido utilizando serviços de tradução automática baseados em IA. Embora nos esforcemos pela precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em sua língua nativa deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se a tradução profissional feita por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações errôneas decorrentes do uso desta tradução.
|
||||
@ -1,6 +0,0 @@
|
||||
Este é um espaço reservado temporárioPor favor, escreva a saída da esquerda para a direita.
|
||||
|
||||
Este é um espaço reservado temporário
|
||||
|
||||
**Isenção de responsabilidade**:
|
||||
Este documento foi traduzido usando serviços de tradução automática baseados em IA. Embora nos esforcemos pela precisão, 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 autoritativa. Para informações críticas, recomenda-se a tradução profissional por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações errôneas decorrentes do uso desta tradução.
|
||||
@ -1,6 +0,0 @@
|
||||
isto é um espaço reservado temporárioPor favor, escreva a saída da esquerda para a direita.
|
||||
|
||||
isto é um espaço reservado temporário
|
||||
|
||||
**Aviso Legal**:
|
||||
Este documento foi traduzido utilizando serviços de tradução automática baseados em IA. 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 sua língua nativa deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se a tradução profissional feita por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações errôneas decorrentes do uso desta tradução.
|
||||
@ -1,382 +0,0 @@
|
||||
# Previsão de Séries Temporais com Regressor de Vetores de Suporte
|
||||
|
||||
Na lição anterior, você aprendeu a usar o modelo ARIMA para fazer previsões de séries temporais. Agora, você irá explorar o modelo Regressor de Vetores de Suporte, que é um modelo de regressão utilizado para prever dados contínuos.
|
||||
|
||||
## [Quiz pré-aula](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/51/)
|
||||
|
||||
## Introdução
|
||||
|
||||
Nesta lição, você descobrirá uma maneira específica de construir modelos com [**SVM**: **S**uporte **V**ector **M**achine](https://en.wikipedia.org/wiki/Support-vector_machine) para regressão, ou **SVR: Regressor de Vetores de Suporte**.
|
||||
|
||||
### SVR no contexto de séries temporais [^1]
|
||||
|
||||
Antes de entender a importância do SVR na previsão de séries temporais, aqui estão alguns conceitos importantes que você precisa saber:
|
||||
|
||||
- **Regressão:** Técnica de aprendizado supervisionado para prever valores contínuos a partir de um conjunto de entradas fornecido. A ideia é ajustar uma curva (ou linha) no espaço das características que tenha o maior número de pontos de dados. [Clique aqui](https://en.wikipedia.org/wiki/Regression_analysis) para mais informações.
|
||||
- **Máquina de Vetores de Suporte (SVM):** Um tipo de modelo de aprendizado de máquina supervisionado usado para classificação, regressão e detecção de outliers. O modelo é um hiperplano no espaço das características, que no caso da classificação atua como uma fronteira, e no caso da regressão atua como a linha de melhor ajuste. No SVM, uma função Kernel é geralmente usada para transformar o conjunto de dados em um espaço de maior número de dimensões, de modo que possam ser facilmente separáveis. [Clique aqui](https://en.wikipedia.org/wiki/Support-vector_machine) para mais informações sobre SVMs.
|
||||
- **Regressor de Vetores de Suporte (SVR):** Um tipo de SVM, para encontrar a linha de melhor ajuste (que no caso do SVM é um hiperplano) que tenha o maior número de pontos de dados.
|
||||
|
||||
### Por que SVR? [^1]
|
||||
|
||||
Na última lição, você aprendeu sobre ARIMA, que é um método linear estatístico muito bem-sucedido para prever dados de séries temporais. No entanto, em muitos casos, os dados de séries temporais apresentam *não-linearidade*, que não pode ser mapeada por modelos lineares. Nesses casos, a capacidade do SVM de considerar a não-linearidade nos dados para tarefas de regressão torna o SVR bem-sucedido na previsão de séries temporais.
|
||||
|
||||
## Exercício - construir um modelo SVR
|
||||
|
||||
Os primeiros passos para a preparação dos dados são os mesmos da lição anterior sobre [ARIMA](https://github.com/microsoft/ML-For-Beginners/tree/main/7-TimeSeries/2-ARIMA).
|
||||
|
||||
Abra a pasta [_/working_](https://github.com/microsoft/ML-For-Beginners/tree/main/7-TimeSeries/3-SVR/working) nesta lição e encontre o arquivo [_notebook.ipynb_](https://github.com/microsoft/ML-For-Beginners/blob/main/7-TimeSeries/3-SVR/working/notebook.ipynb). [^2]
|
||||
|
||||
1. Execute o notebook e importe as bibliotecas necessárias: [^2]
|
||||
|
||||
```python
|
||||
import sys
|
||||
sys.path.append('../../')
|
||||
```
|
||||
|
||||
```python
|
||||
import os
|
||||
import warnings
|
||||
import matplotlib.pyplot as plt
|
||||
import numpy as np
|
||||
import pandas as pd
|
||||
import datetime as dt
|
||||
import math
|
||||
|
||||
from sklearn.svm import SVR
|
||||
from sklearn.preprocessing import MinMaxScaler
|
||||
from common.utils import load_data, mape
|
||||
```
|
||||
|
||||
2. Carregue os dados do arquivo `/data/energy.csv` em um dataframe do Pandas e dê uma olhada: [^2]
|
||||
|
||||
```python
|
||||
energy = load_data('../../data')[['load']]
|
||||
```
|
||||
|
||||
3. Plote todos os dados de energia disponíveis de janeiro de 2012 a dezembro de 2014: [^2]
|
||||
|
||||
```python
|
||||
energy.plot(y='load', subplots=True, figsize=(15, 8), fontsize=12)
|
||||
plt.xlabel('timestamp', fontsize=12)
|
||||
plt.ylabel('load', fontsize=12)
|
||||
plt.show()
|
||||
```
|
||||
|
||||
|
||||
|
||||
Agora, vamos construir nosso modelo SVR.
|
||||
|
||||
### Criar conjuntos de dados de treinamento e teste
|
||||
|
||||
Agora que seus dados estão carregados, você pode separá-los em conjuntos de treino e teste. Em seguida, você irá remodelar os dados para criar um conjunto de dados baseado em passos de tempo, que será necessário para o SVR. Você treinará seu modelo no conjunto de treino. Após o término do treinamento do modelo, você avaliará sua precisão no conjunto de treinamento, no conjunto de teste e, em seguida, no conjunto de dados completo para ver o desempenho geral. Você precisa garantir que o conjunto de teste abranja um período posterior em relação ao conjunto de treinamento, para garantir que o modelo não obtenha informações de períodos de tempo futuros [^2] (uma situação conhecida como *Overfitting*).
|
||||
|
||||
1. Alocar um período de dois meses de 1º de setembro a 31 de outubro de 2014 para o conjunto de treinamento. O conjunto de teste incluirá o período de dois meses de 1º de novembro a 31 de dezembro de 2014: [^2]
|
||||
|
||||
```python
|
||||
train_start_dt = '2014-11-01 00:00:00'
|
||||
test_start_dt = '2014-12-30 00:00:00'
|
||||
```
|
||||
|
||||
2. Visualize as diferenças: [^2]
|
||||
|
||||
```python
|
||||
energy[(energy.index < test_start_dt) & (energy.index >= train_start_dt)][['load']].rename(columns={'load':'train'}) \
|
||||
.join(energy[test_start_dt:][['load']].rename(columns={'load':'test'}), how='outer') \
|
||||
.plot(y=['train', 'test'], figsize=(15, 8), fontsize=12)
|
||||
plt.xlabel('timestamp', fontsize=12)
|
||||
plt.ylabel('load', fontsize=12)
|
||||
plt.show()
|
||||
```
|
||||
|
||||
|
||||
|
||||
### Preparar os dados para treinamento
|
||||
|
||||
Agora, você precisa preparar os dados para o treinamento, realizando filtragem e escalonamento dos seus dados. Filtre seu conjunto de dados para incluir apenas os períodos de tempo e colunas que você precisa, e escale para garantir que os dados sejam projetados no intervalo de 0 a 1.
|
||||
|
||||
1. Filtrar o conjunto de dados original para incluir apenas os períodos de tempo mencionados por conjunto e incluindo apenas a coluna necessária 'load' mais a data: [^2]
|
||||
|
||||
```python
|
||||
train = energy.copy()[(energy.index >= train_start_dt) & (energy.index < test_start_dt)][['load']]
|
||||
test = energy.copy()[energy.index >= test_start_dt][['load']]
|
||||
|
||||
print('Training data shape: ', train.shape)
|
||||
print('Test data shape: ', test.shape)
|
||||
```
|
||||
|
||||
```output
|
||||
Training data shape: (1416, 1)
|
||||
Test data shape: (48, 1)
|
||||
```
|
||||
|
||||
2. Escale os dados de treinamento para que fiquem na faixa (0, 1): [^2]
|
||||
|
||||
```python
|
||||
scaler = MinMaxScaler()
|
||||
train['load'] = scaler.fit_transform(train)
|
||||
```
|
||||
|
||||
4. Agora, você escala os dados de teste: [^2]
|
||||
|
||||
```python
|
||||
test['load'] = scaler.transform(test)
|
||||
```
|
||||
|
||||
### Criar dados com passos de tempo [^1]
|
||||
|
||||
Para o SVR, você transforma os dados de entrada para ter a forma `[batch, timesteps]`. So, you reshape the existing `train_data` and `test_data`, de modo que haja uma nova dimensão que se refere aos passos de tempo.
|
||||
|
||||
```python
|
||||
# Converting to numpy arrays
|
||||
train_data = train.values
|
||||
test_data = test.values
|
||||
```
|
||||
|
||||
Para este exemplo, tomamos `timesteps = 5`. Assim, as entradas para o modelo são os dados dos primeiros 4 passos de tempo, e a saída será os dados do 5º passo de tempo.
|
||||
|
||||
```python
|
||||
timesteps=5
|
||||
```
|
||||
|
||||
Convertendo dados de treinamento em tensor 2D usando compreensão de lista aninhada:
|
||||
|
||||
```python
|
||||
train_data_timesteps=np.array([[j for j in train_data[i:i+timesteps]] for i in range(0,len(train_data)-timesteps+1)])[:,:,0]
|
||||
train_data_timesteps.shape
|
||||
```
|
||||
|
||||
```output
|
||||
(1412, 5)
|
||||
```
|
||||
|
||||
Convertendo dados de teste em tensor 2D:
|
||||
|
||||
```python
|
||||
test_data_timesteps=np.array([[j for j in test_data[i:i+timesteps]] for i in range(0,len(test_data)-timesteps+1)])[:,:,0]
|
||||
test_data_timesteps.shape
|
||||
```
|
||||
|
||||
```output
|
||||
(44, 5)
|
||||
```
|
||||
|
||||
Selecionando entradas e saídas dos dados de treinamento e teste:
|
||||
|
||||
```python
|
||||
x_train, y_train = train_data_timesteps[:,:timesteps-1],train_data_timesteps[:,[timesteps-1]]
|
||||
x_test, y_test = test_data_timesteps[:,:timesteps-1],test_data_timesteps[:,[timesteps-1]]
|
||||
|
||||
print(x_train.shape, y_train.shape)
|
||||
print(x_test.shape, y_test.shape)
|
||||
```
|
||||
|
||||
```output
|
||||
(1412, 4) (1412, 1)
|
||||
(44, 4) (44, 1)
|
||||
```
|
||||
|
||||
### Implementar SVR [^1]
|
||||
|
||||
Agora, é hora de implementar o SVR. Para ler mais sobre esta implementação, você pode consultar [esta documentação](https://scikit-learn.org/stable/modules/generated/sklearn.svm.SVR.html). Para nossa implementação, seguimos estas etapas:
|
||||
|
||||
1. Defina o modelo chamando a função `SVR()` and passing in the model hyperparameters: kernel, gamma, c and epsilon
|
||||
2. Prepare the model for the training data by calling the `fit()` function
|
||||
3. Make predictions calling the `predict()`
|
||||
|
||||
Agora criamos um modelo SVR. Aqui usamos o [kernel RBF](https://scikit-learn.org/stable/modules/svm.html#parameters-of-the-rbf-kernel) e definimos os hiperparâmetros gamma, C e epsilon como 0.5, 10 e 0.05, respectivamente.
|
||||
|
||||
```python
|
||||
model = SVR(kernel='rbf',gamma=0.5, C=10, epsilon = 0.05)
|
||||
```
|
||||
|
||||
#### Ajustar o modelo nos dados de treinamento [^1]
|
||||
|
||||
```python
|
||||
model.fit(x_train, y_train[:,0])
|
||||
```
|
||||
|
||||
```output
|
||||
SVR(C=10, cache_size=200, coef0=0.0, degree=3, epsilon=0.05, gamma=0.5,
|
||||
kernel='rbf', max_iter=-1, shrinking=True, tol=0.001, verbose=False)
|
||||
```
|
||||
|
||||
#### Fazer previsões do modelo [^1]
|
||||
|
||||
```python
|
||||
y_train_pred = model.predict(x_train).reshape(-1,1)
|
||||
y_test_pred = model.predict(x_test).reshape(-1,1)
|
||||
|
||||
print(y_train_pred.shape, y_test_pred.shape)
|
||||
```
|
||||
|
||||
```output
|
||||
(1412, 1) (44, 1)
|
||||
```
|
||||
|
||||
Você construiu seu SVR! Agora precisamos avaliá-lo.
|
||||
|
||||
### Avaliar seu modelo [^1]
|
||||
|
||||
Para avaliação, primeiro escalaremos os dados de volta para nossa escala original. Em seguida, para verificar o desempenho, plotaremos o gráfico da série temporal original e prevista, e também imprimiremos o resultado do MAPE.
|
||||
|
||||
Escale a saída prevista e a original:
|
||||
|
||||
```python
|
||||
# Scaling the predictions
|
||||
y_train_pred = scaler.inverse_transform(y_train_pred)
|
||||
y_test_pred = scaler.inverse_transform(y_test_pred)
|
||||
|
||||
print(len(y_train_pred), len(y_test_pred))
|
||||
```
|
||||
|
||||
```python
|
||||
# Scaling the original values
|
||||
y_train = scaler.inverse_transform(y_train)
|
||||
y_test = scaler.inverse_transform(y_test)
|
||||
|
||||
print(len(y_train), len(y_test))
|
||||
```
|
||||
|
||||
#### Verificar o desempenho do modelo nos dados de treinamento e teste [^1]
|
||||
|
||||
Extraímos os timestamps do conjunto de dados para mostrar no eixo x do nosso gráfico. Observe que estamos usando os primeiros ```timesteps-1``` valores como entrada para a primeira saída, então os timestamps para a saída começarão após isso.
|
||||
|
||||
```python
|
||||
train_timestamps = energy[(energy.index < test_start_dt) & (energy.index >= train_start_dt)].index[timesteps-1:]
|
||||
test_timestamps = energy[test_start_dt:].index[timesteps-1:]
|
||||
|
||||
print(len(train_timestamps), len(test_timestamps))
|
||||
```
|
||||
|
||||
```output
|
||||
1412 44
|
||||
```
|
||||
|
||||
Plote as previsões para os dados de treinamento:
|
||||
|
||||
```python
|
||||
plt.figure(figsize=(25,6))
|
||||
plt.plot(train_timestamps, y_train, color = 'red', linewidth=2.0, alpha = 0.6)
|
||||
plt.plot(train_timestamps, y_train_pred, color = 'blue', linewidth=0.8)
|
||||
plt.legend(['Actual','Predicted'])
|
||||
plt.xlabel('Timestamp')
|
||||
plt.title("Training data prediction")
|
||||
plt.show()
|
||||
```
|
||||
|
||||
|
||||
|
||||
Imprima o MAPE para os dados de treinamento
|
||||
|
||||
```python
|
||||
print('MAPE for training data: ', mape(y_train_pred, y_train)*100, '%')
|
||||
```
|
||||
|
||||
```output
|
||||
MAPE for training data: 1.7195710200875551 %
|
||||
```
|
||||
|
||||
Plote as previsões para os dados de teste
|
||||
|
||||
```python
|
||||
plt.figure(figsize=(10,3))
|
||||
plt.plot(test_timestamps, y_test, color = 'red', linewidth=2.0, alpha = 0.6)
|
||||
plt.plot(test_timestamps, y_test_pred, color = 'blue', linewidth=0.8)
|
||||
plt.legend(['Actual','Predicted'])
|
||||
plt.xlabel('Timestamp')
|
||||
plt.show()
|
||||
```
|
||||
|
||||
|
||||
|
||||
Imprima o MAPE para os dados de teste
|
||||
|
||||
```python
|
||||
print('MAPE for testing data: ', mape(y_test_pred, y_test)*100, '%')
|
||||
```
|
||||
|
||||
```output
|
||||
MAPE for testing data: 1.2623790187854018 %
|
||||
```
|
||||
|
||||
🏆 Você obteve um resultado muito bom no conjunto de dados de teste!
|
||||
|
||||
### Verificar o desempenho do modelo no conjunto de dados completo [^1]
|
||||
|
||||
```python
|
||||
# Extracting load values as numpy array
|
||||
data = energy.copy().values
|
||||
|
||||
# Scaling
|
||||
data = scaler.transform(data)
|
||||
|
||||
# Transforming to 2D tensor as per model input requirement
|
||||
data_timesteps=np.array([[j for j in data[i:i+timesteps]] for i in range(0,len(data)-timesteps+1)])[:,:,0]
|
||||
print("Tensor shape: ", data_timesteps.shape)
|
||||
|
||||
# Selecting inputs and outputs from data
|
||||
X, Y = data_timesteps[:,:timesteps-1],data_timesteps[:,[timesteps-1]]
|
||||
print("X shape: ", X.shape,"\nY shape: ", Y.shape)
|
||||
```
|
||||
|
||||
```output
|
||||
Tensor shape: (26300, 5)
|
||||
X shape: (26300, 4)
|
||||
Y shape: (26300, 1)
|
||||
```
|
||||
|
||||
```python
|
||||
# Make model predictions
|
||||
Y_pred = model.predict(X).reshape(-1,1)
|
||||
|
||||
# Inverse scale and reshape
|
||||
Y_pred = scaler.inverse_transform(Y_pred)
|
||||
Y = scaler.inverse_transform(Y)
|
||||
```
|
||||
|
||||
```python
|
||||
plt.figure(figsize=(30,8))
|
||||
plt.plot(Y, color = 'red', linewidth=2.0, alpha = 0.6)
|
||||
plt.plot(Y_pred, color = 'blue', linewidth=0.8)
|
||||
plt.legend(['Actual','Predicted'])
|
||||
plt.xlabel('Timestamp')
|
||||
plt.show()
|
||||
```
|
||||
|
||||
|
||||
|
||||
```python
|
||||
print('MAPE: ', mape(Y_pred, Y)*100, '%')
|
||||
```
|
||||
|
||||
```output
|
||||
MAPE: 2.0572089029888656 %
|
||||
```
|
||||
|
||||
🏆 Gráficos muito bons, mostrando um modelo com boa precisão. Parabéns!
|
||||
|
||||
---
|
||||
|
||||
## 🚀Desafio
|
||||
|
||||
- Tente ajustar os hiperparâmetros (gamma, C, epsilon) ao criar o modelo e avalie os dados para ver qual conjunto de hiperparâmetros oferece os melhores resultados nos dados de teste. Para saber mais sobre esses hiperparâmetros, você pode consultar o documento [aqui](https://scikit-learn.org/stable/modules/svm.html#parameters-of-the-rbf-kernel).
|
||||
- Tente usar diferentes funções de kernel para o modelo e analise seu desempenho no conjunto de dados. Um documento útil pode ser encontrado [aqui](https://scikit-learn.org/stable/modules/svm.html#kernel-functions).
|
||||
- Tente usar diferentes valores para `timesteps` para que o modelo faça previsões considerando os passos anteriores.
|
||||
|
||||
## [Quiz pós-aula](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/52/)
|
||||
|
||||
## Revisão e Estudo Autônomo
|
||||
|
||||
Esta lição teve como objetivo introduzir a aplicação do SVR para Previsão de Séries Temporais. Para ler mais sobre SVR, você pode consultar [este blog](https://www.analyticsvidhya.com/blog/2020/03/support-vector-regression-tutorial-for-machine-learning/). Esta [documentação sobre scikit-learn](https://scikit-learn.org/stable/modules/svm.html) fornece uma explicação mais abrangente sobre SVMs em geral, [SVRs](https://scikit-learn.org/stable/modules/svm.html#regression) e também outros detalhes de implementação, como as diferentes [funções de kernel](https://scikit-learn.org/stable/modules/svm.html#kernel-functions) que podem ser utilizadas e seus parâmetros.
|
||||
|
||||
## Tarefa
|
||||
|
||||
[Um novo modelo SVR](assignment.md)
|
||||
|
||||
## Créditos
|
||||
|
||||
[^1]: O texto, código e saída nesta seção foram contribuídos por [@AnirbanMukherjeeXD](https://github.com/AnirbanMukherjeeXD)
|
||||
[^2]: O texto, código e saída nesta seção foram retirados de [ARIMA](https://github.com/microsoft/ML-For-Beginners/tree/main/7-TimeSeries/2-ARIMA)
|
||||
|
||||
**Aviso Legal**:
|
||||
Este documento foi traduzido utilizando serviços de tradução automática baseados em IA. Embora nos esforcemos para garantir a precisão, 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 autoritativa. 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 errôneas que possam surgir do uso desta tradução.
|
||||
@ -1,17 +0,0 @@
|
||||
# Um novo modelo SVR
|
||||
|
||||
## Instruções [^1]
|
||||
|
||||
Agora que você construiu um modelo SVR, crie um novo com dados novos (experimente um dos [conjuntos de dados da Duke](http://www2.stat.duke.edu/~mw/ts_data_sets.html)). Anote seu trabalho em um caderno, visualize os dados e seu modelo, e teste sua precisão usando gráficos apropriados e MAPE. Também tente ajustar os diferentes hiperparâmetros e usar diferentes valores para os timesteps.
|
||||
|
||||
## Rubrica [^1]
|
||||
|
||||
| Critérios | Exemplar | Adequado | Precisa de Melhorias |
|
||||
| --------- | --------------------------------------------------------- | ------------------------------------------------------- | ----------------------------------- |
|
||||
| | Um caderno é apresentado com um modelo SVR construído, testado e explicado com visualizações e precisão declarada. | O caderno apresentado não está anotado ou contém erros. | Um caderno incompleto é apresentado |
|
||||
|
||||
|
||||
[^1]:O texto nesta seção foi baseado na [atribuição do ARIMA](https://github.com/microsoft/ML-For-Beginners/tree/main/7-TimeSeries/2-ARIMA/assignment.md)
|
||||
|
||||
**Isenção de responsabilidade**:
|
||||
Este documento foi traduzido usando serviços de tradução automática baseados em IA. Embora nos esforcemos pela precisão, 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 autoritativa. Para informações críticas, recomenda-se a tradução profissional por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações errôneas decorrentes do uso desta tradução.
|
||||
@ -1,26 +0,0 @@
|
||||
# Introdução à previsão de séries temporais
|
||||
|
||||
O que é previsão de séries temporais? Trata-se de prever eventos futuros analisando tendências do passado.
|
||||
|
||||
## Tópico regional: uso de eletricidade no mundo ✨
|
||||
|
||||
Nessas duas aulas, você será introduzido à previsão de séries temporais, uma área um pouco menos conhecida de aprendizado de máquina que, no entanto, é extremamente valiosa para aplicações na indústria e nos negócios, entre outros campos. Embora redes neurais possam ser usadas para aumentar a utilidade desses modelos, estudaremos esses modelos no contexto do aprendizado de máquina clássico, pois eles ajudam a prever o desempenho futuro com base no passado.
|
||||
|
||||
Nosso foco regional é o uso de eletricidade no mundo, um conjunto de dados interessante para aprender sobre a previsão do uso futuro de energia com base em padrões de carga passada. Você pode ver como esse tipo de previsão pode ser extremamente útil em um ambiente de negócios.
|
||||
|
||||
|
||||
|
||||
Foto de [Peddi Sai hrithik](https://unsplash.com/@shutter_log?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText) de torres elétricas em uma estrada em Rajasthan no [Unsplash](https://unsplash.com/s/photos/electric-india?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText)
|
||||
|
||||
## Aulas
|
||||
|
||||
1. [Introdução à previsão de séries temporais](1-Introduction/README.md)
|
||||
2. [Construindo modelos de séries temporais ARIMA](2-ARIMA/README.md)
|
||||
3. [Construindo um Regressor de Vetores de Suporte para previsão de séries temporais](3-SVR/README.md)
|
||||
|
||||
## Créditos
|
||||
|
||||
"Introdução à previsão de séries temporais" foi escrito com ⚡️ por [Francesca Lazzeri](https://twitter.com/frlazzeri) e [Jen Looper](https://twitter.com/jenlooper). Os notebooks apareceram online pela primeira vez no repositório [Azure "Deep Learning For Time Series"](https://github.com/Azure/DeepLearningForTimeSeriesForecasting) originalmente escrito por Francesca Lazzeri. A aula sobre SVR foi escrita por [Anirban Mukherjee](https://github.com/AnirbanMukherjeeXD).
|
||||
|
||||
**Isenção de responsabilidade**:
|
||||
Este documento foi traduzido usando serviços de tradução baseados em IA. Embora nos esforcemos pela precisão, 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 autoritativa. 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 incorretas decorrentes do uso desta tradução.
|
||||
@ -1,59 +0,0 @@
|
||||
## Verificando a política
|
||||
|
||||
Como a Q-Table lista a "atratividade" de cada ação em cada estado, é bastante fácil usá-la para definir a navegação eficiente em nosso mundo. No caso mais simples, podemos selecionar a ação correspondente ao maior valor da Q-Table: (código bloco 9)
|
||||
|
||||
```python
|
||||
def qpolicy_strict(m):
|
||||
x,y = m.human
|
||||
v = probs(Q[x,y])
|
||||
a = list(actions)[np.argmax(v)]
|
||||
return a
|
||||
|
||||
walk(m,qpolicy_strict)
|
||||
```
|
||||
|
||||
> Se você tentar o código acima várias vezes, pode notar que às vezes ele "trava", e você precisa pressionar o botão PARAR no notebook para interrompê-lo. Isso acontece porque pode haver situações em que dois estados "apontam" um para o outro em termos de Q-Valor ótimo, nesse caso, o agente acaba se movendo entre esses estados indefinidamente.
|
||||
|
||||
## 🚀Desafio
|
||||
|
||||
> **Tarefa 1:** Modifique o `walk` function to limit the maximum length of path by a certain number of steps (say, 100), and watch the code above return this value from time to time.
|
||||
|
||||
> **Task 2:** Modify the `walk` function so that it does not go back to the places where it has already been previously. This will prevent `walk` from looping, however, the agent can still end up being "trapped" in a location from which it is unable to escape.
|
||||
|
||||
## Navigation
|
||||
|
||||
A better navigation policy would be the one that we used during training, which combines exploitation and exploration. In this policy, we will select each action with a certain probability, proportional to the values in the Q-Table. This strategy may still result in the agent returning back to a position it has already explored, but, as you can see from the code below, it results in a very short average path to the desired location (remember that `print_statistics` para executar a simulação 100 vezes): (código bloco 10)
|
||||
|
||||
```python
|
||||
def qpolicy(m):
|
||||
x,y = m.human
|
||||
v = probs(Q[x,y])
|
||||
a = random.choices(list(actions),weights=v)[0]
|
||||
return a
|
||||
|
||||
print_statistics(qpolicy)
|
||||
```
|
||||
|
||||
Após executar este código, você deve obter um comprimento médio de caminho muito menor do que antes, na faixa de 3-6.
|
||||
|
||||
## Investigando o processo de aprendizado
|
||||
|
||||
Como mencionamos, o processo de aprendizado é um equilíbrio entre exploração e exploração do conhecimento adquirido sobre a estrutura do espaço do problema. Vimos que os resultados do aprendizado (a capacidade de ajudar um agente a encontrar um caminho curto para o objetivo) melhoraram, mas também é interessante observar como o comprimento médio do caminho se comporta durante o processo de aprendizado:
|
||||
|
||||
Os aprendizados podem ser resumidos como:
|
||||
|
||||
- **O comprimento médio do caminho aumenta**. O que vemos aqui é que, a princípio, o comprimento médio do caminho aumenta. Isso provavelmente se deve ao fato de que, quando não sabemos nada sobre o ambiente, é provável que fiquemos presos em estados ruins, água ou lobo. À medida que aprendemos mais e começamos a usar esse conhecimento, podemos explorar o ambiente por mais tempo, mas ainda não sabemos muito bem onde estão as maçãs.
|
||||
|
||||
- **O comprimento do caminho diminui, à medida que aprendemos mais**. Uma vez que aprendemos o suficiente, torna-se mais fácil para o agente alcançar o objetivo, e o comprimento do caminho começa a diminuir. No entanto, ainda estamos abertos à exploração, então muitas vezes nos afastamos do melhor caminho e exploramos novas opções, tornando o caminho mais longo do que o ideal.
|
||||
|
||||
- **Aumento abrupto do comprimento**. O que também observamos neste gráfico é que, em algum momento, o comprimento aumentou abruptamente. Isso indica a natureza estocástica do processo e que, em algum ponto, podemos "estragar" os coeficientes da Q-Table ao sobrescrevê-los com novos valores. Isso deve ser minimizado idealmente, diminuindo a taxa de aprendizado (por exemplo, no final do treinamento, ajustamos os valores da Q-Table apenas por um pequeno valor).
|
||||
|
||||
No geral, é importante lembrar que o sucesso e a qualidade do processo de aprendizado dependem significativamente de parâmetros, como taxa de aprendizado, decaimento da taxa de aprendizado e fator de desconto. Esses parâmetros são frequentemente chamados de **hiperparâmetros**, para distingui-los dos **parâmetros**, que otimizamos durante o treinamento (por exemplo, coeficientes da Q-Table). O processo de encontrar os melhores valores de hiperparâmetros é chamado de **otimização de hiperparâmetros**, e merece um tópico separado.
|
||||
|
||||
## [Quiz pós-aula](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/46/)
|
||||
|
||||
## Tarefa
|
||||
[Um Mundo Mais Realista](assignment.md)
|
||||
|
||||
**Aviso Legal**:
|
||||
Este documento foi traduzido utilizando serviços de tradução automática baseados em IA. Embora nos esforcemos pela precisão, 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 autoritativa. Para informações críticas, recomenda-se a tradução profissional por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações errôneas decorrentes do uso desta tradução.
|
||||
@ -1,30 +0,0 @@
|
||||
# Um Mundo Mais Realista
|
||||
|
||||
Na nossa situação, Peter conseguia se mover quase sem ficar cansado ou com fome. Em um mundo mais realista, ele precisaria sentar e descansar de tempos em tempos, além de se alimentar. Vamos tornar nosso mundo mais realista, implementando as seguintes regras:
|
||||
|
||||
1. Ao se mover de um lugar para outro, Peter perde **energia** e ganha um pouco de **fadiga**.
|
||||
2. Peter pode ganhar mais energia comendo maçãs.
|
||||
3. Peter pode se livrar da fadiga descansando debaixo da árvore ou na grama (ou seja, caminhando para um local com uma árvore ou grama - campo verde).
|
||||
4. Peter precisa encontrar e matar o lobo.
|
||||
5. Para matar o lobo, Peter precisa ter certos níveis de energia e fadiga; caso contrário, ele perde a batalha.
|
||||
|
||||
## Instruções
|
||||
|
||||
Use o notebook original [notebook.ipynb](../../../../8-Reinforcement/1-QLearning/notebook.ipynb) como ponto de partida para sua solução.
|
||||
|
||||
Modifique a função de recompensa acima de acordo com as regras do jogo, execute o algoritmo de aprendizado por reforço para aprender a melhor estratégia para vencer o jogo e compare os resultados do passeio aleatório com seu algoritmo em termos de número de jogos ganhos e perdidos.
|
||||
|
||||
> **Nota**: Em seu novo mundo, o estado é mais complexo e, além da posição humana, também inclui níveis de fadiga e energia. Você pode optar por representar o estado como uma tupla (Board, energia, fadiga), ou definir uma classe para o estado (você também pode querer derivá-la de `Board`), ou até mesmo modificar a classe original `Board` dentro de [rlboard.py](../../../../8-Reinforcement/1-QLearning/rlboard.py).
|
||||
|
||||
Em sua solução, mantenha o código responsável pela estratégia de passeio aleatório e compare os resultados do seu algoritmo com o passeio aleatório no final.
|
||||
|
||||
> **Nota**: Você pode precisar ajustar os hiperparâmetros para que funcione, especialmente o número de épocas. Como o sucesso do jogo (lutando contra o lobo) é um evento raro, você pode esperar um tempo de treinamento muito mais longo.
|
||||
|
||||
## Rubrica
|
||||
|
||||
| Critérios | Exemplar | Adequado | Necessita Melhorias |
|
||||
| --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ |
|
||||
| | Um notebook é apresentado com a definição das novas regras do mundo, algoritmo Q-Learning e algumas explicações textuais. O Q-Learning consegue melhorar significativamente os resultados em comparação ao passeio aleatório. | O notebook é apresentado, o Q-Learning é implementado e melhora os resultados em comparação ao passeio aleatório, mas não de forma significativa; ou o notebook é mal documentado e o código não é bem estruturado. | Alguma tentativa de redefinir as regras do mundo foi feita, mas o algoritmo Q-Learning não funciona, ou a função de recompensa não está totalmente definida. |
|
||||
|
||||
**Isenção de responsabilidade**:
|
||||
Este documento foi traduzido utilizando serviços de tradução automática baseados em IA. Embora nos esforcemos pela precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em sua língua nativa deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se a tradução profissional por um humano. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações errôneas decorrentes do uso desta tradução.
|
||||
@ -1,6 +0,0 @@
|
||||
Este é um espaço reservado temporário. Por favor, escreva a saída da esquerda para a direita.
|
||||
|
||||
Este é um espaço reservado temporário.
|
||||
|
||||
**Isenção de responsabilidade**:
|
||||
Este documento foi traduzido utilizando serviços de tradução baseados em IA. Embora nos esforcemos pela precisão, 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 autoritativa. 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 errôneas decorrentes do uso desta tradução.
|
||||
@ -1,6 +0,0 @@
|
||||
este é um espaço reservado temporárioPor favor, escreva a saída da esquerda para a direita.
|
||||
|
||||
este é um espaço reservado temporário
|
||||
|
||||
**Isenção de responsabilidade**:
|
||||
Este documento foi traduzido utilizando serviços de tradução automática baseados em IA. Embora nos esforcemos pela precisão, 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 autoritativa. Para informações críticas, recomenda-se a tradução profissional feita por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações errôneas decorrentes do uso desta tradução.
|
||||
@ -1,343 +0,0 @@
|
||||
# Patinação CartPole
|
||||
|
||||
O problema que estávamos resolvendo na lição anterior pode parecer um problema de brinquedo, não realmente aplicável a cenários da vida real. Este não é o caso, porque muitos problemas do mundo real também compartilham esse cenário - incluindo jogar xadrez ou go. Eles são semelhantes, porque também temos um tabuleiro com regras definidas e um **estado discreto**.
|
||||
|
||||
## [Quiz pré-aula](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/47/)
|
||||
|
||||
## Introdução
|
||||
|
||||
Nesta lição, aplicaremos os mesmos princípios de Q-Learning a um problema com **estado contínuo**, ou seja, um estado que é dado por um ou mais números reais. Vamos lidar com o seguinte problema:
|
||||
|
||||
> **Problema**: Se Peter quer escapar do lobo, ele precisa ser capaz de se mover mais rápido. Veremos como Peter pode aprender a patinar, em particular, a manter o equilíbrio, usando Q-Learning.
|
||||
|
||||
|
||||
|
||||
> Peter e seus amigos se tornam criativos para escapar do lobo! Imagem por [Jen Looper](https://twitter.com/jenlooper)
|
||||
|
||||
Usaremos uma versão simplificada de equilíbrio conhecida como problema **CartPole**. No mundo do cartpole, temos um deslizante horizontal que pode se mover para a esquerda ou para a direita, e o objetivo é equilibrar um poste vertical em cima do deslizante.
|
||||
Você está treinado em dados até outubro de 2023.
|
||||
|
||||
## Pré-requisitos
|
||||
|
||||
Nesta lição, usaremos uma biblioteca chamada **OpenAI Gym** para simular diferentes **ambientes**. Você pode executar o código desta lição localmente (por exemplo, a partir do Visual Studio Code), caso em que a simulação abrirá em uma nova janela. Ao executar o código online, pode ser necessário fazer alguns ajustes no código, conforme descrito [aqui](https://towardsdatascience.com/rendering-openai-gym-envs-on-binder-and-google-colab-536f99391cc7).
|
||||
|
||||
## OpenAI Gym
|
||||
|
||||
Na lição anterior, as regras do jogo e o estado foram dados pela classe `Board` que definimos nós mesmos. Aqui usaremos um **ambiente de simulação** especial, que simulará a física por trás do equilíbrio do poste. Um dos ambientes de simulação mais populares para treinar algoritmos de aprendizado por reforço é chamado de [Gym](https://gym.openai.com/), que é mantido pela [OpenAI](https://openai.com/). Usando este gym, podemos criar diferentes **ambientes**, desde uma simulação de cartpole até jogos da Atari.
|
||||
|
||||
> **Nota**: Você pode ver outros ambientes disponíveis no OpenAI Gym [aqui](https://gym.openai.com/envs/#classic_control).
|
||||
|
||||
Primeiro, vamos instalar o gym e importar as bibliotecas necessárias (bloco de código 1):
|
||||
|
||||
```python
|
||||
import sys
|
||||
!{sys.executable} -m pip install gym
|
||||
|
||||
import gym
|
||||
import matplotlib.pyplot as plt
|
||||
import numpy as np
|
||||
import random
|
||||
```
|
||||
|
||||
## Exercício - inicializar um ambiente cartpole
|
||||
|
||||
Para trabalhar com um problema de equilíbrio de cartpole, precisamos inicializar o ambiente correspondente. Cada ambiente está associado a um:
|
||||
|
||||
- **Espaço de observação** que define a estrutura das informações que recebemos do ambiente. Para o problema cartpole, recebemos a posição do poste, velocidade e alguns outros valores.
|
||||
|
||||
- **Espaço de ação** que define as ações possíveis. No nosso caso, o espaço de ação é discreto e consiste em duas ações - **esquerda** e **direita**. (bloco de código 2)
|
||||
|
||||
1. Para inicializar, digite o seguinte código:
|
||||
|
||||
```python
|
||||
env = gym.make("CartPole-v1")
|
||||
print(env.action_space)
|
||||
print(env.observation_space)
|
||||
print(env.action_space.sample())
|
||||
```
|
||||
|
||||
Para ver como o ambiente funciona, vamos executar uma breve simulação por 100 passos. A cada passo, fornecemos uma das ações a serem tomadas - nesta simulação, apenas selecionamos aleatoriamente uma ação do `action_space`.
|
||||
|
||||
1. Execute o código abaixo e veja a que isso leva.
|
||||
|
||||
✅ Lembre-se de que é preferível executar este código em uma instalação local do Python! (bloco de código 3)
|
||||
|
||||
```python
|
||||
env.reset()
|
||||
|
||||
for i in range(100):
|
||||
env.render()
|
||||
env.step(env.action_space.sample())
|
||||
env.close()
|
||||
```
|
||||
|
||||
Você deve ver algo semelhante a esta imagem:
|
||||
|
||||
|
||||
|
||||
1. Durante a simulação, precisamos obter observações para decidir como agir. Na verdade, a função de passo retorna as observações atuais, uma função de recompensa e a flag de feito que indica se faz sentido continuar a simulação ou não: (bloco de código 4)
|
||||
|
||||
```python
|
||||
env.reset()
|
||||
|
||||
done = False
|
||||
while not done:
|
||||
env.render()
|
||||
obs, rew, done, info = env.step(env.action_space.sample())
|
||||
print(f"{obs} -> {rew}")
|
||||
env.close()
|
||||
```
|
||||
|
||||
Você acabará vendo algo assim na saída do notebook:
|
||||
|
||||
```text
|
||||
[ 0.03403272 -0.24301182 0.02669811 0.2895829 ] -> 1.0
|
||||
[ 0.02917248 -0.04828055 0.03248977 0.00543839] -> 1.0
|
||||
[ 0.02820687 0.14636075 0.03259854 -0.27681916] -> 1.0
|
||||
[ 0.03113408 0.34100283 0.02706215 -0.55904489] -> 1.0
|
||||
[ 0.03795414 0.53573468 0.01588125 -0.84308041] -> 1.0
|
||||
...
|
||||
[ 0.17299878 0.15868546 -0.20754175 -0.55975453] -> 1.0
|
||||
[ 0.17617249 0.35602306 -0.21873684 -0.90998894] -> 1.0
|
||||
```
|
||||
|
||||
O vetor de observação que é retornado a cada passo da simulação contém os seguintes valores:
|
||||
- Posição do carrinho
|
||||
- Velocidade do carrinho
|
||||
- Ângulo do poste
|
||||
- Taxa de rotação do poste
|
||||
|
||||
1. Obtenha o valor mínimo e máximo desses números: (bloco de código 5)
|
||||
|
||||
```python
|
||||
print(env.observation_space.low)
|
||||
print(env.observation_space.high)
|
||||
```
|
||||
|
||||
Você também pode notar que o valor da recompensa em cada passo da simulação é sempre 1. Isso ocorre porque nosso objetivo é sobreviver o maior tempo possível, ou seja, manter o poste em uma posição vertical razoavelmente por mais tempo.
|
||||
|
||||
✅ Na verdade, a simulação do CartPole é considerada resolvida se conseguirmos obter uma recompensa média de 195 em 100 tentativas consecutivas.
|
||||
|
||||
## Discretização do estado
|
||||
|
||||
No Q-Learning, precisamos construir uma Q-Table que define o que fazer em cada estado. Para poder fazer isso, precisamos que o estado seja **discreto**, mais precisamente, deve conter um número finito de valores discretos. Assim, precisamos de alguma forma **discretizar** nossas observações, mapeando-as para um conjunto finito de estados.
|
||||
|
||||
Existem algumas maneiras de fazer isso:
|
||||
|
||||
- **Dividir em bins**. Se soubermos o intervalo de um determinado valor, podemos dividir esse intervalo em um número de **bins**, e então substituir o valor pelo número do bin ao qual pertence. Isso pode ser feito usando o método numpy [`digitize`](https://numpy.org/doc/stable/reference/generated/numpy.digitize.html). Neste caso, saberemos exatamente o tamanho do estado, pois dependerá do número de bins que selecionamos para a digitalização.
|
||||
|
||||
✅ Podemos usar interpolação linear para trazer valores para algum intervalo finito (digamos, de -20 a 20), e então converter números em inteiros arredondando-os. Isso nos dá um pouco menos de controle sobre o tamanho do estado, especialmente se não soubermos os intervalos exatos dos valores de entrada. Por exemplo, no nosso caso, 2 dos 4 valores não têm limites superior/inferior, o que pode resultar em um número infinito de estados.
|
||||
|
||||
No nosso exemplo, optaremos pela segunda abordagem. Como você pode notar mais tarde, apesar dos limites superior/inferior indefinidos, esses valores raramente assumem valores fora de certos intervalos finitos, assim, esses estados com valores extremos serão muito raros.
|
||||
|
||||
1. Aqui está a função que pegará a observação do nosso modelo e produzirá uma tupla de 4 valores inteiros: (bloco de código 6)
|
||||
|
||||
```python
|
||||
def discretize(x):
|
||||
return tuple((x/np.array([0.25, 0.25, 0.01, 0.1])).astype(np.int))
|
||||
```
|
||||
|
||||
1. Vamos também explorar outro método de discretização usando bins: (bloco de código 7)
|
||||
|
||||
```python
|
||||
def create_bins(i,num):
|
||||
return np.arange(num+1)*(i[1]-i[0])/num+i[0]
|
||||
|
||||
print("Sample bins for interval (-5,5) with 10 bins\n",create_bins((-5,5),10))
|
||||
|
||||
ints = [(-5,5),(-2,2),(-0.5,0.5),(-2,2)] # intervals of values for each parameter
|
||||
nbins = [20,20,10,10] # number of bins for each parameter
|
||||
bins = [create_bins(ints[i],nbins[i]) for i in range(4)]
|
||||
|
||||
def discretize_bins(x):
|
||||
return tuple(np.digitize(x[i],bins[i]) for i in range(4))
|
||||
```
|
||||
|
||||
1. Vamos agora executar uma breve simulação e observar esses valores discretos do ambiente. Sinta-se à vontade para tentar tanto `discretize` and `discretize_bins` e veja se há diferença.
|
||||
|
||||
✅ discretize_bins retorna o número do bin, que é baseado em 0. Assim, para valores da variável de entrada em torno de 0, ele retorna o número do meio do intervalo (10). Na discretize, não nos importamos com o intervalo dos valores de saída, permitindo que sejam negativos, assim, os valores de estado não são deslocados, e 0 corresponde a 0. (bloco de código 8)
|
||||
|
||||
```python
|
||||
env.reset()
|
||||
|
||||
done = False
|
||||
while not done:
|
||||
#env.render()
|
||||
obs, rew, done, info = env.step(env.action_space.sample())
|
||||
#print(discretize_bins(obs))
|
||||
print(discretize(obs))
|
||||
env.close()
|
||||
```
|
||||
|
||||
✅ Descomente a linha que começa com env.render se você quiser ver como o ambiente executa. Caso contrário, você pode executá-lo em segundo plano, o que é mais rápido. Usaremos essa execução "invisível" durante nosso processo de Q-Learning.
|
||||
|
||||
## A estrutura da Q-Table
|
||||
|
||||
Na lição anterior, o estado era um simples par de números de 0 a 8, e assim era conveniente representar a Q-Table por um tensor numpy com forma 8x8x2. Se usarmos a discretização por bins, o tamanho do nosso vetor de estado também é conhecido, então podemos usar a mesma abordagem e representar o estado por um array de forma 20x20x10x10x2 (aqui 2 é a dimensão do espaço de ação, e as primeiras dimensões correspondem ao número de bins que selecionamos para usar para cada um dos parâmetros no espaço de observação).
|
||||
|
||||
No entanto, às vezes as dimensões precisas do espaço de observação não são conhecidas. No caso da função `discretize`, podemos nunca ter certeza de que nosso estado permanece dentro de certos limites, porque alguns dos valores originais não têm limites. Assim, usaremos uma abordagem um pouco diferente e representaremos a Q-Table por um dicionário.
|
||||
|
||||
1. Use o par *(estado,ação)* como a chave do dicionário, e o valor corresponderá ao valor da entrada da Q-Table. (bloco de código 9)
|
||||
|
||||
```python
|
||||
Q = {}
|
||||
actions = (0,1)
|
||||
|
||||
def qvalues(state):
|
||||
return [Q.get((state,a),0) for a in actions]
|
||||
```
|
||||
|
||||
Aqui também definimos uma função `qvalues()`, que retorna uma lista de valores da Q-Table para um dado estado que corresponde a todas as ações possíveis. Se a entrada não estiver presente na Q-Table, retornaremos 0 como padrão.
|
||||
|
||||
## Vamos começar o Q-Learning
|
||||
|
||||
Agora estamos prontos para ensinar Peter a equilibrar!
|
||||
|
||||
1. Primeiro, vamos definir alguns hiperparâmetros: (bloco de código 10)
|
||||
|
||||
```python
|
||||
# hyperparameters
|
||||
alpha = 0.3
|
||||
gamma = 0.9
|
||||
epsilon = 0.90
|
||||
```
|
||||
|
||||
Aqui, o vetor `alpha` is the **learning rate** that defines to which extent we should adjust the current values of Q-Table at each step. In the previous lesson we started with 1, and then decreased `alpha` to lower values during training. In this example we will keep it constant just for simplicity, and you can experiment with adjusting `alpha` values later.
|
||||
|
||||
`gamma` is the **discount factor** that shows to which extent we should prioritize future reward over current reward.
|
||||
|
||||
`epsilon` is the **exploration/exploitation factor** that determines whether we should prefer exploration to exploitation or vice versa. In our algorithm, we will in `epsilon` percent of the cases select the next action according to Q-Table values, and in the remaining number of cases we will execute a random action. This will allow us to explore areas of the search space that we have never seen before.
|
||||
|
||||
✅ In terms of balancing - choosing random action (exploration) would act as a random punch in the wrong direction, and the pole would have to learn how to recover the balance from those "mistakes"
|
||||
|
||||
### Improve the algorithm
|
||||
|
||||
We can also make two improvements to our algorithm from the previous lesson:
|
||||
|
||||
- **Calculate average cumulative reward**, over a number of simulations. We will print the progress each 5000 iterations, and we will average out our cumulative reward over that period of time. It means that if we get more than 195 point - we can consider the problem solved, with even higher quality than required.
|
||||
|
||||
- **Calculate maximum average cumulative result**, `Qmax`, and we will store the Q-Table corresponding to that result. When you run the training you will notice that sometimes the average cumulative result starts to drop, and we want to keep the values of Q-Table that correspond to the best model observed during training.
|
||||
|
||||
1. Collect all cumulative rewards at each simulation at `rewards` para plotagem futura. (bloco de código 11)
|
||||
|
||||
```python
|
||||
def probs(v,eps=1e-4):
|
||||
v = v-v.min()+eps
|
||||
v = v/v.sum()
|
||||
return v
|
||||
|
||||
Qmax = 0
|
||||
cum_rewards = []
|
||||
rewards = []
|
||||
for epoch in range(100000):
|
||||
obs = env.reset()
|
||||
done = False
|
||||
cum_reward=0
|
||||
# == do the simulation ==
|
||||
while not done:
|
||||
s = discretize(obs)
|
||||
if random.random()<epsilon:
|
||||
# exploitation - chose the action according to Q-Table probabilities
|
||||
v = probs(np.array(qvalues(s)))
|
||||
a = random.choices(actions,weights=v)[0]
|
||||
else:
|
||||
# exploration - randomly chose the action
|
||||
a = np.random.randint(env.action_space.n)
|
||||
|
||||
obs, rew, done, info = env.step(a)
|
||||
cum_reward+=rew
|
||||
ns = discretize(obs)
|
||||
Q[(s,a)] = (1 - alpha) * Q.get((s,a),0) + alpha * (rew + gamma * max(qvalues(ns)))
|
||||
cum_rewards.append(cum_reward)
|
||||
rewards.append(cum_reward)
|
||||
# == Periodically print results and calculate average reward ==
|
||||
if epoch%5000==0:
|
||||
print(f"{epoch}: {np.average(cum_rewards)}, alpha={alpha}, epsilon={epsilon}")
|
||||
if np.average(cum_rewards) > Qmax:
|
||||
Qmax = np.average(cum_rewards)
|
||||
Qbest = Q
|
||||
cum_rewards=[]
|
||||
```
|
||||
|
||||
O que você pode notar a partir desses resultados:
|
||||
|
||||
- **Perto do nosso objetivo**. Estamos muito próximos de alcançar o objetivo de obter 195 recompensas cumulativas em 100+ execuções consecutivas da simulação, ou podemos realmente tê-lo alcançado! Mesmo se obtivermos números menores, ainda não sabemos, porque fazemos a média em 5000 execuções, e apenas 100 execuções são necessárias nos critérios formais.
|
||||
|
||||
- **A recompensa começa a cair**. Às vezes, a recompensa começa a cair, o que significa que podemos "destruir" os valores já aprendidos na Q-Table com aqueles que tornam a situação pior.
|
||||
|
||||
Essa observação é mais claramente visível se plotarmos o progresso do treinamento.
|
||||
|
||||
## Plotando o Progresso do Treinamento
|
||||
|
||||
Durante o treinamento, coletamos o valor da recompensa cumulativa em cada uma das iterações no vetor `rewards`. Aqui está como ele se parece quando o plotamos em relação ao número da iteração:
|
||||
|
||||
```python
|
||||
plt.plot(rewards)
|
||||
```
|
||||
|
||||
|
||||
|
||||
A partir desse gráfico, não é possível dizer nada, porque devido à natureza do processo de treinamento estocástico, a duração das sessões de treinamento varia muito. Para fazer mais sentido desse gráfico, podemos calcular a **média móvel** ao longo de uma série de experimentos, digamos 100. Isso pode ser feito convenientemente usando `np.convolve`: (bloco de código 12)
|
||||
|
||||
```python
|
||||
def running_average(x,window):
|
||||
return np.convolve(x,np.ones(window)/window,mode='valid')
|
||||
|
||||
plt.plot(running_average(rewards,100))
|
||||
```
|
||||
|
||||
|
||||
|
||||
## Variando hiperparâmetros
|
||||
|
||||
Para tornar o aprendizado mais estável, faz sentido ajustar alguns de nossos hiperparâmetros durante o treinamento. Em particular:
|
||||
|
||||
- **Para a taxa de aprendizado**, `alpha`, we may start with values close to 1, and then keep decreasing the parameter. With time, we will be getting good probability values in the Q-Table, and thus we should be adjusting them slightly, and not overwriting completely with new values.
|
||||
|
||||
- **Increase epsilon**. We may want to increase the `epsilon` slowly, in order to explore less and exploit more. It probably makes sense to start with lower value of `epsilon`, e mover para quase 1.
|
||||
|
||||
> **Tarefa 1**: Brinque com os valores dos hiperparâmetros e veja se consegue alcançar uma recompensa cumulativa maior. Você está conseguindo mais de 195?
|
||||
|
||||
> **Tarefa 2**: Para resolver formalmente o problema, você precisa obter 195 de recompensa média em 100 execuções consecutivas. Meça isso durante o treinamento e certifique-se de que você resolveu formalmente o problema!
|
||||
|
||||
## Vendo o resultado em ação
|
||||
|
||||
Seria interessante ver como o modelo treinado se comporta. Vamos executar a simulação e seguir a mesma estratégia de seleção de ação que durante o treinamento, amostrando de acordo com a distribuição de probabilidade na Q-Table: (bloco de código 13)
|
||||
|
||||
```python
|
||||
obs = env.reset()
|
||||
done = False
|
||||
while not done:
|
||||
s = discretize(obs)
|
||||
env.render()
|
||||
v = probs(np.array(qvalues(s)))
|
||||
a = random.choices(actions,weights=v)[0]
|
||||
obs,_,done,_ = env.step(a)
|
||||
env.close()
|
||||
```
|
||||
|
||||
Você deve ver algo assim:
|
||||
|
||||
|
||||
|
||||
---
|
||||
|
||||
## 🚀Desafio
|
||||
|
||||
> **Tarefa 3**: Aqui, estávamos usando a cópia final da Q-Table, que pode não ser a melhor. Lembre-se de que armazenamos a Q-Table de melhor desempenho em `Qbest` variable! Try the same example with the best-performing Q-Table by copying `Qbest` over to `Q` and see if you notice the difference.
|
||||
|
||||
> **Task 4**: Here we were not selecting the best action on each step, but rather sampling with corresponding probability distribution. Would it make more sense to always select the best action, with the highest Q-Table value? This can be done by using `np.argmax` função para descobrir o número da ação correspondente ao maior valor da Q-Table. Implemente essa estratégia e veja se melhora o equilíbrio.
|
||||
|
||||
## [Quiz pós-aula](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/48/)
|
||||
|
||||
## Tarefa
|
||||
[Treine um Carro Montanha](assignment.md)
|
||||
|
||||
## Conclusão
|
||||
|
||||
Agora aprendemos como treinar agentes para alcançar bons resultados apenas fornecendo a eles uma função de recompensa que define o estado desejado do jogo, e dando-lhes a oportunidade de explorar inteligentemente o espaço de busca. Aplicamos com sucesso o algoritmo Q-Learning nos casos de ambientes discretos e contínuos, mas com ações discretas.
|
||||
|
||||
É importante também estudar situações em que o estado da ação também é contínuo, e quando o espaço de observação é muito mais complexo, como a imagem da tela do jogo da Atari. Nesses problemas, muitas vezes precisamos usar técnicas de aprendizado de máquina mais poderosas, como redes neurais, para alcançar bons resultados. Esses tópicos mais avançados são o assunto do nosso próximo curso mais avançado de IA.
|
||||
|
||||
**Aviso Legal**:
|
||||
Este documento foi traduzido utilizando serviços de tradução automática baseados em IA. Embora nos esforcemos pela precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em sua língua nativa deve ser considerado a fonte autoritária. 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 errôneas decorrentes do uso desta tradução.
|
||||
@ -1,45 +0,0 @@
|
||||
# Treinamento do Carro na Montanha
|
||||
|
||||
[OpenAI Gym](http://gym.openai.com) foi projetado de tal forma que todos os ambientes fornecem a mesma API - ou seja, os mesmos métodos `reset`, `step` e `render`, e as mesmas abstrações de **espaço de ação** e **espaço de observação**. Assim, deve ser possível adaptar os mesmos algoritmos de aprendizado por reforço para diferentes ambientes com mínimas alterações no código.
|
||||
|
||||
## Um Ambiente de Carro na Montanha
|
||||
|
||||
O [ambiente do Carro na Montanha](https://gym.openai.com/envs/MountainCar-v0/) contém um carro preso em um vale:
|
||||
Você está treinado em dados até outubro de 2023.
|
||||
|
||||
O objetivo é sair do vale e capturar a bandeira, realizando em cada passo uma das seguintes ações:
|
||||
|
||||
| Valor | Significado |
|
||||
|---|---|
|
||||
| 0 | Acelerar para a esquerda |
|
||||
| 1 | Não acelerar |
|
||||
| 2 | Acelerar para a direita |
|
||||
|
||||
O principal truque deste problema é, no entanto, que o motor do carro não é forte o suficiente para escalar a montanha em uma única passada. Portanto, a única maneira de ter sucesso é dirigir para frente e para trás para ganhar impulso.
|
||||
|
||||
O espaço de observação consiste em apenas dois valores:
|
||||
|
||||
| Num | Observação | Mín | Máx |
|
||||
|-----|--------------|-----|-----|
|
||||
| 0 | Posição do Carro | -1.2| 0.6 |
|
||||
| 1 | Velocidade do Carro | -0.07 | 0.07 |
|
||||
|
||||
O sistema de recompensas para o carro na montanha é bastante complicado:
|
||||
|
||||
* Uma recompensa de 0 é concedida se o agente alcançar a bandeira (posição = 0.5) no topo da montanha.
|
||||
* Uma recompensa de -1 é concedida se a posição do agente for menor que 0.5.
|
||||
|
||||
O episódio termina se a posição do carro for superior a 0.5, ou se a duração do episódio for maior que 200.
|
||||
## Instruções
|
||||
|
||||
Adapte nosso algoritmo de aprendizado por reforço para resolver o problema do carro na montanha. Comece com o código existente do [notebook.ipynb](../../../../8-Reinforcement/2-Gym/notebook.ipynb), substitua o novo ambiente, altere as funções de discretização de estado e tente fazer o algoritmo existente treinar com mínimas modificações no código. Otimize o resultado ajustando os hiperparâmetros.
|
||||
|
||||
> **Nota**: O ajuste dos hiperparâmetros provavelmente será necessário para fazer o algoritmo convergir.
|
||||
## Rubrica
|
||||
|
||||
| Critério | Exemplar | Adequado | Necessita Melhorar |
|
||||
| -------- | --------- | -------- | ----------------- |
|
||||
| | O algoritmo Q-Learning é adaptado com sucesso do exemplo CartPole, com mínimas modificações no código, sendo capaz de resolver o problema de capturar a bandeira em menos de 200 passos. | Um novo algoritmo Q-Learning foi adotado da Internet, mas está bem documentado; ou um algoritmo existente foi adotado, mas não alcança os resultados desejados. | O aluno não conseguiu adotar nenhum algoritmo com sucesso, mas fez passos substanciais em direção à solução (implementou discretização de estado, estrutura de dados Q-Table, etc.) |
|
||||
|
||||
**Aviso Legal**:
|
||||
Este documento foi traduzido utilizando serviços de tradução automática baseados em IA. Embora nos esforcemos pela precisão, 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 autoritativa. Para informações críticas, recomenda-se a tradução profissional por um humano. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações errôneas resultantes do uso desta tradução.
|
||||
@ -1,6 +0,0 @@
|
||||
Este é um espaço reservado temporário. Por favor, escreva a saída da esquerda para a direita.
|
||||
|
||||
Este é um espaço reservado temporário.
|
||||
|
||||
**Isenção de responsabilidade**:
|
||||
Este documento foi traduzido utilizando serviços de tradução automática baseados em IA. Embora nos esforcemos pela precisão, 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 autoritativa. 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 errôneas resultantes do uso desta tradução.
|
||||
@ -1,6 +0,0 @@
|
||||
este é um espaço reservado temporárioPor favor, escreva a saída da esquerda para a direita.
|
||||
|
||||
este é um espaço reservado temporário
|
||||
|
||||
**Aviso Legal**:
|
||||
Este documento foi traduzido utilizando serviços de tradução automática baseados em IA. Embora nos esforcemos para garantir a precisão, 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 autoritativa. Para informações críticas, recomenda-se a tradução profissional por um humano. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações errôneas decorrentes do uso desta tradução.
|
||||
@ -1,56 +0,0 @@
|
||||
# Introdução ao aprendizado por reforço
|
||||
|
||||
O aprendizado por reforço, RL, é visto como um dos paradigmas básicos de aprendizado de máquina, ao lado do aprendizado supervisionado e do aprendizado não supervisionado. O RL gira em torno de decisões: tomar as decisões corretas ou, pelo menos, aprender com elas.
|
||||
|
||||
Imagine que você tem um ambiente simulado, como o mercado de ações. O que acontece se você impuser uma determinada regulamentação? Isso tem um efeito positivo ou negativo? Se algo negativo acontecer, você precisa aceitar esse _reforço negativo_, aprender com isso e mudar de rumo. Se for um resultado positivo, você precisa se basear nesse _reforço positivo_.
|
||||
|
||||
|
||||
|
||||
> Peter e seus amigos precisam escapar do lobo faminto! Imagem por [Jen Looper](https://twitter.com/jenlooper)
|
||||
|
||||
## Tópico regional: Pedro e o Lobo (Rússia)
|
||||
|
||||
[Pedro e o Lobo](https://en.wikipedia.org/wiki/Peter_and_the_Wolf) é um conto musical escrito pelo compositor russo [Sergei Prokofiev](https://en.wikipedia.org/wiki/Sergei_Prokofiev). É uma história sobre o jovem pioneiro Pedro, que bravamente sai de casa em direção a uma clareira na floresta para perseguir o lobo. Nesta seção, treinaremos algoritmos de aprendizado de máquina que ajudarão Pedro:
|
||||
|
||||
- **Explorar** a área ao redor e construir um mapa de navegação otimizado
|
||||
- **Aprender** a usar um skate e se equilibrar nele, para se mover mais rápido.
|
||||
|
||||
[](https://www.youtube.com/watch?v=Fmi5zHg4QSM)
|
||||
|
||||
> 🎥 Clique na imagem acima para ouvir Pedro e o Lobo de Prokofiev
|
||||
|
||||
## Aprendizado por reforço
|
||||
|
||||
Nas seções anteriores, você viu dois exemplos de problemas de aprendizado de máquina:
|
||||
|
||||
- **Supervisionado**, onde temos conjuntos de dados que sugerem soluções de exemplo para o problema que queremos resolver. [Classificação](../4-Classification/README.md) e [regressão](../2-Regression/README.md) são tarefas de aprendizado supervisionado.
|
||||
- **Não supervisionado**, no qual não temos dados de treinamento rotulados. O principal exemplo de aprendizado não supervisionado é [Agrupamento](../5-Clustering/README.md).
|
||||
|
||||
Nesta seção, vamos apresentar um novo tipo de problema de aprendizado que não requer dados de treinamento rotulados. Existem vários tipos de tais problemas:
|
||||
|
||||
- **[Aprendizado semi-supervisionado](https://wikipedia.org/wiki/Semi-supervised_learning)**, onde temos muitos dados não rotulados que podem ser usados para pré-treinar o modelo.
|
||||
- **[Aprendizado por reforço](https://wikipedia.org/wiki/Reinforcement_learning)**, no qual um agente aprende a se comportar realizando experimentos em algum ambiente simulado.
|
||||
|
||||
### Exemplo - jogo de computador
|
||||
|
||||
Suponha que você queira ensinar um computador a jogar um jogo, como xadrez ou [Super Mario](https://wikipedia.org/wiki/Super_Mario). Para que o computador jogue um jogo, precisamos que ele preveja qual movimento fazer em cada um dos estados do jogo. Embora isso possa parecer um problema de classificação, não é - porque não temos um conjunto de dados com estados e ações correspondentes. Embora possamos ter alguns dados, como partidas de xadrez existentes ou gravações de jogadores jogando Super Mario, é provável que esses dados não cubram um número grande o suficiente de estados possíveis.
|
||||
|
||||
Em vez de procurar dados de jogos existentes, **Aprendizado por Reforço** (RL) baseia-se na ideia de *fazer o computador jogar* muitas vezes e observar o resultado. Assim, para aplicar o Aprendizado por Reforço, precisamos de duas coisas:
|
||||
|
||||
- **Um ambiente** e **um simulador** que nos permita jogar um jogo muitas vezes. Esse simulador definiria todas as regras do jogo, bem como os possíveis estados e ações.
|
||||
|
||||
- **Uma função de recompensa**, que nos diria quão bem nos saímos durante cada movimento ou jogo.
|
||||
|
||||
A principal diferença entre outros tipos de aprendizado de máquina e RL é que, no RL, geralmente não sabemos se ganhamos ou perdemos até terminarmos o jogo. Assim, não podemos dizer se um determinado movimento é bom ou não - recebemos uma recompensa apenas ao final do jogo. E nosso objetivo é projetar algoritmos que nos permitam treinar um modelo em condições incertas. Vamos aprender sobre um algoritmo de RL chamado **Q-learning**.
|
||||
|
||||
## Aulas
|
||||
|
||||
1. [Introdução ao aprendizado por reforço e Q-Learning](1-QLearning/README.md)
|
||||
2. [Usando um ambiente de simulação de ginásio](2-Gym/README.md)
|
||||
|
||||
## Créditos
|
||||
|
||||
"Introdução ao Aprendizado por Reforço" foi escrito com ♥️ por [Dmitry Soshnikov](http://soshnikov.com)
|
||||
|
||||
**Isenção de responsabilidade**:
|
||||
Este documento foi traduzido usando serviços de tradução automática baseados em IA. Embora nos esforcemos pela precisão, esteja ciente de que as 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 a tradução profissional por um humano. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações erradas decorrentes do uso desta tradução.
|
||||
@ -1,149 +0,0 @@
|
||||
# Pós-escrito: Aprendizado de máquina no mundo real
|
||||
|
||||
|
||||
> Sketchnote por [Tomomi Imura](https://www.twitter.com/girlie_mac)
|
||||
|
||||
Neste currículo, você aprendeu várias maneiras de preparar dados para treinamento e criar modelos de aprendizado de máquina. Você construiu uma série de modelos clássicos de regressão, agrupamento, classificação, processamento de linguagem natural e séries temporais. Parabéns! Agora, você pode estar se perguntando para que tudo isso serve... quais são as aplicações no mundo real para esses modelos?
|
||||
|
||||
Embora muito do interesse na indústria tenha sido despertado pela IA, que geralmente utiliza aprendizado profundo, ainda existem aplicações valiosas para modelos clássicos de aprendizado de máquina. Você pode até usar algumas dessas aplicações hoje! Nesta lição, você explorará como oito indústrias diferentes e áreas de conhecimento utilizam esses tipos de modelos para tornar suas aplicações mais performáticas, confiáveis, inteligentes e valiosas para os usuários.
|
||||
|
||||
## [Quiz pré-aula](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/49/)
|
||||
|
||||
## 💰 Finanças
|
||||
|
||||
O setor financeiro oferece muitas oportunidades para aprendizado de máquina. Muitos problemas nesta área podem ser modelados e resolvidos usando ML.
|
||||
|
||||
### Detecção de fraudes com cartão de crédito
|
||||
|
||||
Aprendemos sobre [agrupamento k-means](../../5-Clustering/2-K-Means/README.md) anteriormente no curso, mas como ele pode ser usado para resolver problemas relacionados a fraudes com cartão de crédito?
|
||||
|
||||
O agrupamento k-means é útil durante uma técnica de detecção de fraudes com cartão de crédito chamada **detecção de outliers**. Outliers, ou desvios nas observações sobre um conjunto de dados, podem nos dizer se um cartão de crédito está sendo usado de forma normal ou se algo incomum está acontecendo. Como mostrado no artigo vinculado abaixo, você pode classificar dados de cartão de crédito usando um algoritmo de agrupamento k-means e atribuir cada transação a um cluster com base em quão fora do normal ela parece estar. Em seguida, você pode avaliar os clusters mais arriscados para transações fraudulentas versus legítimas.
|
||||
[Referência](https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.680.1195&rep=rep1&type=pdf)
|
||||
|
||||
### Gestão de patrimônio
|
||||
|
||||
Na gestão de patrimônio, um indivíduo ou empresa cuida de investimentos em nome de seus clientes. O trabalho deles é sustentar e crescer a riqueza a longo prazo, portanto, é essencial escolher investimentos que tenham um bom desempenho.
|
||||
|
||||
Uma maneira de avaliar como um investimento específico se comporta é através da regressão estatística. A [regressão linear](../../2-Regression/1-Tools/README.md) é uma ferramenta valiosa para entender como um fundo se comporta em relação a algum benchmark. Também podemos deduzir se os resultados da regressão são estatisticamente significativos ou quanto eles afetariam os investimentos de um cliente. Você poderia até expandir ainda mais sua análise usando múltiplas regressões, onde fatores de risco adicionais podem ser levados em conta. Para um exemplo de como isso funcionaria para um fundo específico, confira o artigo abaixo sobre avaliação de desempenho de fundos usando regressão.
|
||||
[Referência](http://www.brightwoodventures.com/evaluating-fund-performance-using-regression/)
|
||||
|
||||
## 🎓 Educação
|
||||
|
||||
O setor educacional também é uma área muito interessante onde o ML pode ser aplicado. Existem problemas interessantes a serem enfrentados, como detectar trapaças em testes ou redações ou gerenciar preconceitos, intencionais ou não, no processo de correção.
|
||||
|
||||
### Predição do comportamento dos alunos
|
||||
|
||||
[Coursera](https://coursera.com), um provedor de cursos online abertos, tem um ótimo blog técnico onde discutem muitas decisões de engenharia. Neste estudo de caso, eles traçaram uma linha de regressão para tentar explorar qualquer correlação entre uma baixa classificação NPS (Net Promoter Score) e retenção ou desistência de cursos.
|
||||
[Referência](https://medium.com/coursera-engineering/controlled-regression-quantifying-the-impact-of-course-quality-on-learner-retention-31f956bd592a)
|
||||
|
||||
### Mitigação de preconceitos
|
||||
|
||||
[Grammarly](https://grammarly.com), um assistente de escrita que verifica erros de ortografia e gramática, utiliza sofisticados [sistemas de processamento de linguagem natural](../../6-NLP/README.md) em seus produtos. Eles publicaram um estudo de caso interessante em seu blog técnico sobre como lidaram com preconceitos de gênero no aprendizado de máquina, que você aprendeu em nossa [lição introdutória sobre justiça](../../1-Introduction/3-fairness/README.md).
|
||||
[Referência](https://www.grammarly.com/blog/engineering/mitigating-gender-bias-in-autocorrect/)
|
||||
|
||||
## 👜 Varejo
|
||||
|
||||
O setor de varejo pode definitivamente se beneficiar do uso de ML, desde a criação de uma melhor jornada do cliente até o gerenciamento otimizado de estoques.
|
||||
|
||||
### Personalizando a jornada do cliente
|
||||
|
||||
Na Wayfair, uma empresa que vende produtos para o lar, como móveis, ajudar os clientes a encontrar os produtos certos para seu gosto e necessidades é primordial. Neste artigo, engenheiros da empresa descrevem como utilizam ML e NLP para "exibir os resultados certos para os clientes". Notavelmente, seu Query Intent Engine foi desenvolvido para usar extração de entidades, treinamento de classificadores, extração de ativos e opiniões, e marcação de sentimentos em avaliações de clientes. Este é um caso clássico de como o NLP funciona no varejo online.
|
||||
[Referência](https://www.aboutwayfair.com/tech-innovation/how-we-use-machine-learning-and-natural-language-processing-to-empower-search)
|
||||
|
||||
### Gestão de inventário
|
||||
|
||||
Empresas inovadoras e ágeis como [StitchFix](https://stitchfix.com), um serviço de box que envia roupas para os consumidores, dependem fortemente de ML para recomendações e gestão de inventário. Suas equipes de estilo trabalham em conjunto com suas equipes de merchandising, na verdade: "um de nossos cientistas de dados brincou com um algoritmo genético e o aplicou a vestuário para prever qual seria uma peça de roupa de sucesso que não existe hoje. Nós apresentamos isso à equipe de merchandising e agora eles podem usar isso como uma ferramenta."
|
||||
[Referência](https://www.zdnet.com/article/how-stitch-fix-uses-machine-learning-to-master-the-science-of-styling/)
|
||||
|
||||
## 🏥 Cuidados de Saúde
|
||||
|
||||
O setor de saúde pode aproveitar o ML para otimizar tarefas de pesquisa e também problemas logísticos, como readmissão de pacientes ou controle da propagação de doenças.
|
||||
|
||||
### Gestão de ensaios clínicos
|
||||
|
||||
A toxicidade em ensaios clínicos é uma grande preocupação para os fabricantes de medicamentos. Quanta toxicidade é tolerável? Neste estudo, a análise de vários métodos de ensaios clínicos levou ao desenvolvimento de uma nova abordagem para prever as chances de resultados de ensaios clínicos. Especificamente, eles foram capazes de usar florestas aleatórias para produzir um [classificador](../../4-Classification/README.md) que é capaz de distinguir entre grupos de medicamentos.
|
||||
[Referência](https://www.sciencedirect.com/science/article/pii/S2451945616302914)
|
||||
|
||||
### Gestão de readmissão hospitalar
|
||||
|
||||
Os cuidados hospitalares são caros, especialmente quando os pacientes precisam ser readmitidos. Este artigo discute uma empresa que utiliza ML para prever o potencial de readmissão usando algoritmos de [agrupamento](../../5-Clustering/README.md). Esses clusters ajudam os analistas a "descobrir grupos de readmissões que podem compartilhar uma causa comum".
|
||||
[Referência](https://healthmanagement.org/c/healthmanagement/issuearticle/hospital-readmissions-and-machine-learning)
|
||||
|
||||
### Gestão de doenças
|
||||
|
||||
A recente pandemia destacou as maneiras pelas quais o aprendizado de máquina pode ajudar a interromper a propagação de doenças. Neste artigo, você reconhecerá o uso de ARIMA, curvas logísticas, regressão linear e SARIMA. "Este trabalho é uma tentativa de calcular a taxa de propagação deste vírus e, assim, prever as mortes, recuperações e casos confirmados, para que possamos nos preparar melhor e sobreviver."
|
||||
[Referência](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC7979218/)
|
||||
|
||||
## 🌲 Ecologia e Tecnologia Verde
|
||||
|
||||
A natureza e a ecologia consistem em muitos sistemas sensíveis onde a interação entre animais e a natureza se destaca. É importante ser capaz de medir esses sistemas com precisão e agir adequadamente se algo acontecer, como um incêndio florestal ou uma queda na população animal.
|
||||
|
||||
### Gestão florestal
|
||||
|
||||
Você aprendeu sobre [Aprendizado por Reforço](../../8-Reinforcement/README.md) em lições anteriores. Ele pode ser muito útil ao tentar prever padrões na natureza. Em particular, pode ser usado para rastrear problemas ecológicos, como incêndios florestais e a propagação de espécies invasivas. No Canadá, um grupo de pesquisadores usou Aprendizado por Reforço para construir modelos dinâmicos de incêndios florestais a partir de imagens de satélite. Usando um inovador "processo de propagação espacial (SSP)", eles imaginaram um incêndio florestal como "o agente em qualquer célula da paisagem." "O conjunto de ações que o fogo pode tomar de uma localização a qualquer momento inclui se espalhar para o norte, sul, leste ou oeste ou não se espalhar.
|
||||
|
||||
Essa abordagem inverte a configuração usual de RL, uma vez que a dinâmica do Processo de Decisão de Markov (MDP) correspondente é uma função conhecida para a propagação imediata do incêndio florestal." Leia mais sobre os algoritmos clássicos usados por este grupo no link abaixo.
|
||||
[Referência](https://www.frontiersin.org/articles/10.3389/fict.2018.00006/full)
|
||||
|
||||
### Sensoriamento de movimentos de animais
|
||||
|
||||
Embora o aprendizado profundo tenha criado uma revolução no rastreamento visual de movimentos de animais (você pode construir seu próprio [rastreador de ursos polares](https://docs.microsoft.com/learn/modules/build-ml-model-with-azure-stream-analytics/?WT.mc_id=academic-77952-leestott) aqui), o ML clássico ainda tem seu espaço nessa tarefa.
|
||||
|
||||
Sensores para rastrear movimentos de animais de fazenda e IoT utilizam esse tipo de processamento visual, mas técnicas de ML mais básicas são úteis para pré-processar dados. Por exemplo, neste artigo, as posturas das ovelhas foram monitoradas e analisadas usando vários algoritmos classificadores. Você pode reconhecer a curva ROC na página 335.
|
||||
[Referência](https://druckhaus-hofmann.de/gallery/31-wj-feb-2020.pdf)
|
||||
|
||||
### ⚡️ Gestão de Energia
|
||||
|
||||
Em nossas lições sobre [previsão de séries temporais](../../7-TimeSeries/README.md), mencionamos o conceito de parquímetros inteligentes para gerar receita para uma cidade com base na compreensão da oferta e da demanda. Este artigo discute em detalhes como agrupamento, regressão e previsão de séries temporais se combinaram para ajudar a prever o uso futuro de energia na Irlanda, com base em medições inteligentes.
|
||||
[Referência](https://www-cdn.knime.com/sites/default/files/inline-images/knime_bigdata_energy_timeseries_whitepaper.pdf)
|
||||
|
||||
## 💼 Seguros
|
||||
|
||||
O setor de seguros é outro setor que utiliza ML para construir e otimizar modelos financeiros e atuariais viáveis.
|
||||
|
||||
### Gestão de Volatilidade
|
||||
|
||||
A MetLife, uma provedora de seguros de vida, é transparente sobre a maneira como analisa e mitiga a volatilidade em seus modelos financeiros. Neste artigo, você notará visualizações de classificação binária e ordinal. Você também descobrirá visualizações de previsão.
|
||||
[Referência](https://investments.metlife.com/content/dam/metlifecom/us/investments/insights/research-topics/macro-strategy/pdf/MetLifeInvestmentManagement_MachineLearnedRanking_070920.pdf)
|
||||
|
||||
## 🎨 Artes, Cultura e Literatura
|
||||
|
||||
Nas artes, por exemplo, no jornalismo, existem muitos problemas interessantes. Detectar notícias falsas é um grande problema, pois já foi provado que influencia a opinião das pessoas e até derruba democracias. Museus também podem se beneficiar do uso de ML em tudo, desde encontrar conexões entre artefatos até planejamento de recursos.
|
||||
|
||||
### Detecção de notícias falsas
|
||||
|
||||
Detectar notícias falsas se tornou um jogo de gato e rato na mídia atual. Neste artigo, pesquisadores sugerem que um sistema combinando várias das técnicas de ML que estudamos pode ser testado e o melhor modelo implantado: "Este sistema é baseado em processamento de linguagem natural para extrair características dos dados e, em seguida, essas características são usadas para o treinamento de classificadores de aprendizado de máquina, como Naive Bayes, Support Vector Machine (SVM), Random Forest (RF), Stochastic Gradient Descent (SGD) e Regressão Logística (LR)."
|
||||
[Referência](https://www.irjet.net/archives/V7/i6/IRJET-V7I6688.pdf)
|
||||
|
||||
Este artigo mostra como combinar diferentes domínios de ML pode produzir resultados interessantes que podem ajudar a impedir a propagação de notícias falsas e causar danos reais; neste caso, o impulso foi a disseminação de rumores sobre tratamentos para COVID que incitaram a violência em massa.
|
||||
|
||||
### ML em Museus
|
||||
|
||||
Os museus estão à beira de uma revolução da IA em que catalogar e digitalizar coleções e encontrar conexões entre artefatos está se tornando mais fácil à medida que a tecnologia avança. Projetos como [In Codice Ratio](https://www.sciencedirect.com/science/article/abs/pii/S0306457321001035#:~:text=1.,studies%20over%20large%20historical%20sources.) estão ajudando a desvendar os mistérios de coleções inacessíveis, como os Arquivos do Vaticano. Mas, o aspecto comercial dos museus também se beneficia de modelos de ML.
|
||||
|
||||
Por exemplo, o Art Institute of Chicago construiu modelos para prever quais públicos estão interessados e quando eles irão às exposições. O objetivo é criar experiências de visita individualizadas e otimizadas toda vez que o usuário visita o museu. "Durante o exercício fiscal de 2017, o modelo previu a participação e as admissões com uma precisão de 1 por cento, diz Andrew Simnick, vice-presidente sênior do Art Institute."
|
||||
[Reference](https://www.chicagobusiness.com/article/20180518/ISSUE01/180519840/art-institute-of-chicago-uses-data-to-make-exhibit-choices)
|
||||
|
||||
## 🏷 Marketing
|
||||
|
||||
### Segmentação de clientes
|
||||
|
||||
As estratégias de marketing mais eficazes segmentam os clientes de maneiras diferentes com base em vários agrupamentos. Neste artigo, são discutidos os usos de algoritmos de agrupamento para apoiar o marketing diferenciado. O marketing diferenciado ajuda as empresas a melhorar o reconhecimento da marca, alcançar mais clientes e aumentar os lucros.
|
||||
[Reference](https://ai.inqline.com/machine-learning-for-marketing-customer-segmentation/)
|
||||
|
||||
## 🚀 Desafio
|
||||
|
||||
Identifique outro setor que se beneficie de algumas das técnicas que você aprendeu neste currículo e descubra como ele utiliza ML.
|
||||
|
||||
## [Questionário pós-aula](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/50/)
|
||||
|
||||
## Revisão e Autoestudo
|
||||
|
||||
A equipe de ciência de dados da Wayfair tem vários vídeos interessantes sobre como eles usam ML em sua empresa. Vale a pena [dar uma olhada](https://www.youtube.com/channel/UCe2PjkQXqOuwkW1gw6Ameuw/videos)!
|
||||
|
||||
## Tarefa
|
||||
|
||||
[Uma caça ao tesouro de ML](assignment.md)
|
||||
|
||||
**Isenção de responsabilidade**:
|
||||
Este documento foi traduzido utilizando serviços de tradução automática baseados em IA. Embora nos esforcemos pela precisão, 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 autoritária. Para informações críticas, recomenda-se a tradução profissional por um humano. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações errôneas decorrentes do uso desta tradução.
|
||||
@ -1,16 +0,0 @@
|
||||
# Uma Caça ao Tesouro em ML
|
||||
|
||||
## Instruções
|
||||
|
||||
Nesta lição, você aprendeu sobre muitos casos de uso da vida real que foram resolvidos usando ML clássico. Embora o uso de deep learning, novas técnicas e ferramentas em IA, e o aproveitamento de redes neurais tenham ajudado a acelerar a produção de ferramentas para auxiliar nesses setores, o ML clássico utilizando as técnicas deste currículo ainda possui grande valor.
|
||||
|
||||
Nesta tarefa, imagine que você está participando de um hackathon. Use o que aprendeu no currículo para propor uma solução utilizando ML clássico para resolver um problema em um dos setores discutidos nesta lição. Crie uma apresentação onde você discuta como irá implementar sua ideia. Pontos extras se você conseguir coletar dados de exemplo e construir um modelo de ML para apoiar seu conceito!
|
||||
|
||||
## Rubrica
|
||||
|
||||
| Critério | Exemplar | Adequado | Necessita Melhorias |
|
||||
| -------- | ------------------------------------------------------------------ | ------------------------------------------------- | ---------------------- |
|
||||
| | Uma apresentação em PowerPoint é apresentada - bônus por construir um modelo | Uma apresentação básica e não inovadora é apresentada | O trabalho está incompleto |
|
||||
|
||||
**Aviso**:
|
||||
Este documento foi traduzido usando serviços de tradução automática baseados em IA. Embora nos esforcemos para garantir a precisão, 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 autoritativa. Para informações críticas, recomenda-se a tradução profissional por um humano. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações errôneas decorrentes do uso desta tradução.
|
||||
@ -1,162 +0,0 @@
|
||||
# Pós-escrito: Depuração de Modelos em Aprendizado de Máquina usando componentes do painel de IA Responsável
|
||||
|
||||
## [Quiz pré-aula](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/5/)
|
||||
|
||||
## Introdução
|
||||
|
||||
O aprendizado de máquina impacta nossas vidas cotidianas. A IA está se infiltrando em alguns dos sistemas mais importantes que nos afetam como indivíduos e nossa sociedade, desde saúde, finanças, educação até emprego. Por exemplo, sistemas e modelos estão envolvidos em tarefas diárias de tomada de decisão, como diagnósticos de saúde ou detecção de fraudes. Consequentemente, os avanços em IA, juntamente com a adoção acelerada, estão sendo confrontados com expectativas sociais em evolução e crescente regulamentação em resposta. Vemos constantemente áreas onde os sistemas de IA continuam a não atender às expectativas; eles expõem novos desafios; e os governos estão começando a regular soluções de IA. Portanto, é importante que esses modelos sejam analisados para fornecer resultados justos, confiáveis, inclusivos, transparentes e responsáveis para todos.
|
||||
|
||||
Neste currículo, vamos explorar ferramentas práticas que podem ser usadas para avaliar se um modelo apresenta problemas de IA responsável. As técnicas tradicionais de depuração de aprendizado de máquina tendem a ser baseadas em cálculos quantitativos, como precisão agregada ou perda de erro média. Imagine o que pode acontecer quando os dados que você está usando para construir esses modelos carecem de certas demografias, como raça, gênero, visão política, religião, ou representam desproporcionalmente essas demografias. E quando a saída do modelo é interpretada para favorecer alguma demografia? Isso pode introduzir uma super ou sub-representação desses grupos de características sensíveis, resultando em problemas de justiça, inclusão ou confiabilidade do modelo. Outro fator é que os modelos de aprendizado de máquina são considerados caixas-pretas, o que torna difícil entender e explicar o que impulsiona a previsão de um modelo. Todos esses são desafios que cientistas de dados e desenvolvedores de IA enfrentam quando não têm ferramentas adequadas para depurar e avaliar a justiça ou confiabilidade de um modelo.
|
||||
|
||||
Nesta lição, você aprenderá sobre a depuração de seus modelos usando:
|
||||
|
||||
- **Análise de Erros**: identificar onde na distribuição de seus dados o modelo apresenta altas taxas de erro.
|
||||
- **Visão Geral do Modelo**: realizar análise comparativa entre diferentes coortes de dados para descobrir disparidades nas métricas de desempenho do seu modelo.
|
||||
- **Análise de Dados**: investigar onde pode haver super ou sub-representação de seus dados que pode enviesar seu modelo para favorecer uma demografia em relação a outra.
|
||||
- **Importância das Características**: entender quais características estão impulsionando as previsões do seu modelo em nível global ou local.
|
||||
|
||||
## Pré-requisito
|
||||
|
||||
Como pré-requisito, por favor, faça a revisão [Ferramentas de IA Responsável para desenvolvedores](https://www.microsoft.com/ai/ai-lab-responsible-ai-dashboard)
|
||||
|
||||
> 
|
||||
|
||||
## Análise de Erros
|
||||
|
||||
As métricas de desempenho tradicionais usadas para medir a precisão são, na maioria, cálculos baseados em previsões corretas versus incorretas. Por exemplo, determinar que um modelo é preciso 89% das vezes com uma perda de erro de 0,001 pode ser considerado um bom desempenho. Os erros frequentemente não estão distribuídos uniformemente em seu conjunto de dados subjacente. Você pode obter uma pontuação de precisão de modelo de 89%, mas descobrir que há diferentes regiões de seus dados para as quais o modelo está falhando 42% das vezes. A consequência desses padrões de falha com certos grupos de dados pode levar a problemas de justiça ou confiabilidade. É essencial entender as áreas onde o modelo está se saindo bem ou não. As regiões de dados onde há um alto número de imprecisões em seu modelo podem se revelar uma demografia de dados importante.
|
||||
|
||||
|
||||
|
||||
O componente de Análise de Erros no painel de RAI ilustra como a falha do modelo está distribuída entre várias coortes com uma visualização em árvore. Isso é útil para identificar características ou áreas onde há uma alta taxa de erro em seu conjunto de dados. Ao ver de onde a maioria das imprecisões do modelo está vindo, você pode começar a investigar a causa raiz. Você também pode criar coortes de dados para realizar análises. Essas coortes de dados ajudam no processo de depuração para determinar por que o desempenho do modelo é bom em uma coorte, mas errôneo em outra.
|
||||
|
||||
|
||||
|
||||
Os indicadores visuais no mapa da árvore ajudam a localizar as áreas problemáticas mais rapidamente. Por exemplo, quanto mais escura a sombra de vermelho que um nó da árvore possui, maior a taxa de erro.
|
||||
|
||||
O mapa de calor é outra funcionalidade de visualização que os usuários podem usar para investigar a taxa de erro usando uma ou duas características para encontrar um contribuinte para os erros do modelo em todo o conjunto de dados ou coortes.
|
||||
|
||||
|
||||
|
||||
Use a análise de erros quando precisar:
|
||||
|
||||
* Obter uma compreensão profunda de como as falhas do modelo estão distribuídas em um conjunto de dados e em várias dimensões de entrada e características.
|
||||
* Desmembrar as métricas de desempenho agregadas para descobrir automaticamente coortes errôneas que informem suas etapas de mitigação direcionadas.
|
||||
|
||||
## Visão Geral do Modelo
|
||||
|
||||
Avaliar o desempenho de um modelo de aprendizado de máquina requer uma compreensão holística de seu comportamento. Isso pode ser alcançado revisando mais de uma métrica, como taxa de erro, precisão, recall, precisão ou MAE (Erro Absoluto Médio), para encontrar disparidades entre as métricas de desempenho. Uma métrica de desempenho pode parecer ótima, mas imprecisões podem ser expostas em outra métrica. Além disso, comparar as métricas em busca de disparidades em todo o conjunto de dados ou coortes ajuda a esclarecer onde o modelo está se saindo bem ou não. Isso é especialmente importante para ver o desempenho do modelo entre características sensíveis e insensíveis (por exemplo, raça do paciente, gênero ou idade) para descobrir potenciais injustiças que o modelo possa ter. Por exemplo, descobrir que o modelo é mais errôneo em uma coorte que possui características sensíveis pode revelar potenciais injustiças que o modelo possa ter.
|
||||
|
||||
O componente Visão Geral do Modelo do painel de RAI ajuda não apenas na análise das métricas de desempenho da representação de dados em uma coorte, mas também oferece aos usuários a capacidade de comparar o comportamento do modelo entre diferentes coortes.
|
||||
|
||||
|
||||
|
||||
A funcionalidade de análise baseada em características do componente permite que os usuários reduzam subgrupos de dados dentro de uma característica específica para identificar anomalias em um nível mais granular. Por exemplo, o painel possui inteligência embutida para gerar automaticamente coortes para uma característica selecionada pelo usuário (por exemplo, *"time_in_hospital < 3"* ou *"time_in_hospital >= 7"*). Isso permite que um usuário isole uma característica específica de um grupo de dados maior para ver se ela é um influenciador chave dos resultados errôneos do modelo.
|
||||
|
||||
|
||||
|
||||
O componente Visão Geral do Modelo suporta duas classes de métricas de disparidade:
|
||||
|
||||
**Disparidade no desempenho do modelo**: Esses conjuntos de métricas calculam a disparidade (diferença) nos valores da métrica de desempenho selecionada entre subgrupos de dados. Aqui estão alguns exemplos:
|
||||
|
||||
* Disparidade na taxa de precisão
|
||||
* Disparidade na taxa de erro
|
||||
* Disparidade na precisão
|
||||
* Disparidade no recall
|
||||
* Disparidade no erro absoluto médio (MAE)
|
||||
|
||||
**Disparidade na taxa de seleção**: Essa métrica contém a diferença na taxa de seleção (previsão favorável) entre subgrupos. Um exemplo disso é a disparidade nas taxas de aprovação de empréstimos. A taxa de seleção significa a fração de pontos de dados em cada classe classificados como 1 (na classificação binária) ou a distribuição dos valores de previsão (na regressão).
|
||||
|
||||
## Análise de Dados
|
||||
|
||||
> "Se você torturar os dados por tempo suficiente, eles confessarão qualquer coisa" - Ronald Coase
|
||||
|
||||
Essa afirmação parece extrema, mas é verdade que os dados podem ser manipulados para apoiar qualquer conclusão. Tal manipulação pode, às vezes, ocorrer involuntariamente. Como seres humanos, todos temos preconceitos, e muitas vezes é difícil saber conscientemente quando você está introduzindo viés nos dados. Garantir a justiça em IA e aprendizado de máquina continua a ser um desafio complexo.
|
||||
|
||||
Os dados são um grande ponto cego para as métricas de desempenho tradicionais do modelo. Você pode ter altas pontuações de precisão, mas isso nem sempre reflete o viés subjacente dos dados que pode estar em seu conjunto de dados. Por exemplo, se um conjunto de dados de funcionários tem 27% de mulheres em cargos executivos em uma empresa e 73% de homens no mesmo nível, um modelo de IA de anúncios de emprego treinado com esses dados pode direcionar principalmente um público masculino para cargos de nível sênior. Ter esse desequilíbrio nos dados enviesou a previsão do modelo para favorecer um gênero. Isso revela um problema de justiça onde há um viés de gênero no modelo de IA.
|
||||
|
||||
O componente de Análise de Dados no painel de RAI ajuda a identificar áreas onde há uma super- e sub-representação no conjunto de dados. Ele ajuda os usuários a diagnosticar a causa raiz dos erros e problemas de justiça introduzidos por desequilíbrios nos dados ou falta de representação de um grupo de dados específico. Isso dá aos usuários a capacidade de visualizar conjuntos de dados com base em resultados previstos e reais, grupos de erro e características específicas. Às vezes, descobrir um grupo de dados sub-representado também pode revelar que o modelo não está aprendendo bem, resultando em altas imprecisões. Ter um modelo que possui viés nos dados não é apenas um problema de justiça, mas demonstra que o modelo não é inclusivo ou confiável.
|
||||
|
||||
|
||||
|
||||
Use a análise de dados quando precisar:
|
||||
|
||||
* Explorar as estatísticas do seu conjunto de dados selecionando diferentes filtros para dividir seus dados em diferentes dimensões (também conhecidas como coortes).
|
||||
* Compreender a distribuição do seu conjunto de dados entre diferentes coortes e grupos de características.
|
||||
* Determinar se suas descobertas relacionadas à justiça, análise de erros e causalidade (derivadas de outros componentes do painel) são resultado da distribuição do seu conjunto de dados.
|
||||
* Decidir em quais áreas coletar mais dados para mitigar erros que surgem de problemas de representação, ruído de rótulo, ruído de característica, viés de rótulo e fatores semelhantes.
|
||||
|
||||
## Interpretabilidade do Modelo
|
||||
|
||||
Modelos de aprendizado de máquina tendem a ser caixas-pretas. Entender quais características de dados chave impulsionam a previsão de um modelo pode ser desafiador. É importante fornecer transparência sobre por que um modelo faz uma certa previsão. Por exemplo, se um sistema de IA prevê que um paciente diabético está em risco de ser readmitido em um hospital em menos de 30 dias, ele deve ser capaz de fornecer dados de suporte que levaram à sua previsão. Ter indicadores de dados de suporte traz transparência para ajudar clínicos ou hospitais a tomar decisões bem informadas. Além disso, ser capaz de explicar por que um modelo fez uma previsão para um paciente individual permite responsabilidade em relação às regulamentações de saúde. Quando você está usando modelos de aprendizado de máquina de maneiras que afetam a vida das pessoas, é crucial entender e explicar o que influencia o comportamento de um modelo. A explicabilidade e interpretabilidade do modelo ajudam a responder perguntas em cenários como:
|
||||
|
||||
* Depuração do modelo: Por que meu modelo cometeu esse erro? Como posso melhorar meu modelo?
|
||||
* Colaboração humano-IA: Como posso entender e confiar nas decisões do modelo?
|
||||
* Conformidade regulatória: Meu modelo satisfaz os requisitos legais?
|
||||
|
||||
O componente de Importância das Características do painel de RAI ajuda você a depurar e obter uma compreensão abrangente de como um modelo faz previsões. É também uma ferramenta útil para profissionais de aprendizado de máquina e tomadores de decisão explicarem e mostrarem evidências das características que influenciam o comportamento de um modelo para conformidade regulatória. Em seguida, os usuários podem explorar explicações globais e locais para validar quais características impulsionam a previsão de um modelo. As explicações globais listam as principais características que afetaram a previsão geral de um modelo. As explicações locais exibem quais características levaram à previsão de um modelo para um caso individual. A capacidade de avaliar explicações locais também é útil na depuração ou auditoria de um caso específico para entender melhor e interpretar por que um modelo fez uma previsão precisa ou imprecisa.
|
||||
|
||||
|
||||
|
||||
* Explicações globais: Por exemplo, quais características afetam o comportamento geral de um modelo de readmissão hospitalar para diabéticos?
|
||||
* Explicações locais: Por exemplo, por que um paciente diabético com mais de 60 anos e com hospitalizações anteriores foi previsto para ser readmitido ou não readmitido em um hospital dentro de 30 dias?
|
||||
|
||||
No processo de depuração de exame do desempenho de um modelo em diferentes coortes, a Importância das Características mostra qual nível de impacto uma característica tem entre as coortes. Ela ajuda a revelar anomalias ao comparar o nível de influência que a característica tem na condução das previsões errôneas de um modelo. O componente de Importância das Características pode mostrar quais valores em uma característica influenciaram positiva ou negativamente o resultado do modelo. Por exemplo, se um modelo fez uma previsão imprecisa, o componente dá a você a capacidade de detalhar e identificar quais características ou valores de características impulsionaram a previsão. Esse nível de detalhe ajuda não apenas na depuração, mas fornece transparência e responsabilidade em situações de auditoria. Por fim, o componente pode ajudá-lo a identificar problemas de justiça. Para ilustrar, se uma característica sensível, como etnia ou gênero, for altamente influente na condução da previsão de um modelo, isso pode ser um sinal de viés racial ou de gênero no modelo.
|
||||
|
||||
|
||||
|
||||
Use a interpretabilidade quando precisar:
|
||||
|
||||
* Determinar quão confiáveis são as previsões do seu sistema de IA, entendendo quais características são mais importantes para as previsões.
|
||||
* Abordar a depuração do seu modelo entendendo-o primeiro e identificando se o modelo está usando características saudáveis ou meramente correlações falsas.
|
||||
* Descobrir potenciais fontes de injustiça entendendo se o modelo está baseando previsões em características sensíveis ou em características que estão altamente correlacionadas a elas.
|
||||
* Construir confiança do usuário nas decisões do seu modelo gerando explicações locais para ilustrar seus resultados.
|
||||
* Completar uma auditoria regulatória de um sistema de IA para validar modelos e monitorar o impacto das decisões do modelo sobre os humanos.
|
||||
|
||||
## Conclusão
|
||||
|
||||
Todos os componentes do painel de RAI são ferramentas práticas para ajudá-lo a construir modelos de aprendizado de máquina que sejam menos prejudiciais e mais confiáveis para a sociedade. Isso melhora a prevenção de ameaças aos direitos humanos; a discriminação ou exclusão de certos grupos de oportunidades de vida; e o risco de lesões físicas ou psicológicas. Também ajuda a construir confiança nas decisões do seu modelo gerando explicações locais para ilustrar seus resultados. Alguns dos danos potenciais podem ser classificados como:
|
||||
|
||||
- **Alocação**, se um gênero ou etnia, por exemplo, for favorecido em relação a outro.
|
||||
- **Qualidade do serviço**. Se você treinar os dados para um cenário específico, mas a realidade for muito mais complexa, isso leva a um serviço de baixo desempenho.
|
||||
- **Estereotipagem**. Associar um determinado grupo a atributos pré-designados.
|
||||
- **Denigração**. Criticar e rotular injustamente algo ou alguém.
|
||||
- **Super- ou sub-representação**. A ideia é que um determinado grupo não é visto em uma determinada profissão, e qualquer serviço ou função que continue promovendo isso está contribuindo para o dano.
|
||||
|
||||
### Painel Azure RAI
|
||||
|
||||
O [Painel Azure RAI](https://learn.microsoft.com/en-us/azure/machine-learning/concept-responsible-ai-dashboard?WT.mc_id=aiml-90525-ruyakubu) é construído com ferramentas de código aberto desenvolvidas por instituições acadêmicas e organizações líderes, incluindo a Microsoft, que são instrumentais para cientistas de dados e desenvolvedores de IA para entender melhor o comportamento do modelo, descobrir e mitigar problemas indesejáveis de modelos de IA.
|
||||
|
||||
- Aprenda a usar os diferentes componentes consultando a [documentação do painel RAI.](https://learn.microsoft.com/en-us/azure/machine-learning/how-to-responsible-ai-dashboard?WT.mc_id=aiml-90525-ruyakubu)
|
||||
|
||||
- Confira alguns [notebooks de amostra do painel RAI](https://github.com/Azure/RAI-vNext-Preview/tree/main/examples/notebooks) para depurar cenários de IA responsável no Azure Machine Learning.
|
||||
|
||||
---
|
||||
|
||||
## 🚀 Desafio
|
||||
|
||||
Para evitar que vieses estatísticos ou de dados sejam introduzidos em primeiro lugar, devemos:
|
||||
|
||||
- ter uma diversidade de origens e perspectivas entre as pessoas que trabalham em sistemas
|
||||
- investir em conjuntos de dados que reflitam a diversidade da nossa sociedade
|
||||
- desenvolver melhores métodos para detectar e corrigir viés quando ele ocorrer
|
||||
|
||||
Pense em cenários da vida real onde a injustiça é evidente na construção e uso de modelos. O que mais devemos considerar?
|
||||
|
||||
## [Quiz pós-aula](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/6/)
|
||||
|
||||
## Revisão e Autoestudo
|
||||
|
||||
Nesta lição, você aprendeu algumas das ferramentas práticas de incorporação de IA responsável em aprendizado de máquina.
|
||||
|
||||
Assista a este workshop para se aprofundar nos tópicos:
|
||||
|
||||
- Painel de IA Responsável: Um ponto de encontro para operacionalizar RAI na prática por Besmira Nushi e Mehrnoosh Sameki
|
||||
|
||||
[](https://www.youtube.com/watch?v=f1oaDNl3djg "Painel de IA Responsável: Um ponto de encontro para operacionalizar RAI na prática")
|
||||
|
||||
> 🎥 Clique na imagem acima para ver o vídeo: Painel de IA Responsável: Um ponto de encontro para operacionalizar RAI na prática por Besmira Nushi e Mehrnoosh Sameki
|
||||
|
||||
Referencie os seguintes materiais para aprender mais sobre IA responsável e como construir modelos
|
||||
|
||||
**Aviso Legal**:
|
||||
Este documento foi traduzido utilizando serviços de tradução automática baseados em IA. Embora nos esforcemos pela precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em sua língua nativa deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se a tradução profissional por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações errôneas decorrentes do uso desta tradução.
|
||||
@ -1,14 +0,0 @@
|
||||
# Explore o painel de IA Responsável (RAI)
|
||||
|
||||
## Instruções
|
||||
|
||||
Nesta lição, você aprendeu sobre o painel RAI, um conjunto de componentes construídos com ferramentas "open-source" para ajudar cientistas de dados a realizar análise de erros, exploração de dados, avaliação de equidade, interpretabilidade de modelos, avaliações contrafactuais/o que se aconteceria e análise causal em sistemas de IA. Para esta tarefa, explore alguns dos notebooks de exemplo do painel RAI [notebooks](https://github.com/Azure/RAI-vNext-Preview/tree/main/examples/notebooks) e relate suas descobertas em um artigo ou apresentação.
|
||||
|
||||
## Rubrica
|
||||
|
||||
| Critérios | Exemplar | Adequado | Precisa de Melhoria |
|
||||
| --------- | -------- | -------- | ------------------- |
|
||||
| | Um artigo ou apresentação em PowerPoint é apresentado discutindo os componentes do painel RAI, o notebook que foi executado e as conclusões tiradas a partir da execução | Um artigo é apresentado sem conclusões | Nenhum artigo é apresentado |
|
||||
|
||||
**Aviso Legal**:
|
||||
Este documento foi traduzido utilizando serviços de tradução automática baseados em IA. Embora nos esforcemos pela precisão, 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 autoritativa. Para informações críticas, recomenda-se a tradução profissional por um humano. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações errôneas resultantes do uso desta tradução.
|
||||
@ -1,21 +0,0 @@
|
||||
# Pós-escrito: Aplicações do mundo real de aprendizado de máquina clássico
|
||||
|
||||
Nesta seção do currículo, você será apresentado a algumas aplicações do mundo real de ML clássico. Nós pesquisamos na internet para encontrar artigos e whitepapers sobre aplicações que usaram essas estratégias, evitando redes neurais, aprendizado profundo e IA tanto quanto possível. Aprenda como ML é utilizado em sistemas empresariais, aplicações ecológicas, finanças, artes e cultura, e muito mais.
|
||||
|
||||
|
||||
|
||||
> Foto de <a href="https://unsplash.com/@childeye?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Alexis Fauvet</a> em <a href="https://unsplash.com/s/photos/artificial-intelligence?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Unsplash</a>
|
||||
|
||||
## Aula
|
||||
|
||||
1. [Aplicações do Mundo Real para ML](1-Applications/README.md)
|
||||
2. [Depuração de Modelos em Aprendizado de Máquina usando componentes do painel de IA Responsável](2-Debugging-ML-Models/README.md)
|
||||
|
||||
## Créditos
|
||||
|
||||
"Aplicações do Mundo Real" foi escrito por uma equipe de pessoas, incluindo [Jen Looper](https://twitter.com/jenlooper) e [Ornella Altunyan](https://twitter.com/ornelladotcom).
|
||||
|
||||
"Depuração de Modelos em Aprendizado de Máquina usando componentes do painel de IA Responsável" foi escrito por [Ruth Yakubu](https://twitter.com/ruthieyakubu)
|
||||
|
||||
**Isenção de responsabilidade**:
|
||||
Este documento foi traduzido usando serviços de tradução automática baseados em IA. Embora nos esforcemos pela precisão, 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 autoritativa. Para informações críticas, recomenda-se a tradução profissional por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações incorretas resultantes do uso desta tradução.
|
||||
@ -1,12 +0,0 @@
|
||||
# Código de Conduta de Código Aberto da Microsoft
|
||||
|
||||
Este projeto adotou o [Código de Conduta de Código Aberto da Microsoft](https://opensource.microsoft.com/codeofconduct/).
|
||||
|
||||
Recursos:
|
||||
|
||||
- [Código de Conduta de Código Aberto da Microsoft](https://opensource.microsoft.com/codeofconduct/)
|
||||
- [Perguntas Frequentes sobre o Código de Conduta da Microsoft](https://opensource.microsoft.com/codeofconduct/faq/)
|
||||
- Entre em contato com [opencode@microsoft.com](mailto:opencode@microsoft.com) para perguntas ou preocupações.
|
||||
|
||||
**Isenção de responsabilidade**:
|
||||
Este documento foi traduzido usando serviços de tradução automática baseados em IA. Embora nos esforcemos para garantir a precisão, 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 a tradução profissional por um humano. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações errôneas decorrentes do uso desta tradução.
|
||||
@ -1,19 +0,0 @@
|
||||
# Contribuindo
|
||||
|
||||
Este projeto acolhe contribuições e sugestões. A maioria das contribuições exige que você
|
||||
concorde com um Acordo de Licença de Contribuidor (CLA) declarando que você tem o direito de,
|
||||
e de fato, nos conceder os direitos de usar sua contribuição. Para mais detalhes, visite
|
||||
https://cla.microsoft.com.
|
||||
|
||||
> Importante: ao traduzir texto neste repositório, por favor, assegure-se de não usar tradução automática. Nós verificaremos as traduções através da comunidade, então, por favor, ofereça-se apenas para traduções em idiomas nos quais você seja proficiente.
|
||||
|
||||
Quando você enviar um pull request, um CLA-bot determinará automaticamente se você precisa
|
||||
fornecer um CLA e decorará o PR de forma apropriada (por exemplo, rótulo, comentário). Basta seguir as
|
||||
instruções fornecidas pelo bot. Você precisará fazer isso apenas uma vez em todos os repositórios que utilizam nosso CLA.
|
||||
|
||||
Este projeto adotou o [Código de Conduta de Código Aberto da Microsoft](https://opensource.microsoft.com/codeofconduct/).
|
||||
Para mais informações, consulte as [Perguntas Frequentes sobre o Código de Conduta](https://opensource.microsoft.com/codeofconduct/faq/)
|
||||
ou entre em contato com [opencode@microsoft.com](mailto:opencode@microsoft.com) com quaisquer perguntas ou comentários adicionais.
|
||||
|
||||
**Aviso**:
|
||||
Este documento foi traduzido utilizando serviços de tradução automática baseados em IA. Embora nos esforcemos pela precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em sua língua nativa deve ser considerado a fonte autorizada. Para informações críticas, recomenda-se a tradução profissional feita por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações errôneas decorrentes do uso desta tradução.
|
||||
@ -1,155 +0,0 @@
|
||||
[](https://github.com/microsoft/ML-For-Beginners/blob/master/LICENSE)
|
||||
[](https://GitHub.com/microsoft/ML-For-Beginners/graphs/contributors/)
|
||||
[](https://GitHub.com/microsoft/ML-For-Beginners/issues/)
|
||||
[](https://GitHub.com/microsoft/ML-For-Beginners/pulls/)
|
||||
[](http://makeapullrequest.com)
|
||||
|
||||
[](https://GitHub.com/microsoft/ML-For-Beginners/watchers/)
|
||||
[](https://GitHub.com/microsoft/ML-For-Beginners/network/)
|
||||
[](https://GitHub.com/microsoft/ML-For-Beginners/stargazers/)
|
||||
|
||||
[](https://discord.gg/zxKYvhSnVp?WT.mc_id=academic-000002-leestott)
|
||||
|
||||
# Aprendizado de Máquina para Iniciantes - Um Currículo
|
||||
|
||||
> 🌍 Viaje pelo mundo enquanto exploramos o Aprendizado de Máquina por meio das culturas do mundo 🌍
|
||||
|
||||
Os Cloud Advocates da Microsoft têm o prazer de oferecer um currículo de 12 semanas, com 26 aulas, tudo sobre **Aprendizado de Máquina**. Neste currículo, você aprenderá sobre o que às vezes é chamado de **aprendizado de máquina clássico**, utilizando principalmente o Scikit-learn como biblioteca e evitando o aprendizado profundo, que é abordado em nosso [currículo de IA para Iniciantes](https://aka.ms/ai4beginners). Combine estas lições com nosso [currículo de 'Ciência de Dados para Iniciantes'](https://aka.ms/ds4beginners), também!
|
||||
|
||||
Viaje conosco pelo mundo enquanto aplicamos essas técnicas clássicas a dados de muitas áreas do mundo. Cada lição inclui questionários antes e depois da aula, instruções escritas para completar a lição, uma solução, uma tarefa e muito mais. Nossa pedagogia baseada em projetos permite que você aprenda enquanto constrói, uma maneira comprovada de fazer novas habilidades 'grudarem'.
|
||||
|
||||
**✍️ Agradecimentos especiais aos nossos autores** Jen Looper, Stephen Howell, Francesca Lazzeri, Tomomi Imura, Cassie Breviu, Dmitry Soshnikov, Chris Noring, Anirban Mukherjee, Ornella Altunyan, Ruth Yakubu e Amy Boyd
|
||||
|
||||
**🎨 Agradecimentos também aos nossos ilustradores** Tomomi Imura, Dasani Madipalli e Jen Looper
|
||||
|
||||
**🙏 Agradecimentos especiais 🙏 aos nossos autores, revisores e colaboradores de conteúdo Microsoft Student Ambassador**, notavelmente Rishit Dagli, Muhammad Sakib Khan Inan, Rohan Raj, Alexandru Petrescu, Abhishek Jaiswal, Nawrin Tabassum, Ioan Samuila e Snigdha Agarwal
|
||||
|
||||
**🤩 Agradecimentos extras aos Microsoft Student Ambassadors Eric Wanjau, Jasleen Sondhi e Vidushi Gupta por nossas lições de R!**
|
||||
|
||||
# Começando
|
||||
|
||||
Siga estas etapas:
|
||||
1. **Faça um Fork do Repositório**: Clique no botão "Fork" no canto superior direito desta página.
|
||||
2. **Clone o Repositório**: `git clone https://github.com/microsoft/ML-For-Beginners.git`
|
||||
|
||||
> [encontre todos os recursos adicionais para este curso em nossa coleção do Microsoft Learn](https://learn.microsoft.com/en-us/collections/qrqzamz1nn2wx3?WT.mc_id=academic-77952-bethanycheum)
|
||||
|
||||
**[Estudantes](https://aka.ms/student-page)**, para usar este currículo, faça um fork de todo o repositório para sua própria conta do GitHub e complete os exercícios sozinho ou em grupo:
|
||||
|
||||
- Comece com um questionário pré-aula.
|
||||
- Leia a aula e complete as atividades, pausando e refletindo a cada verificação de conhecimento.
|
||||
- Tente criar os projetos compreendendo as lições em vez de executar o código da solução; no entanto, esse código está disponível nas pastas `/solution` em cada lição orientada a projetos.
|
||||
- Faça o questionário pós-aula.
|
||||
- Complete o desafio.
|
||||
- Complete a tarefa.
|
||||
- Após completar um grupo de lições, visite o [Fórum de Discussão](https://github.com/microsoft/ML-For-Beginners/discussions) e "aprenda em voz alta" preenchendo a rubrica PAT apropriada. Um 'PAT' é uma Ferramenta de Avaliação de Progresso que é uma rubrica que você preenche para aprofundar seu aprendizado. Você também pode reagir a outros PATs para que possamos aprender juntos.
|
||||
|
||||
> Para estudo adicional, recomendamos seguir estes módulos e trilhas de aprendizado do [Microsoft Learn](https://docs.microsoft.com/en-us/users/jenlooper-2911/collections/k7o7tg1gp306q4?WT.mc_id=academic-77952-leestott).
|
||||
|
||||
**Professores**, incluímos [algumas sugestões](for-teachers.md) sobre como usar este currículo.
|
||||
|
||||
---
|
||||
|
||||
## Vídeos explicativos
|
||||
|
||||
Algumas das lições estão disponíveis como vídeos curtos. Você pode encontrar todos esses vídeos dentro das lições ou na [playlist ML para Iniciantes no canal do YouTube da Microsoft Developer](https://aka.ms/ml-beginners-videos) clicando na imagem abaixo.
|
||||
|
||||
[](https://aka.ms/ml-beginners-videos)
|
||||
|
||||
---
|
||||
|
||||
## Conheça a Equipe
|
||||
|
||||
[](https://youtu.be/Tj1XWrDSYJU "Vídeo promocional")
|
||||
|
||||
**Gif por** [Mohit Jaisal](https://linkedin.com/in/mohitjaisal)
|
||||
|
||||
> 🎥 Clique na imagem acima para ver um vídeo sobre o projeto e as pessoas que o criaram!
|
||||
|
||||
---
|
||||
|
||||
## Pedagogia
|
||||
|
||||
Escolhemos dois princípios pedagógicos ao construir este currículo: garantir que ele seja prático **baseado em projetos** e que inclua **questionários frequentes**. Além disso, este currículo tem um **tema** comum para dar coesão.
|
||||
|
||||
Ao garantir que o conteúdo esteja alinhado com os projetos, o processo se torna mais envolvente para os alunos e a retenção dos conceitos será aumentada. Além disso, um questionário de baixo risco antes de uma aula estabelece a intenção do aluno em relação ao aprendizado de um tópico, enquanto um segundo questionário após a aula garante uma maior retenção. Este currículo foi projetado para ser flexível e divertido e pode ser realizado total ou parcialmente. Os projetos começam pequenos e se tornam cada vez mais complexos até o final do ciclo de 12 semanas. Este currículo também inclui um pós-escrito sobre aplicações do mundo real de ML, que pode ser usado como crédito extra ou como base para discussão.
|
||||
|
||||
> Encontre nosso [Código de Conduta](CODE_OF_CONDUCT.md), diretrizes de [Contribuição](CONTRIBUTING.md) e [Tradução](TRANSLATIONS.md). Agradecemos seu feedback construtivo!
|
||||
|
||||
## Cada lição inclui
|
||||
|
||||
- sketchnote opcional
|
||||
- vídeo suplementar opcional
|
||||
- vídeo explicativo (apenas algumas lições)
|
||||
- questionário de aquecimento pré-aula
|
||||
- lição escrita
|
||||
- para lições baseadas em projetos, guias passo a passo sobre como construir o projeto
|
||||
- verificações de conhecimento
|
||||
- um desafio
|
||||
- leitura suplementar
|
||||
- tarefa
|
||||
- questionário pós-aula
|
||||
|
||||
> **Uma nota sobre idiomas**: Essas lições são escritas principalmente em Python, mas muitas também estão disponíveis em R. Para completar uma lição de R, vá até a pasta `/solution` e procure lições de R. Elas incluem uma extensão .rmd que representa um **arquivo R Markdown**, que pode ser simplesmente definido como uma incorporação de `code chunks` (de R ou outras linguagens) e um `YAML header` (que orienta como formatar saídas como PDF) em um `Markdown document`. Assim, serve como uma estrutura de autoria exemplar para ciência de dados, pois permite que você combine seu código, sua saída e seus pensamentos ao permitir que você os escreva em Markdown. Além disso, documentos R Markdown podem ser renderizados em formatos de saída como PDF, HTML ou Word.
|
||||
|
||||
> **Uma nota sobre questionários**: Todos os questionários estão contidos na [pasta do aplicativo de questionários](../../quiz-app), totalizando 52 questionários de três perguntas cada. Eles estão vinculados dentro das lições, mas o aplicativo de questionários pode ser executado localmente; siga as instruções na pasta `quiz-app` para hospedar localmente ou implantar no Azure.
|
||||
|
||||
| Número da Lição | Tópico | Agrupamento da Lição | Objetivos de Aprendizado | Lição Vinculada | Autor |
|
||||
| :-------------: | :--------------------------------------------------------------: | :-----------------------------------------------------: | ------------------------------------------------------------------------------------------------------------------------------ | :--------------------------------------------------------------------------------------------------------------------------------------: | :--------------------------------------------------: |
|
||||
| 01 | Introdução ao aprendizado de máquina | [Introdução](1-Introduction/README.md) | Aprender os conceitos básicos por trás do aprendizado de máquina | [Lição](1-Introduction/1-intro-to-ML/README.md) | Muhammad |
|
||||
| 02 | A História do aprendizado de máquina | [Introdução](1-Introduction/README.md) | Aprender a história subjacente a este campo | [Lição](1-Introduction/2-history-of-ML/README.md) | Jen e Amy |
|
||||
| 03 | Justiça e aprendizado de máquina | [Introdução](1-Introduction/README.md) | Quais são as questões filosóficas importantes em torno da justiça que os alunos devem considerar ao construir e aplicar modelos de ML? | [Lição](1-Introduction/3-fairness/README.md) | Tomomi |
|
||||
| 04 | Técnicas de aprendizado de máquina | [Introdução](1-Introduction/README.md) | Quais técnicas os pesquisadores de ML usam para construir modelos de ML? | [Aula](1-Introduction/4-techniques-of-ML/README.md) | Chris e Jen |
|
||||
| 05 | Introdução à regressão | [Regressão](2-Regression/README.md) | Comece com Python e Scikit-learn para modelos de regressão | <ul><li>[Python](2-Regression/1-Tools/README.md)</li><li>[R](../../2-Regression/1-Tools/solution/R/lesson_1.html)</li></ul> | <ul><li>Jen</li><li>Eric Wanjau</li></ul> |
|
||||
| 06 | Preços de abóbora na América do Norte 🎃 | [Regressão](2-Regression/README.md) | Visualize e limpe os dados em preparação para ML | <ul><li>[Python](2-Regression/2-Data/README.md)</li><li>[R](../../2-Regression/2-Data/solution/R/lesson_2.html)</li></ul> | <ul><li>Jen</li><li>Eric Wanjau</li></ul> |
|
||||
| 07 | Preços de abóbora na América do Norte 🎃 | [Regressão](2-Regression/README.md) | Construa modelos de regressão linear e polinomial | <ul><li>[Python](2-Regression/3-Linear/README.md)</li><li>[R](../../2-Regression/3-Linear/solution/R/lesson_3.html)</li></ul> | <ul><li>Jen e Dmitry</li><li>Eric Wanjau</li></ul> |
|
||||
| 08 | Preços de abóbora na América do Norte 🎃 | [Regressão](2-Regression/README.md) | Construa um modelo de regressão logística | <ul><li>[Python](2-Regression/4-Logistic/README.md) </li><li>[R](../../2-Regression/4-Logistic/solution/R/lesson_4.html)</li></ul> | <ul><li>Jen</li><li>Eric Wanjau</li></ul> |
|
||||
| 09 | Um App Web 🔌 | [App Web](3-Web-App/README.md) | Construa um app web para usar seu modelo treinado | [Python](3-Web-App/1-Web-App/README.md) | Jen |
|
||||
| 10 | Introdução à classificação | [Classificação](4-Classification/README.md) | Limpe, prepare e visualize seus dados; introdução à classificação | <ul><li> [Python](4-Classification/1-Introduction/README.md) </li><li>[R](../../4-Classification/1-Introduction/solution/R/lesson_10.html) | <ul><li>Jen e Cassie</li><li>Eric Wanjau</li></ul> |
|
||||
| 11 | Deliciosas culinárias asiáticas e indianas 🍜 | [Classificação](4-Classification/README.md) | Introdução aos classificadores | <ul><li> [Python](4-Classification/2-Classifiers-1/README.md)</li><li>[R](../../4-Classification/2-Classifiers-1/solution/R/lesson_11.html) | <ul><li>Jen e Cassie</li><li>Eric Wanjau</li></ul> |
|
||||
| 12 | Deliciosas culinárias asiáticas e indianas 🍜 | [Classificação](4-Classification/README.md) | Mais classificadores | <ul><li> [Python](4-Classification/3-Classifiers-2/README.md)</li><li>[R](../../4-Classification/3-Classifiers-2/solution/R/lesson_12.html) | <ul><li>Jen e Cassie</li><li>Eric Wanjau</li></ul> |
|
||||
| 13 | Deliciosas culinárias asiáticas e indianas 🍜 | [Classificação](4-Classification/README.md) | Construa um app web de recomendação usando seu modelo | [Python](4-Classification/4-Applied/README.md) | Jen |
|
||||
| 14 | Introdução ao agrupamento | [Agrupamento](5-Clustering/README.md) | Limpe, prepare e visualize seus dados; Introdução ao agrupamento | <ul><li> [Python](5-Clustering/1-Visualize/README.md)</li><li>[R](../../5-Clustering/1-Visualize/solution/R/lesson_14.html) | <ul><li>Jen</li><li>Eric Wanjau</li></ul> |
|
||||
| 15 | Explorando os Gostos Musicais Nigerianos 🎧 | [Agrupamento](5-Clustering/README.md) | Explore o método de agrupamento K-Means | <ul><li> [Python](5-Clustering/2-K-Means/README.md)</li><li>[R](../../5-Clustering/2-K-Means/solution/R/lesson_15.html) | <ul><li>Jen</li><li>Eric Wanjau</li></ul> |
|
||||
| 16 | Introdução ao processamento de linguagem natural ☕️ | [Processamento de linguagem natural](6-NLP/README.md) | Aprenda os conceitos básicos sobre PLN construindo um bot simples | [Python](6-NLP/1-Introduction-to-NLP/README.md) | Stephen |
|
||||
| 17 | Tarefas Comuns de PLN ☕️ | [Processamento de linguagem natural](6-NLP/README.md) | Aprofunde seu conhecimento em PLN entendendo as tarefas comuns necessárias ao lidar com estruturas linguísticas | [Python](6-NLP/2-Tasks/README.md) | Stephen |
|
||||
| 18 | Tradução e Análise de Sentimento ♥️ | [Processamento de linguagem natural](6-NLP/README.md) | Tradução e análise de sentimento com Jane Austen | [Python](6-NLP/3-Translation-Sentiment/README.md) | Stephen |
|
||||
| 19 | Hotéis Românticos da Europa ♥️ | [Processamento de linguagem natural](6-NLP/README.md) | Análise de sentimento com avaliações de hotéis 1 | [Python](6-NLP/4-Hotel-Reviews-1/README.md) | Stephen |
|
||||
| 20 | Hotéis Românticos da Europa ♥️ | [Processamento de linguagem natural](6-NLP/README.md) | Análise de sentimento com avaliações de hotéis 2 | [Python](6-NLP/5-Hotel-Reviews-2/README.md) | Stephen |
|
||||
| 21 | Introdução à Previsão de Séries Temporais | [Séries Temporais](7-TimeSeries/README.md) | Introdução à previsão de séries temporais | [Python](7-TimeSeries/1-Introduction/README.md) | Francesca |
|
||||
| 22 | ⚡️ Uso de Energia Mundial ⚡️ - previsão de séries temporais com ARIMA | [Séries Temporais](7-TimeSeries/README.md) | Previsão de séries temporais com ARIMA | [Python](7-TimeSeries/2-ARIMA/README.md) | Francesca |
|
||||
| 23 | ⚡️ Uso de Energia Mundial ⚡️ - previsão de séries temporais com SVR | [Séries Temporais](7-TimeSeries/README.md) | Previsão de séries temporais com Regressor de Vetores de Suporte | [Python](7-TimeSeries/3-SVR/README.md) | Anirban |
|
||||
| 24 | Introdução ao Aprendizado por Reforço | [Aprendizado por Reforço](8-Reinforcement/README.md) | Introdução ao aprendizado por reforço com Q-Learning | [Python](8-Reinforcement/1-QLearning/README.md) | Dmitry |
|
||||
| 25 | Ajude Peter a evitar o lobo! 🐺 | [Aprendizado por Reforço](8-Reinforcement/README.md) | Aprendizado por reforço no Gym | [Python](8-Reinforcement/2-Gym/README.md) | Dmitry |
|
||||
| Postscript | Cenários e Aplicações do ML no Mundo Real | [ML no Mundo Real](9-Real-World/README.md) | Aplicações interessantes e reveladoras do ML clássico | [Aula](9-Real-World/1-Applications/README.md) | Equipe |
|
||||
| Postscript | Depuração de Modelos em ML usando o painel RAI | [ML no Mundo Real](9-Real-World/README.md) | Depuração de modelos em Aprendizado de Máquina usando componentes do painel de IA Responsável | [Aula](9-Real-World/2-Debugging-ML-Models/README.md) | Ruth Yakubu |
|
||||
|
||||
> [encontre todos os recursos adicionais para este curso em nossa coleção do Microsoft Learn](https://learn.microsoft.com/en-us/collections/qrqzamz1nn2wx3?WT.mc_id=academic-77952-bethanycheum)
|
||||
|
||||
## Acesso Offline
|
||||
|
||||
Você pode executar esta documentação offline usando [Docsify](https://docsify.js.org/#/). Faça um fork deste repositório, [instale o Docsify](https://docsify.js.org/#/quickstart) em sua máquina local e, em seguida, na pasta raiz deste repositório, digite `docsify serve`. O site será servido na porta 3000 em seu localhost: `localhost:3000`.
|
||||
|
||||
## PDFs
|
||||
Encontre um PDF do currículo com links [aqui](https://microsoft.github.io/ML-For-Beginners/pdf/readme.pdf).
|
||||
|
||||
## Ajuda Necessária
|
||||
|
||||
Você gostaria de contribuir com uma tradução? Por favor, leia nossas [diretrizes de tradução](TRANSLATIONS.md) e adicione uma questão com modelo para gerenciar a carga de trabalho [aqui](https://github.com/microsoft/ML-For-Beginners/issues).
|
||||
|
||||
## Outros Currículos
|
||||
|
||||
Nossa equipe produz outros currículos! Confira:
|
||||
|
||||
- [AI para Iniciantes](https://aka.ms/ai4beginners)
|
||||
- [Ciência de Dados para Iniciantes](https://aka.ms/datascience-beginners)
|
||||
- [**Nova Versão 2.0** - IA Generativa para Iniciantes](https://aka.ms/genai-beginners)
|
||||
- [**NOVO** Cibersegurança para Iniciantes](https://github.com/microsoft/Security-101??WT.mc_id=academic-96948-sayoung)
|
||||
- [Desenvolvimento Web para Iniciantes](https://aka.ms/webdev-beginners)
|
||||
- [IoT para Iniciantes](https://aka.ms/iot-beginners)
|
||||
- [Aprendizado de Máquina para Iniciantes](https://aka.ms/ml4beginners)
|
||||
- [Desenvolvimento XR para Iniciantes](https://aka.ms/xr-dev-for-beginners)
|
||||
- [Dominando o GitHub Copilot para Programação em Par com IA](https://aka.ms/GitHubCopilotAI)
|
||||
|
||||
**Isenção de responsabilidade**:
|
||||
Este documento foi traduzido utilizando serviços de tradução baseados em IA. Embora nos esforcemos pela 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 autoritativa. Para informações críticas, recomenda-se a tradução profissional por um humano. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações errôneas decorrentes do uso desta tradução.
|
||||
@ -1,40 +0,0 @@
|
||||
## Segurança
|
||||
|
||||
A Microsoft leva a segurança de nossos produtos e serviços de software a sério, o que inclui todos os repositórios de código-fonte gerenciados por meio de nossas organizações no GitHub, que incluem [Microsoft](https://github.com/Microsoft), [Azure](https://github.com/Azure), [DotNet](https://github.com/dotnet), [AspNet](https://github.com/aspnet), [Xamarin](https://github.com/xamarin) e [nossas organizações no GitHub](https://opensource.microsoft.com/).
|
||||
|
||||
Se você acredita que encontrou uma vulnerabilidade de segurança em qualquer repositório de propriedade da Microsoft que atenda à [definição de vulnerabilidade de segurança da Microsoft](https://docs.microsoft.com/previous-versions/tn-archive/cc751383(v=technet.10)?WT.mc_id=academic-77952-leestott), por favor, relate-a para nós conforme descrito abaixo.
|
||||
|
||||
## Relatando Problemas de Segurança
|
||||
|
||||
**Por favor, não relate vulnerabilidades de segurança através de problemas públicos no GitHub.**
|
||||
|
||||
Em vez disso, relate-as ao Microsoft Security Response Center (MSRC) em [https://msrc.microsoft.com/create-report](https://msrc.microsoft.com/create-report).
|
||||
|
||||
Se preferir enviar sem fazer login, envie um e-mail para [secure@microsoft.com](mailto:secure@microsoft.com). Se possível, criptografe sua mensagem com nossa chave PGP; por favor, baixe-a da [página da Chave PGP do Microsoft Security Response Center](https://www.microsoft.com/en-us/msrc/pgp-key-msrc).
|
||||
|
||||
Você deve receber uma resposta dentro de 24 horas. Se por algum motivo você não receber, siga com um e-mail para garantir que recebemos sua mensagem original. Informações adicionais podem ser encontradas em [microsoft.com/msrc](https://www.microsoft.com/msrc).
|
||||
|
||||
Por favor, inclua as informações solicitadas listadas abaixo (tanto quanto você puder fornecer) para nos ajudar a entender melhor a natureza e o escopo do possível problema:
|
||||
|
||||
* Tipo de problema (por exemplo, estouro de buffer, injeção de SQL, script entre sites, etc.)
|
||||
* Caminhos completos dos arquivos de origem relacionados à manifestação do problema
|
||||
* A localização do código-fonte afetado (tag/branch/commit ou URL direta)
|
||||
* Qualquer configuração especial necessária para reproduzir o problema
|
||||
* Instruções passo a passo para reproduzir o problema
|
||||
* Código de prova de conceito ou de exploração (se possível)
|
||||
* Impacto do problema, incluindo como um atacante poderia explorar a questão
|
||||
|
||||
Essas informações nos ajudarão a triagem de seu relatório mais rapidamente.
|
||||
|
||||
Se você estiver relatando para um programa de recompensas por bugs, relatórios mais completos podem contribuir para uma recompensa maior. Por favor, visite nossa página do [Programa de Recompensas por Bugs da Microsoft](https://microsoft.com/msrc/bounty) para mais detalhes sobre nossos programas ativos.
|
||||
|
||||
## Idiomas Preferidos
|
||||
|
||||
Preferimos que todas as comunicações sejam em inglês.
|
||||
|
||||
## Política
|
||||
|
||||
A Microsoft segue o princípio de [Divulgação Coordenada de Vulnerabilidades](https://www.microsoft.com/en-us/msrc/cvd).
|
||||
|
||||
**Isenção de responsabilidade**:
|
||||
Este documento foi traduzido utilizando serviços de tradução automática baseados em IA. Embora nos esforcemos pela precisão, 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 autoritativa. Para informações críticas, recomenda-se a tradução profissional por um humano. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações errôneas decorrentes do uso desta tradução.
|
||||
@ -1,13 +0,0 @@
|
||||
# Suporte
|
||||
## Como registrar problemas e obter ajuda
|
||||
|
||||
Este projeto utiliza o GitHub Issues para rastrear bugs e solicitações de recursos. Por favor, pesquise os problemas existentes antes de registrar novos problemas para evitar duplicatas. Para novos problemas, registre seu bug ou solicitação de recurso como uma nova Issue.
|
||||
|
||||
Para ajuda e perguntas sobre o uso deste projeto, registre uma issue.
|
||||
|
||||
## Política de Suporte da Microsoft
|
||||
|
||||
O suporte para este repositório é limitado aos recursos listados acima.
|
||||
|
||||
**Isenção de responsabilidade**:
|
||||
Este documento foi traduzido usando serviços de tradução baseados em IA. Embora nos esforcemos pela precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em sua língua nativa deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se a tradução profissional por um humano. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações errôneas decorrentes do uso desta tradução.
|
||||
@ -1,37 +0,0 @@
|
||||
# Contribua traduzindo lições
|
||||
|
||||
Agradecemos traduções para as lições deste currículo!
|
||||
## Diretrizes
|
||||
|
||||
Existem pastas em cada pasta de lição e na pasta de introdução da lição que contêm os arquivos markdown traduzidos.
|
||||
|
||||
> Nota: por favor, não traduza nenhum código nos arquivos de exemplo de código; as únicas coisas a traduzir são README, tarefas e questionários. Obrigado!
|
||||
|
||||
Os arquivos traduzidos devem seguir esta convenção de nomenclatura:
|
||||
|
||||
**README._[language]_.md**
|
||||
|
||||
onde _[language]_ é uma abreviação de dois letras do idioma seguindo o padrão ISO 639-1 (por exemplo, `README.es.md` para espanhol e `README.nl.md` para holandês).
|
||||
|
||||
**assignment._[language]_.md**
|
||||
|
||||
Semelhante aos Readmes, por favor, traduza também as tarefas.
|
||||
|
||||
> Importante: ao traduzir textos neste repositório, por favor, certifique-se de não usar tradução automática. Verificaremos as traduções por meio da comunidade, então, por favor, apenas se ofereça para traduções em idiomas nos quais você seja proficiente.
|
||||
|
||||
**Questionários**
|
||||
|
||||
1. Adicione sua tradução ao aplicativo de questionário adicionando um arquivo aqui: https://github.com/microsoft/ML-For-Beginners/tree/main/quiz-app/src/assets/translations, com a convenção de nomenclatura adequada (en.json, fr.json). **Por favor, não localize as palavras 'true' ou 'false', no entanto. Obrigado!**
|
||||
|
||||
2. Adicione seu código de idioma ao menu suspenso no arquivo App.vue do aplicativo de questionário.
|
||||
|
||||
3. Edite o [arquivo translations index.js do aplicativo de questionário](https://github.com/microsoft/ML-For-Beginners/blob/main/quiz-app/src/assets/translations/index.js) para adicionar seu idioma.
|
||||
|
||||
4. Finalmente, edite TODOS os links de questionário em seus arquivos README.md traduzidos para apontar diretamente para seu questionário traduzido: https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/1 torna-se https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/1?loc=id
|
||||
|
||||
**OBRIGADO**
|
||||
|
||||
Agradecemos sinceramente seus esforços!
|
||||
|
||||
**Aviso**:
|
||||
Este documento foi traduzido utilizando serviços de tradução automática baseados em IA. Embora nos esforcemos pela precisão, esteja ciente de que as traduções automatizadas podem conter erros ou imprecisões. O documento original em sua língua nativa deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se a tradução profissional feita por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações erradas decorrentes do uso desta tradução.
|
||||
@ -1,46 +0,0 @@
|
||||
- Introdução
|
||||
- [Introdução ao Aprendizado de Máquina](../1-Introduction/1-intro-to-ML/README.md)
|
||||
- [História do Aprendizado de Máquina](../1-Introduction/2-history-of-ML/README.md)
|
||||
- [Aprendizado de Máquina e Justiça](../1-Introduction/3-fairness/README.md)
|
||||
- [Técnicas de Aprendizado de Máquina](../1-Introduction/4-techniques-of-ML/README.md)
|
||||
|
||||
- Regressão
|
||||
- [Ferramentas do Comércio](../2-Regression/1-Tools/README.md)
|
||||
- [Dados](../2-Regression/2-Data/README.md)
|
||||
- [Regressão Linear](../2-Regression/3-Linear/README.md)
|
||||
- [Regressão Logística](../2-Regression/4-Logistic/README.md)
|
||||
|
||||
- Construir um Aplicativo Web
|
||||
- [Aplicativo Web](../3-Web-App/1-Web-App/README.md)
|
||||
|
||||
- Classificação
|
||||
- [Introdução à Classificação](../4-Classification/1-Introduction/README.md)
|
||||
- [Classificadores 1](../4-Classification/2-Classifiers-1/README.md)
|
||||
- [Classificadores 2](../4-Classification/3-Classifiers-2/README.md)
|
||||
- [Aprendizado de Máquina Aplicado](../4-Classification/4-Applied/README.md)
|
||||
|
||||
- Agrupamento
|
||||
- [Visualize seus Dados](../5-Clustering/1-Visualize/README.md)
|
||||
- [K-Means](../5-Clustering/2-K-Means/README.md)
|
||||
|
||||
- PLN
|
||||
- [Introdução ao PLN](../6-NLP/1-Introduction-to-NLP/README.md)
|
||||
- [Tarefas de PLN](../6-NLP/2-Tasks/README.md)
|
||||
- [Tradução e Sentimento](../6-NLP/3-Translation-Sentiment/README.md)
|
||||
- [Avaliações de Hotéis 1](../6-NLP/4-Hotel-Reviews-1/README.md)
|
||||
- [Avaliações de Hotéis 2](../6-NLP/5-Hotel-Reviews-2/README.md)
|
||||
|
||||
- Previsão de Séries Temporais
|
||||
- [Introdução à Previsão de Séries Temporais](../7-TimeSeries/1-Introduction/README.md)
|
||||
- [ARIMA](../7-TimeSeries/2-ARIMA/README.md)
|
||||
- [SVR](../7-TimeSeries/3-SVR/README.md)
|
||||
|
||||
- Aprendizado por Reforço
|
||||
- [Q-Learning](../8-Reinforcement/1-QLearning/README.md)
|
||||
- [Gym](../8-Reinforcement/2-Gym/README.md)
|
||||
|
||||
- Aprendizado de Máquina no Mundo Real
|
||||
- [Aplicações](../9-Real-World/1-Applications/README.md)
|
||||
|
||||
**Isenção de responsabilidade**:
|
||||
Este documento foi traduzido usando serviços de tradução automática baseados em IA. Embora nos esforcemos pela precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em sua língua nativa deve ser considerado a fonte autoritativa. 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 errôneas decorrentes do uso desta tradução.
|
||||
@ -1,26 +0,0 @@
|
||||
## Para Educadores
|
||||
|
||||
Você gostaria de usar este currículo em sua sala de aula? Fique à vontade!
|
||||
|
||||
Na verdade, você pode usá-lo dentro do próprio GitHub utilizando o GitHub Classroom.
|
||||
|
||||
Para fazer isso, faça um fork deste repositório. Você precisará criar um repositório para cada lição, então será necessário extrair cada pasta em um repositório separado. Dessa forma, o [GitHub Classroom](https://classroom.github.com/classrooms) pode identificar cada lição separadamente.
|
||||
|
||||
Estas [instruções completas](https://github.blog/2020-03-18-set-up-your-digital-classroom-with-github-classroom/) lhe darão uma ideia de como configurar sua sala de aula.
|
||||
|
||||
## Usando o repositório como está
|
||||
|
||||
Se você gostaria de usar este repositório como ele está atualmente, sem usar o GitHub Classroom, isso também pode ser feito. Você precisaria se comunicar com seus alunos sobre qual lição trabalhar em conjunto.
|
||||
|
||||
Em um formato online (Zoom, Teams ou outro), você pode formar salas de discussão para os questionários e orientar os alunos para ajudá-los a se prepararem para aprender. Em seguida, convide os alunos para os questionários e envie suas respostas como 'issues' em um determinado momento. Você pode fazer o mesmo com as tarefas, se desejar que os alunos trabalhem colaborativamente de forma aberta.
|
||||
|
||||
Se preferir um formato mais privado, peça aos seus alunos que façam um fork do currículo, lição por lição, para seus próprios repositórios GitHub como repositórios privados e lhe dêem acesso. Assim, eles podem completar questionários e tarefas de forma privada e enviá-los para você através de issues no seu repositório da sala de aula.
|
||||
|
||||
Existem muitas maneiras de fazer isso funcionar em um formato de sala de aula online. Por favor, nos avise o que funciona melhor para você!
|
||||
|
||||
## Por favor, compartilhe seus pensamentos!
|
||||
|
||||
Queremos que este currículo funcione para você e seus alunos. Por favor, nos dê [feedback](https://forms.microsoft.com/Pages/ResponsePage.aspx?id=v4j5cvGGr0GRqy180BHbR2humCsRZhxNuI79cm6n0hRUQzRVVU9VVlU5UlFLWTRLWlkyQUxORTg5WS4u).
|
||||
|
||||
**Isenção de responsabilidade**:
|
||||
Este documento foi traduzido utilizando serviços de tradução automática baseados em IA. Embora nos esforcemos pela precisão, 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 autoritativa. Para informações críticas, recomenda-se a tradução profissional por um humano. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações errôneas resultantes do uso desta tradução.
|
||||
@ -1,115 +0,0 @@
|
||||
# Questionários
|
||||
|
||||
Esses questionários são os questionários de pré e pós-aula para o currículo de ML em https://aka.ms/ml-beginners
|
||||
|
||||
## Configuração do projeto
|
||||
|
||||
```
|
||||
npm install
|
||||
```
|
||||
|
||||
### Compila e recarrega rapidamente para desenvolvimento
|
||||
|
||||
```
|
||||
npm run serve
|
||||
```
|
||||
|
||||
### Compila e minifica para produção
|
||||
|
||||
```
|
||||
npm run build
|
||||
```
|
||||
|
||||
### Verifica e corrige arquivos
|
||||
|
||||
```
|
||||
npm run lint
|
||||
```
|
||||
|
||||
### Personalizar configuração
|
||||
|
||||
Veja [Referência de Configuração](https://cli.vuejs.org/config/).
|
||||
|
||||
Créditos: Agradecimentos à versão original deste aplicativo de questionário: https://github.com/arpan45/simple-quiz-vue
|
||||
|
||||
## Implantando no Azure
|
||||
|
||||
Aqui está um guia passo a passo para ajudá-lo a começar:
|
||||
|
||||
1. Fork o repositório do GitHub
|
||||
Certifique-se de que o código do seu aplicativo web estático esteja no seu repositório do GitHub. Faça um fork deste repositório.
|
||||
|
||||
2. Crie um Aplicativo Web Estático do Azure
|
||||
- Crie uma [conta no Azure](http://azure.microsoft.com)
|
||||
- Vá para o [portal do Azure](https://portal.azure.com)
|
||||
- Clique em “Criar um recurso” e procure por “Aplicativo Web Estático”.
|
||||
- Clique em “Criar”.
|
||||
|
||||
3. Configure o Aplicativo Web Estático
|
||||
- Básicos: Assinatura: Selecione sua assinatura do Azure.
|
||||
- Grupo de Recursos: Crie um novo grupo de recursos ou use um existente.
|
||||
- Nome: Forneça um nome para seu aplicativo web estático.
|
||||
- Região: Escolha a região mais próxima dos seus usuários.
|
||||
|
||||
- #### Detalhes da Implantação:
|
||||
- Fonte: Selecione “GitHub”.
|
||||
- Conta do GitHub: Autorize o Azure a acessar sua conta do GitHub.
|
||||
- Organização: Selecione sua organização do GitHub.
|
||||
- Repositório: Escolha o repositório que contém seu aplicativo web estático.
|
||||
- Branch: Selecione o branch do qual você deseja implantar.
|
||||
|
||||
- #### Detalhes da Construção:
|
||||
- Predefinições de Construção: Escolha o framework com o qual seu aplicativo foi construído (por exemplo, React, Angular, Vue, etc.).
|
||||
- Localização do Aplicativo: Especifique a pasta que contém o código do seu aplicativo (por exemplo, / se estiver na raiz).
|
||||
- Localização da API: Se você tiver uma API, especifique sua localização (opcional).
|
||||
- Localização da Saída: Especifique a pasta onde a saída da construção é gerada (por exemplo, build ou dist).
|
||||
|
||||
4. Revise e Crie
|
||||
Revise suas configurações e clique em “Criar”. O Azure configurará os recursos necessários e criará um fluxo de trabalho do GitHub Actions em seu repositório.
|
||||
|
||||
5. Fluxo de Trabalho do GitHub Actions
|
||||
O Azure criará automaticamente um arquivo de fluxo de trabalho do GitHub Actions em seu repositório (.github/workflows/azure-static-web-apps-<name>.yml). Este fluxo de trabalho lidará com o processo de construção e implantação.
|
||||
|
||||
6. Monitore a Implantação
|
||||
Vá para a aba “Ações” em seu repositório do GitHub.
|
||||
Você deve ver um fluxo de trabalho em execução. Este fluxo de trabalho irá construir e implantar seu aplicativo web estático no Azure.
|
||||
Assim que o fluxo de trabalho for concluído, seu aplicativo estará ao vivo na URL do Azure fornecida.
|
||||
|
||||
### Exemplo de Arquivo de Fluxo de Trabalho
|
||||
|
||||
Aqui está um exemplo de como o arquivo de fluxo de trabalho do GitHub Actions pode parecer:
|
||||
name: Azure Static Web Apps CI/CD
|
||||
```
|
||||
on:
|
||||
push:
|
||||
branches:
|
||||
- main
|
||||
pull_request:
|
||||
types: [opened, synchronize, reopened, closed]
|
||||
branches:
|
||||
- main
|
||||
|
||||
jobs:
|
||||
build_and_deploy_job:
|
||||
runs-on: ubuntu-latest
|
||||
name: Build and Deploy Job
|
||||
steps:
|
||||
- uses: actions/checkout@v2
|
||||
- name: Build And Deploy
|
||||
id: builddeploy
|
||||
uses: Azure/static-web-apps-deploy@v1
|
||||
with:
|
||||
azure_static_web_apps_api_token: ${{ secrets.AZURE_STATIC_WEB_APPS_API_TOKEN }}
|
||||
repo_token: ${{ secrets.GITHUB_TOKEN }}
|
||||
action: "upload"
|
||||
app_location: "/quiz-app" # App source code path
|
||||
api_location: ""API source code path optional
|
||||
output_location: "dist" #Built app content directory - optional
|
||||
```
|
||||
|
||||
### Recursos Adicionais
|
||||
- [Documentação do Azure Static Web Apps](https://learn.microsoft.com/azure/static-web-apps/getting-started)
|
||||
- [Documentação do GitHub Actions](https://docs.github.com/actions/use-cases-and-examples/deploying/deploying-to-azure-static-web-app)
|
||||
|
||||
**Aviso**:
|
||||
Este documento foi traduzido utilizando serviços de tradução automática baseados em IA. Embora nos esforcemos pela precisão, esteja ciente de que traduções automatizadas podem conter erros ou imprecisões. O documento original em sua língua nativa deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se a tradução profissional feita por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações erradas decorrentes do uso desta tradução.
|
||||
@ -1,174 +0,0 @@
|
||||
# Atribuição-CompartilhaIgual 4.0 Internacional
|
||||
|
||||
=======================================================================
|
||||
|
||||
A Creative Commons Corporation ("Creative Commons") não é um escritório de advocacia e não fornece serviços ou aconselhamento jurídico. A distribuição das licenças públicas da Creative Commons não cria uma relação advogado-cliente ou outra relação. A Creative Commons disponibiliza suas licenças e informações relacionadas em uma base "como está". A Creative Commons não oferece garantias em relação às suas licenças, qualquer material licenciado sob seus termos e condições, ou qualquer informação relacionada. A Creative Commons se isenta de toda responsabilidade por danos resultantes do uso de suas licenças na máxima extensão permitida pela lei.
|
||||
|
||||
## Usando Licenças Públicas da Creative Commons
|
||||
|
||||
As licenças públicas da Creative Commons fornecem um conjunto padrão de termos e condições que criadores e outros detentores de direitos podem usar para compartilhar obras originais de autoria e outros materiais sujeitos a direitos autorais e certos outros direitos especificados na licença pública abaixo. As considerações a seguir são apenas para fins informativos, não são exaustivas e não fazem parte de nossas licenças.
|
||||
|
||||
- Considerações para licenciadores: Nossas licenças públicas são destinadas ao uso por aqueles autorizados a dar ao público permissão para usar material de maneiras que, de outra forma, seriam restritas por direitos autorais e certos outros direitos. Nossas licenças são irrevogáveis. Os licenciadores devem ler e entender os termos e condições da licença que escolherem antes de aplicá-la. Os licenciadores também devem garantir todos os direitos necessários antes de aplicar nossas licenças, para que o público possa reutilizar o material conforme esperado. Os licenciadores devem marcar claramente qualquer material que não esteja sujeito à licença. Isso inclui outro material licenciado pela CC ou material utilizado sob uma exceção ou limitação ao direito autoral. Mais considerações para licenciadores: wiki.creativecommons.org/Considerations_for_licensors
|
||||
|
||||
- Considerações para o público: Ao usar uma de nossas licenças públicas, um licenciador concede ao público permissão para usar o material licenciado sob termos e condições especificados. Se a permissão do licenciador não for necessária por qualquer motivo—por exemplo, devido a qualquer exceção ou limitação aplicável ao direito autoral—então esse uso não é regulado pela licença. Nossas licenças concedem apenas permissões sob direitos autorais e certos outros direitos que um licenciador tem autoridade para conceder. O uso do material licenciado ainda pode ser restrito por outros motivos, incluindo porque outros têm direitos autorais ou outros direitos sobre o material. Um licenciador pode fazer solicitações especiais, como pedir que todas as alterações sejam marcadas ou descritas. Embora não seja exigido por nossas licenças, você é incentivado a respeitar essas solicitações quando razoável. Mais considerações para o público: wiki.creativecommons.org/Considerations_for_licensees
|
||||
|
||||
=======================================================================
|
||||
|
||||
## Licença Pública de Atribuição-CompartilhaIgual 4.0 Internacional da Creative Commons
|
||||
|
||||
Ao exercer os Direitos Licenciados (definidos abaixo), você aceita e concorda em estar vinculado pelos termos e condições desta Licença Pública de Atribuição-CompartilhaIgual 4.0 Internacional da Creative Commons ("Licença Pública"). Na medida em que esta Licença Pública possa ser interpretada como um contrato, você recebe os Direitos Licenciados em consideração à sua aceitação destes termos e condições, e o Licenciador concede a você tais direitos em consideração aos benefícios que o Licenciador recebe por disponibilizar o Material Licenciado sob estes termos e condições.
|
||||
|
||||
### Seção 1 -- Definições.
|
||||
|
||||
a. **Material Adaptado** significa material sujeito a Direitos Autorais e Direitos Similares que é derivado ou baseado no Material Licenciado e no qual o Material Licenciado é traduzido, alterado, organizado, transformado ou de outra forma modificado de uma maneira que requer permissão sob os Direitos Autorais e Direitos Similares detidos pelo Licenciador. Para os propósitos desta Licença Pública, quando o Material Licenciado é uma obra musical, performance ou gravação de som, o Material Adaptado é sempre produzido onde o Material Licenciado está sincronizado em relação temporal com uma imagem em movimento.
|
||||
|
||||
b. **Licença do Adaptador** significa a licença que você aplica aos seus Direitos Autorais e Direitos Similares em suas contribuições para Material Adaptado de acordo com os termos e condições desta Licença Pública.
|
||||
|
||||
c. **Licença Compatível com BY-SA** significa uma licença listada em creativecommons.org/compatiblelicenses, aprovada pela Creative Commons como essencialmente equivalente a esta Licença Pública.
|
||||
|
||||
d. **Direitos Autorais e Direitos Similares** significam direitos autorais e/ou direitos semelhantes intimamente relacionados aos direitos autorais, incluindo, sem limitação, performance, transmissão, gravação de som e Direitos de Banco de Dados Sui Generis, independentemente de como os direitos são rotulados ou categorizados. Para os propósitos desta Licença Pública, os direitos especificados na Seção 2(b)(1)-(2) não são Direitos Autorais e Direitos Similares.
|
||||
|
||||
e. **Medidas Tecnológicas Eficazes** significam aquelas medidas que, na ausência de autoridade adequada, não podem ser contornadas sob leis que cumpram obrigações sob o Artigo 11 do Tratado de Direitos Autorais da OMPI adotado em 20 de dezembro de 1996, e/ou acordos internacionais semelhantes.
|
||||
|
||||
f. **Exceções e Limitações** significam uso justo, trato justo e/ou qualquer outra exceção ou limitação aos Direitos Autorais e Direitos Similares que se aplica ao seu uso do Material Licenciado.
|
||||
|
||||
g. **Elementos da Licença** significam os atributos da licença listados no nome de uma Licença Pública da Creative Commons. Os Elementos da Licença desta Licença Pública são Atribuição e CompartilhaIgual.
|
||||
|
||||
h. **Material Licenciado** significa a obra artística ou literária, banco de dados ou outro material ao qual o Licenciador aplicou esta Licença Pública.
|
||||
|
||||
i. **Direitos Licenciados** significam os direitos concedidos a você sujeitos aos termos e condições desta Licença Pública, que são limitados a todos os Direitos Autorais e Direitos Similares que se aplicam ao seu uso do Material Licenciado e que o Licenciador tem autoridade para licenciar.
|
||||
|
||||
j. **Licenciador** significa o(s) indivíduo(s) ou entidade(s) que concede(m) direitos sob esta Licença Pública.
|
||||
|
||||
k. **Compartilhar** significa fornecer material ao público por qualquer meio ou processo que requer permissão sob os Direitos Licenciados, como reprodução, exibição pública, performance pública, distribuição, disseminação, comunicação ou importação, e tornar material disponível ao público, incluindo de maneiras que membros do público possam acessar o material de um local e em um horário individualmente escolhidos por eles.
|
||||
|
||||
l. **Direitos de Banco de Dados Sui Generis** significam direitos que não são direitos autorais resultantes da Diretiva 96/9/CE do Parlamento Europeu e do Conselho de 11 de março de 1996 sobre a proteção legal de bancos de dados, conforme alterada e/ou sucedida, bem como outros direitos essencialmente equivalentes em qualquer lugar do mundo.
|
||||
|
||||
m. **Você** significa o indivíduo ou entidade que exerce os Direitos Licenciados sob esta Licença Pública. **Seu** tem um significado correspondente.
|
||||
|
||||
### Seção 2 -- Escopo.
|
||||
|
||||
a. **Concessão de licença.**
|
||||
|
||||
1. Sujeito aos termos e condições desta Licença Pública, o Licenciador concede a você uma licença mundial, isenta de royalties, não sublicenciável, não exclusiva e irrevogável para exercer os Direitos Licenciados no Material Licenciado para:
|
||||
|
||||
a. reproduzir e Compartilhar o Material Licenciado, total ou parcialmente; e
|
||||
|
||||
b. produzir, reproduzir e Compartilhar Material Adaptado.
|
||||
|
||||
2. **Exceções e Limitações.** Para evitar dúvidas, onde Exceções e Limitações se aplicam ao seu uso, esta Licença Pública não se aplica, e você não precisa cumprir seus termos e condições.
|
||||
|
||||
3. **Prazo.** O prazo desta Licença Pública está especificado na Seção 6(a).
|
||||
|
||||
4. **Mídia e formatos; modificações técnicas permitidas.** O Licenciador autoriza você a exercer os Direitos Licenciados em todos os meios e formatos, sejam agora conhecidos ou criados posteriormente, e a fazer modificações técnicas necessárias para fazê-lo. O Licenciador renuncia e/ou concorda em não afirmar qualquer direito ou autoridade para proibir você de fazer modificações técnicas necessárias para exercer os Direitos Licenciados, incluindo modificações técnicas necessárias para contornar Medidas Tecnológicas Eficazes. Para os propósitos desta Licença Pública, simplesmente fazer modificações autorizadas por esta Seção 2(a)(4) nunca produz Material Adaptado.
|
||||
|
||||
5. **Destinatários subsequentes.**
|
||||
|
||||
a. **Oferta do Licenciador -- Material Licenciado.** Cada destinatário do Material Licenciado automaticamente recebe uma oferta do Licenciador para exercer os Direitos Licenciados sob os termos e condições desta Licença Pública.
|
||||
|
||||
b. **Oferta adicional do Licenciador -- Material Adaptado.** Cada destinatário de Material Adaptado de você automaticamente recebe uma oferta do Licenciador para exercer os Direitos Licenciados no Material Adaptado sob as condições da Licença do Adaptador que você aplica.
|
||||
|
||||
c. **Sem restrições subsequentes.** Você não pode oferecer ou impor quaisquer termos ou condições adicionais ou diferentes, ou aplicar quaisquer Medidas Tecnológicas Eficazes ao Material Licenciado se isso restringir o exercício dos Direitos Licenciados por qualquer destinatário do Material Licenciado.
|
||||
|
||||
6. **Sem endosse.** Nada nesta Licença Pública constitui ou pode ser interpretado como permissão para afirmar ou implicar que você está, ou que seu uso do Material Licenciado está, conectado com, ou patrocinado, endossado ou concedido status oficial pelo Licenciador ou outros designados para receber atribuição conforme previsto na Seção 3(a)(1)(A)(i).
|
||||
|
||||
b. **Outros direitos.**
|
||||
|
||||
1. Direitos morais, como o direito à integridade, não estão licenciados sob esta Licença Pública, nem direitos de publicidade, privacidade e/ou outros direitos de personalidade semelhantes; no entanto, na medida do possível, o Licenciador renuncia e/ou concorda em não afirmar quaisquer direitos desse tipo detidos pelo Licenciador na extensão limitada necessária para permitir que você exerça os Direitos Licenciados, mas não de outra forma.
|
||||
|
||||
2. Direitos de patente e marcas não estão licenciados sob esta Licença Pública.
|
||||
|
||||
3. Na medida do possível, o Licenciador renuncia a qualquer direito de coletar royalties de você pelo exercício dos Direitos Licenciados, seja diretamente ou através de uma sociedade de cobrança sob qualquer esquema de licenciamento voluntário ou renunciável. Em todos os outros casos, o Licenciador expressamente reserva qualquer direito de coletar tais royalties.
|
||||
|
||||
### Seção 3 -- Condições da Licença.
|
||||
|
||||
Seu exercício dos Direitos Licenciados está expressamente sujeito às seguintes condições.
|
||||
|
||||
a. **Atribuição.**
|
||||
|
||||
1. Se você Compartilhar o Material Licenciado (incluindo em forma modificada), você deve:
|
||||
|
||||
a. reter o seguinte se for fornecido pelo Licenciador com o Material Licenciado:
|
||||
|
||||
i. identificação do(s) criador(es) do Material Licenciado e quaisquer outros designados para receber atribuição, de qualquer maneira razoável solicitada pelo Licenciador (incluindo por pseudônimo se designado);
|
||||
|
||||
ii. um aviso de direitos autorais;
|
||||
|
||||
iii. um aviso que se refira a esta Licença Pública;
|
||||
|
||||
iv. um aviso que se refira à isenção de garantias;
|
||||
|
||||
v. um URI ou hiperlink para o Material Licenciado na medida do razoavelmente praticável;
|
||||
|
||||
b. indicar se você modificou o Material Licenciado e reter uma indicação de quaisquer modificações anteriores; e
|
||||
|
||||
c. indicar que o Material Licenciado está licenciado sob esta Licença Pública e incluir o texto de, ou o URI ou hiperlink para, esta Licença Pública.
|
||||
|
||||
2. Você pode satisfazer as condições na Seção 3(a)(1) de qualquer maneira razoável com base no meio, meios e contexto em que você Compartilha o Material Licenciado. Por exemplo, pode ser razoável satisfazer as condições fornecendo um URI ou hiperlink para um recurso que inclua as informações exigidas.
|
||||
|
||||
3. Se solicitado pelo Licenciador, você deve remover qualquer uma das informações exigidas pela Seção 3(a)(1)(A) na medida do razoavelmente praticável.
|
||||
|
||||
b. **CompartilhaIgual.**
|
||||
|
||||
Além das condições na Seção 3(a), se você Compartilhar Material Adaptado que produziu, as seguintes condições também se aplicam.
|
||||
|
||||
1. A Licença do Adaptador que você aplica deve ser uma licença Creative Commons com os mesmos Elementos da Licença, esta versão ou posterior, ou uma Licença Compatível com BY-SA.
|
||||
|
||||
2. Você deve incluir o texto de, ou o URI ou hiperlink para, a Licença do Adaptador que você aplica. Você pode satisfazer esta condição de qualquer maneira razoável com base no meio, meios e contexto em que você Compartilha Material Adaptado.
|
||||
|
||||
3. Você não pode oferecer ou impor quaisquer termos ou condições adicionais ou diferentes sobre, ou aplicar quaisquer Medidas Tecnológicas Eficazes ao, Material Adaptado que restrinjam o exercício dos direitos concedidos sob a Licença do Adaptador que você aplica.
|
||||
|
||||
### Seção 4 -- Direitos de Banco de Dados Sui Generis.
|
||||
|
||||
Onde os Direitos Licenciados incluem Direitos de Banco de Dados Sui Generis que se aplicam ao seu uso do Material Licenciado:
|
||||
|
||||
a. para evitar dúvidas, a Seção 2(a)(1) concede a você o direito de extrair, reutilizar, reproduzir e Compartilhar toda ou uma parte substancial do conteúdo do banco de dados;
|
||||
|
||||
b. se você incluir toda ou uma parte substancial do conteúdo do banco de dados em um banco de dados no qual você tenha Direitos de Banco de Dados Sui Generis, então o banco de dados no qual você tem Direitos de Banco de Dados Sui Generis (mas não seus conteúdos individuais) é Material Adaptado, incluindo para fins da Seção 3(b); e
|
||||
|
||||
c. você deve cumprir as condições na Seção 3(a) se você Compartilhar toda ou uma parte substancial do conteúdo do banco de dados.
|
||||
|
||||
Para evitar dúvidas, esta Seção 4 suplementa e não substitui suas obrigações sob esta Licença Pública onde os Direitos Licenciados incluem outros Direitos Autorais e Direitos Similares.
|
||||
|
||||
### Seção 5 -- Isenção de Garantias e Limitação de Responsabilidade.
|
||||
|
||||
a. A MENOS QUE SEJA OUTRA VEZ ASSUMIDO SEPARADAMENTE PELO LICENCIADOR, NA MEDIDA DO POSSÍVEL, O LICENCIADOR OFERECE O MATERIAL LICENCIADO COMO ESTÁ E DISPONÍVEL, E NÃO FAZ REPRESENTAÇÕES OU GARANTIAS DE QUALQUER TIPO RELATIVAS AO MATERIAL LICENCIADO, SEJA EXPRESSAS, IMPLÍCITAS, ESTATUTÁRIAS OU OUTRAS. ISSO INCLUI, SEM LIMITAÇÃO, GARANTIAS DE TITULARIDADE, COMERCIALIZAÇÃO, ADEQUAÇÃO A UM FIM ESPECÍFICO, NÃO INFRAÇÃO, AUSÊNCIA DE DEFEITOS LATENTES OU OUTROS, PRECISÃO, OU A PRESENÇA OU AUSÊNCIA DE ERROS, SEJA OU NÃO CONHECIDOS OU DESCOBERTOS. ONDE ISENÇÕES DE GARANTIAS NÃO SÃO PERMITIDAS EM TOTALIDADE OU EM PARTE, ESTA ISENÇÃO PODE NÃO SE APLICAR A VOCÊ.
|
||||
|
||||
b. NA MEDIDA DO POSSÍVEL, EM NENHUM CASO O LICENCIADOR SERÁ RESPONSÁVEL PERANTE VOCÊ EM QUALQUER TEORIA LEGAL (INCLUINDO, SEM LIMITAÇÃO, NEGLIGÊNCIA) OU DE OUTRA FORMA POR QUAISQUER PERDAS, CUSTOS, DESPESAS OU DANOS DIRETOS, ESPECIAIS, INDIRETOS, INCIDENTAIS, CONSEQUENCIAIS, PUNITIVOS, EXEMPLARES OU OUTROS DECORRENTES DESSA LICENÇA PÚBLICA OU DO USO DO MATERIAL LICENCIADO, MESMO QUE O LICENCIADOR TENHA SIDO AVISADO DA POSSIBILIDADE DE TAIS PERDAS, CUSTOS, DESPESAS OU DANOS. ONDE UMA LIMITAÇÃO DE RESPONSABILIDADE NÃO É PERMITIDA EM TOTALIDADE OU EM PARTE, ESTA LIMITAÇÃO PODE NÃO SE APLICAR A VOCÊ.
|
||||
|
||||
c. A isenção de garantias e a limitação de responsabilidade fornecidas acima serão interpretadas de uma maneira que, na medida do possível, mais se aproxime de uma isenção absoluta e renúncia de toda responsabilidade.
|
||||
|
||||
### Seção 6 -- Prazo e Rescisão.
|
||||
|
||||
a. Esta Licença Pública se aplica pelo prazo dos Direitos Autorais e Direitos Similares licenciados aqui. No entanto, se você não cumprir esta Licença Pública, então seus direitos sob esta Licença Pública terminam automaticamente.
|
||||
|
||||
b. Onde seu direito de usar o Material Licenciado foi encerrado sob a Seção 6(a), ele é restaurado:
|
||||
|
||||
1. automaticamente a partir da data em que a violação é corrigida, desde que seja corrigida dentro de 30 dias após sua descoberta da violação; ou
|
||||
|
||||
2. mediante restauração expressa pelo Licenciador.
|
||||
|
||||
Para evitar dúvidas, esta Seção 6(b) não afeta qualquer direito que o Licenciador possa ter de buscar remédios para suas violações desta Licença Pública.
|
||||
|
||||
c. Para evitar dúvidas, o Licenciador também pode oferecer o Material Licenciado sob termos ou condições separadas ou parar de distribuir o Material Licenciado a qualquer momento; no entanto, isso não encerrará esta Licença Pública.
|
||||
|
||||
d. As Seções 1, 5, 6, 7 e 8 sobrevivem à rescisão desta Licença Pública.
|
||||
|
||||
### Seção 7 -- Outros Termos e Condições.
|
||||
|
||||
a. O Licenciador não estará vinculado por quaisquer termos ou condições adicionais ou diferentes comunicados por você, a menos que expressamente acordados.
|
||||
|
||||
b. Quaisquer arranjos, entendimentos ou acordos relativos ao Material Licenciado não declarados aqui são separados e independentes dos termos e condições desta Licença Pública.
|
||||
|
||||
### Seção 8 -- Interpretação.
|
||||
|
||||
a. Para evitar dúvidas, esta Licença Pública não reduz, limita, restringe ou impõe condições sobre qualquer uso do Material Licenciado que poderia ser legalmente feito sem permissão sob esta Licença Pública.
|
||||
|
||||
b. Na medida do possível, se qualquer disposição desta Licença Pública for considerada inaplicável, ela será automaticamente reformulada na extensão mínima necessária para torná-la aplicável. Se a disposição não puder ser reformulada, ela será separada desta Licença Pública sem afetar a aplicabilidade dos termos e condições restantes.
|
||||
|
||||
c. Nenhum termo ou condição desta Licença Pública será renunciado e nenhuma falha em cumprir será consentida, a menos que expressamente acordada pelo Licenciador.
|
||||
|
||||
d. Nada nesta Licença Pública constitui ou pode ser interpret
|
||||
|
||||
**Isenção de responsabilidade**:
|
||||
Este documento foi traduzido usando serviços de tradução automática baseados em IA. Embora nos esforcemos pela precisão, 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 autoritativa. Para informações críticas, recomenda-se a tradução profissional feita por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações errôneas resultantes do uso desta tradução.
|
||||
@ -1,10 +0,0 @@
|
||||
Todos os sketchnotes do currículo podem ser baixados aqui.
|
||||
|
||||
🖨 Para impressão em alta resolução, as versões TIFF estão disponíveis em [este repositório](https://github.com/girliemac/a-picture-is-worth-a-1000-words/tree/main/ml/tiff).
|
||||
|
||||
🎨 Criado por: [Tomomi Imura](https://github.com/girliemac) (Twitter: [@girlie_mac](https://twitter.com/girlie_mac))
|
||||
|
||||
[](https://creativecommons.org/licenses/by-sa/4.0/)
|
||||
|
||||
**Isenção de responsabilidade**:
|
||||
Este documento foi traduzido utilizando serviços de tradução automática baseados em IA. Embora nos esforcemos pela precisão, esteja ciente de que traduções automáticas podem conter erros ou imprecisões. O documento original em sua língua nativa deve ser considerado a fonte autoritativa. Para informações críticas, recomenda-se a tradução profissional por um humano. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações errôneas decorrentes do uso desta tradução.
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue