|
Machine Learning
|
Introdução ao R
Instalação e artimética básica
Prof. Walmes M. Zeviani
2018-08-03
1 Introdução ao ambiente R
2 Download e instalação do R
- Download do R: http://cran.r-project.org/.
- Download do RStudio: http://www.rstudio.com/products/RStudio/.
- Download do Emacs+ESS:
- usuários Windows http://vgoulet.act.ulaval.ca/en/emacs/.
- usuários Linux instalam por
sudo apt-get install emacs ess.
- Download do Tinn-R (para Windows apenas): http://sourceforge.net/projects/tinn-r/.
- Outros editores:
3 Primeiros passos
Abra o R instalado em seu sistema para iniciar uma sessão.
# Texto após o sinal de hash não é interpretado, serve de comentário.
2 + 6 + 5 + 9 + 3 + 2 # Comentário pode ser após alguma instrução.
# Uma intrução pode ser dividida em duas linhas.
2 + 6 + 5 +
9 + 3 + 2
# E em uma linha podem existir mais de uma instrução.
2 + 6; 14 + 12; 40 - 234 Objetos
Em um curso introdutório aborda-se os 4 tipos básicos de objetos para armazenamento de dados no R: vetores, arranjos, tabelas (data.frames) e listas. Em resumo, distinguem-se tais objetos pela forma na qual armazenam dados.
- vetor: tem apenas uma dimensão que é o comprimento (número de elementos) e armazena valores de apenas um tipo (ex. só números inteiros).
- arranjo (array): é uma extensão de vetor que permite mais de uma dimensão. Só permite um tipo de valor. No caso de ter duas dimensões (linha e coluna) chamamos os arranjos de matrizes.
- tabela: no idioma R são mais conhecidos por data frames. Têm duas dimensões (linha e coluna). Cada coluna é como se fosse um vetor e por isso pode ter tipo de conteúdo diferente das demais colunas. Todas as colunas têm o mesmo comprimento (que é o que permite acomodar no formato de tabela).
- lista: é um tipo de objeto cuja unidade básica é o item da lista. O “tamanho” da lista é o número de elementos/itens que possui. Cada elemento, no entanto, pode ser um objeto de qualquer classe mecionada acima. O data frame é uma lista especial na qual cada item é um vetor (ou matriz) de mesmo número de elementos (linhas).
Nos objetos é importante conhecer formas de selecionar os valores dentro do objeto. Além disso, conhecer os atributos e saber modificá-los é interessante principalmente porque gráficos e procedimentos sobre tais objetos dependem dos seus atributos propriedades. As formas de selecionar elementos de um objeto são com os operadores:
[],[ , ],[ , , ]: para vetores e arranjos. As virgulas servem para especificar à dimensão que recebe seleção. Serve para selecionar listas e data frames também.$: para listas e data frames (pois DF é um caso de lista).[[]]: serve para listas.@: serve para listas de objetos classe S4.
A seleção de elementos/linhas/colunas/itens nos objetos pode ser de 4 formas:
- Pelo índice: número inteiro correspondente à sua posição.
- Por um vetor lógico: valores
TRUEvão selecionar os elementos correspondentes. - Pelo nome: quando o elemento possui nome.
Abaixo são ilustrados os 4 tipos básicos, atributos e seleção.
#-----------------------------------------------------------------------
# Vetor.
x <- 100:105
# Atributos.
class(x)## [1] "integer"mode(x)## [1] "numeric"typeof(x)## [1] "integer"length(x)## [1] 6str(x)## int [1:6] 100 101 102 103 104 105attributes(x)## NULLdput(x)## 100:105is.vector(x)## [1] TRUEis.numeric(x)## [1] TRUEis.integer(x)## [1] TRUEx[3:5]## [1] 102 103 104x[-2]## [1] 100 102 103 104 105x[c(2, 3)]## [1] 101 102#-----------------------------------------------------------------------
# Vetor nomeado.
x <- c(Paulo = 7.8, Ulisses = 9, Ricardo = 8.5, Lincon = 4.5,
Thobias = 7.1)
# Atributos.
class(x)## [1] "numeric"mode(x)## [1] "numeric"typeof(x)## [1] "double"length(x)## [1] 5str(x)## Named num [1:5] 7.8 9 8.5 4.5 7.1
## - attr(*, "names")= chr [1:5] "Paulo" "Ulisses" "Ricardo" "Lincon" ...attributes(x)## $names
## [1] "Paulo" "Ulisses" "Ricardo" "Lincon" "Thobias"dput(x)## structure(c(7.8, 9, 8.5, 4.5, 7.1), .Names = c("Paulo", "Ulisses",
## "Ricardo", "Lincon", "Thobias"))is.vector(x)## [1] TRUEis.numeric(x)## [1] TRUEis.integer(x)## [1] FALSEx[3:5]## Ricardo Lincon Thobias
## 8.5 4.5 7.1x[-2]## Paulo Ricardo Lincon Thobias
## 7.8 8.5 4.5 7.1x[c(2, 3)]## Ulisses Ricardo
## 9.0 8.5x["Ulisses"]## Ulisses
## 9x[c("Ricardo", "Thobias")]## Ricardo Thobias
## 8.5 7.1#-----------------------------------------------------------------------
# Um arranjo de duas dimensões.
X <- matrix(1:9, nrow = 3, ncol = 3)
class(X)## [1] "matrix"mode(X)## [1] "numeric"typeof(X)## [1] "integer"dim(X) # ncol(X) e nrow(X).## [1] 3 3str(X)## int [1:3, 1:3] 1 2 3 4 5 6 7 8 9attributes(X)## $dim
## [1] 3 3dput(X)## structure(1:9, .Dim = c(3L, 3L))is.matrix(X)## [1] TRUEis.array(X)## [1] TRUEis.numeric(X)## [1] TRUEis.integer(X)## [1] TRUEX[1, ]## [1] 1 4 7X[1:2, ]## [,1] [,2] [,3]
## [1,] 1 4 7
## [2,] 2 5 8X[-2, ]## [,1] [,2] [,3]
## [1,] 1 4 7
## [2,] 3 6 9X[, -2]## [,1] [,2]
## [1,] 1 7
## [2,] 2 8
## [3,] 3 9X[, c(3, 2, 1)]## [,1] [,2] [,3]
## [1,] 7 4 1
## [2,] 8 5 2
## [3,] 9 6 3X[3:1, c(3, 2, 1)]## [,1] [,2] [,3]
## [1,] 9 6 3
## [2,] 8 5 2
## [3,] 7 4 1#-----------------------------------------------------------------------
# Um arranjo de 3 dimensões (cúbico).
X <- array(1:24, dim = c(3, 4, 2))
class(X)## [1] "array"mode(X)## [1] "numeric"typeof(X)## [1] "integer"dim(X) # ncol(X) e nrow(X).## [1] 3 4 2str(X)## int [1:3, 1:4, 1:2] 1 2 3 4 5 6 7 8 9 10 ...attributes(X)## $dim
## [1] 3 4 2dput(X)## structure(1:24, .Dim = c(3L, 4L, 2L))is.matrix(X)## [1] FALSEis.array(X)## [1] TRUEis.numeric(X)## [1] TRUEis.integer(X)## [1] TRUEX## , , 1
##
## [,1] [,2] [,3] [,4]
## [1,] 1 4 7 10
## [2,] 2 5 8 11
## [3,] 3 6 9 12
##
## , , 2
##
## [,1] [,2] [,3] [,4]
## [1,] 13 16 19 22
## [2,] 14 17 20 23
## [3,] 15 18 21 24X[1, , ]## [,1] [,2]
## [1,] 1 13
## [2,] 4 16
## [3,] 7 19
## [4,] 10 22X[, 1, ]## [,1] [,2]
## [1,] 1 13
## [2,] 2 14
## [3,] 3 15X[, , 1]## [,1] [,2] [,3] [,4]
## [1,] 1 4 7 10
## [2,] 2 5 8 11
## [3,] 3 6 9 12#-----------------------------------------------------------------------
# Um data frame.
da <- data.frame(id = 1:5,
aluno = c("Júlio", "Ana", "Pietra", "Bianca", "Nelson"),
nota = c(9, 8.5, 7.1, 9.8, 8),
falta = c(12, 4, 4, 0, 2))
class(da)## [1] "data.frame"mode(da)## [1] "list"typeof(da)## [1] "list"dim(da) # ncol(da) e nrow(da).## [1] 5 4str(da)## 'data.frame': 5 obs. of 4 variables:
## $ id : int 1 2 3 4 5
## $ aluno: Factor w/ 5 levels "Ana","Bianca",..: 3 1 5 2 4
## $ nota : num 9 8.5 7.1 9.8 8
## $ falta: num 12 4 4 0 2attributes(da)## $names
## [1] "id" "aluno" "nota" "falta"
##
## $row.names
## [1] 1 2 3 4 5
##
## $class
## [1] "data.frame"dput(da)## structure(list(id = 1:5, aluno = structure(c(3L, 1L, 5L, 2L,
## 4L), .Label = c("Ana", "Bianca", "Júlio", "Nelson", "Pietra"
## ), class = "factor"), nota = c(9, 8.5, 7.1, 9.8, 8), falta = c(12,
## 4, 4, 0, 2)), .Names = c("id", "aluno", "nota", "falta"), row.names = c(NA,
## -5L), class = "data.frame")is.data.frame(da)## [1] TRUEis.list(da)## [1] TRUEda[1, ]## id aluno nota falta
## 1 1 Júlio 9 12da[, 2]## [1] Júlio Ana Pietra Bianca Nelson
## Levels: Ana Bianca Júlio Nelson Pietrada[, "aluno"]## [1] Júlio Ana Pietra Bianca Nelson
## Levels: Ana Bianca Júlio Nelson Pietrada[, c("nota", "falta")]## nota falta
## 1 9.0 12
## 2 8.5 4
## 3 7.1 4
## 4 9.8 0
## 5 8.0 2da[1:3, c("nota", "falta")]## nota falta
## 1 9.0 12
## 2 8.5 4
## 3 7.1 4#-----------------------------------------------------------------------
# Uma lista.
L <- list(item1 = x, item2 = X, item3 = da)
class(L)## [1] "list"mode(L)## [1] "list"typeof(L)## [1] "list"length(L)## [1] 3str(L)## List of 3
## $ item1: Named num [1:5] 7.8 9 8.5 4.5 7.1
## ..- attr(*, "names")= chr [1:5] "Paulo" "Ulisses" "Ricardo" "Lincon" ...
## $ item2: int [1:3, 1:4, 1:2] 1 2 3 4 5 6 7 8 9 10 ...
## $ item3:'data.frame': 5 obs. of 4 variables:
## ..$ id : int [1:5] 1 2 3 4 5
## ..$ aluno: Factor w/ 5 levels "Ana","Bianca",..: 3 1 5 2 4
## ..$ nota : num [1:5] 9 8.5 7.1 9.8 8
## ..$ falta: num [1:5] 12 4 4 0 2attributes(L)## $names
## [1] "item1" "item2" "item3"dput(L)## structure(list(item1 = structure(c(7.8, 9, 8.5, 4.5, 7.1), .Names = c("Paulo",
## "Ulisses", "Ricardo", "Lincon", "Thobias")), item2 = structure(1:24, .Dim = c(3L,
## 4L, 2L)), item3 = structure(list(id = 1:5, aluno = structure(c(3L,
## 1L, 5L, 2L, 4L), .Label = c("Ana", "Bianca", "Júlio", "Nelson",
## "Pietra"), class = "factor"), nota = c(9, 8.5, 7.1, 9.8, 8),
## falta = c(12, 4, 4, 0, 2)), .Names = c("id", "aluno", "nota",
## "falta"), row.names = c(NA, -5L), class = "data.frame")), .Names = c("item1",
## "item2", "item3"))is.data.frame(L)## [1] FALSEis.list(L)## [1] TRUEL$item1## Paulo Ulisses Ricardo Lincon Thobias
## 7.8 9.0 8.5 4.5 7.1L$item3[, "aluno"]## [1] Júlio Ana Pietra Bianca Nelson
## Levels: Ana Bianca Júlio Nelson PietraL[-2]## $item1
## Paulo Ulisses Ricardo Lincon Thobias
## 7.8 9.0 8.5 4.5 7.1
##
## $item3
## id aluno nota falta
## 1 1 Júlio 9.0 12
## 2 2 Ana 8.5 4
## 3 3 Pietra 7.1 4
## 4 4 Bianca 9.8 0
## 5 5 Nelson 8.0 2L[["item1"]]## Paulo Ulisses Ricardo Lincon Thobias
## 7.8 9.0 8.5 4.5 7.1L[[1]]## Paulo Ulisses Ricardo Lincon Thobias
## 7.8 9.0 8.5 4.5 7.15 Regras lógicas
É muito frequênte a necessidade de selecionar elementos de um objeto de acordo com alguma regra lógica. No objeto da, por exemplo, quais os alunos com mais de 10 faltas? Quantos alunos nota superior à 9?
Para responder à essas perguntam tem-se que utilizar regras lógicas. As regras lógicas podem ser simples ou compostas. Os operadores para regras lógicas são < > <= >= == !=. Os operadores para fazer regras compostas são o E & e o OU |. E o operador %in% é usado para representar o operador pertence para conjuntos. O resultado de uma regra lógica é um vetor lógico que no caso será usando para seleção. São operadores também úteis o “todos” all() e “algum” any().
# Selecionando as notas maiores que 8.
sel <- da$nota > 8
sel## [1] TRUE TRUE FALSE TRUE FALSEda[sel, ]## id aluno nota falta
## 1 1 Júlio 9.0 12
## 2 2 Ana 8.5 4
## 4 4 Bianca 9.8 0# Selecionando as notas maiores que 8 com faltas não superior à 10.
sel <- da$nota > 8 & da$falta <= 10
sel## [1] FALSE TRUE FALSE TRUE FALSEda[sel, ]## id aluno nota falta
## 2 2 Ana 8.5 4
## 4 4 Bianca 9.8 0# O operador ! inverte um vetor lógico.
!sel## [1] TRUE FALSE TRUE FALSE TRUEda[!sel, ]## id aluno nota falta
## 1 1 Júlio 9.0 12
## 3 3 Pietra 7.1 4
## 5 5 Nelson 8.0 2da$nota > 8 & da$falta <= 10## [1] FALSE TRUE FALSE TRUE FALSE# da$nota>8 && da$falta<=10 # **verificar!
sel <- da$aluno %in% c("Ana", "Bianca")
# sel <- is.element(da$aluno, c("Ana", "Bianca"))
da[sel, ]## id aluno nota falta
## 2 2 Ana 8.5 4
## 4 4 Bianca 9.8 0all(da$nota > 7)## [1] TRUEany(da$falta < 10)## [1] TRUEsum(da$nota > 8)## [1] 36 Conversão
As conversões podem ser de formato ou de tipo de conteúdo. Pode-se precisar converter um data frame em uma matriz para, por exemplo, fazer uma análise de componentes principais bem como converter um vetor de characteres para fator para mudar a ordem ou rótulo de seus níveis. As funções para conversão iniciam com o padrão as.*.
# As funções para conversão.
apropos("^as\\.")## [1] "as.array" "as.array.default"
## [3] "as.call" "as.character"
## [5] "as.character.condition" "as.character.Date"
## [7] "as.character.default" "as.character.error"
## [9] "as.character.factor" "as.character.hexmode"
## [11] "as.character.numeric_version" "as.character.octmode"
## [13] "as.character.POSIXt" "as.character.srcref"
## [15] "as.complex" "as.data.frame"
## [17] "as.data.frame.array" "as.data.frame.AsIs"
## [19] "as.data.frame.character" "as.data.frame.complex"
## [21] "as.data.frame.data.frame" "as.data.frame.Date"
## [23] "as.data.frame.default" "as.data.frame.difftime"
## [25] "as.data.frame.factor" "as.data.frame.integer"
## [27] "as.data.frame.list" "as.data.frame.logical"
## [29] "as.data.frame.matrix" "as.data.frame.model.matrix"
## [31] "as.data.frame.noquote" "as.data.frame.numeric"
## [33] "as.data.frame.numeric_version" "as.data.frame.ordered"
## [35] "as.data.frame.POSIXct" "as.data.frame.POSIXlt"
## [37] "as.data.frame.raw" "as.data.frame.table"
## [39] "as.data.frame.ts" "as.data.frame.vector"
## [41] "as.Date" "as.Date.character"
## [43] "as.Date.date" "as.Date.dates"
## [45] "as.Date.default" "as.Date.factor"
## [47] "as.Date.numeric" "as.Date.POSIXct"
## [49] "as.Date.POSIXlt" "as.dendrogram"
## [51] "as.difftime" "as.dist"
## [53] "as.double" "as.double.difftime"
## [55] "as.double.POSIXlt" "as.environment"
## [57] "as.expression" "as.expression.default"
## [59] "as.factor" "as.factorOrShingle"
## [61] "as.formula" "as.function"
## [63] "as.function.default" "as.graphicsAnnot"
## [65] "as.hclust" "as.hexmode"
## [67] "as.integer" "as.layer"
## [69] "as.list" "as.list.data.frame"
## [71] "as.list.Date" "as.list.default"
## [73] "as.list.environment" "as.list.factor"
## [75] "as.list.function" "as.list.numeric_version"
## [77] "as.list.POSIXct" "as.logical"
## [79] "as.logical.factor" "as.matrix"
## [81] "as.matrix.data.frame" "as.matrix.default"
## [83] "as.matrix.noquote" "as.matrix.POSIXlt"
## [85] "as.name" "as.null"
## [87] "as.null.default" "as.numeric"
## [89] "as.numeric_version" "as.octmode"
## [91] "as.ordered" "as.package_version"
## [93] "as.pairlist" "as.person"
## [95] "as.personList" "as.POSIXct"
## [97] "as.POSIXct.date" "as.POSIXct.Date"
## [99] "as.POSIXct.dates" "as.POSIXct.default"
## [101] "as.POSIXct.numeric" "as.POSIXct.POSIXlt"
## [103] "as.POSIXlt" "as.POSIXlt.character"
## [105] "as.POSIXlt.date" "as.POSIXlt.Date"
## [107] "as.POSIXlt.dates" "as.POSIXlt.default"
## [109] "as.POSIXlt.factor" "as.POSIXlt.numeric"
## [111] "as.POSIXlt.POSIXct" "as.qr"
## [113] "as.raster" "as.raw"
## [115] "as.relistable" "as.roman"
## [117] "as.shingle" "as.single"
## [119] "as.single.default" "as.stepfun"
## [121] "as.symbol" "as.table"
## [123] "as.table.default" "as.ts"
## [125] "as.vector" "as.vector.factor"# De numérico para inteiro.
x <- seq(from = 1, to = 12, by = 2)
x## [1] 1 3 5 7 9 11# c(1, 3, 4)
# c(1L, 3L, 4L)
is.integer(x)## [1] FALSEobject.size(x)## 88 bytesdput(x)## c(1, 3, 5, 7, 9, 11)x <- as.integer(x)
object.size(x)## 72 bytesdput(x)## c(1L, 3L, 5L, 7L, 9L, 11L)# De data.frame para lista.
as.list(da)## $id
## [1] 1 2 3 4 5
##
## $aluno
## [1] Júlio Ana Pietra Bianca Nelson
## Levels: Ana Bianca Júlio Nelson Pietra
##
## $nota
## [1] 9.0 8.5 7.1 9.8 8.0
##
## $falta
## [1] 12 4 4 0 2# De vetor para matriz.
as.matrix(x)## [,1]
## [1,] 1
## [2,] 3
## [3,] 5
## [4,] 7
## [5,] 9
## [6,] 11Dentre os tipos de conversão deve-se destacar a importância daquela que envolve characteres e fatores. Muitos dos métodos de análise de dados, das tabelas de frequência até análise de variância são desenvolvidos para dados do tipo fator.
# Um vetor com 3 níveis.
x <- sample(c("bom", "regular", "ruim"), size = 10, replace = TRUE)
# Atributos.
class(x)## [1] "character"mode(x)## [1] "character"typeof(x)## [1] "character"length(x)## [1] 10str(x)## chr [1:10] "regular" "regular" "ruim" "ruim" "regular" "ruim" "ruim" ...attributes(x)## NULLdput(x)## c("regular", "regular", "ruim", "ruim", "regular", "ruim", "ruim",
## "ruim", "regular", "regular")is.vector(x)## [1] TRUEis.character(x)## [1] TRUEis.factor(x)## [1] FALSE# Conversão.
x <- as.factor(x)
# Atributos.
class(x)## [1] "factor"mode(x)## [1] "numeric"typeof(x)## [1] "integer"length(x)## [1] 10str(x)## Factor w/ 2 levels "regular","ruim": 1 1 2 2 1 2 2 2 1 1attributes(x)## $levels
## [1] "regular" "ruim"
##
## $class
## [1] "factor"dput(x)## structure(c(1L, 1L, 2L, 2L, 1L, 2L, 2L, 2L, 1L, 1L), .Label = c("regular",
## "ruim"), class = "factor")is.vector(x)## [1] FALSEis.character(x)## [1] FALSEis.factor(x)## [1] TRUElevels(x)## [1] "regular" "ruim"nlevels(x)## [1] 27 Informações da sessão
Consultar e fornecer as informações da sessão é algo útil para ter conhecimento da versão do R e seus pacotes bem como detalhes do sistema operacional. Dessa forma pode-se verificar se a atual instalação está defasada, por exemplo. Usuários Linux que fazer instalação do R pelo repositório debian estão sempre com a versão mais recente do R.
# Lista os objetos existentes.
ls()
# Remove objetos existentes.
rm(list = c("da", "L"))
# Mostra informações da sessão, versões e pacotes.
sessionInfo()
# Mais informações.
cbind(Sys.info())
# Salva a imagem (objetos criados) para serem carregados no
# futuro ou compartilhados.
save.image("minhaprimeirasessao.RData")
rm(list = ls())
ls()
# Carrega sessão.
load("minhaprimeirasessao.RData")
ls()
# Mostra o diretório de trabalho.
getwd()
# setwd()
# Mostra os arquivos dentro no diretório.
list.files()8 Instalar pacotes oficiais
Os pacotes oficiais para o R são disponibilizados pelo cran.r-project.org.
# Instala um pacote.
install.packages("plyr",
dependencies = TRUE,
repos = "http://cran-r.c3sl.ufpr.br/")
# Instala vários.
install.packages(c("plyr",
"doBy",
"multcomp",
"latticeExtra",
"devtools"),
dependencies = TRUE,
repos = "http://cran-r.c3sl.ufpr.br/")
# Faz requisição do pacote.
library(plyr)
library(multcomp)9 Instalar pacotes do GitHub
Muitos desenvolvedores de pacotes R têm utilizado o GitHub para manter seus projetos e fazer colaboração em código. O pacote knitr e o plyr são exemplos de pacotes R mantidos no GitHub.
# Pacote wzRfun por Walmes Zeviani.
browseURL("https://github.com/walmes/wzRfun")
library(devtools)
install_github("wzRfun", "walmes")#-----------------------------------------------------------------------
# Versões dos pacotes e data do documento.
devtools::session_info()## setting value
## version R version 3.4.4 (2018-03-15)
## system x86_64, linux-gnu
## ui X11
## language en_US
## collate en_US.UTF-8
## tz America/Sao_Paulo
## date 2018-08-03
##
## package * version date source
## backports 1.1.2 2017-12-13 cran (@1.1.2)
## base * 3.4.4 2018-03-16 local
## compiler 3.4.4 2018-03-16 local
## datasets * 3.4.4 2018-03-16 local
## devtools 1.13.3 2017-08-02 CRAN (R 3.4.1)
## digest 0.6.14 2018-01-14 cran (@0.6.14)
## evaluate 0.10.1 2017-06-24 cran (@0.10.1)
## graphics * 3.4.4 2018-03-16 local
## grDevices * 3.4.4 2018-03-16 local
## grid 3.4.4 2018-03-16 local
## htmltools 0.3.6 2017-04-28 cran (@0.3.6)
## knitr * 1.19 2018-01-29 cran (@1.19)
## lattice * 0.20-35 2017-03-25 CRAN (R 3.4.1)
## latticeExtra * 0.6-28 2016-02-09 CRAN (R 3.4.1)
## magrittr 1.5 2014-11-22 CRAN (R 3.4.1)
## memoise 1.1.0 2017-04-21 CRAN (R 3.4.1)
## methods 3.4.4 2018-03-16 local
## RColorBrewer * 1.1-2 2014-12-07 CRAN (R 3.4.1)
## Rcpp 0.12.17 2018-05-18 cran (@0.12.17)
## rmarkdown * 1.8.10 2018-02-05 Github (rstudio/rmarkdown@b49b7eb)
## rprojroot 1.3-2 2018-01-03 cran (@1.3-2)
## stats * 3.4.4 2018-03-16 local
## stringi 1.1.5 2017-04-07 CRAN (R 3.4.1)
## stringr 1.2.0 2017-02-18 CRAN (R 3.4.1)
## tools 3.4.4 2018-03-16 local
## utils * 3.4.4 2018-03-16 local
## withr 2.0.0 2017-07-28 CRAN (R 3.4.1)
## yaml 2.1.19 2018-05-01 cran (@2.1.19)Sys.time()## [1] "2018-08-03 21:58:35 -03"| Machine Learning | Prof. Eduardo V. Ferreira & Prof. Walmes M. Zeviani |
