é interessante saber uma linguagem de programação

Pensando em alternativas na construção de soluções envolvendo aprendizagem de máquina, é interessante dar os primeiros passos em Machine Learning. Pode-se fazer isso escolhendo uma linguagem de programação estatística, como o R ou Python, ou então seguindo com serviços cognitivos. Mas afinal, se for para o caminho da linguagem de programação, qual das duas devo investir meu tempo? Seguindo o ranking de linguagens de programação da IEEE, em 2019, o Python aparece em primeiro lugar e o R em quinto. Contudo, isso não significa que você deve escolher o Python apenas por isso. Ambas linguagens são ótimas para trabalhar com Machine Learning!

Você poderia desenvolver soluções de Machine Learning com qualquer linguagem como Java ou C#, porque no final das contas, os algoritmos são representações matemáticas. Porém, isso não é recomendado, porque estas linguagens são poderosas para alguns tipos de desenvolvimentos mas não possuem módulos específicos para cálculos matriciais complexos.

O R é uma das linguagens de programação estatística mais utilizadas para este fim, assim como o Python. Por outro lado, o Python é bastante versátil permitindo inclusive desenvolvimento de aplicações web.

IDE – Integrated Development Environment

As duas linguagens são gratuitas, isso significa que não precisa pagar para desenvolver soluções com elas. Por outro lado as IDEs, que são os software utilizados para escrever os códigos, podem ser cobradas. É muito comum usar o RStudio para desenvolver com linguagem R e o PyCharm para Python. Estas duas IDEs possuem a versão gratuita e a paga. Em ambas a versão gratuita é utilizada principalmente para estudos, e a paga é para quando você terá algum tipo de rentabilidade com a sua solução desenvolvida.

Existem alternativas. Uma é o VSCode que tem o Python nativo mas o R precisa ser adicionado como extensão. Ou o Jupyter Notebook, que é uma IDE web-based que permite nativamente escolher o Kernel de interpretação do código com Python ou R.

Comunidade

Para as duas linguagens existe uma comunidade muito ativa. Esta comunidade publica diariamente vários pacotes de funcionalidades, que resolvem problemas específicos. No R a comunidade se centraliza no CRAN – The Comprehensive R Archive Network enquanto a comunidade Python utiliza o PyPi – Python Package Index.  Estes pacotes ajudam a acelerar o desenvolvimento, facilitando a execução de tarefas complexas de forma simples. Imagine que você esteja fazendo uma análise exploratória descritiva e necessita gerar diversos gráficos sobre os dados. No R existe o GGPLOT2 que é um dos pacotes mais usados para geração de gráficos, e no Python o MatPlotLib. Mas repare que você não precisará criar do zero, você poderá utilizar algo já pronto que resolve o seu problema de forma específica.

A mesma coisa acontece para os principais pacotes de Machine Learning. Existem pacotes preparados em cada uma das comunidades, que facilitam o desenvolvimento dos seus modelos de aprendizagem de máquina.

Para aprender

Sendo totalmente imparcial, para você dar seus primeiros passos em Machine Learning, escolha uma das duas linguagens de programação e se arrisque. Existem diversos cursos gratuitos de R e de Python na internet. O Kaggle possui diversas bases de dados com muitos desafios, assim como o repositório de dataset da UCI. Os fóruns de discussão são ótimos pontos de encontro para tirar duvidas sobre a linguagem. E o principal benefício de escolher entre uma ou outra linguagem, é que a migração entre elas é bastante rápida. Ao aprender uma linguagem, migrar para a outra é questão praticamente de sintaxe. A forma de pensar, e de resolver problemas, é muito similar. Se não se adaptou com R, mude para o Python com muita fluidez.

Ah, outro ponto importante. Não se preocupe em aprender a matemática complexa por trás de cada modelo agora. Sugiro que aprenda uma das linguagens, estude alguns algoritmos que resolvem os principais problemas (classificação binária, classificação multi-classes, regressão linear bivariada, regressão linear multivariada, regressão logística, clustering e regras de associação). Depois que já estiver fluido em resolver problemas com estes algoritmos, ai sim comece a estudar o que eles fazem e como funcionam. Assim poderá entender o que está fazendo, e até melhorar a performance quando for preciso.

O post Primeiros passos em Machine Learning apareceu primeiro em Diego Nogare.

O pacote permite a interação do R com o Facebook usando uma chave de autenticação, chamada Token, que é fornecida ao criar um aplicativo do Facebook. Esta chave tem duração de 2 horas e pode ser renovada sempre que precisar. É importante lembrar que este Token é para usar em tempo de desenvolvimento, quando quiser colocar o aplicativo para produção, você deve buscar outra forma de autenticação do seu aplicativo no Facebook, uma que não expire em 2 horas. Neste post, como tem o objetivo de mostrar a integração, o Token de desenvolvimento é suficiente.

Criando o aplicativo no Facebook

Você precisa de uma conta válida no Facebook. Ao se conectar ao Facebook, vá até o link: https://developers.facebook.com/apps

Ao acessar o link de desenvolvimento do Facebook, clique no botão para adicionar um novo aplicativo.

Vai abrir uma tela perguntando o nome do App, informe um nome do seu app.

Após, clique no botão para gerar o ID do aplicativo. Para questões de segurança você deve informar o captcha e pronto.

Algumas vezes é necessário que a extensão de login do facebook seja habilitada.

Para garantir, habilite esta extensão. Neste nosso exemplo, informe que será um login por WWW. Ao abrir a soliticação de qual endereço do site, informe: http://localhost:1410/. Para este nosso exemplo muitas vezes não pede esta autenticação, mas já deixe habilitado para caso precise. Pode salvar esta alteração.

Em seguida, acesse a URL: https://developers.facebook.com/tools/explorer/ para pegar o Token temporário (aquele de 2h de duração).

Caso você mantenha esta tela aberta por mais de 2hs, uma mensagem informando que o Token expirou é apresentada.

Pronto, com isso, seu aplicativo do Facebook está disponível.

Começando o desenvolvimento com o R

Para integrar, será usado o pacote RFacebook criado por Pablo Barbera (pablo.barbera@nyu.edu).

Instale e inicie o pacote, para isso, pode usar os códigos abaixo:

#Instalação do pacote

install.packages("Rfacebook")

#Carregamento do pacote

library(Rfacebook)

Também faça o armazenamento do token de acesso em uma variável. Volte até o aplicativo que você criou, vá até a URL que gera o Token, e copie o valor. Para colocar em uma variável, faça a atribuição como a linha de código abaixo:

appToken <- 'SEU_TOKEN_DE_ACESSO'

Para garantir que o acesso está funcionando, pode-se testar o retorno de alguma função. Neste caso, usaremos a função GetUsers que retorna os dados de perfil de um usuário específico. Praticamente todas funções exige que seja passado o token de acesso. Esta função não é diferente, veja abaixo como retornar os dados de um usuário.

eu <- getUsers("me", token = appToken)

eu$name

O resultado desta execução retorna o perfil de quem foi solicitado. O termo “me” retorna o perfil de quem está definido como criador do App no Facebook. Você pode passar outro ID de usuário e então os dados do perfil será retornado. Dentre a lista de atributos que retornaram, é possível retornar o nome utilizando o código $name.

Também é possível retornar a lista de páginas que foi curtida por um usuário. A função GetLikes permite isso. O código abaixo apresenta a lista de nomes das páginas que o perfil “me” curtiu.

meuslikes <- getLikes("me", token=appToken)

meuslikes$names

Uma forma de retornar as interações de uma página específica é usar a função GetPage. Esta função recebe alguns parâmetros para retornar os dados necessários, no exemplo passaremos três paramentos, sendo o nome da página que já foi armazenado na variável nomePagina; a quantidade de elementos a serem retornados, mantido na variável Quantidade e por fim o já utilizado token de acesso.

nomePagina <- "NGRSolutions"

Quantidade <- 10

pagina <- getPage(page = nomePagina, token = appToken, n = Quantidade)

Se observar a estrutura do objeto pagina, que armazena o retorno da função GetPage, é possível encontrar diversos atributos da página retornada. Para acessar esta estrutura, uma forma é chamar a função str() passando o objeto que quer consultar como parâmetro. Veja o código abaixo.

str(pagina)

Repare os atributos marcados em amarelo na imagem abaixo, cada um deles retorna uma lista de valores sobre aquela pagina retornada.

Para seguir com o experimento que estamos propondo, vamos retornar um valor do atributo id, que é responsável pelo id do post. Neste exato momento, o elemento número 5 do retorno é específico de um post que publicamos há alguns dias sobre uma promoção e gerou algumas interações. A escolha dele é justamente para podermos coletar retornos desta postagem. Para reutilizar o código desta publicação, ela será armazenada na variável codigoPost, como segue o código abaixo.

codigoPost <- pagina$id[5]

Um novo elemento que pode-se usar para interagir com o Facebook é o retorno de detalhes de um post, utilizando a função GetPost. Esta função recebe os parâmetros como o código do post que está interessado em ter os detalhes e também o token. O resultado será armazenado na variável postagem, e esta variável possui uma estrutura, seguindo a mesma linha que fizemos com o objeto pagina.

postagem <- getPost(post = codigoPost, token = appToken)

Inclusive é possível, também, saber a quantidade das reações de interação com o post. Para isso, use a função GetReactions, como o código abaixo.

reacoes <- getReactions(post = codigoPost, token = appToken)

Seguindo com o propósito inicial, vamos retornar o nome de todos as pessoas que curtiram o post. Assim pode-se pegar o nome e o id de todos os que curtiram. A partir do ID, pode-se retornar à primeira função que vimos lá em cima, e retornar os detalhes daquele perfil… Ao retornar o atributo likes do objeto postagem, todos os elementos que curtiram a postagem são retornados. Neste caso, para trabalhar em forma mais tranquila, converte-se a estrutura de likes em um dataframe. Para facilitar ainda mais, vamos atribuir os nomes das colunas do dataframe em Nome e ID, para ter o objeto todosNomes com duas colunas internas, sendo a Nome e a Id. Veja o código abaixo.

todosNomes <- as.data.frame(postagem$likes)

colnames(todosNomes) <- c('Nome','Id')

A função RunIF retorna valores aleatórios entre um intervalo mínimo e máximo, e utilizando esta função, é possível retornar um valor qualquer entre 1 e o número de pessoas que comentaram o post. Como também quero retornar apenas 1 nome deste retorno, vou usar a função head() que retorna os primeiros registros de um dataframe. Ao passar por parâmetro os dados para “sortear” e a quantidade de retorno sendo 1, a função head() devolve um único número aleatório válido. Ao buscar este número dentro do dataframe todosNomes criados no passo anterior, é possível saber o nome de quem foi escolhido. Para retornar o ID do sorteado, pode-se pesquisas pelo nome diretamente no dataframe. Veja o código abaixo:

nomeAleatorio <- todosNomes[head(as.integer(runif(todosNomes$Nome, 1, nrow(todosNomes))), 1), 'Nome']

idAleatorio <- todosNomes[(todosNomes$Nome == nomeAleatorio),'Id']

Para encerrar o experimento deste artigo, vamos usar o método updateStatus, que faz a postagem no Facebook. Este método recebe os parâmetros text, token e link. Sendo o text a mensagem a ser publicada, o token como já vimos e por fim, o link, como sendo uma URL para compartilhar junto ao post. Veja o código abaixo esta atualização no Facebook.

updateStatus(text = 'Postagem no Facebook através do R. Li em um post no blog Think Think SQL.', token = appToken, link = 'https://diegonogare.net/2017/07/integrando-o-r-com-o-seu-facebook/')

Agora abra o facebook e veja esta publicação em seu perfil. Parabéns e obrigado por compartilhar!

Hah, porque mostrei como retornar os nomes de quem curtiu e acabei não usando no post?? Usei o nome para fazer o sorteio, também usei para postar no facebook o nome do vencedor. Faça seus experimentos, inclusive subi no github o código com esta utilização. Caso queira, o código em R funcionando, e você pode ver aqui!

Por fim, caso não tenha visto o Github ainda, neste post falei como usar o Github.

O post Integrando o R com o seu Facebook apareceu primeiro em Diego Nogare.

O direcionamento da escrita será o mesmo de sempre, olhar para tecnologias focadas em dados!

Para voltar, escolhi contar como pode-se desenvolver scripts e projetos usando Linguagem R dentro do Visual Studio, tanto 2015 quanto 2017. E o melhor, pode-se usar a versão Community do Visual Studio, que é gratuita. Esta pode ser uma alternativa ao RStudio (que também é gratuito se não for usado para fins lucrativos), caso tenha o ambiente de desenvolvimento baseado em Microsoft já configurado.

Vamos lá, a primeira coisa a se fazer é baixar os softwares necessários. Caso já tenha o .Net Framework instalado, pode pular o download. Se estiver na dúvida, baixe.

1. .Net Framework 4.5.2 (+ – 70MB)
2. Microsoft R Client (+ – 300 MB)
3. Visual Studio Community 2017 (+ – 4.7Gb)

Todos os links acima são de distribuições gratuitas. Lembrando que o terceiro link, o do Visual Studio, você pode manter uma versão paga caso tenha a licença do produto.

Para começar o processo, faça a instalação do .Net Framework. Provavelmente se você mantém seu Windows atualizado, você não precisará instalar o .Net Framework e terá uma mensagem de alerta como a seguir. Caso precise instalar, é só avançar até concluir.

Seguindo o processo, entendendo que o .Net Framework já está instalado e rodando no seu ambiente, é o momento de instalar o Microsoft R Client. Faça a instalação agora, já tiver o Visual Studio em seu ambiente ou não. Ao iniciar a instalação, uma imagem como a seguir é apresentada, e solicita quais são os elementos que gostaria de instalar no ambiente. Eu desmarquei o Pre-Trained Models, mas se quiser estudar por eles, pode marcar a seguir a instalação.

Ao final da instalação, a tela avisa que finalizou e é só clicar em Finish.

O passo seguinte é iniciar a instalação do Visual Studio.

Ao iniciar o instalador atual do Visual Studio, existem vários presets de ambiente configurado. Cada uma destas pré configurações agiliza o processo de setup do ambiente para aquele Workload que pretende trabalhar.

Assegure-se de marcar a opção “Data Science and Analytical applications” e, nas opções da lateral direita, verifique se está marcado o R Language Support e Microsoft R Client dentro das opções de Individual Components. Repare que neste momento o setup faz a instalação do Microsoft R Client, que foi instalado manualmente no passo anterior. A instalação manual é justamente para deixar a ultima versão da publicação no ambiente. Manualmente foi instalado o Microsoft R Client 3.3.3 e a instalação de agora coloca a versão 3.3.2

Ao avançar, a instalação do ambiente começa a trabalhar. No final,

Após alguns instantes, a instalação termina e é possível abrir o Visual Studio. Para abrir, clique em Launch.

Se for a primeira execução do Visual Studio, poderá ser solicitado o seu e-mail de conta Microsoft. É só informar e avançar.

Neste momento, se tudo ocorrer bem, você terá uma versão funcional e totalmente gratuita do Visual Studio 2017 em seu ambiente.

Ao criar um novo projeto (File >> New >> Project)) e informar que será um projeto em R. Você será lançado ao editor do R no Visual Studio.

Escrevi o código abaixo há alguns anos (para outros exemplos). O resultado é criar um gráfico com 10 barras, indo em um dégradé de cores entre vermelho e verde, passando por amarelo.

color <- colorRampPalette(c(“red”, “yellow”, “green”)) 

color(10)

a <- c(1:10)

barplot(a, col = color(10), main = “R no Visual Studio 2017 – Diego Nogare”)

Ao executar o script, o resultado deverá ser como o da imagem abaixo.

Simples assim você tem um ambiente funcional (e gratuito) para escrever códigos em R no seu Visual Studio.

O post Desenvolvendo seus projetos em R no Visual Studio 2017 apareceu primeiro em Diego Nogare.

O evento foi MUITO superior ao que esperava, a estrutura do evento foi impecável. As salas comportaram todos os participantes, workshops e palestras relevantes, interação com os patrocinadores ocorreu naturalmente por serem patrocinadores com importância pro evento e pra nós, participantes. No fim do primeiro dia tivemos um momento pra fazer network (com cerveja na faixa!) no hotel mesmo, e foi interessante conversar com alguns cientistas de dados aqui dos Estados Unidos.

Fiz algumas anotações das palestras/workshops que achei mais interessantes durante o evento, veja abaixo:

Dia 1 – Sábado

Keynote

Brian Granger – Criador do IPython e Project Jupyter

O Jupyter é um compilador/interpretador online para Python (e mais 40 outras linguagens) que permite trabalhar em soluções narrativas com outros profissionais. Parecido com o Knirt (para R), mas ao invés de só renderizar na tela no formato escolhido, ele permite que o script que é escrito seja processador pelo server através do navegador. Jupyter é uma plataforma aberta, desenvolvida pela comunidade e com um time de estrelas por trás, a facilidade do crescimento se dá pelo uso do GitHub como repositório. Empresas como Microsoft, Google, IBM e varias outras estão desenvolvendo soluções para o Jupyter Notebook ou Kernel. JupyterHub permite empresas usar o Jupyter em suas organizações (pelo que entendi, como um repositório privado do github). Num futuro próximo pode ser que mude o nome para Jupyter Workbench, e também estão trabalhando para entregar Real-Time Colaboration, e na tentativa de permitir em uma única janela do navegador ter um console, graficos interativos, e várias outras coisas de UX para os desenvolvedores ficarem só em uma janela e aumentar a produtividade.

O Brian deu um exemplo de dois jornalistas que escrevem sobre ciência no BuzzFeed, que entregam seus experimentos no github e permite que nós possamos reproduzir as pesquisas. Caso queiram ver, este é o link: https://github.com/BuzzFeedNews/everything

Palestras

Claudia Perlich – Big Data matou o click | heróis de métricas não celebrados

40% dos clicks são acidentais ou fraudes! Fraudes são fáceis de gerar através de robos (bots) em eventos de conversão, principalmente nos retargets para aumentar o CTR e o contratante pagar mais pelo serviço. O comportamento de robos são mais fáceis de prever do que humanos, nosso comportamento é quase impossível de prever. Em uma análise focada, quando se analisa um dataset atrás de padrão de comportamento, deve-se conhecer o que procura para eliminar problemas gerados por randomização. Quando se tem uma precisão/acurácia de aproximadamente 50%, isso significa uma randomização. O objetivo é conseguir um valor de limiar acima de 70 ou 80%. Uma técnica que pode ajudar, é coletar para análise alguns registros randomicamente dos 1 ou 2% mais importantes do universo que tem, e analisar o comportamento desta amostra. A chance desta técnica apresentar um padrão de comportamento diferente do comportamento geral é muito grande, e diversos estudos mostram que este comportamento pode ser mais próximo do real do que se imagina.

Richard Socher, PhD – Metamind.io – Deep Learning for Enterprise

Esta foi a palestra mais foda e que eu mais me impressionei. Richard apresentou diversos problemas do mundo e as soluções que sua empresa criou utilizando Deep Learning. Esta palestra me fez mudar a agenda e participar de um Workshop de Deep Learning no segundo dia do evento ao invés de assistir às palestras que tinha me planejado. Não sei como descrever as técnicas que ele apresentou, e não teve quase nenhuma teoria, só que o reconhecimento de voz e de imagem são complexos para se executar com algoritmos convencionais de Data Science. O uso de técnicas de Deep Learning ajuda muito nestas tarefas. Processar isso é muito custos e usa-se o CPU pra procesamento de texto e a GPU pra processar imagens.

Workshop

John Mount / Nina Zumel – Preparando dados para análise usando R: Técnicas avançadas através das básicas

Workshop de 2 horas com diversas técnicas para se trabalhar com dados, limpar e processar as análises. Foi disponibilizado um repositório no github pra gente configurar a máquina antes e acompanhar o workshop com tudo o que foi discutido (repo garfado): https://github.com/diegonogare/PreparingDataWorkshop

Dia 2 – Domingo

Workshop

Markus Beissinger – Intro to Deep Learning with Theano and OpenDeep

Deep Learning segmenta a análise em hierarquia, encontrando item a item treinado separadamente para encontrar o objeto que quer depois. Por exemplo, imagine o reconhecimento de um rosto: em Deep Learning a tecnica começa com uma camada reconhecimento elementos separados, como nariz, orelha, olho, boca, etc; na sequencia a proxima camada reconhece um pouco mais de coisas, como as posições de olhos próximos ao nariz. Boca próximo ao nariz. Orelhas ao lado dos olhos, e assim por diante. Por fim, neste exemplo, ele consegue reconhecer um rosto completo em uma terceira camada de classificação.

O processo interno usa algebra linear, porque tudo dentro de Deep Learning é calculado com matrizes e vetores. Um dos calculos mais básicos ainda é a Regressão Logistica para analisar as probabilidades.

Mesmo a Regressão Logistica sendo a estrutura mais básica, uma das mais usadas é a Rede Neural, que possibilita executar muitas Regressões Logisticas em paralelo e encontrar uma melhor solução para a análise que está fazendo com Deep Learning. Muitas outras técnicas, como Convolutional Nets, por exemplo, devem combinar com as redes neurais artificiais para conseguir fazer o reconhecimento de imagem.

Códigos usados para os exemplos, estão disponíveis nestes dois repositórios garfados https://github.com/diegonogare/odsc e https://github.com/diegonogare/OpenDeep

Fidan Boylu / Muxi Li – How to build and operationalize data science solutions with Cortana Analytics

Fidan apresentou um overview interessante de AzureML utilizando alguns modelos nativos de algoritmos existentes dentro do AzureML, avançou expandindo as possibilidades utilizando R. Um tour guiado para analisar dados que fizemos upload, com certeza todos conseguiram acompanhar. Na sequência Mixu mostrou integração entre AzureML e scripts em Python, analisando tudo nos Workbooks do Jupyter que possui integração com o AzureML. Esta segunda parte eu não acompanhei, e pelo visto, a galera que estava acompanhando também se perdeu.

PS. Não falaram nada de Cortana Analytics!

Dá pra acompanhar depois, passo a passo, com os dados que foram disponibilizados neste repositório garfado: https://github.com/diegonogare/Azure-Machine-Learning-Lab

Ted Kwartler – Introduction to text mining using R

Existem muitos problemas na interpretação de texto: O dado não é estruturado, expressões são individualistas, implicações culturais, e vários outros fatores. É possível trabalhar com Text Mining de duas formas, uma é usando validação sintatica e outra é usando “bag of words”. O foco desta sessão é trabalhar com o bag of words. A análise de sentimentos é sempre lembrada quando se fala de mineração de texto, o Ted ainda está estudando esta disciplina e mostrou algumas coisas utilizando técnicas de Score baseada em dicionários. Em resumo, várias técnicas foram apresentadas, e podem ser acompanhadas no repositório do Github que garfei, não do github do Ted, e sim de uma pasta no Amazon Drive dele: https://github.com/diegonogare/DataScience/tree/master/Text%20Mining

O post Open Data Science Conference – São Francisco/2015 apareceu primeiro em Diego Nogare.

Pré-Requisitos

SQL Server 2016 CTP 3 (2.7GB)

Revolution R Open 3.2.2 for Revolution R Enterprise 7.5.0 (60MB)

Revolution R Enterprise 7.5.0 (RRE-7.5.0) (470MB)

Instalação

O primeiro passo é instalar o SQL Server 2016 CTP 3, lembrando de habilitar o recurso de Advanced Analytics Extensions.

Depois de concluir a instalação, é necessário instalar o Revolution R Open 3.2.2 for Revolution R Enterprise 7.5.0 e em seguida Revolution R Enterprise 7.5. Estas ferramentas são, respectivamente, a distribuição do R com o runtime e algumas bibliotecas, e, um grupo de melhorias nos pacotes que oferece suporte de alta performance á diversas origens de dados.

Da parte de instalação é só isso, agora faltam só mais alguns passos de configuração e o R começará a responder de dentro do SQL Server.

Configuração

Pode parecer complexo pra quem vê a primeira vez, mas é bem simples. A primeira coisa é habilitar a execução de scripts externos no SQL Server que por padrão, vem desabilitado. Você pode verificar isso chamando o código SP_CONFIGURE.

Para habilitar, execute o código abaixo:

Exec sp_configure 'external scripts enabled', 1;
reconfigure;

O resultado deve ter mudado a linha do External Scripts Enabled, que agora está habilitado.

Depois de habilitar a execução de scripts externos no SQL Server, é necessário registrar um daqueles serviços externos que foram instalados, é o serviço do Revolution R Open. Para isso, abra um prompt de comando com privilégios de admin e vé até o caminho que fez a instalação do RRO. No meu caso foi neste caminho (provavelmente você precisará editar isso para que funcione no seu servidor).

c:\Program Files\RRO\RRO-3.2.2-for-RRE-7.5.0\R-3.2.2\
library\RevoScaleR\rxLibs\x64>

Procure um executável chamado registerRext.exe e passe a instrução de instalar. Como eu renomeei a minha instância para SQL2016, eu também precisei passar o nome da instância para o executavel. Ficou assim:

c:\Program Files\RRO\RRO-3.2.2-for-RRE-7.5.0\R-3.2.2\
library\RevoScaleR\rxLibs\x64>registerRext.exe /install /instance:SQL2016

Ele executa um monte de instalações e registros internos, olha o resultado do prompt de comando depois dos registros:

Source directory to pick the RExtension binaries determined to be “c:\Program Files\RRO\RRO-3.2.2-for-RRE-7.5.0\R-3.2.2\library\RevoScaleR\rxLibs\x64\”.

Connecting to SQL server…

Sql server binn directory is “C:\Program Files\Microsoft SQL Server\MSSQL13.SQL2016\MSSQL\Binn”.

Sql server log directory is “C:\Program Files\Microsoft SQL Server\MSSQL13.SQL2016\MSSQL\Log”.

Creating user account pool…

Creating user accounts.

Processing 20/20

Adding firewall rule for user account pool.

***WARNING: For security reasons, it is recommended to block network access for

R processes executing under local user accounts. It appears that Windows Firewall is currently disabled for the Network Profiles DOMAIN, PRIVATE. Please enable Windows Firewall or use another firewall to block network access

Creating working directory for user accounts.

Saving user account configuration.

User account pool with 20 users created.

R installation found at C:\Program Files\RRO\RRO-3.2.2-for-RRE-7.5.0\R-3.2.2.MPI installation found at C:\Program Files\Microsoft MPI.

Settings file C:\Program Files\Microsoft SQL Server\MSSQL13.SQL2016\MSSQL\Binn\rlauncher.config created.

Stopping service MSSQLLaunchpad$SQL2016…

Stopping service MSSQL$SQL2016…

Copied xp_callrre.dll from c:\Program Files\RRO\RRO-3.2.2-for-RRE-7.5.0\R-3.2.2\library\RevoScaleR\rxLibs\x64\ to C:\Program Files\Microsoft SQL Server\MSSQL13.SQL2016\MSSQL\Binn.

Copied RLauncher.dll from c:\Program Files\RRO\RRO-3.2.2-for-RRE-7.5.0\R-3.2.2\library\RevoScaleR\rxLibs\x64\ to C:\Program Files\Microsoft SQL Server\MSSQL13.SQL2016\MSSQL\Binn.

Starting service MSSQLLaunchpad$SQL2016…

Connecting to SQL server…

Created role db_rrerole

Added extended stored procedure xp_ScaleR_init_job.

Granted Execute for extended stored procedure xp_ScaleR_init_job to db_rrerole.

Added extended stored procedure xp_ScaleR_queue_job.

Granted Execute for extended stored procedure xp_ScaleR_queue_job to db_rrerole.

Added extended stored procedure xp_ScaleR_retrieve_results.

Granted Execute for extended stored procedure xp_ScaleR_retrieve_results to db_rrerole.

Added extended stored procedure xp_ScaleR_query_status.

Granted Execute for extended stored procedure xp_ScaleR_query_status to db_rrerole.

Added extended stored procedure xp_ScaleR_cancel_job.

Granted Execute for extended stored procedure xp_ScaleR_cancel_job to db_rrerole.

Added extended stored procedure xp_ScaleR_cleanup.

Granted Execute for extended stored procedure xp_ScaleR_cleanup to db_rrerole.

R extensibility installed successfully.

Agora só falta reiniciar o serviço do SQL Server.

Primeira execução!

Agora é momento de abrir o SQL Server 2016 e executar o seu código em R. Peguei um código já criado aqui no blog anteriormente (Trabalhando com cores no R), e reaproveitei. Execute o código abaixo:

EXECUTE   sp_execute_external_script
 @language = N'R'               , @script = N'OutputDataSet <- InputDataSet
             color <- colorRampPalette(c("red","yellow", "green"))               color(10)
             a <- c(1:10)               jpeg("C:/TEMP/Barras.jpg")
             barplot(a, col=color(10), main="R no SQL Server 2016")               dev.off()'
 , @input_data_1 = N'SELECT ''R no SQL Server 2016'' as Col'               WITH RESULT SETS ((col varchar(30) not null));
go

E vá até sua pasta C:\Temp e pocure o arquivo Barras.jpg. Se tudo deu certo, você terá um gráfico como este abaixo gerado pelo R diretamente do seu SQL Server 2016.

Agora é explorar as funcionalidades e possibilidades do R, e integrar isso ao seu ambiente. Fique atento que mais posts sobre R dentro do SQL Server serão publicados em breve!

Links de Referência

Todas estas configurações acima foram consolidadas e tiradas destes links de referências abaixo.

Installing SQL Server R Services

Install Advanced Analytics Extensions

Install R Packages and Providers for SQL Server R Services

Configure and Manage Advanced Analytics Extensions

O post Introdução ao SQL Server R Services 2016 apareceu primeiro em Diego Nogare.

Flexibilidade na análise de dados

Fala galera, uma coisa interessante de se trabalhar com ferramentas de análise de dados é a possibilidade de customizar ao máximo os elementos visuais que você apresenta em relatórios e gráficos. Estas análises te ajudam a entender o cenário que se está trabalhando. Entre várias possibilidades, uma delas diz respeito à cores, e é por isso que explico rapidamente como trabalhar com cores no R.

Trabalhar com cores no R

Para fugir das cores iniciais de todos os gráficos e relatórios feitos em R, existem várias saídas. Você pode usar padrão RGB e definir os valores de R – red (vermelho), G – green (verde) e B – blue (azul) e então formar a cor que tem interesse. Você pode usar uma paleta de cores já existente. Também pode usar um pacote de cores criado por outros desenvolvedores da linguagem R e expandir seus horizontes.

Cores padrão

Para começar, o padrão inicial de cores do R é expresso nestas cores: Black (preto), red (vermelho), green (verde), blue (azul), cyan, (ciano), magenta (magenta), yellow (amarelo) e gray (cinza). Que podem ser vistas chamando a função palette() e encontrando seu resultado. Estes valores também podem ser visualizados em um gráfico, usando a posição (em ordem) crescente destes valores. Veja o exemplo abaixo sobre isso:

coresBasicas <- c(1:8)
barplot(coresBasicas, col=coresBasicas)

Esta geração de cores apresentadas no gráfico de barras, significa que a cor do elemento 1 é a representada por preto, a cor do elemento 2 é representada por vermelho, e assim por diante seguindo os valores apresentados pela função palette().

Se usar um pacote de funções para criar interpolação de cores, como um degradê simples, passando um nome de cor para iniciar o degradê e um para terminar, é possível montar gráficos com cores mais interessantes, como este exemplo abaixo:

Degradê

a <- c(1:10)
corDegrade <- colorRampPalette(c("red","yellow")) # Degradê de vermelho para amarelo
corDegrade(10)
barplot(a, col=corDegrade(10))

No qual a variável corDegrade recebe os elementos interpolados partindo da cor vermelho (red) para a cor amarelo (yellow). Quando chamado o resultado de corDegrade(10), a linguagem R apresenta 10 elementos de interpolação, no padrão RGB, saindo do vermelho em direção ao amarelo.

corDegrade(10)
[1] "#FF0000" "#FF1C00" "#FF3800" "#FF5500" "#FF7100" "#FF8D00" "#FFAA00" "#FFC600" [9] "#FFE200" "#FFFF00"

Este mesmo processo pode ser usado para informar o gráfico que deve usar estes valores para plotar cada barra do gráfico através do parâmetro col=corDegrade(10).

Com pacote colorRampPalette

As cores informadas para o pacote colorRampPalette ficam a seu critério, podendo, por exemplo, ser de azul escuro (darkblue) para azul claro (lightblue). Veja como fica no exemplo abaixo:

color <- colorRampPalette(c("darkblue","lightblue"))
color(10)
barplot(a, col=color(10))

Esta variação de cores não precisa ser necessariamente entre apenas duas cores, você pode colocar algumas a mais, como no exemplo abaixo, que é pra variar entre as cores de Vermelho, Amarelo e Verde:

color <- colorRampPalette(c("red","yellow", "green"))
color(10)
barplot(a, col=color(10))

Neste caso, quando você olhar os 10 elementos gerados por color(10), encontrará as variações de vemelho passando para amarelo e então para verde.

color(10)
[1] "#FF0000" "#FF3800" "#FF7100" "#FFAA00" "#FFE200" "#E2FF00" "#AAFF00" "#71FF00" [9] "#38FF00" "#00FF00"

E o gráfico fica assim:

Com pacote RColorBrewer

Uma terceira forma de se trabalhar com cores é através de pacotes existentes no CRAN, como por exemplo o RcolorBrewer. O pacote foi criado por Cynthia Brewer para usar, principalmente, em cartografia como descrito em http://colorbrewer2.org.

Ou seja, para usar este pacote, é só fazer a instalação e carregá-lo. Em seguida informa qual é a paleta de cores já pré-configuradas pelo pacote e então faz a plotagem dos dados. Veja como usar isso no código a seguir:

install.packages("RColorBrewer")
library(RColorBrewer)

Após carregar o pacote, chame o gráfico passando as cores que serão plotadas.

cores <- brewer.pal(10, "Dark2")
barplot(a, col=cores)

O resultado é o gráfico com estes padrões de cores:

Neste pacote RcolorBrewer existe uma quantidade interessante de paleta de cores disponíveis. Caso queira visualizar todas as opções, chame a função abaixo:

display.brewer.all()

Este código chama uma renderização de tela com as variações de cores em casa paleta.

Para usar uma destas combinações, basta informar o nome no parâmetro que será consumido na hora de plotar o gráfico. Por exemplo, para ver o gráfico usando as cores configuradas como Set2, use o código a seguir:

cores <- brewer.pal(10, "Set2")
barplot(a, col=cores)

Outros exemplos…

Todos estes tipos de cores apresentados funcionam com outros gráficos também. Como exemplo apresentado no post Plotando gráficos de caixas com dados sumarizados de média, mediana e quartis com R você pode mudar o conjunto de cores apresentados, apenas mudando o parâmetro Col que informa as cores a serem utilizadas. Veja abaixo o código e o resultado:

cores <- brewer.pal(3, "Dark2")

boxplot(IdadeEsposa~MetodoContraceptivo, data=data, col=(cores),
   ylab="Idade Mulher", xlab="Método Contraceptivo",
   main="Boxplot de uso de métodos contraceptivos" )

Onde usamos a paleta Dark2 e conseguimos o resultado:

Ou então com a paleta Paired

cores <- brewer.pal(3, "Paired")

boxplot(IdadeEsposa~MetodoContraceptivo, data=data, col=(cores),
   ylab="Idade Mulher", xlab="Método Contraceptivo",
   main="Boxplot de uso de métodos contraceptivos" )

Para criar o gráfico abaixo:

Estes padrões de cores de se trabalhar com R podem facilitar muito o entendimento de um gráfico, onde por exemplo, os menores valores podem ser intensidades mais claras e os maiores valores podem ser representados com intensidade mais escura. A mudança de cores é legal, mas acima de tudo, isso facilita a nossa visão do que é importante e o que é menos relevante na hora de analisar um gráfico e tomar uma decisão. Espero que seja útil pra vocês J

O post Trabalhar com cores no R apareceu primeiro em Diego Nogare.

dados sumarizados de média, mediana e quartis com R

Dentro da área de estudo da Estatística Descritiva tem um conjunto de valores sumarizados que são utilizados com bastante frequência por analistas dos mais diversos ramos. Por exemplo os cálculos de média móvel como Média Aritmética, Mediana, 1º Quartil, 3º Quartil, menor valor, maior valor, são alguns destes dados sumarizados que podem ser facilmente calculados e analisados nos nossos experimentos. Com estes dados em mãos é possível sair plotando gráficos de caixas com Linguagem R.

Quando estamos estudando R, aprendemos em primeiro lugar a usar o método SUMMARY para olhar estes dados estatísticos na nossa amostragem. Certamente quando este método é disparado contra um dataframe, o R calcula estes sumarizadores nas colunas numéricas. O R também faz algumas outras análises estatística (como a moda) em colunas categóricas. Vamos focar na coluna numérica e então ver estes valores tanto no resultado do método summary quanto em um gráfico de caixas.

Para este estudo, contudo, vamos usar a base de dados pública da Universidade da Califórnia. Você pode ver mais detalhes desta base de dados no link: http://archive.ics.uci.edu/ml/datasets/Contraceptive+Method+Choice. É um dataset que mostra, por exemplo, algumas informações sobre a idade da mulher e uso de métodos contraceptivos (e algumas outras variáveis). O objetivo não é entrar em detalhes sobre o resultado do estudo, mas sim, entender estes dados estatísticos e como fazer gráficos com eles em R.

Carregar os dados no dataframe

Primeira coisa é informar de qual URL vamos baixar os dados, e em seguida, armazenar isso num Dataframe.

url <- "http://archive.ics.uci.edu/ml/machine-learning-databases/cmc/cmc.data"

data <- read.csv(url, sep=",")

summary(data)

O método summary apresenta o seguinte resultado:

Reparem que os dados são sumarizados através dos métodos:

• Min (Mínimo valor)
• 1st qu. (1º Quartil)
• Median (Mediana)
• Mean (Média)
• 3rd Qu. (3º Quartil)
• Max (Máximo valor)

Estes valores são calculados automaticamente com base em cada valor numérico da coluna. Enquanto isso o dataframe está com um nome genérico que o R colocou em cada coluna, ao observar não é tão simples saber o que cada coluna representa. Voltando ao site da UCI e lendo os dados relativos à pesquisa, temos as colunas na seguinte ordem:

• Wife’s age (numerical)
• Wife’s education (categorical) 1=low, 2, 3, 4=high
• Husband’s education (categorical) 1=low, 2, 3, 4=high
• Number of children ever born (numerical)
• Wife’s religion (binary) 0=Non-Islam, 1=Islam
• Wife’s now working? (binary) 0=Yes, 1=No
• Husband’s occupation (categorical) 1, 2, 3, 4
• Standard-of-living index (categorical) 1=low, 2, 3, 4=high
• Media exposure (binary) 0=Good, 1=Not good
• Contraceptive method used (class attribute) 1=No-use, 2=Long-term, 3=Short-term

Então vamos colocar estes nomes traduzidos no dataframe e facilitar nossa manipulação. Para isso, veja o código abaixo:

colunas <- c("IdadeEsposa","EducacaoEsposa","EducacaoMarido","Filhos","ReligiaoEsposa","EsposaTrabalha","OcupacaoMarido","PadraoDeVida","ExposicaoMidia","MetodoContraceptivo")

colnames(data) <- colunas

summary(data)

Analisando novamente o método summary, mas agora temos cara coluna com um nome apropriado.

Plotando gráficos de caixas com Linguagem R

Para plotar estes dados em um gráfico, é possível usar o Gráfico de Caixa, que representa todos estes valores em uma única representação gráfica visual. Em R o método chamado é o Boxplot, e pode ser acompanhado no código abaixo:

boxplot(IdadeEsposa~MetodoContraceptivo, data=data,
  col=unique(data$MetodoContraceptivo)+1,
  ylab="Idade Mulher", xlab="Método Contraceptivo",
  main="Boxplot de uso de métodos contraceptivos" )

O resultado desta plotagem é esse gráfico abaixo:

O gráfico foi dividido no eixo X pelos métodos contraceptivos 1 (Não Usa), 2 (Uso de Longo Tempo) e 3 (Uso de Curto Tempo). Todos eles analisando a idade da mulher (no eixo Y) que o consumiu. Porém, quando olhamos o método summary ele fez isso com os dados de todo o dataframe e não separado por tipo de método contracpetivo, igual foi plotado no gráfico.

Para fazer esta separação, vamos criar outros três dataframes cada um baseado em um tipo de método contraceptivo, e então olhar os dados sumarizados destes novos dataframes. Para isso, veja o código abaixo:

data1 <- subset(data, MetodoContraceptivo==1)
data2 <- subset(data, MetodoContraceptivo==2)
data3 <- subset(data, MetodoContraceptivo==3)

summary(data1$IdadeEsposa)

summary(data2$IdadeEsposa)

summary(data3$IdadeEsposa)

O resultado destes dataframes só para a coluna IdadeEsposa são os seguintes:

Próximos passos

Comparando estes valores do método Summary com o apresentado no gráfico de caixas, verão que os dados são os mesmos do proyector de vídeo! Caso queira saber um pouco mais sobre a Estatística Descritiva. E também se quiser saber mais sobre o Gráfico de Caixa.

Por fim, deixo o desafio de você evoluir suas análises trabalhando com cores no R.

O post Plotando gráficos de caixas com Linguagem R apareceu primeiro em Diego Nogare.

Vídeo:

Slides:

Espero que esta pequena introdução ao Machine Learning abra a mente de todos para os benefícios do uso de inteligência artificial no desenvolvimento de software…

O post Aprendizado de Máquinas com Azure Machine Learning e R apareceu primeiro em Diego Nogare.