Linguagem R

---------------- VARIÁVEIS ----------------
mensagem <- "Hello world!"
print(mensagem)

# Documentações
?head
?str
?getwd
?mean
?sd
?sum
?seq


---------------- PACOTES ----------------
install.packages("ggplot2") # Instalar pacote ggplot2
library(ggplot2) # Carregar ggplot2
?ggplot2 # Pacote de visualização de dados - para gráficos


---------------- ESTRUTURA DE DADOS ----------------
Vetor: Armazena conjunto de valores ordenados, os elementos. Todos elementos de um vetor devem ser do mesmo tipo.
Fator: Armazena valores categóricos (nominal ou ordinal).
Lista: Tipo especial de vetor, onde pode-se adicionar elementos de tipos diferentes.
Data frame: Usado para organizar elementos em linhas e colunas, semelhante a planilha ou base de dados. Inclusive, pode ser formado por listas ou vetores.
Matriz: Armazena dados tabulares semelhante ao data frame, porém só aceita 1 tipo de dado.

---------------- VETOR ----------------
?c()
cidade <-c("Brasília","São Paulo","Rio de Janeiro","Porto Alegre")
cidade # Ver dados do vetor

temperatura <- c(32,22,35,17)
regiao <- c(1,2,2,3)

cidade[1] # Acessar 1º elemento
temperatura[1:3] # Acessar elementos do 1º ao 3º

cidade2 <- cidade # Copiar vetor
cidade2
temperatura[-2] # Excluir 2º elemento da consulta

cidade2[3] <- "Belo Horizonte" # Alterar 3º elemento
cidade2[5] <- "Curitiba" # Adicionar elemento
cidade2 

cidade2 <- NULL # Excluir vetor
cidade2


---------------- FATOR ----------------
?factor
UF <- factor(c("DF","SP","RJ","RS"))
UF

grau.instrucao <- factor(c("Nível Médio",
                           "Superior",
                           "Nivel Médio",
                           "Fundamental"),
                         levels = c("Fundamental",
                                    "Nivel Médio",
                                    "Superior"),
                         ordered = TRUE)

grau.instrucao
# Levels é o ordenamento dos dados


---------------- LISTA ----------------
?list()
pessoa <- list(sexo = "M", cidade = "Brasília", idade = 20)
pessoa

pessoa[1] # Acessar 1º elemento
pessoa[[1]] # Acessar valor do 1º elemento

pessoa[["idade"]] <- 22 # Alterar elemento
pessoa

pessoa[["idade"]] <- NULL # Excluir elemento
pessoa

pessoa <- list(sexo = "M", cidade = "Brasília", idade = 20)
pessoa[c("cidade","idade")] # Filtrar elementos

# Lista de listas
cidades <- list(cidade = cidade,temperatura = temperatura,regiao = regiao)
cidades


---------------- DATA FRAME ----------------
df <- data.frame(cidade,temperatura)
df

df2 <- data.frame(cidades)
df2

df[1,2] # Mostrar valor lin1, col2
df[, 1] # Mostrar todas linhas col1
df[1,] # Mostrar todas colunas lin1
df2[c(1:3), c(1,3)] # Mostrar 3 primeiras linhas da primeira e última col

names(df) # Ver nome colunas
dim(df) # Ver qtd de linhas x colunas
str(df) # Ver tipos de dados

df$cidade # Ver coluna inteira
df['cidade']


---------------- MATRIZ ----------------
?matrix()
m <- matrix(seq(1:9), nrow = 3) # Criar matriz (Valores de 1 à 9, distribuídos em 3 linhas)
m

m2 <- matrix(seq(1:25), 
             ncol = 5,
             byrow = TRUE,
             dimnames = list(c(seq(1:5)),
                             c('A','B','C','D','E'))
)
m2 # Matriz de 25lin x 5col, byrow indica que martriz será preenchida por linhas, dimnames especifica títulos de linhas e colunas
m2[c(1:2), c("B","C")] # Filtrar matriz (Linhas 1 à 2, Colunas B e C)


---------------- FOR ----------------
?seq
for (i in seq(12)) {
  print(i)
}


---------------- WHILE ----------------
i <- 0
while(i <= 10) {
  print(i)
  i = i+1
}


---------------- IF ----------------
x = 10
if (x > 0) {
  print("Número Positivo")
}

nota = 4
if (nota >=7) {
  print("Aprovado")
} else if (nota > 5 && nota < 7) {
  print("Recuperação")
} else {
  print("Reprovado")
}


---------------- FUNÇÃO ----------------
par.impar <- function(num) {
  if((num %% 2) == 0) {
    return("Par")
  }else
    return("Ímpar")
}

num = 3
par.impar(num)


---------------- APPLY ----------------
?apply
x <- seq(1:9)
x
matriz <- matrix(x, ncol = 3)
matriz

result1 <- apply(matriz, 1, sum) # O primeiro parâmetro é a matriz, 1 é para realizar operação por linha (2 para coluna), o sum é a soma
result1

result2 <- apply(matriz, 2, sum) # Similar acima, porém soma feita via colunas
result2

numeros.p <- c(2,4,6,8,10,12)
numeros.i <- c(1,3,5,7,9,11)
numeros <- list(numeros.p,numeros.i) # Converter vetores em uma lista
numeros

?lapply # Similar a apply, sendo aplicada em vetores e listas
lapply(numeros, mean) # mean retorna média dos valores

?sapply # Similar a lapply, exibindo resultados organizadamente
sapply(numeros, mean)


---------------- GRÁFICOS ----------------
?mtcars # Conjunto de dados pré-pronto

carros <- mtcars[,c(1,2,9)] # Filtrar colunas do dataset
head(carros) # Ver dataset

hist(carros$mpg) # Histograma
plot(carros$mpg,carros$cyl) # Dispersão

install.packages("ggplot2")
library(ggplot2)

ggplot(carros,aes(am)) + geom_bar() # Gráfico de barras com ggplot2 (dataset,coluna)


---------------- UNIR DADOS ----------------
# Join une 2 conjuntos de dados em um único

install.packages("dplyr")
library(dplyr)

??dplyr
?data.frame

df1 <- data.frame(Produto = c(1,2,3,5), Preco = c(15,10,25,20))
head(df1)

df2 <- data.frame(Produto = c(1,2,3,4), Nome = c("A","B","C","D"))
head(df2)

df3 <- left_join(df1,df2,"Produto") # Une dados, mantém valores da tabela esquerda, caso não encontre correspondente na direita, atribuirá '<NA>'
head(df3)

df4 <- right_join(df1,df2, "Produto") # Similar acima, porém mantem valores da tabela direita
head(df4)

df5 <- inner_join(df1, df2, "Produto") # Unir elementos em comum (campos comparados, coluna de comparação)
head(df5)


---------------- SELECIONAR DADOS ----------------
install.packages("dplyr")
library(dplyr)

?iris
head(iris) # Conjunto de dados pré-pronto (flor, sépalas e pétalas, e classificação da flor)
glimpse(iris) # Ver tipos de dados

versicolor <- filter(iris, Species == "versicolor") # Filtrar dados
versicolor
dim(versicolor)

slice(iris, 5:10) # Selecionar linhas específicas (Retornar valores das linhas 5 à 10, ou índice da linha específica)
select(iris, 2:4) # Selecionar colunas específicas (Similar acima, mas com colunas)
select(iris, -Sepal.Width) # Ocultar coluna na seleção

iris2 <- mutate(iris, nova.coluna = Sepal.Length + Sepal.Width) # Criar nova coluna com base em colunas existentes, combinando-as
iris2[,c("Sepal.Length", "Sepal.Width", "nova.coluna")]

?arrange # Ordenar dados no dataframe (Select, e colunas a ser ordenadas). Operador %>% concatena comandos
select(iris, Sepal.Length) %>%
  arrange(Sepal.Length)

?group_by # Agrupar dados por determinada coluna
iris %>% group_by(Species) %>%
  summarise(mean(Sepal.Length))


---------------- TRANSFORMAR DADOS ----------------
install.packages("tidyr") # Tranformar dados (depende de dplyr)
library(tidyr)

dfDate <- data.frame(Produto = c('A','B','C'),
                     A.2015 = c(10,12,20),
                     A.2016 = c(20,25,35),
                     A.2017 = c(15,20,30)
                     )
head(dfDate) # Dataframe criado manualmente

?gather
dfDate2 <- gather(dfDate, "Ano", "Quantidade", 2:4) # Mudar formato da tabela (colRecebeDadosColunas, colRecebeDadosLinhas, índices das colunas a ser transformados)
head(dfDate2)

install.packages("dplyr")
library(dplyr)

?separate # Separar texto com base em condição
dfDate3 <- separate(dfDate2, Ano, c("A", "Ano")) # Separar A.2015 em A e 2015 (colParaSeparar, colsReceberSeparacao)
dfDate3
dfDate3 <- dfDate3[-2] # Coluna A deletada
dfDate3

dfDate3$Mes <- c('01','02','03') # Acrescentar coluna Mês
dfDate3

?unite # Unir colunas Ano e Mês em coluna Data (separado por '/')
dfDate4 <- dfDate3 %>%
  unite(Data, Mes, Ano, sep = '/')
head(dfDate4)


---------------- ALGORITMOS DE MACHINE LEARNING ----------------
-Instâncias ou observações: Linhas do dataset
-Variável resposta/dependente, classe, label ou target: Variável/coluna que se quer prever
-Features, atributos, dimensões ou variáveis independentes/explicativas: Colunas do dataset que podem ser utilizadas para prever a variável target

Aprendizagem Supervisionada:
Predição estimada com base na relação entre dados de entrada (features) e dados de saída (variável resposta). Para cada entrada, é apresentado o resultado esperado. Usada para resolver problemas de classificação e regressão.
-Regressão linear: Relacionamento entre variável dependente Y (var resposta) e variável independente X (var explicativa), calculado via 'y = W+x+B' (W=weight, B=bias, parâmetros do modelo, estimados via treinamento). Após parâmetros bem definidos, pode-se construir previsões de Y.
-K-Nearest Neighbors (KNN): Previsão baseada nos vizinhos mais próximos. Parâmetro K é quantidade de vizinhos mais próximos. Com base na classificação desses vizinhos, será a resposta da previsão
-Árvore de Decisão: Estrutura, similar a fluxograma, com regras de decisão, possuindo nós (variáveis), ramos (possíveis valores) e folhas (valor final do nó)

Aprendizagem Não Supervisionada:
Previsão sem base de dados rotulados. Algoritmos são baseados em medidas de similaridade e padrões ocultos nos dados. Usada para resolver problemas de agrupamento (clustering, agrupar dados de características similares), associação e detecção de anomalias.
-K-means: Dividir dados em grupos (clusters) com base na similaridade dos mesmos


---------------- CONSTRUÇÃO MODELO PREDITIVO ----------------
1.Pré-processamento dos dados: Dados divididos em dados de treino (dados com respostas prontas, para algoritmo aprender e criar modelo) e teste (dados sem respostas, para verificar se algoritmo aprendeu), a fim de melhorar a qualidade dos mesmos.
-Feature selection: Selecionar atributos mais relevantes que serão utilizados para treinar o modelo
-Feature engineering: Criar variáveis a partir de conjunto de dados para melhorar performance do modelo
-Normalização: Dataset pode conter variáveis em diferentes escalas, então deve-se padronizar tais dados para mesma escala
-Redução de dimensionalidade: Diminuir dimensões (colunas) de conjuntos de dados
-Divisão dos dados em treino e teste: Dividir dados em conjunto de treino e teste

2.Aprendizagem: Construção do modelo a partir do conjunto treino.
-Cross-validation: Dividir cojunto de dados em partições/iterações, alternando entre dados de treino e teste
-Métricas de desempenho: Medição de acurácia (precisão, percentual de previsões corretas em classificações)
-Otimização de hiperparâmetros: Conjunto de hiperparâmetros que possams ser alterados, em combinação certa de valores, com objetivo de otimizar a performance do modelo

3.Avaliação: Dados de teste submetidos ao modelo, gerando previsões, que são comparadas com resultados desejados, para avaliar desempenho do modelo

4.Predição: Modelo avaliado com bom resultado pode ser usado para receber novos dados e realizar previsões


---------------- ML COM R: OBTENÇÃO DE DADOS ----------------
Entender Qual valor gasto por órgão, Qual valor gasto por cidade, Qual a quantidade de viagens/mês
Baixar planilhas de dados abertos 2019 (https://portaldatransparencia.gov.br/download-de-dados/viagens), arquivo '2019_viagem.csv'

viagens <- read.csv(
  file = "/home/mateus/Downloads/2019_Viagem.csv",
  sep = ';',
  dec = ',',
  fileEncoding='latin1'
)
head(viagens) # Ou 'View(viagens)' Ou 'dim(viagens)' mostra nº de observações e colunas do dataset
summary(viagens) # Ver valores mínimos/máximos. Ou 'summary(viagens$Valor.passagens)' coluna específica
glimpse(viagens) # Ver tipos de dados de cada coluna (Necessário dplyr)


---------------- ML COM R: TRANSFORMAÇÃO DOS DADOS ----------------
viagens$data.inicio <- as.Date(viagens$Período...Data.de.início, "%d/%m/%Y") # Converter datas para tipo Date
viagens$data.inicio.formatada <- format(viagens$data.inicio, "%Y-%m") # Data para apenas mês e ano
viagens$data.inicio.formatada


---------------- ML COM R: EXPLORAÇÃO DOS DADOS ----------------
hist(viagens$Valor.passagens) # Gerar histograma
passagens_fitro <- viagens %>%
  select(Valor.passagens) %>%
  filter(Valor.passagens >= 200 & Valor.passagens <= 5000) 
passagens_fitro
hist(passagens_fitro$Valor.passagens) # Histograma com filtro

summary(viagens$Valor.passagens) # Valor máximo muito distante da média (outliers, valores que fogem da normalidade dos dados)
boxplot(passagens_fitro$Valor.passagens) # Gráfico boxplot, com valores em filtro
sd(viagens$Valor.passagens) # Desvio padrão

colSums(is.na(viagens)) # 'is.na' verifica se há campos não preenchidos (true para encontrado), 'colSums' mostra qtd de campos não preenchidos por coluna
viagens$Situação <- factor(viagens$Situação) # Converter Situação para factor

str(viagens$Situação) # Ver quantidade de ocorrências da coluna
table(viagens$Situação) # Ver quantidade de ocorrências para cada classe
prop.table(table(viagens$Situação))*100 # Obter percentual para cada classe


---------------- ML COM R: VISUALIZAÇÃO DOS RESULTADOS ----------------
#1.Valor gasto por órgão em passagens
p1 <- viagens %>%
  group_by(Nome.do.órgão.superior) %>%
  summarise(n = sum(Valor.passagens)) %>%
  arrange(desc(n)) %>%
  top_n(15) # Criar dataframe com 15 órgãos que mais gastam em viagens

names(p1) <- c("orgao", "valor") # Alterar nome das colunas
p1

library(ggplot2)
ggplot(p1, aes(x = reorder(orgao, valor), y = valor))+
  geom_bar(stat = "identity")+
  coord_flip()+
  labs(x = "Valor", y = "Órgãos") # Gráfico de barras identity. Função reorder(dado,eixoX,eixoY). Função coord_flip torna orientação gráfico dinâmica. Função labs editar labels de cada eixo

#2.Valor gasto por cidade em passagens
p2 <- viagens %>%
  group_by(Destinos) %>%
  summarise(n = sum(Valor.passagens)) %>%
  arrange(desc(n)) %>%
  top_n(15) # Dataframe com 15 cidades que mais gastam em viagens

names(p2) <- c("destino", "valor") # Alterar nome das colunas
p2

ggplot(p2, aes(x = reorder(destino, valor), y = valor))+
  geom_bar(stat = "identity", fill = "#0ba791")+
  geom_text(aes(label = valor), vjust = 0.3, size = 3)+
  coord_flip()+
  labs(x = "Valor", y = "Destino") # Gráfico de barras identity, com coloração de barras e texto diretamente nas barras
  #options(scipen = 999)

#3.Quantidade de viagens/mês
p3 <- viagens %>%
  group_by(data.inicio.formatada) %>%
  summarise(qtd = n_distinct(Identificador.do.processo.de.viagem)) # Dataframe com quantidade de viagens realizadas por mês, em valores distintos, evitando duplicações
head(p3)

ggplot(p3, aes(x = data.inicio.formatada, y = qtd, group = 1))+
  geom_line()+
  geom_point() # Gráfico de barras. Função geom_line cria linhas definidas por pares. Função geom_point cria gráficos de dispersão transformando os pares em pontos


---------------- ML COM R: VISUALIZAÇÃO VIA R MARKDOWN ----------------
install.packages("rmarkdown")
install.packages('tinytex')
library(tinytex)
tinytex::install_tinytex()

# Criar novo arquivo Markdown (.md), com saída PDF, com conteúdo abaixo:

---
title: "Relatório"
output: pdf_document
---

```{r setup, include=FALSE}
knitr::opts_chunk$set(echo = TRUE)
```

## R Markdown
Ao clicar rm **Knit**, um documento é gerado, incluindo conteúdo quanto saída de código R embutido no documento

```{r cars}
summary(cars)
```

## Criando gráficos
```{r pressure, echo=FALSE}
plot(pressure)
```
Parâmetro 'echo = FALSE' adicionado pra evitar impressão do código R que gerou o gráfico.


---------------- ML COM R PRÁTICA: OBTENÇÃO DE DADOS ----------------
Objetivo do modelo: Identificar pacientes com risco de diabetes (mínimo 75% de acurácia): 0 não diabetes, 1 com diabetes

diabetes <- read.csv(
  file = "/home/mateus/Downloads/diabetes.csv"
)
head(diabetes)
str(diabetes) # Ver tipos de dados
colSums(is.na(diabetes)) # Ver se há colunas não preenchidas
table(diabetes$Outcome)

diabetes$Outcome <- as.factor(diabetes$Outcome) # Mudar coluna Outcome para factor
summary(diabetes$Insulin) # Ver valores mínimo, máximo, mediana

boxplot(diabetes) # Gráfico boxplot para todo dataframe
boxplot(diabetes$Insulin) # Gráfico boxplot para coluna Insulin
hist(diabetes$Insulin) # Gráfico histograma para coluna Insulin

---------------- ML COM R PRÁTICA: ANÁLISE EXPLORATÓRIA ----------------
diabetes2 <- diabetes %>%
  filter(Insulin <= 250) # Dataset com filtro Insulin (para não mostrar outliers)

boxplot(diabetes2)
summary(diabetes2$Insulin)
boxplot(diabetes2$Insulin)
hist(diabetes2$Pregnancies)
hist(diabetes2$Age)
hist(diabetes2$BMI)


---------------- ML COM R PRÁTICA: CONSTRUÇÃO DO MODELO ----------------
install.packages("caTools") # Separar dados de treino e teste (Nesse caso, 70% treino, 30% teste)
library(caTools)
set.seed(123)

index = sample.split(diabetes2$Pregnancies, SplitRatio = .70) # split(colunaDataset, percDivisao). Criará Trues e Falses
index

train = subset(diabetes2, index == TRUE) # Dataset para treino
test  = subset(diabetes2, index == FALSE) # Dataset para testes
dim(diabetes2) # Exibe valores de linhas e colunas de dataset
dim(train)
dim(test)

install.packages("caret")
install.packages("e1071")
library(caret)
library(e1071)

--- KNN ---
modelo <- train(
  Outcome ~., data = train, method = "knn") # Criar modelo de treino(varResposta ~., datasetTreino, algoritmoTreino) Outcome é varResposta, ponto para usar todas colunas como variáveis preditoras (ou informar campos manualmente após ~)
modelo$results # Acurácia para cada valor de K
modelo$bestTune # Melhor valor de K

modelo2 <- train(
  Outcome ~., data = train, method = "knn",
  tuneGrid = expand.grid(k = c(1:20))) # Testar entre intervalo de valores
modelo2$results # Nesse intervalo, obteve-se melhor acurácia de K (72%)
modelo2$bestTune
plot(modelo2)

--- Naive Bayes ---
install.packages("naivebayes")
library(naivebayes)

modelo3 <- train(
  Outcome ~., data = train, method = "naive_bayes")
modelo3$results # Acurácia 75%
modelo3$bestTune

--- Random Forest ---
install.packages("randomForest")
library(randomForest)

modelo4 <- train(
  Outcome ~., data = train, method = "rpart2"
)
modelo4
varImp(modelo4$finalModel) # Ver importância das váriaveis para aprendizado do modelo (Insulin e Blood Pressure não contribuem muito para tal)

modelo4_1 <- train(
  Outcome ~., data = train[,c(-3,-5)], method = "rpart2"
) # treinamento removendo colunas Insulin e Blood Pressure
modelo4_1
plot(modelo4_1$finalModel)
text(modelo4_1$finalModel)

--- svmRadialSigma ---
install.packages("kernlab")
library(kernlab)

set.seed(100)
modelo5 <- train(
  Outcome ~., data = train, method = "svmRadialSigma"
  ,preProcess=c("center")
)
modelo5$results # Acurácia 76%
modelo5$bestTune

predicoes <- predict(modelo5,test) # Testar modelo com dados teste
predicoes
confusionMatrix(predicoes, test$Outcome) # Matriz de confusão (comparação dados treino x teste). Acurácia do algoritmo 79%

novos.dados <- data.frame(
  Pregnancies = c(3),           
  Glucose = c(111.50),
  BloodPressure = c(70),
  SkinThickness = c(20),          
  Insulin = c(47.49),
  BMI = c(30.80),       
  DiabetesPedigreeFunction = c(0.34),
  Age = c(28)                     
)
novos.dados # Novo dataframe para submeter ao algoritmo
previsao <- predict(modelo5,novos.dados) # Submissão
resultado <- ifelse(previsao == 1, "Positivo","Negativo") # Positivo para 1-tem diabetes, negativo para 0-não tem diabetes
print(paste("Resultado:",resultado)) # Ver resultado da predição do modelo


---------------- ML COM R PRÁTICA: VISUALIZAÇÃO DOS RESULTADOS ----------------
write.csv(predicoes,'resultado.csv') # Criar planilha com resultados das predições
resultado.csv <- read.csv('resultado.csv') # Ler arquivo gerado
names(resultado.csv) <- c('Indice','Valor previsto') # Alterar nome das colunas
resultado.csv

# Gerado arquivo PDF de R Markdown, conforme conteúdo abaixo:
---
title: "Diabetes"
output: pdf_document
---

```{r setup, include=FALSE}
knitr::opts_chunk$set(echo = TRUE)
```

# Obtenção dos dados
```{r}
diabetes <- read.csv(
  file = "E:/Datasets/diabetes.csv"
)
head(diabetes[1:6])
```

# Preparação dos dados
```{r message=FALSE, warning=FALSE}
diabetes$Outcome <- as.factor(diabetes$Outcome)
library(dplyr)
diabetes2 <- diabetes %>%
  filter(Insulin <= 250)
```

# Construção do modelo
## Divisão dos dados
```{r message=FALSE, warning=FALSE, paged.print=TRUE}
library(caTools)
set.seed(123)
index = sample.split(diabetes2$Pregnancies, SplitRatio = .70)
train = subset(diabetes2, index == TRUE)
test  = subset(diabetes2, index == FALSE)
```

# Construção do modelo
## Treinamento
```{r message=FALSE, warning=FALSE}
library(caret)
library(e1071)
set.seed(321)
modelo2 <- train(
  Outcome ~., data = train, method = "knn",
   tuneGrid = expand.grid(k = c(1:20)))
modelo2$results
modelo2$bestTune
plot(modelo2)
```

# Avaliando o modelo
```{r message=FALSE, warning=FALSE}
predicoes <- predict(modelo2,test)
predicoes
?caret::confusionMatrix
confusionMatrix(predicoes, test$Outcome)
```