Exercício 12: Visualização de Dados

Questão 1

Enunciado: Use os dados fornecidos para gerar dois gráficos. Para o segundo gráfico (barras), use a escala logarítmica (log = "y") e as cores "#E6E6E6", "#666666". Os gráficos devem ser organizados com a função layout().

# Dados fornecidos
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)

# Criar o dataframe
df_q1 <- data.frame(
  clock = clock,
  MRT_1F = MRT_1F,
  MRT_3F = MRT_3F,
  MRT_5F = MRT_5F,
  MRT_10F = MRT_10F,
  MRT_15F = MRT_15F,
  MRT_sem_F = MRT_sem_F
)

# Preparar para múltiplos gráficos com layout()
par(mfrow = c(1, 1)) 

# Configurar o layout para 2 gráficos (1 linha, 2 colunas)
layout(matrix(c(1, 2), nrow = 1, ncol = 2), widths = c(1, 1))

# Gráfico 1: Gráfico de Linhas
plot(df_q1$clock, df_q1$MRT_1F, type = "l", col = "red", ylim = range(df_q1[, -1]),
     xlab = "Clock", ylab = "MRT", main = "MRT vs. Clock para Diferentes Frequências")
lines(df_q1$clock, df_q1$MRT_3F, col = "blue")
lines(df_q1$clock, df_q1$MRT_5F, col = "green")
lines(df_q1$clock, df_q1$MRT_10F, col = "purple")
lines(df_q1$clock, df_q1$MRT_15F, col = "orange")
lines(df_q1$clock, df_q1$MRT_sem_F, col = "black")
legend("topright", legend = names(df_q1)[-1], col = c("red", "blue", "green", "purple", "orange", "black"), lty = 1, cex = 0.8)

# Gráfico 2: Barras (apenas a primeira linha de dados)
data_barras <- as.numeric(df_q1[1, -1])
names(data_barras) <- names(df_q1)[-1]

# Definir as cores
cores_barras <- c("#E6E6E6", "#666666", "#E6E6E6", "#666666", "#E6E6E6", "#666666")

# Criar o gráfico de barras com escala logarítmica
barplot(data_barras, log = "y", col = cores_barras,
        main = "MRT Inicial (Clock = 0.1) em Escala Logarítmica",
        ylab = "MRT (log)", xlab = "Frequência")

# Resetar o layout
par(mfrow = c(1, 1))
layout(matrix(1))

Questão 2

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

# Dados para o gráfico de barras empilhadas
# Tabela representativa (exemplo)
qualidade_refeicao <- matrix(
  c(10, 5, 2, 
    15, 10, 5, 
    5, 15, 10),
  nrow = 3,
  byrow = TRUE,
  dimnames = list(
    Qualidade = c("Baixa", "Média", "Alta"),
    Preco = c("Econômico", "Moderado", "Premium")
  )
)

# Transpor a matriz para que as categorias de preço fiquem no eixo X
qualidade_refeicao_t <- t(qualidade_refeicao)

# Criar o gráfico de barras empilhadas
barplot(qualidade_refeicao_t, 
        main = "Qualidade de Refeição por Categoria de Preço",
        xlab = "Categoria de Preço",
        ylab = "Contagem de Refeições",
        col = brewer.pal(n = 3, name = "Set1"), 
        legend.text = rownames(qualidade_refeicao_t), 
        args.legend = list(x = "topright", title = "Qualidade da Refeição"),
        ylim = c(0, max(colSums(qualidade_refeicao_t)) * 1.2) 
)

Questão 3

Enunciado: Faça o histograma das temperaturas do mês de maio do dataset airquality. Converta as temperaturas para graus Celsius através da expressão °C = (°F − 32) / 1.8. Adicione título, nomes de eixos, cor e curva de densidade.

# Dataset airquality está disponível no R
data(airquality)

# Filtrar dados de maio (Month == 5)
maio_temp <- airquality %>%
  filter(Month == 5) %>%
  select(Temp)

# Converter Fahrenheit para Celsius: °C = (°F − 32) / 1.8
maio_temp$Temp_C <- (maio_temp$Temp - 32) / 1.8

# Criar o histograma
hist(maio_temp$Temp_C, 
     main = "Histograma das Temperaturas em Maio (Graus Celsius)",
     xlab = "Temperatura (°C)",
     ylab = "Frequência",
     col = "lightblue", 
     probability = TRUE 
)

# Adicionar a curva de densidade
lines(density(maio_temp$Temp_C, na.rm = TRUE), col = "red", lwd = 2)

Questão 4

Enunciado: Crie um gráfico de pizza com a porcentagem da tabela total de vendas por país, usando o dataset Sales.txt. Inclua a porcentagem de cada fatia, as cores das fatias e o nome do gráfico. Use o comando legend() para incluir a legenda.

# Carregar o dataset sales
sales_url <- "https://training-course-material.com/images/8/8f/Sales.txt"
sales <- read.delim(sales_url, header = TRUE, sep = "", stringsAsFactors = FALSE)

# Calcular o total de vendas por país
vendas_por_pais <- sales %>%
  group_by(COUNTRY) %>% 
  summarise(Total_Vendas = sum(SALES)) 

# Calcular a porcentagem
vendas_por_pais$Porcentagem <- vendas_por_pais$Total_Vendas / sum(vendas_por_pais$Total_Vendas) * 100

# Criar o gráfico de pizza
# Preparar os rótulos com porcentagem
rotulos <- paste0(vendas_por_pais$COUNTRY, " (", round(vendas_por_pais$Porcentagem, 1), "%)")

# Definir cores
cores_pizza <- brewer.pal(n = nrow(vendas_por_pais), name = "Pastel1")

# Criar o gráfico de pizza
pie(vendas_por_pais$Total_Vendas, 
    labels = rotulos, 
    main = "Porcentagem Total de Vendas por País",
    col = cores_pizza,
    cex = 0.8 
)

# Adicionar a legenda separadamente com legend()
legend("topright", 
       legend = vendas_por_pais$COUNTRY, 
       fill = cores_pizza, 
       title = "País",
       cex = 0.8)

Questão 5

Enunciado: 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. As caixas devem ser preenchidas com a cor “yellow”.

# Dataset InsectSprays está disponível no R
data(InsectSprays)

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

Questão 6

Enunciado: Gere gráficos de linha do tempo de coleta dos recursos (currentTime) em relação à memória usada (usedMemory) a partir dos arquivos monitoringCloudData_*.csv. É necessário ajustar a coluna currentTime para que o tempo fique contínuo (em horas) e a coluna usedMemory para que todas as informações fiquem em megabytes. Use a função layout() para organizar os gráficos.

# Nomes dos arquivos
arquivos <- c("monitoringCloudData_0.1.csv", "monitoringCloudData_0.5.csv", 
              "monitoringCloudData_1.csv", "monitoringCloudData_NONE.csv")
# Caminhos para os arquivos
caminhos <- paste0(base_path_monitoring, arquivos)

# Função para carregar, limpar e processar os dados
processar_dados <- function(caminho, nome_arquivo) {
  df <- read.csv(caminho)
  
  # 1. Ajustar a coluna "currentTime" para que o tempo fique contínuo (em horas)
  df$currentTime <- as.POSIXct(df$currentTime, format = "%Y-%m-%d %H:%M:%S")
  df$tempo_continuo_horas <- as.numeric(difftime(df$currentTime, df$currentTime[1], units = "hours"))
  
  # 2. Ajustar a coluna "usedMemory" para que todas as informações fiquem em megabytes
  converter_para_mb <- function(mem_str) {
    mem_str <- trimws(as.character(mem_str))
    
    if (grepl("TB", mem_str)) {
      valor <- as.numeric(gsub("TB", "", mem_str))
      return(valor * 1000000) 
    } else if (grepl("GB", mem_str)) {
      valor <- as.numeric(gsub("GB", "", mem_str))
      return(valor * 1024) 
    } else if (grepl("MB", mem_str)) {
      valor <- as.numeric(gsub("MB", "", mem_str))
      return(valor) 
    } else {
      valor <- as.numeric(mem_str)
      return(valor)
    }
  }
  
  # Aplicar a função de conversão
  df$usedMemory_MB <- sapply(df$usedMemory, converter_para_mb)
  
  # Adicionar uma coluna para identificar o dataset
  df$dataset <- gsub(".csv", "", nome_arquivo)
  
  return(df)
}

# Carregar e processar todos os datasets
dados_q6 <- lapply(seq_along(caminhos), function(i) processar_dados(caminhos[i], arquivos[i]))
dados_q6_df <- bind_rows(dados_q6)

# Configurar o layout para 2 linhas e 2 colunas (4 gráficos)
layout(matrix(1:4, nrow = 2, ncol = 2, byrow = TRUE))

# Gerar os gráficos de linha do tempo para cada dataset
datasets_unicos <- unique(dados_q6_df$dataset)

for (ds in datasets_unicos) {
  df_plot <- dados_q6_df %>% filter(dataset == ds)
  
  plot(df_plot$tempo_continuo_horas, df_plot$usedMemory_MB, 
       type = "l", 
       main = paste("Uso de Memória ao Longo do Tempo -", ds),
       xlab = "Tempo Contínuo (Horas)",
       ylab = "Memória Utilizada (MB)",
       lwd = 2)
}

# Resetar o layout
par(mfrow = c(1, 1))
layout(matrix(1))

Questão 7

Enunciado: 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.

# Carregar o dataset netflix_titles.csv
netflix_data <- read.csv(netflix_path)

# Filtrar conteúdos com apenas UM país de origem
netflix_single_country <- netflix_data %>%
  filter(!is.na(country) & !grepl(",", country))

# Contar o conteúdo por país
top_10_paises <- netflix_single_country %>%
  group_by(country) %>%
  summarise(Total_Conteudo = n()) %>%
  arrange(desc(Total_Conteudo)) %>%
  head(10) %>%
  filter(country != "") # Remove entradas vazias que podem causar problemas de visualização

# Criar o gráfico de pizza com Plotly
fig_q7 <- plot_ly(top_10_paises, 
                  labels = ~country, 
                  values = ~Total_Conteudo, 
                  type = 'pie', 
                  textinfo = 'label+percent',
                  insidetextorientation = 'radial') %>%
  layout(title = 'Top 10 Países com Mais Conteúdo na Netflix (País Único)',
         xaxis = list(showgrid = FALSE, zeroline = FALSE, showticklabels = FALSE),
         yaxis = list(showgrid = FALSE, zeroline = FALSE, showticklabels = FALSE))

fig_q7

Questão 8

Enunciado: 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”. O cabeçalho deve ter fundo cinza e letra branca, e todos os textos das células devem estar centralizados.

# Usar os 10 países da Questão 7 (top_10_paises)

# Renomear colunas para "País" e "Total de conteúdos"
tabela_q8 <- top_10_paises %>%
  rename(País = country, `Total de conteúdos` = Total_Conteudo)

# Criar a tabela com Plotly
fig_q8 <- plot_ly(
  type = 'table',
  header = list(
    values = c("<b>País</b>", "<b>Total de conteúdos</b>"),
    align = c("center", "center"),
    line = list(width = 1, color = 'black'),
    fill = list(color = "gray"), 
    font = list(color = "white", size = 12) 
  ),
  cells = list(
    values = t(as.matrix(tabela_q8)),
    align = c("center", "center"), 
    line = list(color = "black", width = 1),
    font = list(size = 11)
  )) %>%
  layout(title = "Top 10 Países por Total de Conteúdos na Netflix")

fig_q8

Questão 9

Enunciado: Utilizando o Plotly, obtenha um gráfico de linha com a quantidade de conteúdo por década na Netflix, onde o eixo X representa as décadas e o eixo Y a quantidade de conteúdo disponível. Use uma linha azul para séries e uma linha amarela para filmes. (Considerar como década o período que compreende os anos de XXX0 à XXX9).

# Usar o dataset netflix_titles.csv
# Colunas: type, release_year

# Calcular a década (XXX0 a XXX9)
netflix_data$decada <- floor(netflix_data$release_year / 10) * 10

# Contar o conteúdo por década e tipo
conteudo_por_decada <- netflix_data %>%
  group_by(decada, type) %>%
  summarise(Total_Conteudo = n(), .groups = 'drop') %>%
  filter(decada >= 1940)

# Criar o gráfico de linha com Plotly
fig_q9_final <- plot_ly() %>%
  add_trace(data = filter(conteudo_por_decada, type == "TV Show"), 
            x = ~decada, y = ~Total_Conteudo, 
            type = 'scatter', mode = 'lines', 
            line = list(color = 'blue', width = 2), 
            name = 'Séries') %>%
  add_trace(data = filter(conteudo_por_decada, type == "Movie"), 
            x = ~decada, y = ~Total_Conteudo, 
            type = 'scatter', mode = 'lines', 
            line = list(color = 'yellow', width = 2), 
            name = 'Filmes') %>%
  layout(title = 'Quantidade de Conteúdo na Netflix por Década e Tipo',
         xaxis = list(title = 'Década', tickmode = 'linear', dtick = 10),
         yaxis = list(title = 'Quantidade de Conteúdo'))

fig_q9_final

Questão 10

Enunciado: Utilizando o Plotly, obtenha um gráfico de barras lado-a-lado que representa a quantidade de filmes lançados dos gêneros “Dramas”, “Action & Adventure” e “Comedies” entre os anos de 2000 e 2010. (Para filmes com múltiplos gêneros, considerar apenas o primeiro descrito na coluna “listed_in”).

# Usar o dataset netflix_titles.csv
# Filtrar por tipo "Movie" e anos entre 2000 e 2010 (inclusive)
# Gêneros a considerar: "Dramas", "Action & Adventure", "Comedies"

# 1. Filtrar filmes e anos
filmes_2000_2010 <- netflix_data %>%
  filter(type == "Movie" & release_year >= 2000 & release_year <= 2010)

# 2. Extrair o primeiro gênero
filmes_2000_2010$primeiro_genero <- sapply(strsplit(as.character(filmes_2000_2010$listed_in), ", "), `[`, 1)

# 3. Filtrar pelos gêneros de interesse
generos_interesse <- c("Dramas", "Action & Adventure", "Comedies")
filmes_filtrados <- filmes_2000_2010 %>%
  filter(primeiro_genero %in% generos_interesse)

# 4. Contar a quantidade de filmes por ano e gênero
contagem_por_ano_genero <- filmes_filtrados %>%
  group_by(release_year, primeiro_genero) %>%
  summarise(Total_Filmes = n(), .groups = 'drop') %>%
  rename(Ano = release_year, Gênero = primeiro_genero)

# 5. Criar o gráfico de barras lado-a-lado com Plotly
fig_q10 <- plot_ly(contagem_por_ano_genero, 
                   x = ~Ano, 
                   y = ~Total_Filmes, 
                   color = ~Gênero, 
                   type = 'bar') %>%
  layout(title = 'Quantidade de Filmes Lançados por Gênero (2000-2010)',
         xaxis = list(title = 'Ano de Lançamento', type = 'category'),
         yaxis = list(title = 'Quantidade de Filmes'),
         barmode = 'group') 

fig_q10