Relatório de Visualização de Dados (Exercício 12)

---

Exercício 12 - Visualização de Dados

Crie os gráficos abaixo no R Markdown cada um em uma aba chamada de, por exemplo, Questão 1, Questão 2, etc. Após finalizar os gráficos, publique a resposta e submeta o link do R markdown no formulário. Note que o código precisa ser apresentado. Além disso, para as questões de 1 a 6 use o R tradicional, enquanto para as questões de 7 a 10 use o Ploty.

Questão 1

Este código R cria visualizações gráficas para analisar dados de Mean Residence Time (MRT - Tempo Médio de Residência) em diferentes configurações de clock (tempo em segundos).

# Carregar os dados
MRT_1F <- c(517.1468515630205, 85.13094142168089, 30.333207896694553, 12.694776264558937, 3.3041601673945418, 1.1823111717498882, 1.1892293502386786)
MRT_3F <- c(156.68929936163462, 11.540837783562276, 0.4512835621696538, 0.4509797929766453, 0.4502068233039181, 0.4496185276300172, 0.4543157082191288)
MRT_5F <- c(83.90319666471157, 0.3068151086494968, 0.30522314133037304, 0.3072588968084928, 0.30655265997285697, 0.3055812715727718, 0.3053297166713006)
MRT_10F <- c(29.55430642951759, 0.19832832665772515, 0.1971923924717474, 0.19796648905716516, 0.19615594370806338, 0.2034569237883263, 0.19617420889447737)
MRT_15F <- c(11.317736530583566, 0.167364215666193, 0.16172168266811013, 0.16701085329580515, 0.1598052657153692, 0.1645934043532696, 0.16216563797118075)
MRT_sem_F <- c(11.93430909937736, 0.6095414637034009, 0.6060645101029295, 0.612167181646899, 0.6146761002685637, 0.6096747087200697, 0.6125810476877268)
clock <- c(0.1, 0.5, 1, 1.5, 2, 2.5, 3)

# Definir o layout dos gráficos
layout(matrix(c(1,1), nrow = 1, byrow = TRUE))

# Primeiro Gráfico (Linha)
plot(clock, MRT_1F, type = "o",pch=4, col = "black", xlab = "Clock", ylab = "Tempo de resposta(seg)")
lines(clock, MRT_3F, type = "o", pch=11, col = "yellow")
lines(clock, MRT_5F, type = "o",pch=1, col = "red")
lines(clock, MRT_10F, type = "o",pch=2, col = "blue")
lines(clock, MRT_15F, type = "o",pch=5, col = "purple")
lines(clock, MRT_sem_F, type = "o",pch=4, col = "green")
legend("topright", legend = c("MRT_1F", "MRT_3F", "MRT_5F", "MRT_10F", "MRT_15F", "MRT_sem_F"), col = c("black", "yellow", "red", "blue", "purple", "green"), lty = 1)

# Definir o layout dos gráficos
layout(matrix(c(1,1), nrow = 1, byrow = TRUE))

par(mfrow = c(1,2))
# Segundo Gráfico (Barras com Escala Logarítmica)
barplot(rbind(MRT_sem_F, MRT_1F), beside = TRUE, log = "y", col = c("#E6E6E6", "#666666"), xlab = "Clock", ylab = "Tempo de resposta(seg)")
legend("topright", legend = c("MRT_sem_F", "MRT_1F"), col = c("#E6E6E6", "#666666"), lwd = 10)
barplot(rbind(MRT_sem_F, MRT_3F), beside = TRUE, log = "y", col = c("#E6E6E6", "#666666"), xlab = "Clock", ylab = "Tempo de resposta(seg)")
legend("topright", legend = c("MRT_sem_F", "MRT_3F"), col = c("#E6E6E6", "#666666"), lwd = 10)

barplot(rbind(MRT_sem_F, MRT_5F), beside = TRUE, log = "y", col = c("#E6E6E6", "#666666"), xlab = "Clock", ylab = "Tempo de resposta(seg)")
legend("topright", legend = c("MRT_sem_F", "MRT_5F"), col = c("#E6E6E6", "#666666"), lwd = 10)
barplot(rbind(MRT_sem_F, MRT_10F), beside = TRUE, log = "y", col = c("#E6E6E6", "#666666"),xlab = "Clock", ylab = "Tempo de resposta(seg)")
legend("topright", legend = c("MRT_sem_F", "MRT_10F"), col = c("#E6E6E6", "#666666"), lwd = 10)

barplot(rbind(MRT_sem_F, MRT_15F), beside = TRUE, log = "y", col = c("#E6E6E6", "#666666"), xlab = "Clock",ylab = "Tempo de resposta(seg)")
legend("topright", legend = c("MRT_sem_F", "MRT_15F"), col = c("#E6E6E6", "#666666"), lwd = 10)

Questão 2

Para a tabela abaixo que classifica a qualidade de refeição de acordo com categorias de preços crie um gráfico de barras empilhadas. Também adicione título, nomes de eixos e legenda.

# Dados da tabela de qualidade de refeições
meal_prices <- c("$10–19", "$20–29", "$30–39", "$40–49")
good <- c(53.8, 33.9, 2.6, 0.0)
very_good <- c(43.6, 54.2, 60.5, 21.4)
excellent <- c(2.6, 11.9, 36.8, 78.6)

# Convertendo as porcentagens em proporções
good <- good / 100
very_good <- very_good / 100
excellent <- excellent / 100

# Criando um dataframe
quality_ratings <- data.frame(good, very_good, excellent)

# A matriz precisa ser transposta porque barplot espera colunas como grupos
quality_ratings_matrix <- t(as.matrix(quality_ratings))

# Criando o gráfico de barras empilhadas
barplot(quality_ratings_matrix, 
        beside = FALSE, 
        col = c("lightblue", "blue", "darkblue"),
        legend.text = TRUE, 
        args.legend = list(x = "topright", inset = c(-0.085, 0)), # ajustar posição da legenda
        main = "Qualidade das refeições por preço",
        xlab = "Preço medio",
        ylab = "Indice de satistação",
        names.arg = meal_prices)

Questão 3

Faça o histograma das temperaturas do mês de maio do dataset airquality. No entanto, primeiro converta as temperaturas para graus Celsius através da expressão °C = (°F - 32) / 1.8. Após isso, gere o histograma. Também adicione título, nomes de eixos, cor e curva de densidade.

# Carregar o conjunto de dados airquality
data("airquality")

# Filtrar os dados para o mês de maio
may_temps <- subset(airquality, Month == 5)$Temp

# Converter as temperaturas para Celsius
may_temps_c <- (may_temps - 32) * 5 / 9

# Calcular a média e o desvio padrão
mean_temp <- mean(may_temps_c, na.rm = TRUE)
sd_temp <- sd(may_temps_c, na.rm = TRUE)

# Criar o histograma com densidade em vez de contagem
hist(may_temps_c, 
     col = 'skyblue', 
     main = 'Histograma de Temperaturas em Maio com Curva Normal (em °C)', 
     xlab = 'Temperatura (°C)', 
     ylab = 'Densidade',
     freq = FALSE)

# Adicionar a curva de densidade
dens <- density(may_temps_c)
lines(dens, col = 'blue', lwd = 2)

# Adicionar a curva normal
x <- seq(min(may_temps_c, na.rm = TRUE), max(may_temps_c, na.rm = TRUE), length.out = 100)
y <- dnorm(x, mean = mean_temp, sd = sd_temp)
lines(x, y, col = 'red', lwd = 2)

# Adicionar uma legenda
legend('topright', legend = c("Densidade", "Normal"), col = c("blue", "red"), lwd = 2)

Questão 4

Gerando um gráfico de pizza com a porcentagem da tabela total de vendas por país. Usando o dataset Sales. TXT, disponível em: https://training-course-material.com/images/8/8f/Sales.txt

# Carregar dados de vendas
sales <- read.table("https://training-course-material.com/images/8/8f/Sales.txt", header = TRUE)

# Calcular a soma das vendas por país
sales_by_country <- sales

# Calcular as porcentagens
sales_by_country$Perc <- sales_by_country$SALES / sum(sales_by_country$SALES) * 100

lbls<- paste(round(sales_by_country$Perc), "%",sep= "")

# Criar o gráfico de pizza incluindo as porcentagens
pie(sales_by_country$SALES, labels= lbls, main = "Total Sales Percentage by Country", col = rainbow(length(sales_by_country$SALES)))

# Adicionar a legenda
legend("topright", legend = sales_by_country$COUNTRY, fill = rainbow(length(sales_by_country$COUNTRY)),cex=0.8)

Questão 5

Utilize os dados de contagens de insetos em unidades experimentais agrícolas tratados com inseticidas diferentes disponíveis no R em InsectSprays e construa um boxplot sem a presença dos outliers para os 6 tipos de inseticidas. Coloque título e nomes de eixos adequados. Além disso, as caixas devem ser preenchidas com a cor “yellow”.

data("InsectSprays")
View(InsectSprays)
# Criar o boxplot sem outliers
boxplot(count ~ spray, data = InsectSprays, 
        main = "Boxplot de Contagens de Insetos por Tipo de Inseticida", 
        xlab = "Tipo de Inseticida", 
        ylab = "Contagem de Insetos", 
        col = "yellow", 
        outline = FALSE)

Questão 6

Gere os gráficos abaixo a partir dos seguintes dados: monitoringCloudData_0.1.csv, monitoringCloudData_0.5.csv, monitoringCloudData_1.csv e monitoringCloudData_NONE.csv. Esses dados consistem de informações de monitoramento dos recursos de uma máquina virtual. Basicamente, é necessário gerar gráficos de linha do tempo de coleta dos recursos (currentTime) em relação a memória usada (usedMemory). Porém, é necessário ajustar a coluna “currentTime” para que o tempo fique contínuo e a coluna “usedMemory” para que todas as informações fiquem megabytes. Por fim, use a função layout() para organizar os gráficos. Dica 1: use a função difftime() para calcular a diferença do tempo em horas. Dica 2: use os conceitos vistos na aula de string/regex para converter os dados na coluna “usedMemory” para apenas megabytes. Além disso, considere que um terabyte equivale a 1000000 megabytes e 1 gigabyte equivale a 1024 megabytes.

# Função concisa para converter string de memória para MB (mesma anterior)
cvt_mb <- function(ms) {
  if (!is.character(ms) || is.na(ms)) return(NA)
  ms <- trimws(ms)
  m <- regmatches(ms, regexec("([0-9\\.]+)\\s*([A-Za-z]+)", ms))[[1]]
  
  if (length(m) == 0) {
    suppressWarnings({v <- as.numeric(ms)}); return(ifelse(!is.na(v), v, NA))
  }
  
  v <- as.numeric(m[2]); u <- toupper(m[3])
  if(is.na(v)) return(NA)
  
  f <- c(MB = 1, GB = 1024, TB = 1000000)[u]
  
  ifelse(!is.na(f), v * f, NA)
}

# Lista de arquivos
files <- c('monitoringCloudData_0.1.csv', 'monitoringCloudData_0.5.csv', 'monitoringCloudData_1.csv', 'monitoringCloudData_NONE.csv')

# Processa os arquivos usando lapply
data_list <- lapply(files, function(f) {
  tryCatch({
    d <- read.csv(f, stringsAsFactors = FALSE)
    d$currentTime <- as.POSIXct(d$currentTime)
    st <- min(d$currentTime, na.rm = TRUE)
    d$time_h <- as.numeric(difftime(d$currentTime, st, units = "hours"))
    d$memory_MB <- sapply(d$usedMemory, cvt_mb)
    return(d)
  }, error = function(e) {
    message(paste("Err procs", f, ":", e$message))
    return(NULL)
  })
})
names(data_list) <- files
data_list <- data_list[!sapply(data_list, is.null)]

# Verifica se há dados para plotar
if (length(data_list) > 0) {
  # Define cores para cada linha no gráfico
  plot_colors <- c('blue', 'red', 'green', 'purple')
  
  # Configura o layout para 2 linhas, 2 colunas para gráficos + 1 linha para a legenda
  # matrix(c(1,2,3,4,5,5), nrow=3, ncol=2, byrow=TRUE) cria 5 painéis:
  # Painel 1: Top-Left Plot
  # Painel 2: Top-Right Plot
  # Painel 3: Bottom-Left Plot
  # Painel 4: Bottom-Right Plot
  # Painel 5: Span bottom row for Legend
  num_plots <- length(data_list)
  # Garante que temos espaço suficiente para os plots + legenda
  if (num_plots > 0) {
    layout_matrix <- matrix(c(1:num_plots, rep(num_plots + 1, 2)), nrow = ceiling((num_plots + 1)/2), ncol = 2, byrow = TRUE)
    # Adjust matrix size if num_plots is not exactly 4 to fit in 2x2 + legend row
    if (num_plots == 4) {
      layout_matrix <- matrix(c(1,2,3,4,5,5), nrow=3, ncol=2, byrow=TRUE)
    } else if (num_plots == 3) {
      layout_matrix <- matrix(c(1,2,3,0,4,4), nrow=3, ncol=2, byrow=TRUE) # Example for 3 plots + legend
    } else if (num_plots == 2) {
      layout_matrix <- matrix(c(1,2,3,3), nrow=2, ncol=2, byrow=TRUE) # Example for 2 plots + legend
    } else if (num_plots == 1) {
      layout_matrix <- matrix(c(1,2), nrow=2, ncol=1, byrow=TRUE) # Example for 1 plot + legend
    } # Add more conditions for other numbers of plots if necessary
    
    layout(layout_matrix)
    
    # Loop para plotar cada conjunto de dados
    for (i in 1:num_plots) {
      name <- names(data_list)[i]
      d <- data_list[[i]] # Acessa pelo índice pois layout é por índice
      
      plot(d$time_h, d$memory_MB, type = 'l',
           main = paste('Memória (', name, ')'),
           xlab = 'Tempo (h)', ylab = 'Memória (MB)',
           col = plot_colors[i], # Usa a cor correspondente
           lwd = 2) # Largura da linha
      
      grid(col = "lightgray", lty = "dotted")
    }
    
    # Ativa o painel da legenda e desenha a legenda
    # O próximo 'plot' command iria para o próximo número no layout, que é o painel da legenda
    # Usamos plot.new() ou frame() para iniciar um novo painel vazio para a legenda
    plot.new() # Ou frame()
    
    
    # Reseta o layout para o padrão
    layout(matrix(1))
    
  } else {
    message("Não há dados processados para plotar.")
  }
  
} else {
  message("Não há dados processados a partir dos arquivos. Não é possível gerar plots.")
}

Questão 7

Filtrando os conteúdos com apenas UM país de origem (coluna “country”), utilize o Plotly para obter um gráfico de pizza dos 10 países com mais conteúdo na plataforma.

if (!require(plotly)) {
    # Escolher um espelho do CRAN
    options(repos = c(CRAN = "http://cran.rstudio.com"))
    
    # Instalar o pacote plotly
    install.packages("plotly")
}

library(plotly)

netflix_data<- read.csv("https://www.dropbox.com/s/bso7ierg8oyjjun/netflix_titles.csv?dl=1", header = TRUE)
View(netflix_data)

# Filtrar conteúdos com apenas um país de origem
single_country_data <- netflix_data[grepl("^([^,]+)$", netflix_data$country), ]

# Contar quantos conteúdos estão associados a cada país
country_counts <- table(single_country_data$country)

# Selecionar os 10 países com mais conteúdos
top_countries <- sort(country_counts, decreasing = TRUE)[1:10]
View(top_countries)
# Converter para dataframe
top_countries_df <- data.frame(Country = names(top_countries), Count = as.numeric(top_countries))

# Criar um gráfico de pizza com Plotly
plot_ly(data = top_countries_df, labels = ~Country, values = ~Count, type = 'pie', textinfo = 'label+percent') %>%
    layout(title = 'Top 10 Países com Mais Conteúdo na Netflix (Somente um País de Origem)')

Questão 8

Considerando os 10 países descritos na questão anterior, utilize o Plotly para obter uma tabela com as colunas “País” e “Total de conteúdos”. Para tal tabela, é necessário que o cabeçalho esteja com o fundo da célula cinza e a letra em branco, e que todos os textos das células estejam @centralizados.

netflix_data<- read.csv("https://www.dropbox.com/s/bso7ierg8oyjjun/netflix_titles.csv?dl=1", header = TRUE)
View(netflix_data)

# Filtrar conteúdos com apenas um país de origem
single_country_data <- netflix_data[grepl("^([^,]+)$", netflix_data$country), ]

# Contar quantos conteúdos estão associados a cada país
country_counts <- table(single_country_data$country)

# Selecionar os 10 países com mais conteúdos
top_countries <- sort(country_counts, decreasing = TRUE)[1:10]
View(top_countries)
# Converter para dataframe
top_countries_df <- data.frame(Country = names(top_countries), Count = as.numeric(top_countries))

# Criar uma tabela com Plotly
plot_ly() %>%
    add_table(
        data = top_countries_df,
        header = list(
            values = c("País", "Total de conteúdos"),
            align = c("center", "center"),
            line = list(color = "black"),
            fill = list(color = "grey"),
            font = list(color = "white", size = 12)
        ),
        cells = list(
            values = rbind(top_countries_df$Country, top_countries_df$Count),
            align = c("center", "center"),
            line = list(color = "black"),
            fill = list(color = "white"),
            font = list(color = "black", size = 11)
        )
    )

Questão 9

Gráfico de linha utilizando Plotly mostrando a quantidade de filmes e séries lançados por década no Netflix. Filmes são representados pela linha amarela e Séries pela linha azul.

# Carregar dados (se ainda não carregado)
# netflix_data <- read_csv("netflix_titles.csv") # Já carregado na Q7

# Calcular a década
netflix_decade <- netflix_data %>%
  filter(!is.na(release_year)) %>% # Remover NA em release_year antes de calcular década
  mutate(decade = floor(release_year / 10) * 10) %>%
  filter(type %in% c("Movie", "TV Show")) # Filtrar apenas Filmes e Séries

# Contar por década e tipo
decade_counts <- netflix_decade %>%
  count(decade, type) %>%
  complete(decade, type, fill = list(n = 0)) %>% # Garantir que todas as décadas para ambos os tipos estejam presentes
  arrange(decade)

# Preparar dados para Plotly
movies_by_decade <- decade_counts %>% filter(type == "Movie")
series_by_decade <- decade_counts %>% filter(type == "TV Show")

# Criar gráfico de linha Plotly
plot_ly() %>%
  add_lines(data = movies_by_decade, x = ~decade, y = ~n, name = 'Movies',
            line = list(color = 'yellow')) %>% # Linha amarela para filmes (conforme imagem exemplo no PDF)
  add_lines(data = series_by_decade, x = ~decade, y = ~n, name = 'TV Series',
            line = list(color = 'blue')) %>% # Linha azul para séries (conforme imagem exemplo no PDF)
  layout(title = "Quantidade de Conteúdo no Netflix por Década",
         xaxis = list(title = "Década", tickmode = 'linear', dtick = 10),
         yaxis = list(title = "Quantidade de Conteúdo"))

Questão 10

Gráfico de barras lado a lado utilizando Plotly mostrando a quantidade de filmes dos gêneros “Dramas”, “Action & Adventure” e “Comedies” lançados entre 2000 e 2010. O gráfico segue o estilo de barras agrupadas conforme imagem exemplo no PDF.

# Carregar dados (se ainda não carregado)
# netflix_data <- read_csv("netflix_titles.csv") # Já carregado

# Filtrar para filmes entre 2000 e 2010
movies_2000_2010 <- netflix_data %>%
  filter(type == "Movie", release_year >= 2000, release_year <= 2010) %>%
  filter(!is.na(listed_in)) # Remover linhas sem gênero listado (não é valor não finito, mas sim ausente)

# Definir os gêneros de interesse (conforme PDF)
target_genres <- c("Dramas", "Action & Adventure", "Comedies")

# Separar os gêneros e filtrar pelos gêneros de interesse
genre_counts_2000_2010 <- movies_2000_2010 %>%
  select(release_year, listed_in) %>%
  mutate(listed_in = strsplit(as.character(listed_in), ", ")) %>% # Separar gêneros (considera ', ' como separador)
  unnest(listed_in) %>% # Expandir a lista de gêneros
  filter(listed_in %in% target_genres) %>% # Filtrar pelos gêneros alvo
  count(release_year, listed_in) %>% # Contar por ano e gênero
  complete(release_year, listed_in, fill = list(n = 0)) %>% # Garantir que todos os anos/gêneros estejam presentes no intervalo
  arrange(release_year, listed_in) # Ordenar para melhor visualização

# Criar gráfico de barras Plotly
plot_ly(data = genre_counts_2000_2010, x = ~as.factor(release_year), y = ~n, color = ~listed_in, type = 'bar') %>%
  layout(title = "Quantidade de Filmes por Gênero (2000-2010)",
         xaxis = list(title = "Ano de Lançamento"),
         yaxis = list(title = "Quantidade de Filmes"),
         barmode = 'group') # Barras lado a lado

---

Este relatório foi gerado dinamicamente combinando texto, código R e visualizações interativas utilizando R Markdown e as bibliotecas especificadas nas instruções.