Como construir aplicativos da Web interativos com Shiny em R

Como Construir Aplicativos Da Web Interativos Com Shiny Em R



Devido à estrutura R Shiny, um pacote do RStudio, criar aplicativos web dinâmicos com R é relativamente fácil. A vantagem do Shiny é que ele possibilita colocar seu código R na web, tornando-o mais acessível a uma gama maior de usuários. Com R Shiny, você pode criar relatórios de dados e recursos visuais muito poderosos que permitem ao usuário analisar o conjunto de dados. Junto com os componentes Shiny, os elementos HTML podem ser usados ​​para projetar o conteúdo do programa. O artigo de hoje orienta você no processo de construção de um aplicativo Web interativo empregando o pacote Shiny do R. Para isso, certifique-se de já ter o “RStudio” instalado.

Instale o pacote Shiny no RStudio

Antes de prosseguirmos para a criação de uma aplicação web interativa dentro do RStudio, devemos ter o pacote “Shiny” já instalado nela. Para isso, é necessário expandir o menu “Ferramentas” do RStudio seguido da opção “Instalar Pacotes”. Na janela aberta, você deve mencionar o pacote que deseja instalar, ou seja, “brilhante”, e tocar no botão “Instalar”. O RStudio instalará o pacote brilhante no console do RStudio.







Comece com o Shiny em R

Para começar a usar o Shiny em R, você precisa criar um novo arquivo R usando o menu “Arquivo” localizado no primeiro lugar do RStudio. Expanda-o e use a opção “Novo Arquivo” seguida da opção “R Script”. O arquivo de script “sem título” será aberto no RStudio. Renomeie-o como um arquivo “R” no local desejado.



Agora, carregue os pacotes necessários para construir uma aplicação interativa em R, ou seja, usando a função “library” de R. As instruções “if” são usadas para instalar os pacotes que não foram instalados anteriormente. O pacote Shiny é usado para construir uma interface interativa para aplicações web junto com algumas visualizações gráficas. O pacote “dplyr” é usado principalmente para facilitar a manipulação de dados em R, utilizando algumas funções úteis.



Por último, o pacote “ggplot2” é carregado como uma ótima fonte de visualização de dados, criando gráficos poderosos e customizados.





se ( ! requireNamespace ( 'brilhante' , silenciosamente = verdadeiro ) ) {

instalar. pacotes ( 'brilhante' )

}

se ( ! requireNamespace ( 'dplyr' , silenciosamente = verdadeiro ) ) {

instalar. pacotes ( 'dplyr' )

}

se ( ! requireNamespace ( 'ggplot2' , silenciosamente = verdadeiro ) ) {

instalar. pacotes ( 'ggplot2' )

}

biblioteca ( brilhante )

biblioteca ( dplyr )

biblioteca ( ggplot2 )

Crie um sistema interativo de classificação para exames

Neste tutorial, criaremos um “Sistema de notas de exames” para que os alunos obtenham as notas alcançadas por meio das notas obtidas em 100. O script fornecido é o componente “ui” de um aplicativo Shiny que especifica o design e a aparência de o programa. O programa gera um fluidPage, um design adaptável que pode ser dimensionado para se ajustar à janela do navegador.

Um “titlePanel” e um “sidebarLayout” são descendentes do “fluidPage”. O título “Exam Grading System” do programa é tudo o que é exibido no “titlePanel”. Um “sidebarPanel” e um “mainPanel” são as duas seções que o “sidebarLayout” usa para dividir o aplicativo. Um par de entradas está incluído no “sidebarPanel”: um “textAreaInput” denominado “score” mais um “actionButton” denominado “calcular”.



Uma pontuação por linha pode ser inserida para cada aluno usando o “textAreaInput”. A avaliação da nota pode ser iniciada pelo uso do “actionButton”. Um par de saídas está presente no “mainPanel”: um “tableOutput” denominado “Result” mais um “plotOutput” denominado “ResultGraph”. Tanto “tableOutput” quanto “plotOutput” apresentarão os resultados do cálculo na forma de um gráfico.

interface do usuário <- fluidPage (

painel de título ( 'Sistema de classificação de exames' ) ,
barra lateralLayout (
barra lateralPainel (
textAreaInput ( 'pontuação' , 'Insira as pontuações dos alunos (uma por linha):' , '' ) ,
botão de ação ( 'calcular' , 'Vamos calcular notas' )
) ,
painel principal (
tabelaSaída ( 'Resultado' ) ,
plotOutput ( 'Resultado Gráfico' )
) ) )

O método server estabelece a lógica do lado do servidor do aplicativo. As notas dos alunos são inicialmente armazenadas em uma variável reativa chamada “dados”. Para isso, o botão “calcular” é monitorado pelo método “observeEvent” do R. Após o botão ser acionado, o código inicialmente converte os valores que são inseridos na entrada do campo de texto para valores numéricos.

Cada pontuação é seguida por uma quebra de linha usando “\n” para inserir uma nova pontuação na linha seguinte. O método coloca qualquer pontuação que encontrar na variável “dados”. Se um usuário não tiver inserido nenhuma pontuação, o método mostrará uma mensagem com um erro.

servidor <- função ( entrada, saída ) {

dados <- reativoVal ( NULO )

observarEvento ( entrada $ calcular, {

pontuação <- como. numérico ( cancelar lista ( strsplit ( entrada $ pontuação, ' \n ' ) ) )

se ( comprimento ( pontuação ) > 0 ) {

dados ( pontuação )

} outro {

dados ( NULO )

showModal ( modalDialog (

título = 'Erro' ,

'Erro: adicione valor!' ,

fácilFechar = verdadeiro

) )

}

} )

Duas saídas, “output$Result” mais “output$ResultGraph”, são especificadas para mostrar as notas dos alunos e as notas alcançadas. O método dinâmico renderTable() produz uma tabela de dados das notas e notas dos testes do aluno, rotulada como “output$Result”. O método renderPlot(), que também é reativo, gera um gráfico de barras para as notas dos alunos e o salva na saída “output$ResultGraph” de forma semelhante.

Eles serão, portanto, revisados ​​sempre que os dados de entrada forem atualizados. A expressão if (!is.null(data())) determina se os dados que estão sendo recebidos são nulos ou não. O script da instrução “if” é executado se não estiver vazio. Um vetor de pontuações dos alunos compõe os “dados” de entrada. Cada aluno recebe uma nota com base em sua pontuação usando o método case_when(). Um quadro de dados contendo as notas dos alunos e notas dos testes é criado usando o método data.frame(). As seguintes colunas são adicionadas ao quadro de dados: “Aluno”, “Pontuação” e “Nota”. A distribuição de notas é compilada em uma tabela chamada “GradeCount” usando o método table().

saída$Resultado <- renderTable ( {

se ( ! é. nulo ( dados ( ) ) ) {

notas <- caso_quando (

dados ( ) > 80 ~ 'A' ,

dados ( ) > 60 ~ 'B' ,

dados ( ) > 40 ~ 'C' ,

dados ( ) > 30 ~ 'D' ,

verdadeiro ~ 'F'

)

dados. quadro ( Estudante = 1 : comprimento ( dados ( ) ) , Pontuação = dados ( ) , Nota = notas )

}

} )

saída$ResultGraph <- renderPlot ( {

se ( ! é. nulo ( dados ( ) ) ) {

notas <- caso_quando (

dados ( ) > 80 ~ 'A' ,

dados ( ) > 60 ~ 'B' ,

dados ( ) > 40 ~ 'C' ,

dados ( ) > 30 ~ 'D' ,

verdadeiro ~ 'F'

)

Contagem de notas <- mesa ( notas )

O gráfico de barras é criado usando a biblioteca “ggplot2”. A contagem (número total de alunos que obtiveram cada nota) e a coluna Nota são criadas em um DataFrame. Um gráfico de barras com os dados de “Grau” no “eixo x” e os dados de “Contagem” no “eixo y” é produzido usando o método geom_bar(). A opção stat = “identity” instrui o ggplot2 a utilizar os dados reais sem qualquer tipo de transformação. Um título, um rótulo do eixo x e um rótulo do eixo y são todos adicionados por meio do método “labs”. As cores da barra são atribuídas usando o método scale_fill_manual(). Linhas de grade desnecessárias e componentes de sobreposição são removidos usando o método theme_minimal(). O método brilhanteApp(ui, server) cria um aplicativo.

gplot ( dados = dados. quadro ( Nota = nomes ( Contagem de notas ) , Contar = como. numérico ( Contagem de notas ) ) ,
sim ( x = Grau, e = Conte, preencha = Nota ) ) +
geom_bar ( Estado = 'identidade' ) +
laboratórios ( título = 'Distribuição de notas' ,
x = 'Nota' ,
e = 'Contar' ) +
escala_preenchimento_manual ( valores = c ( 'A' = 'verde' , 'B' = 'roxo' , 'C' = 'rosa' ,
'D' = 'laranja' , 'F' = 'vermelho' ) ) +
tema_mínimo ( )
}
} )
}
brilhanteApp ( interface do usuário, servidor )

Ao executar este código, obtivemos uma interface interativa onde adicionamos algumas marcas e clicamos no botão “Vamos calcular notas”.

É exibida a tabela que contém as notas e notas dos alunos, seguida do gráfico de barras da distribuição de notas em cores diferentes.

Conclusão

Este guia explica a importância do uso do pacote Shiny na linguagem R via RStudio. Para complementar nossa explicação, construímos um aplicativo web interativo para o sistema de notas dos alunos no código R, utilizando o pacote “Shiny”.