Índice
Shiny é utilizado por muitos cientistas e analistas de informação para criar visualizações interativas e funções de internet.
Embora o Shiny seja um produto RStudio e bastante amigável, o evento de um aplicativo Shiny difere consideravelmente da visualização e exploração de informações que você pode fazer por meio do universo organizado em um arquivo RMarkdown. Devido a isso, pode haver um pouco de uma curva de aprendizado do Shiny, mesmo para usuários experientes do R, e este tutorial visa apresentar o uso e os recursos do Shiny por meio de uma visão geral conceitual rápida, bem como a criação passo a passo de um aplicativo Shiny de instância .
Neste tutorial , criaremos o próximo aplicativo Shiny, que pode ser apresentado em sua forma interativa completa aqui . Um repositório GitHub relacionado pode ser encontrado aqui . O painel permite que os usuários encontrem informações que representam as 10 principais causas de morte entre os nova-iorquinos em 12 meses, sexo e raça/etnia. Poderíamos ter um gráfico de barras que mostre o número de mortes relacionadas a cada uma dessas principais causas de morte, bem como uma mesa que descreva as principais causas de morte, o número de mortes relacionadas, a taxa de morte relacionada, além de o preço de morte ajustado por idade relacionado.
Visão geral brilhante temporária
O que é brilhante?
Shiny é um pacote R projetado para facilitar a criação de aplicativos e painéis de internet interativos. Toda a codificação pode ser realizada em R, portanto, nenhuma experiência de crescimento na Internet é necessária para usar o Shiny com sucesso. No entanto, o Shiny usa uma estrutura CSS, HTML e JavaScript, portanto, a familiaridade com essas linguagens pode facilitar o desenvolvimento de aplicativos mais avançados. Você pode simplesmente hospedar e implantar aplicativos Shiny, e o RStudio oferece convenientemente opções de implantação na nuvem e no local por meio de shinyapps.io e Shiny Server , respectivamente.
Eu sugiro extremamente passar um tempo explorando a Galeria Shiny . Este é um excelente recurso útil onde você pode ver o que outras pessoas construíram com o Shiny, além de todo o código subjacente. Além disso, existem demonstrações brilhantes na Galeria, que são projetadas pelos construtores brilhantes como um exemplo de opções variadas por meio de exemplos fáceis.
Interface do consumidor (IU)
Aplicativos brilhantes incluem uma interface de pessoa (IU) e um servidor que responde à IU e gera saídas.
A interface do usuário é basicamente responsável pela aparência e pelas entradas do seu aplicativo. A aparência pode ser definida na interface do usuário alterando itens como a estrutura e as cores do aplicativo ou criando outras guias.
Os clientes criam entrada por meio de widgets, que são codificados na parte da interface do usuário do aplicativo Shiny. Os widgets podem assumir vários tipos, como botões, caixas de seleção, controles deslizantes e entrada de conteúdo textual. A Galeria de Widgets Brilhantes do RStudio permite que você veja as opções de widget disponíveis, bem como o código relacionado que as produz.
Servidor
O servidor é o local onde você constrói suas saídas, como gráficos, mapas, valores e tabelas. O servidor incluirá o código para gerar essas saídas, bem como as instruções para R sobre como a saída deve mudar com base em um dado entrar na interface do usuário.
Fornecimento de informações e limpeza de informações
O conjunto de dados que vamos utilizar neste tutorial está disponível publicamente via NYC OpenData. A informação representa as 10 principais causas de morte entre os residentes da cidade de Nova York por sexo e raça entre 2007 e 2014. Dado meu treinamento em saúde pública, achei interessante descobrir como raça e sexo estão associados às causas de morte além de como essas relações poderiam ter modificado ao longo do tempo.
Com o objetivo de obter essas informações, acesse o site NYC OpenData para esta fonte de dados. As informações estarão disponíveis como um arquivo CSV abaixo de “Exportar”, conforme destacado abaixo. O download deve começar instantaneamente quando você clicar no botão CSV.
Essas informações são bem organizadas, no entanto, agora temos um pouco de limpeza a fazer. Modifiquei o título do arquivo para “nyc_death.csv” e o posicionei em uma pasta intitulada “informações” em uma nova missão R.
Primeiro, vamos simplesmente carregar o pacote “tidyverse” em um novo arquivo RMarkdown:
Este pedaço de código subsequente executa apenas alguns processos de limpeza fundamentais. Primeiro, usamos a operação read_csv() para carregar as informações de mortalidade. Em seguida, usamos a operação clean_names() do pacote “janitor” para colocar todos os nomes de variáveis no caso da cobra. Posteriormente, realizamos alguma filtragem. Para as necessidades deste aplicativo, queremos apenas pessoas com uma raça/etnia reconhecida, para que possamos filtrar as entradas onde o valor de raça_etnia era “Não dito/desconhecido” ou “Raça/etnia diferente”. O conjunto de dados também inclui as 10 principais causas de morte para cada mistura de raça e sexo, além de todas as outras causas agrupadas. Queremos apenas essas principais causas de morte, então filtre as linhas onde o valor principal_causa é “Todas as outras causas”. Por último, aplicamos como.
Depois de realizar essa limpeza fundamental, nossas informações parecem ser as seguintes:
Geral, isso parece ser bastante bom. Os valores para nossa variável leader_cause, no entanto, são muito longos e incluem explicações para códigos de morte. Nossos visualizadores pretendidos são visualizadores normais, portanto, essa explicação para os códigos de morte provavelmente não é tão informativa. Essa variável também pode ser usada na parte do gráfico de barras de nosso aplicativo Shiny, com os rótulos do eixo x vindo instantaneamente dessa variável leading_cause. Essas descrições muito extensas terminariam em rótulos do eixo x para nosso gráfico de barras que não são muito legíveis. Devido a este fato, é inteligente editar esses valores até rótulos rápidos e descritivos sem explicação para códigos de morte.
O primeiro passo para fazer essa variação é descobrir quais valores temos que mudar. Devido a este fato, devemos conhecer todos os valores distintivos da variável leading_cause que existem neste conjunto de informações. A operação distintivo () pode nos fornecer esta informação:
Podemos ver que existem 19 valores distintos para lead_cause que devemos considerar encurtar:
Com o objetivo de editar esses valores, temos que mergulhar na longa etapa mutate() abaixo. Na primeira linha da etapa mutate(), usamos str_replace_all() para remover todos os parênteses nessa variável Leading_cause. Como você pode ver acima, todos os valores atualmente têm uma explicação para os códigos de morte incluídos entre parênteses. A função que usaremos para trocar conteúdo textual, str_replace(), não funciona corretamente quando há parênteses incluídos no conteúdo textual, portanto, é inteligente simplesmente removê-los imediatamente.
Em seguida, usamos apenas str_replace() para trocar o conteúdo textual para cada uma dessas explicações para valores de morte. (Observação: copiei esses valores instantaneamente da saída distintivo() para facilitar para mim — mas não se esqueça de deletar os parênteses quando fizer o mesmo!) A operação str_replace() recebe os próximos três argumentos: a variável Título o lugar onde a alternativa de string deve acontecer, a amostra de conteúdo textual que você deseja trocar e com o que você deseja trocá-la. Como você verá abaixo, cada uma dessas etapas str_replace leva Leading_cause como a variável de curiosidade e a explicação autêntica para o rótulo de morte subsequente e, finalmente, uma versão abreviada que pode parecer mais alta em nosso gráfico de barras:
Agora, nossos valores em nossa variável leader_cause parecem muito mais organizados e podem funcionar mais alto em nosso gráfico de barras:
Nossas informações estão prontas agora, e a etapa final é exportar este último conjunto de dados para ser usado em nosso aplicativo Shiny. Isso é feito com a operação write_csv():
Agora podemos continuar com o Shiny!
DESENVOLVIMENTO DE APLICATIVOS SHINY
Criando um novo aplicativo brilhante
A primeira coisa que precisamos fazer é criar um novo aplicativo Shiny em R. No RStudio, escolha Arquivo → Novo arquivo → Aplicativo Shiny Net:
Você será solicitado a escolher um título de software, classificação e site. A classificação do dispositivo refere-se a se a interface do usuário e o servidor existem ou não juntos em um único arquivo ou quando você tem informações separadas para cada um. Essa escolha é basicamente uma questão de desejo não público. Às vezes, é mais fácil usar o tipo Vários arquivos para aplicativos complicados com muito código, e algumas pessoas acham a separação mais simples, mesmo para aplicativos fáceis. Pessoalmente, gosto de ter todo o código em um único local para aplicativos fáceis, então escolhi “Arquivo Único”. Você pode dar um título ao seu aplicativo e colocá-lo em qualquer lugar do seu computador, mas aqui eu o chamei de “nyc_mortality” e o posicionei na minha área de trabalho. Depois de fazer suas escolhas, clique em “Criar” no verso direito:
Seu arquivo app.R deve agora parecer. O RStudio é bom em oferecer detalhes úteis sobre suas criações aos clientes, e o Shiny não é totalmente diferente. Esse código preenchido automaticamente que aparece enquanto você cria um novo aplicativo é definitivamente um aplicativo completo por si só. Você pode experimentá-lo clicando em “Executar aplicativo” no canto superior direito:
Este aplicativo de informações gêiseres desatualizado aparecerá, que inclui um widget deslizante à esquerda e um histograma no preciso. Você precisa usar o controle deslizante para alterar a variedade de caixas atuais no histograma. Mexa com isso por um segundo para se familiarizar com o funcionamento dos aplicativos Shiny em seu tipo mais fácil.
Quando estiver pronto, filtre o código de informações desatualizadas do gêiser devotado para que possamos trocá-lo com o nosso pessoal. Você possivelmente pode excluir todas as peças além da linha principal:
E a linha final:
Observe: em vez de excluir instantaneamente todo esse código de padrão, geralmente acho útil deixar esse código como um modelo e trocá-lo continuamente enquanto crio meu aplicativo. Isso é realmente o que eu fiz quando criei este aplicativo pela primeira vez!
Antes de continuarmos, vamos simplesmente carregar os outros pacotes que usaremos para criar este aplicativo e divulgar nossas informações limpas.
Carregar bibliotecas:
Apenas lembre-se de ter o conjunto de dados limpo que criamos anteriormente onde quer que seu arquivo app.R esteja. Depois de fazer isso, você pode simplesmente usar read_csv() para divulgar nossas informações:
Vamos continuar a codificar nosso próprio aplicativo Shiny.
Codificando a IU
Para relembrar, esse é o aplicativo que criaremos:
Lembre-se de que a IU basicamente controla o que a pessoa vê e interage. Devido a esse fato, tentaremos realizar três problemas com nosso código de interface do usuário: criar o título “NYC Mortality by Race and Intercourse, 2007–2014”, criar os seletores de 12 meses, Intercourse e Raça/Etnia em o preciso e organizar a estrutura para o enredo e a mesa que criaremos na etapa do servidor.
Fazemos todas essas três coisas em um único e longo bloco de código que define a interface do usuário. Todo esse código está contido em um comando fluidPage(). Entenda que Shiny usa camel case, que geralmente é um pouco irritante para aqueles de nós acostumados a snake case (thisIsCamelCase e this_is_snake_case). Primeiro, criamos nosso título utilizando a operação titlePanel() simplesmente escrevendo-o entre aspas. Em seguida, criamos nossos três widgets na barra lateral. Há muito código nesta metade, então vamos passo a passo.
Nossa barra lateral tem apenas um painel, então todos os três widgets estão contidos em uma única operação sidebarPanel() dentro da operação sidebarLayout(). Nosso primeiro widget é um seletor suspenso, que criamos com a operação selectInput(). O argumento inputId determina como você consultará esse widget ao escrever o código do servidor, e o argumento label é onde você define o conteúdo textual que pode aparecer acima do widget no próprio aplicativo. O argumento das alternativas é simplesmente porque soa – aqui você especifica as opções que estarão disponíveis para escolher em seu widget. Existem apenas algumas maneiras alternativas de especificar seleções, e vamos cobrir três delas abaixo. Para nosso widget selectInput(), nossas seleções são meramente uma listagem de todos os anos representados em nosso conjunto de dados.
Em seguida vem nosso primeiro widget radioButtons(). Atribuímos um inputId e um rótulo novamente, mas agora criamos nossas seleções de outra forma. Nas informações cruas, as duas opções para sexo são “F” e “M”. Isso é informativo o suficiente em alguns contextos, mas será mais claro e pode parecer melhor ter “Feminino” e “Masculino” escritos ao lado desses seletores de botão de opção. Podemos fazer isso apenas indicando no argumento das “seleções” que “Feminino” = “F” e “Masculino” = “M”.
Em seguida, adicionamos nosso segundo widget radioButtons(). Mas, novamente, os argumentos inputId e label são bastante simples, mas adotamos uma terceira estratégia para o argumento alternativo aqui. Precisamos torná-lo possível filtrar por raça/etnia existente, mas não precisamos vasculhar os dados para determinar quais são esses valores. Felizmente, podemos contornar essa etapa usando a função distintivo () novamente. Esta operação faz com que as opções disponíveis para o widget de botão de rádio sejam todos os valores distintos da variável race_ethnicity no conjunto de dados nyc_mortality.
Por último, mas não menos importante, organizamos a estrutura para o painel principal. Como você pode ver acima, este painel será composto por um gráfico de barras e uma mesa. Nós realmente não criamos essas saídas, mas – estamos simplesmente dizendo ao Shiny para onde elas irão assim que as criarmos. Fazemos isso com a operação mainPanel() e temos uma linha de código para cada uma de nossas saídas. O gráfico de barras é nomeado primeiro utilizando a operação plotOutput() e, entre aspas, damos ao nosso futuro gráfico de barras o título “deathPlot”. Nossa mesa é nomeada a seguir usando a operação dataTableOutput() do pacote DT e recebe o nome de “deathTable”.
Nossa interface do usuário agora deve estar pronta e podemos transferir para o servidor.
Codificando o servidor
Lembre-se de que o servidor é o local onde criamos nossas saídas (neste caso, nosso gráfico de barra e nossa mesa), além do local onde informamos métodos para reagir à entrada que os clientes podem criar por meio dos widgets.
O servidor é uma operação que recebe um argumento de entrada e saída, e todo o nosso código para criar nosso servidor personalizado vem dentro dessa operação. Primeiro, criamos um objeto que rotulei como “escolhas” que filtra nossas informações de nyc_mortality com base principalmente na pessoa inserida nos widgets. Isso é feito usando a operação reativa (), que é inteligente porque as parcelas “reagem” à entrada do usuário. Dentro da operação reactive(), primeiro exigimos as três entradas que criamos na interface do usuário. Esses nomes devem estar alinhados precisamente com os nomes inputId que foram criados na interface do usuário. Em seguida, informamos o conjunto de dados nyc_mortality para filtrar a variável de 12 meses com base na entrada “12 meses”, a variável sexual com base na entrada “intercourse”,
Agora podemos criar nossas duas saídas: o gráfico de barras e a mesa. Começamos com o gráfico de barras, que foi reconhecido como “deathPlot”. Lembre-se de que o título que você atribui a este gráfico deve corresponder exatamente ao título que você atribuiu a ele na operação mainPanel() na interface do usuário. Pedimos a Shiny para gerar um gráfico usando a operação renderPlot() e, em seguida, criar esse gráfico de maneira razoavelmente normal usando ggplot(). Este código parecerá bastante familiar se você estiver familiarizado com ggplot(), embora façamos apenas algumas alterações para tornar este gráfico reativo à entrada da pessoa. O principal desses ajustes vem com o argumento da “informação”. Em vez de designar nossa fonte de informações como nyc_mortality (o conjunto de dados limpo com o qual trabalhamos), nossas informações são especificadas como o objeto “choices()” que acabamos de criar. Não precisamos plotar todos os dados no conjunto de dados nyc_mortality uma vez – relativamente, precisamos apenas plotar os dados para os 12 meses, a idade e a combinação sexual escolhida pelo usuário. Ao atribuir “choices ()” como nosso suprimento de informações, movemos apenas o modelo filtrado do conjunto de dados nyc_mortality para nosso gráfico. Em seguida, passamos para as especificações aes(), onde você informa ao ggplot o que deseja em seus eixos x e y. Em nosso caso, gostaríamos que essas causas principais de morte fossem nosso eixo x e a variedade de mortes relacionadas em nosso eixo y. No entanto, ggplot rotineiramente organiza variáveis de caracteres no eixo x em ordem alfabética e essa associação não é muito útil para nosso gráfico. Como alternativa, faz mais sentido ter as principais causas de morte organizadas pela redução do número de mortes.
Em seguida, informamos ao ggplot que o gráfico deve ser um gráfico de barras usando geom_bar(). O pequeno trecho de código “stat = ‘identificação'” significa que não há necessidade de o ggplot tentar misturar nossas informações – apresentaremos os valores de y instantaneamente por meio de nossa variável “morte”. A última coisa que fazemos dentro da parte do código geom_bar() é especificar um tom azul para as barras do nosso gráfico utilizando os argumentos “shade” e “fill”. Por fim, usamos o código ggplot() normal para fornecer ao nosso gráfico um título e rótulos de eixo e, em seguida, inclinar os rótulos do eixo x em um ângulo de 45 graus para tornar nosso gráfico mais legível.
Por fim, usamos o pacote “DT” para criar uma mesa chamada deathTable. Contida na operação renderDataTable() do pacote DT, usamos a operação datatable() que também vem do pacote DT. Mas, mais uma vez, usamos o objeto choice() como uma alternativa ao nosso conjunto de dados nyc_mortality completo. Entre parênteses, especificamos as 4 colunas pelas quais estamos ansiosos: Lead_case, mortes, death_rate e age_adjusted_death_rate. A operação colnames() nos permite atribuir nomes que podem ser mais legíveis para cada uma dessas variáveis. Esses nomes aparecerão porque os cabeçalhos das colunas em nossa última mesa. Abaixo do argumento “escolhas”, ressaltamos que as informações devem ser ordenadas com base principalmente na coluna 2 (óbitos) em ordem decrescente. Como em nosso gráfico de barras,
Agora nosso servidor também está codificado! Caso por acaso você o tenha excluído anteriormente, certifique-se de ter a próxima linha de código após o código do servidor:
O aplicativo agora está concluído, então vá em frente e clique em “Executar aplicativo” no canto superior direito.
Reserve um tempo para se divertir com os widgets no painel esquerdo para garantir que as saídas reajam corretamente. Se tudo parece estar funcionando, estamos prontos para passar para a hospedagem do aplicativo!
Internet hospedando o aplicativo Shiny
Embora existam várias maneiras de hospedar aplicativos Shiny, o shinyapps.io é ideal para usuários iniciantes do Shiny porque é gratuito e fácil de usar. Devido a este fato, estaremos utilizando este instrumento para hospedar nosso aplicativo.
Caso você não tenha uma conta shinyapps.io vinculada ao RStudio, você pode observar as seções 2.1 a 2.3.1 deste guia simples criado pelo RStudio.
Assim que essa conexão for feita, selecione “Publicar” no canto superior direito do aplicativo Shiny. Em seguida, escolha “Publish Utility…” no menu suspenso que aparece.
A próxima janela aparecerá. Sua conta shinyapps.io precisa estar vinculada e as informações obrigatórias já devem estar verificadas. Marque a opção “Iniciar navegador” no canto esquerdo traseiro para que seu aplicativo concluído apareça em seu navegador assim que a implantação estiver completa. Apenas lembre-se de ter orgulho do título do seu aplicativo, então vá em frente e clique em “Publicar”!
A implantação começará instantaneamente e pode levar alguns minutos. Assim que estiver cheio, seu navegador deve abrir e mostrar seu aplicativo recém-implantado. Caso você faça login em sua conta shinyapps.io, você também precisa verificar se seu aplicativo está funcionando!
Conclusão
Shiny é uma ferramenta extremamente excelente que os clientes R podem usar para construir todos os tipos de painéis e produtos interativos. É capaz de muito mais do que abordamos neste tutorial, mas esperamos que agora você realmente sinta que conhece os fundamentos de Shiny. Recomendo voltar à Galeria Shiny novamente, agora que você acabou de criar seu próprio aplicativo Shiny. Espero que agora você tenha uma compreensão maior de como esses aplicativos foram criados e, possivelmente, você se inspirará em sua próxima missão Shiny.
Uma última frase de recomendação – uma desvantagem do crescimento brilhante é que pode ser difícil testar seu trabalho da melhor maneira. Nesta instância, escrevemos todo o nosso código antes que o aplicativo pudesse ser executado. À medida que você avança para aplicativos mais complicados, recomendo começar fácil para garantir que os itens do seu aplicativo funcionem antes de incluir recursos e complexidade adicionais. Quando isso é potencial, possivelmente evitará muita frustração de depuração no caminho.
Contanto que você seja cauteloso ao adicionar código e usar a riqueza de fontes disponíveis on-line (especialmente aquelas criadas pelo RStudio!), Você não deve ter nenhuma desvantagem em explorar os vários e emocionantes recursos do Brilhante.