Aprendizagem de Máquina

Introdução ao R

Prof. Jodavid Ferreira

UFPE

R

O R é uma linguagem de programação inicialmente desenvolvida para computação estatística. E licenciada como Software Livre.

Atualmente, é uma linguagem de programação muito utilizada em estatística e ciência de dados, e é uma das linguagens mais populares para análise de dados.

É uma implementação de código aberto do S, que é uma linguagem de programação estatística desenvolvida pela AT&T Bell Laboratories.

As vantagens do R para programação estatística são a facilidade de uso, a capacidade de criar gráficos de alta qualidade e a comunidade de usuários ativos.

Linguagem R

O que é um Software Livre?

Resposta:

Quem são esses caras?

Linguagem R

O que é um Software Livre?

Resposta:

Quem são esses caras?

Richard Stallman e Linus Torvalds:
- criadores do GNU e do Linux, respectivamente, e que são grandes defensores do software livre.
- GNU é um sistema operacional livre, que é compatível com o Unix.
- Linux é um kernel, que é o núcleo do sistema operacional, e é utilizado em conjunto com o GNU para formar o sistema operacional GNU/Linux.

Linguagem R

…voltando ao Software Livre…

Richard Stallman, também foi o fundador da Free Software Foundation, define um software livre como aquele que respeita a liberdade dos usuários.

Para que um software seja considerado livre, os usuários possuir as seguintes liberdades sobre o software:

A liberdade de executar o programa como desejar, para qualquer propósito.

A liberdade de estudar como o programa funciona e adaptá-lo para suas necessidades.

A liberdade de redistribuir cópias do programa.

A liberdade de melhorar o programa e distribuir suas melhorias para o público, para que toda a comunidade se beneficie.

Linguagem R

Mas o que tem de interessante nisso?

Um software livre, significa que você pode utilizá-lo para qualquer propósito, estudar seu código fonte, adaptá-lo para suas necessidades, redistribuir cópias do programa, melhorar o programa e distribuir suas melhorias para a comunidade.

Isso não é no nível de utilizar o R para fazer scripts, mas sim, que você pode pegar o R, fazer uma nova linguagem de programação baseada nele e distribuir para a comunidade, sem ter que pagar nada por isso, mas claro, respeitando a licença do R, esta deve ser a mesma na sua modificação.

Linguagem R

Para obter o R, acesse o link: https://cloud.r-project.org/
O CRAN (Comprehensive R Archive Network) é um conjunto de servidores-espelho distribuídos pelo mundo e é utilizado para distribuir o R e os pacotes do R.

Uma nova grande versão do R é lançada uma vez por ano, e há dois ou três pequenos lançamentos por ano.
É interessante manter o R sempre atualizado, pois as novas versões do R trazem melhorias de desempenho em relação aos hardware mais recentes, novas funcionalidades e correções de bugs. tware para o R.

No momento que essa aula foi criada, o R encontrava-se na versão 4.4.2.

Pacotes

Um pacote no R é uma colação de funções, dados e documentação que estende as capacidades do R base.
- O R base é o conjunto de funções que estão disponíveis quando você instala o R.

Existem milhares de pacotes disponíveis no CRAN, que foram disponibilizados por desenvolvedores de todo o mundo.
Para instalar um pacote no R, é da seguinte forma:

install.packages("nome_do_pacote")

Se não aparecer nenhum erro no console, tudo indica que o pacote foi instalado corretamente.

Pacotes

Para carregar um pacote no R, utilizamos uma das seguintes funções:

# Exemplo de importação de pacotes
library(tidyverse)

# Exemplo de importação de pacotes
require(tidyverse)

e as funções do pacote podem ser usadas de duas formas:

# Exemplo de utilização de função de pacote
iris |>
  filter(Species == "setosa") |>
  head()

  Sepal.Length Sepal.Width Petal.Length Petal.Width Species
1          5.1         3.5          1.4         0.2  setosa
2          4.9         3.0          1.4         0.2  setosa
3          4.7         3.2          1.3         0.2  setosa
4          4.6         3.1          1.5         0.2  setosa
5          5.0         3.6          1.4         0.2  setosa
6          5.4         3.9          1.7         0.4  setosa

Pacotes

# Exemplo de utilização de função de pacote
datasets::iris |>
  dplyr::filter(Species == "setosa") |>
  utils::head()

  Sepal.Length Sepal.Width Petal.Length Petal.Width Species
1          5.1         3.5          1.4         0.2  setosa
2          4.9         3.0          1.4         0.2  setosa
3          4.7         3.2          1.3         0.2  setosa
4          4.6         3.1          1.5         0.2  setosa
5          5.0         3.6          1.4         0.2  setosa
6          5.4         3.9          1.7         0.4  setosa

vou colocar aqui abaixo novamente…

# Exemplo de utilização de função de pacote
iris |>
  filter(Species == "setosa") |>
  head()

  Sepal.Length Sepal.Width Petal.Length Petal.Width Species
1          5.1         3.5          1.4         0.2  setosa
2          4.9         3.0          1.4         0.2  setosa
3          4.7         3.2          1.3         0.2  setosa
4          4.6         3.1          1.5         0.2  setosa
5          5.0         3.6          1.4         0.2  setosa
6          5.4         3.9          1.7         0.4  setosa

Operações Básicas

O R é uma linguagem de programação que suporta operações aritméticas básicas, como adição, subtração, multiplicação e divisão.

# Exemplo de operações aritméticas
1 + 1

[1] 2

8 - 1

[1] 7

10 * 2

[1] 20

35 / 5

[1] 7

Criação de Objetos

No R, é possível criar objetos para armazenar valores, e esses objetos podem ser de diferentes tipos, como números, strings, vetores, matrizes, data frames, entre outros.

Criamos novos objetos utilizando o oprador de atribuição <- ou =, estes podem ser utilizados da seguinte forma:

# Exemplo de criação de objetos
x <- 42/2
y = 47
1+1 -> z
print(x)

[1] 21

print(y)

[1] 47

print(z)

[1] 2

Utilização de Funções

O R possui uma série de funções embutidas que podem ser utilizadas para realizar operações matemáticas, estatísticas, de manipulação de dados, entre outras, estas função são utilizadas da seguinte forma:

# Exemplo de utilização de funções
sqrt(16)

[1] 4

log(2.71828)

[1] 0.9999993

Além disso, é possível criar funções personalizadas no R, e estas funções podem ser utilizadas da seguinte forma:

# Exemplo de criação de funções
quadrado <- function(x) {
  return(x^2)
}

saida <- quadrado(5)
print(saida)

[1] 25

vetores, arrays, listas e matrizes

No R, é possível criar vetores, arrays e listas, que são estruturas de dados que podem armazenar múltiplos valores.

Um vetor é uma sequência de valores de um único tipo, e é criado utilizando a função c().

# Exemplo de criação de vetores
x <- c(1, 2, 3, 4, 5)

print(x)

[1] 1 2 3 4 5

Um array é uma estrutura de dados que pode armazenar múltiplos valores de diferentes tipos, e é criado utilizando a função array().

# Exemplo de criação de arrays
y <- array(c(1, "a", TRUE), dim = c(3, 1))

print(y)

     [,1]  
[1,] "1"   
[2,] "a"   
[3,] "TRUE"

vetores, arrays, listas e matrizes

Uma lista é uma estrutura de dados que pode armazenar múltiplos valores de diferentes tipos, e é criado utilizando a função list().

# Exemplo de criação de listas
z <- list(1, "a", TRUE)

print(z)

[[1]]
[1] 1

[[2]]
[1] "a"

[[3]]
[1] TRUE

Também temos o conceito de Matrizes, que são vetores com dimensões, ou seja, são vetores que possuem linhas e colunas, e são criadas utilizando a função matrix().

# Exemplo de criação de matrizes
m <- matrix(c(1, 2, 3, 4, 5, 6), nrow = 2, ncol = 3)

print(m)

     [,1] [,2] [,3]
[1,]    1    3    5
[2,]    2    4    6

vetores, arrays, listas e matrizes

Para acessar os elementos de estruturas como um vetor, array, lista ou matriz, utilizamos colchetes [].

Vale uma observação, de que os índices em R começam em 1, e não em 0, como em algumas outras linguagens de programação.

# Exemplo de acesso a elementos de vetores
x <- c(1, 2, 3, 4, 5)

print(x[1])

[1] 1

print(x[3])

[1] 3

# Exemplo de acesso a elementos de matrizes
m <- matrix(c(1, 2, 3, 4, 5, 6), nrow = 2, ncol = 3)

print(m[1, 2])

[1] 3

print(m[2, 3])

[1] 6

Manipulação de dados com dplyr

O pacote dplyr é um pacote do R que fornece uma gramática para manipulação de dados, e é muito útil para transformar, filtrar e resumir dados.

O dplyr fornece um conjunto de funções que são fáceis de usar e que permitem realizar operações comuns de manipulação de dados de forma eficiente, dessa forma, para essa parte inicial de tratamento de dados, vamos focar na utilização desse pacote.

Vamos tentar sempre utilizar as funções da seguinte forma pacote::funcao() para evitar conflitos de funções com o mesmo nome em diferentes pacotes.

Manipulação de dados com dplyr

Vamos selecionar uma base de dados para utilizar as funções do dplyr:

dados <- nycflights13::flights

dados |> 
  head(13)

# A tibble: 13 × 19
    year month   day dep_time sched_dep_time dep_delay arr_time sched_arr_time
   <int> <int> <int>    <int>          <int>     <dbl>    <int>          <int>
 1  2013     1     1      517            515         2      830            819
 2  2013     1     1      533            529         4      850            830
 3  2013     1     1      542            540         2      923            850
 4  2013     1     1      544            545        -1     1004           1022
 5  2013     1     1      554            600        -6      812            837
 6  2013     1     1      554            558        -4      740            728
 7  2013     1     1      555            600        -5      913            854
 8  2013     1     1      557            600        -3      709            723
 9  2013     1     1      557            600        -3      838            846
10  2013     1     1      558            600        -2      753            745
11  2013     1     1      558            600        -2      849            851
12  2013     1     1      558            600        -2      853            856
13  2013     1     1      558            600        -2      924            917
# ℹ 11 more variables: arr_delay <dbl>, carrier <chr>, flight <int>,
#   tailnum <chr>, origin <chr>, dest <chr>, air_time <dbl>, distance <dbl>,
#   hour <dbl>, minute <dbl>, time_hour <dttm>

Manipulação de dados com dplyr

Conseguimos fazer filtragem de dados utilizando a função filter()

dados |> 
  dplyr::filter(month == 11, day == 1) |> 
  head(13)

# A tibble: 13 × 19
    year month   day dep_time sched_dep_time dep_delay arr_time sched_arr_time
   <int> <int> <int>    <int>          <int>     <dbl>    <int>          <int>
 1  2013    11     1        5           2359         6      352            345
 2  2013    11     1       35           2250       105      123           2356
 3  2013    11     1      455            500        -5      641            651
 4  2013    11     1      539            545        -6      856            827
 5  2013    11     1      542            545        -3      831            855
 6  2013    11     1      549            600       -11      912            923
 7  2013    11     1      550            600       -10      705            659
 8  2013    11     1      554            600        -6      659            701
 9  2013    11     1      554            600        -6      826            827
10  2013    11     1      554            600        -6      749            751
11  2013    11     1      555            600        -5      847            854
12  2013    11     1      555            600        -5      839            846
13  2013    11     1      555            600        -5      929            943
# ℹ 11 more variables: arr_delay <dbl>, carrier <chr>, flight <int>,
#   tailnum <chr>, origin <chr>, dest <chr>, air_time <dbl>, distance <dbl>,
#   hour <dbl>, minute <dbl>, time_hour <dttm>

Manipulação de dados com dplyr

Para usar filtragens de forma eficaz, você precisa saber como utilizar operadores de comparação e operadores lógicos.

Alguns operadores são:

Operadores de comparação:
- == igual a
- != diferente de
- > maior que
- < menor que

Operadores lógicos:
- & e
- | ou
- ! não

Manipulação de dados com dplyr

Neste caso, podemos utilizar

dados |> 
  dplyr::filter(month == 11 & day == 1) |> 
  head(5)

# A tibble: 5 × 19
   year month   day dep_time sched_dep_time dep_delay arr_time sched_arr_time
  <int> <int> <int>    <int>          <int>     <dbl>    <int>          <int>
1  2013    11     1        5           2359         6      352            345
2  2013    11     1       35           2250       105      123           2356
3  2013    11     1      455            500        -5      641            651
4  2013    11     1      539            545        -6      856            827
5  2013    11     1      542            545        -3      831            855
# ℹ 11 more variables: arr_delay <dbl>, carrier <chr>, flight <int>,
#   tailnum <chr>, origin <chr>, dest <chr>, air_time <dbl>, distance <dbl>,
#   hour <dbl>, minute <dbl>, time_hour <dttm>

dados |> 
  dplyr::filter(!(month != 11 | day != 1)) |> 
  head(5)

# A tibble: 5 × 19
   year month   day dep_time sched_dep_time dep_delay arr_time sched_arr_time
  <int> <int> <int>    <int>          <int>     <dbl>    <int>          <int>
1  2013    11     1        5           2359         6      352            345
2  2013    11     1       35           2250       105      123           2356
3  2013    11     1      455            500        -5      641            651
4  2013    11     1      539            545        -6      856            827
5  2013    11     1      542            545        -3      831            855
# ℹ 11 more variables: arr_delay <dbl>, carrier <chr>, flight <int>,
#   tailnum <chr>, origin <chr>, dest <chr>, air_time <dbl>, distance <dbl>,
#   hour <dbl>, minute <dbl>, time_hour <dttm>

Manipulação de dados com dplyr

Um problema que pode surgir para complicar as comparações, são os valores faltantes.
Os NAs (“not available”, em português, “não disponível”) são valores que não existem na base de dados.
Qualquer operação envolvendo um valor desconhecido, também será desconhecida.

NA > 5

[1] NA

10 == NA

[1] NA

NA + 10

[1] NA

NA == NA

[1] NA

Para verificar se um valor é faltante, pode utilizar a função is.na().

is.na(NA)

[1] TRUE

is.na(10)

[1] FALSE

Manipulação de dados com dplyr

A função filter() só considera as linhas em que a condição é verdadeira (TRUE), e descarta as linhas em que a condição é falsa (FALSE) ou NA. Se deseja preservar os valores faltantes, peça eles explicitamente:

dados |> 
  dplyr::filter(is.na(dep_time)) |> 
  head(10)

# A tibble: 10 × 19
    year month   day dep_time sched_dep_time dep_delay arr_time sched_arr_time
   <int> <int> <int>    <int>          <int>     <dbl>    <int>          <int>
 1  2013     1     1       NA           1630        NA       NA           1815
 2  2013     1     1       NA           1935        NA       NA           2240
 3  2013     1     1       NA           1500        NA       NA           1825
 4  2013     1     1       NA            600        NA       NA            901
 5  2013     1     2       NA           1540        NA       NA           1747
 6  2013     1     2       NA           1620        NA       NA           1746
 7  2013     1     2       NA           1355        NA       NA           1459
 8  2013     1     2       NA           1420        NA       NA           1644
 9  2013     1     2       NA           1321        NA       NA           1536
10  2013     1     2       NA           1545        NA       NA           1910
# ℹ 11 more variables: arr_delay <dbl>, carrier <chr>, flight <int>,
#   tailnum <chr>, origin <chr>, dest <chr>, air_time <dbl>, distance <dbl>,
#   hour <dbl>, minute <dbl>, time_hour <dttm>

Manipulação de dados com dplyr

Outra função interessante é a arraange(), que serve para ordenar os dados.
Ele funciona semelhante ao filter(), mas ao invés de filtrar, ele ordena.

dados |> 
  dplyr::arrange(desc(dep_time)) |> 
  head(10)

# A tibble: 10 × 19
    year month   day dep_time sched_dep_time dep_delay arr_time sched_arr_time
   <int> <int> <int>    <int>          <int>     <dbl>    <int>          <int>
 1  2013    10    30     2400           2359         1      327            337
 2  2013    11    27     2400           2359         1      515            445
 3  2013    12     5     2400           2359         1      427            440
 4  2013    12     9     2400           2359         1      432            440
 5  2013    12     9     2400           2250        70       59           2356
 6  2013    12    13     2400           2359         1      432            440
 7  2013    12    19     2400           2359         1      434            440
 8  2013    12    29     2400           1700       420      302           2025
 9  2013     2     7     2400           2359         1      432            436
10  2013     2     7     2400           2359         1      443            444
# ℹ 11 more variables: arr_delay <dbl>, carrier <chr>, flight <int>,
#   tailnum <chr>, origin <chr>, dest <chr>, air_time <dbl>, distance <dbl>,
#   hour <dbl>, minute <dbl>, time_hour <dttm>

Manipulação de dados com dplyr

é possível ordenar por mais de uma coluna, basta passar mais argumentos para a função arrange().

dados |> 
  dplyr::arrange(year, month, day) |> 
  head(10)

# A tibble: 10 × 19
    year month   day dep_time sched_dep_time dep_delay arr_time sched_arr_time
   <int> <int> <int>    <int>          <int>     <dbl>    <int>          <int>
 1  2013     1     1      517            515         2      830            819
 2  2013     1     1      533            529         4      850            830
 3  2013     1     1      542            540         2      923            850
 4  2013     1     1      544            545        -1     1004           1022
 5  2013     1     1      554            600        -6      812            837
 6  2013     1     1      554            558        -4      740            728
 7  2013     1     1      555            600        -5      913            854
 8  2013     1     1      557            600        -3      709            723
 9  2013     1     1      557            600        -3      838            846
10  2013     1     1      558            600        -2      753            745
# ℹ 11 more variables: arr_delay <dbl>, carrier <chr>, flight <int>,
#   tailnum <chr>, origin <chr>, dest <chr>, air_time <dbl>, distance <dbl>,
#   hour <dbl>, minute <dbl>, time_hour <dttm>

Se deseja ordenar em forma decrescente, basta utilizar a função desc().

Manipulação de dados com dplyr

A função select() é utilizada para selecionar colunas de um data frame.

dados |> 
  dplyr::select(year, month, day) |> 
  head(15)

# A tibble: 15 × 3
    year month   day
   <int> <int> <int>
 1  2013     1     1
 2  2013     1     1
 3  2013     1     1
 4  2013     1     1
 5  2013     1     1
 6  2013     1     1
 7  2013     1     1
 8  2013     1     1
 9  2013     1     1
10  2013     1     1
11  2013     1     1
12  2013     1     1
13  2013     1     1
14  2013     1     1
15  2013     1     1

Manipulação de dados com dplyr

É possível excluir colunas também utilizando o select().

dados |> 
  dplyr::select(-year, -month, -day) |> 
  head(15)

# A tibble: 15 × 16
   dep_time sched_dep_time dep_delay arr_time sched_arr_time arr_delay carrier
      <int>          <int>     <dbl>    <int>          <int>     <dbl> <chr>  
 1      517            515         2      830            819        11 UA     
 2      533            529         4      850            830        20 UA     
 3      542            540         2      923            850        33 AA     
 4      544            545        -1     1004           1022       -18 B6     
 5      554            600        -6      812            837       -25 DL     
 6      554            558        -4      740            728        12 UA     
 7      555            600        -5      913            854        19 B6     
 8      557            600        -3      709            723       -14 EV     
 9      557            600        -3      838            846        -8 B6     
10      558            600        -2      753            745         8 AA     
11      558            600        -2      849            851        -2 B6     
12      558            600        -2      853            856        -3 B6     
13      558            600        -2      924            917         7 UA     
14      558            600        -2      923            937       -14 UA     
15      559            600        -1      941            910        31 AA     
# ℹ 9 more variables: flight <int>, tailnum <chr>, origin <chr>, dest <chr>,
#   air_time <dbl>, distance <dbl>, hour <dbl>, minute <dbl>, time_hour <dttm>

Manipulação de dados com dplyr

A função mutate() é utilizada para criar novas colunas a partir de colunas existentes.

dados |> 
  dplyr::mutate(speed = distance / air_time) |> 
  head(15)

# A tibble: 15 × 20
    year month   day dep_time sched_dep_time dep_delay arr_time sched_arr_time
   <int> <int> <int>    <int>          <int>     <dbl>    <int>          <int>
 1  2013     1     1      517            515         2      830            819
 2  2013     1     1      533            529         4      850            830
 3  2013     1     1      542            540         2      923            850
 4  2013     1     1      544            545        -1     1004           1022
 5  2013     1     1      554            600        -6      812            837
 6  2013     1     1      554            558        -4      740            728
 7  2013     1     1      555            600        -5      913            854
 8  2013     1     1      557            600        -3      709            723
 9  2013     1     1      557            600        -3      838            846
10  2013     1     1      558            600        -2      753            745
11  2013     1     1      558            600        -2      849            851
12  2013     1     1      558            600        -2      853            856
13  2013     1     1      558            600        -2      924            917
14  2013     1     1      558            600        -2      923            937
15  2013     1     1      559            600        -1      941            910
# ℹ 12 more variables: arr_delay <dbl>, carrier <chr>, flight <int>,
#   tailnum <chr>, origin <chr>, dest <chr>, air_time <dbl>, distance <dbl>,
#   hour <dbl>, minute <dbl>, time_hour <dttm>, speed <dbl>

Manipulação de dados com dplyr

Existe também a função summarise(), que é utilizada para resumir os dados.
A função summarise() é muito útil para resumir os dados e obter estatísticas descritivas.

dados |> 
  dplyr::summarise(mean_distance = mean(distance), 
                   mean_air_time = mean(air_time))

# A tibble: 1 × 2
  mean_distance mean_air_time
          <dbl>         <dbl>
1         1040.            NA

Observe que para a variável air_time o resultado foi NA, isso ocorreu porque a função mean() não sabe o que fazer com valores faltantes. Nesse caso, devemos passar como argumento para remover os valores faltantes.

dados |> 
  dplyr::summarise(mean_distance = mean(distance), 
                   mean_air_time = mean(air_time, na.rm = TRUE))

# A tibble: 1 × 2
  mean_distance mean_air_time
          <dbl>         <dbl>
1         1040.          151.

Manipulação de dados com dplyr

A função group_by() é utilizada para agrupar os dados por uma ou mais variáveis.

dados |> 
  dplyr::group_by(month) |> 
  dplyr::summarise(mean_distance = mean(distance), 
                   mean_air_time = mean(air_time, na.rm = TRUE))

# A tibble: 12 × 3
   month mean_distance mean_air_time
   <int>         <dbl>         <dbl>
 1     1         1007.          154.
 2     2         1001.          151.
 3     3         1012.          149.
 4     4         1039.          153.
 5     5         1041.          146.
 6     6         1057.          150.
 7     7         1059.          147.
 8     8         1062.          148.
 9     9         1041.          143.
10    10         1039.          149.
11    11         1050.          155.
12    12         1065.          163.

Manipulação de dados com dplyr

Contagens também é uma operação muito comum, e para isso, utilizamos a função n().

dados |> 
  dplyr::group_by(month) |> 
  dplyr::summarise(n = n())

# A tibble: 12 × 2
   month     n
   <int> <int>
 1     1 27004
 2     2 24951
 3     3 28834
 4     4 28330
 5     5 28796
 6     6 28243
 7     7 29425
 8     8 29327
 9     9 27574
10    10 28889
11    11 27268
12    12 28135

Manipulação de dados com dplyr

Também conseguimos agrupar por múltiplas variáveis, basta passar mais argumentos para a função group_by()

dados |> 
  dplyr::group_by(month, day) |> 
  dplyr::summarise(n = n())

# A tibble: 365 × 3
# Groups:   month [12]
   month   day     n
   <int> <int> <int>
 1     1     1   842
 2     1     2   943
 3     1     3   914
 4     1     4   915
 5     1     5   720
 6     1     6   832
 7     1     7   933
 8     1     8   899
 9     1     9   902
10     1    10   932
# ℹ 355 more rows

Manipulação de dados com dplyr

Então, quando estivermos trabalhando com manipulação de dados, vamos procurar sempre trabalhar com os pacotes do tidyverse, que são pacotes que seguem uma filosofia de organização de dados, e que são muito úteis para manipulação de dados. Entre eles, estão:
- dplyr: para manipulação de dados
- ggplot2: para visualização de dados
- tidyr: para organização de dados
- readr: para leitura de dados
- purrr: para programação funcional, como mapeamento e redução
- tibble: para organização de dados
- stringr: para manipulação de strings
- tidymodels: para modelagem estatística e machine learning

Referências

Básicas

Aprendizado de Máquina: uma abordagem estatística, Izibicki, R. and Santos, T. M., 2020, link: https://rafaelizbicki.com/AME.pdf.
An Introduction to Statistical Learning: with Applications in R, James, G., Witten, D., Hastie, T. and Tibshirani, R., Springer, 2013, link: https://www.statlearning.com/.
Mathematics for Machine Learning, Deisenroth, M. P., Faisal. A. F., Ong, C. S., Cambridge University Press, 2020, link: https://mml-book.com.

Referências

Complementares

An Introduction to Statistical Learning: with Applications in python, James, G., Witten, D., Hastie, T. and Tibshirani, R., Taylor, J., Springer, 2023, link: https://www.statlearning.com/.
Matrix Calculus (for Machine Learning and Beyond), Paige Bright, Alan Edelman, Steven G. Johnson, 2025, link: https://arxiv.org/abs/2501.14787.
Machine Learning Beyond Point Predictions: Uncertainty Quantification, Izibicki, R., 2025, link: https://rafaelizbicki.com/UQ4ML.pdf.
Mathematics of Machine Learning, Petersen, P. C., 2022, link: http://www.pc-petersen.eu/ML_Lecture.pdf.

OBRIGADO!

Slide produzido com quarto