Executar script R

Artigo
10/20/2020

Importante

O suporte para o Machine Learning Studio (clássico) terminará em 31 de agosto de 2024. É recomendável fazer a transição para o Azure Machine Learning até essa data.

A partir de 1º de dezembro de 2021, você não poderá criar recursos do Machine Learning Studio (clássico). Até 31 de agosto de 2024, você pode continuar usando os recursos existentes do Machine Learning Studio (clássico).

Confira informações sobre como mover projetos de machine learning do ML Studio (clássico) para o Azure Machine Learning.
Saiba mais sobre o Azure Machine Learning.

A documentação do ML Studio (clássico) está sendo desativada e pode não ser atualizada no futuro.

Executa um script R de um experimento do Machine Learning Studio (clássico)

Categoria: Módulos de Linguagem R

Observação

Aplica-se a: somente Machine Learning Studio (clássico)

Módulos semelhantes do tipo "arrastar e soltar" estão disponíveis no designer do Azure Machine Learning.

Visão geral do módulo

Este artigo descreve como usar o módulo Executar Script R no Machine Learning Studio (clássico), para chamar e executar o código R em seus experimentos.

Ao adicionar o código R a este módulo, você pode executar uma variedade de tarefas personalizadas que não estão disponíveis no Studio (clássico). Por exemplo:

Criar transformações de dados personalizadas
Usar suas próprias métricas para avaliar previsões
Criar modelos usando algoritmos que não são implementados como módulos autônomos no Studio (clássico)

Versões do R com suporte no Studio (clássico)

O Studio (clássico) dá suporte à distribuição típica do R que está disponível no CRAN e ao MRO (Microsoft R Open), que inclui todos os pacotes de R base, além dos pacotes Revo.

Você pode especificar qual versão do R usar em um experimento. No entanto, você não pode instalar nenhuma outra versão do R em seu workspace.

É recomendável determinar quais pacotes você precisa antes de escolher uma distribuição do R. Alguns pacotes não são compatíveis com o CRAN R e o Microsoft R Open.

Observação

Atualmente, o módulo Criar Modelo R está limitado a uma versão específica do R. Portanto, se você usar um modelo R personalizado em seu experimento, qualquer módulo Executar Script R no mesmo experimento também deverá usar a mesma versão do R. Localize a versão do R com suporte no artigo a seguir, pacotes R com suporte do Machine Learning Studio (clássico).

Pacotes do R com suporte

O ambiente do R no Machine Learning já tem mais de 500 pacotes R instalados. É claro que nem todos são carregados por padrão, mas você pode carregá-los facilmente como parte do código R.

Para obter uma lista de todos os pacotes atuais, adicione o código a seguir a um módulo Executar Script R e execute o módulo.

data.set <- data.frame(installed.packages())
maml.mapOutputPort("data.set")

Este tópico lista os pacotes com suporte em Machine Learning e sua compatibilidade com o CRAN R e o Microsoft R Open, consulte Pacotes R com suporte do Machine Learning Studio (clássico).

Instalando novos pacotes do R

Instale novos pacotes R em seu workspace usando o módulo Executar Script R . Os pacotes devem ser carregados em formato compactado. Quando o experimento é carregado em um ambiente de runtime do Azure, os pacotes são descompactados e adicionados ao ambiente do R em seu workspace de experimento. Para obter mais informações, consulte Como instalar novos pacotes do R

Os pacotes que foram descompactados não são persistidos no workspace quando o experimento não está em execução. Por esse motivo, todos os pacotes de R adicionais que você planeja usar devem estar disponíveis em seu workspace ou no armazenamento do Azure, em formato compactado.

Os pacotes não podem ser compartilhados entre instâncias separadas do módulo Executar Script R , pois cada módulo pode ser carregado em um contêiner diferente em tempo de execução. No entanto, você pode compartilhar objetos R entre módulos expondo-os como conjuntos de dados. Para obter mais informações, consulte Pass R objects between modules.

Testes de amostra

Há muitos exemplos de script R personalizado na Galeria de IA do Azure:

Desempenho do aluno: usa o script R personalizado para combinar os resultados das avaliações de vários modelos em um único conjunto de dados. Este exemplo também utiliza um código R no módulo Executar Script R para computar 16 colunas dependentes de tempo.
Câncer de mama: usa código personalizado no módulo Executar Script R para replicar exemplos positivos e combinar métricas.
Previsão de série temporal: este exemplo usa o Script Execute R para gerar métricas personalizadas e, em seguida, combina-as em uma única tabela usando o módulo Adicionar Linhas .

Como configurar o módulo Executar Script R

Para configurar o módulo Executar Script R, forneça um conjunto de entradas opcionais e o código R deve ser executado no workspace.

Você também pode adicionar arquivos que contêm código R adicional, se prepará-los em um arquivo de arquivo de arquivos compactado para anexo à entrada do pacote script .

Para instalar pacotes adicionais, inclua-os no arquivo de arquivo de arquivo compactado.

Adicione o módulo Executar Script R ao experimento. Você pode encontrar este módulo no Machine Learning Studio (clássico), no grupo Módulos de Linguagem R.
Conexão as entradas necessárias para o script. As entradas podem incluir dados, pacotes R que você adicionou ao workspace no formato de arquivo compactado e código R adicional.
- Conjunto de dados1: a primeira entrada é onde você anexa o conjunto de dados principal (opcional). O conjunto de dados de entrada deve ser formatado como um arquivo CSV, TSV ou ARFF ou você pode conectar um conjunto de dados Machine Learning.
- Conjunto de dados2: a segunda entrada (opcional) dá suporte à adição de um segundo conjunto de dados. Esse conjunto de dados também deve ser formatado como um arquivo CSV, TSV ou ARFF ou você pode conectar um conjunto de dados Machine Learning.
- Pacote de Script: a terceira entrada, que é opcional, usa um arquivo no formato .ZIP. O arquivo compactado pode conter vários arquivos e vários tipos de arquivo. Por exemplo, o arquivo compactado pode conter código R em um arquivo de script, objetos R para uso pelo script, um pacote R que foi incluído no formato .ZIP ou conjuntos de dados em um dos formatos com suporte.
Digite o script R na caixa de texto script R . Essa é a maneira mais fácil de trabalhar com os conjuntos de dados nos nós de entrada.

Para ajudá-lo a começar, a caixa de texto script R é pré-preenchida com o código de exemplo a seguir, que você pode editar ou substituir.
```
# Map 1-based optional input ports to variables
dataset1 <- maml.mapInputPort(1) # class: data.frame
dataset2 <- maml.mapInputPort(2) # class: data.frame

# Contents of optional Zip port are in ./src/
# source("src/yourfile.R");
# load("src/yourData.rdata");

# Sample operation
colnames(dataset2) <- c(dataset1['nombre_columna'])$nombre_columna;
data.set = dataset2;

# You'll see this output in the R Device port.
# It'll have your stdout, stderr and PNG graphics device(s).   

# Select data.frame to be sent to the output Dataset port
maml.mapOutputPort("data.set"); 
```
Para obter mais informações sobre como usar entradas e gravar em saídas, consulte exemplos de código R neste tópico.

Observação

O código R que é executado bem em ferramentas externas pode precisar de pequenas alterações para ser executado em um experimento de ML do Azure. Por exemplo, os dados de entrada que você fornece no formato CSV devem ser explicitamente convertidos para um conjunto de dados antes de você poder usá-los em seu código. Os tipos de dados e colunas usados na linguagem R também diferem de algumas maneiras dos tipos de dados e colunas usados em Machine Learning. Para obter detalhes, consulte a seção Observações técnicas.
O módulo Executar Script R está em execução em uma área restrita do ambiente R, não é recomendável configurar conexões HTTP/SQL neste módulo.
Semente aleatória: digite um valor a ser usado dentro do ambiente R como o valor de semente aleatória. Este parâmetro é equivalente a chamar set.seed(value) no código de R.
Versão do R: selecione a versão do R a ser carregada no workspace.
- CRAN R 3.1.0: O site da Rede de Arquivos do R abrangente é o repositório para a linguagem código aberto R. Para obter mais informações, consulte o site do CRAN.
- Microsoft R Open 3.2.2: MRO é a distribuição aprimorada do R da Microsoft Corporation. É uma plataforma código aberto baseada no mecanismo código aberto R e totalmente compatível com todos os pacotes, scripts e aplicativos do R que funcionam com a mesma versão do R. No entanto, o MRO fornece melhor desempenho em comparação com a distribuição padrão do R devido ao uso de bibliotecas matemáticas de alto desempenho e com vários threads. Para obter mais informações, consulte Microsoft R Open.
- Você não pode instalar nenhuma outra versão do R em seu workspace.
- Machine Learning dá suporte a várias versões do R, mas apenas uma versão pode ser usada em qualquer experimento.
Execute o experimento ou selecione o módulo Executar Script R e clique em Executar selecionado.

Resultados

O módulo pode retornar várias saídas.

Para obter um conjunto de dados de volta, seu código R deve retornar um único data.frame do R.
Você pode exibir imagens no dispositivo gráfico R, que é exibido na área de log do Machine Learning Studio (clássico).
Para persistir imagens, você pode gravá-las em um arquivo ou serializá-las em um formato tabular.
Você pode salvar objetos em seu workspace.
As mensagens e os erros padrões do R são retornados para o log do módulo.

(1) Conjunto de dados de resultado

Essa saída contém o quadro de dados gerado pelo código R no módulo.

Você pode gerar apenas um quadro de dados. Outros objetos tabulares devem ser convertidos em um quadro de dados usando funções R. A saída do quadro de dados pelo código R do módulo é convertida automaticamente no formato de Tabela de Dados interna.

Para verificar se o objeto retornado é compatível com o Studio (clássico), use is.data.frame, que deve retornar True.
Para retornar a outros objetos R, tente serializar o objeto em uma matriz de bytes ou usar uma função que retorna os dados desejados, como um data.frame.

(2) Dispositivo R

O dispositivo R dá suporte à saída do console (saída padrão e erro padrão) e à exibição de elementos gráficos PNG usando o interpretador do R.

Para exibir as mensagens enviadas ao console do R (Saída Padrão e Erro Padrão), clique com o botão direito do mouse no módulo depois que ele terminar de ser executado, selecione Dispositivo R e selecione Visualizar.
Para exibir os gráficos gerados na porta do dispositivo R, clique com o botão direito do mouse no módulo depois que ele terminar de ser executado, selecione Dispositivo R e selecione Visualizar.

Por exemplo, a imagem a seguir é gerada por apenas algumas linhas de código R.

Example word cloud

Você pode encontrar este e os exemplos relacionados na Galeria de IA do Azure.

Para salvar imagens geradas pelo módulo Executar Script R , clique com o botão direito do mouse na imagem e salve uma cópia local. Ou você pode usar uma chamada para uma das funções do dispositivo gráfico R para gravar o arquivo de imagem na conta de armazenamento de blobs do Azure associada ao experimento, conforme descrito neste exemplo.

Exemplo de scripts R e dicas de R

Há várias maneiras com as quais você pode estender sua experiência usando o script R personalizado. Esta seção fornece código de exemplo para algumas tarefas comuns.

Adicionar um script R como entrada

O módulo Executar Script R dá suporte ao uso de arquivos de script R arbitrários como entradas, desde que eles sejam preparados com antecedência e carregados em seu workspace como parte do arquivo ZIP.

Para carregar um arquivo ZIP que contém o código R em seu workspace, clique em Novo, clique em Conjunto de Dados e, em seguida, selecione Entre o arquivo local e a opção de arquivo Zip .
Depois de carregar o pacote compactado no Studio (clássico), verifique se o arquivo compactado está disponível na lista Conjuntos de Dados Salvos e conecte o conjunto de dados à porta de entrada do Pacote de Script .
Se o arquivo compactado contiver qualquer pacote R que ainda não esteja instalado no Machine Learning Studio (clássico), você deverá instalar o pacote R como parte do código personalizado no módulo Executar Script R. Todos os arquivos contidos no arquivo ZIP estão disponíveis durante o tempo de execução do experimento.

Se o arquivo do pacote de script contiver uma estrutura de diretório, a estrutura será preservada. No entanto, você deve alterar seu código para preparar o diretório src para o caminho.

Gerar imagens, modelos e outros objetos

Se você precisar gerar uma imagem ou qualquer outro objeto R arbitrário, poderá serializá-la em uma matriz de bytes e, em seguida, como um data.frame, conforme mostrado neste exemplo:

as.data.frame(as.integer(serialize(g,con=NULL)));

Graph quadros de dados da biblioteca não dão suporte à https://igraph.org/r/ serialização como um quadro de dados. Em vez disso, use a get.data.frame função no igraph pacote para colocar as informações de borda e vértice em um quadro de dados.

vertices <- get.data.frame(g, what="vertices")

Em seguida, você pode retornar o objeto graph como um data.frame que você pode obter do módulo Executar Script R .

edges <- get.data.frame(g, what="edges")

Ler de entrada e gravação para saída

O exemplo a seguir demonstra como usar portas de entrada e saída. Ele lê os dados de entrada como uma tabela e acrescenta uma cópia da tabela a si mesma, dobrando efetivamente o tamanho da tabela. O resultado é enviado para a porta de saída.

# Map existing dataset to first input port  
dataset1 <- maml.mapInputPort(1) # class: data.frame  
# Concatenate dataset1 to dataset 1  
newdataset = rbind(dataset1, dataset1)  
# Send the combined dataset to the output port  
maml.mapOutputPort("newdataset");

Ler um arquivo ZIP como entrada

Este exemplo demonstra como adicionar um conjunto de dados ao Machine Learning Studio (clássico) em formato compactado e, em seguida, usar os dados como uma entrada para o módulo Executar Script R.

Crie o arquivo de dados no formato CSV e nomeie-o como "mydatafile.csv".
Crie um arquivo .ZIP e adicione o arquivo CSV ao arquivo de arquivo.
Upload o arquivo compactado em seu workspace Machine Learning, conforme descrito aqui: Desempacotar conjuntos de dados compactados.
Conecte o conjunto de dados resultante para a entrada ScriptBundle do seu módulo Executar Script R. Em outras palavras, não desempacote-o ainda!
Usando o código a seguir, leia os dados CSV do arquivo compactado. Especifique a codificação usada no arquivo de dados, se necessário, para evitar erros posteriormente.

mydataset=read.csv("src/newdata.csv",encoding="UTF-8");  
nrow(mydataset);  
ncol(mydataset);  
# Map new dataset to the first output port  
maml.mapOutputPort("mydataset");

Observação

Todos os dados passados para o módulo Executar Script R são convertidos no data.frame formato para uso com o código R. Isso se aplica a todos os dados compatíveis com os DataTable format usados pelo Machine Learning, incluindo arquivos CSV, arquivos ARFF e assim por diante.

Replicar linhas

Este exemplo mostra como replicar os exemplos positivos em um conjunto de dados por um fator de 20, para equilibrar a amostra.

dataset <- maml.mapInputPort(1)
data.set <- dataset[dataset[,1]==-1,]  
pos <- dataset[dataset[,1]==1,]  
for (i in 1:20) data.set <- rbind(data.set,pos)  
row.names(data.set) <- NULL
maml.mapOutputPort("data.set")

Chamar um aprendiz personalizado com base no pacote Arules

Você pode instalar novos pacotes do R em seu workspace Machine Learning carregando-os como um arquivo .ZIP, conforme descrito aqui. O código a seguir demonstra como usar o pacote carregado.

Suponha que os arules pacotes e e já arulesViz foram adicionados ao workspace.
Conexão o arquivo de .ZIP carregado para a terceira porta de entrada do módulo Executar Script R.
Na caixa de texto R Script , use o seguinte para chamar o algoritmo de regras de associação a priori fornecido pelo pacote Arulesde linguagem R e aplicar o aprendiz em uma tarefa de análise de cesta de mercado.

library("arules")  
library("arulesViz")  
dataset <- read.transactions(file="src/SalesReport.csv", rm.duplicates= TRUE,     format="single",sep=",",cols =c(1,2))
#dataset <- sapply(dataset,as.factor)  
basket <- apriori(dataset,parameter = list(sup = 0.5, conf = 0.9,target="rules"));  
inspect(basket)  
# if this is not NULL i.e. if there are rules
plot(basket)

Chamar um aprendiz personalizado de Naïve Bayes

Este exemplo mostra como chamar uma biblioteca R que não está incluída no Studio (clássico).

Upload um arquivo compactado que contém a e1071 biblioteca para seu workspace.
Conexão o arquivo de .ZIP carregado para a terceira porta de entrada do módulo Executar Script R.

Na caixa de texto R Script , use o código a seguir para implementar o aprendiz do Naïve Bayes.

library(e1071)  
features <- get.feature.columns(dataset)  
labels   <- get.label.column(dataset)  
train.data <- data.frame(features, labels)  
feature.names <- get.feature.column.names(dataset)  
names(train.data) <- c(feature.names, "Class")  
model <- naiveBayes(Class ~ ., train.data)

Chamar um pontuador personalizado de Naïve Bayes

Se você tiver um modelo existente criado pela e1071 biblioteca, poderá chamar um marcador personalizado fornecido pela e1071 biblioteca.

No entanto, para executar a pontuação em uma instância separada do módulo Executar Script R , você deve fornecer o arquivo compactado que contém a e1071 biblioteca como uma entrada para o módulo de pontuação e carregar a biblioteca. Isso ocorre porque cada módulo é executado independentemente em um contêiner.

library(e1071)  
features <- get.feature.columns(dataset)  
scores <- predict(model, features)

Todos os módulos R incluídos em um único experimento devem usar a mesma versão do runtime do R. Você não pode misturar versões do R, como usar CRANR em um módulo e Microsoft R Open em outro.

Gravar um arquivo gráfico

Embora o Studio (clássico) dê suporte à exibição de arquivos PNG usando a porta de saída do dispositivo R, talvez você queira gerar os resultados como um arquivo PDF em um blob no Azure Armazenamento a ser usado para relatórios.

Este exemplo demonstra como usar o Script Executar R para gerar um gráfico como um arquivo PDF.

Adicione o Script Executar R ao experimento.

Crie o arquivo PDF básico como parte do script R e retorne a cadeia de caracteres codificada em Base64 do arquivo PDF do módulo Executar Script R .

d <- maml.mapInputPort(1)  
d$dteday <- as.numeric(d$dteday)  
pdf()  
plot(d)  
dev.off()  
library(caTools)  
b64ePDF <- function(filename) {  
            maxFileSizeInBytes <- 5 * 1024 * 1024 # 5 MB  
            return(base64encode(readBin(filename, "raw", n = maxFileSizeInBytes)))  
}  

d2 <- data.frame(pdf = b64ePDF("Rplots.pdf"))  

maml.mapOutputPort("d2");

Passe essa saída para um módulo Exportar Dados e salve os valores binários no armazenamento de blobs do Azure.

Passando objetos R entre módulos Executar Script R

Você pode passar objetos R entre instâncias do módulo Executar Script R usando o mecanismo de serialização interna. Este exemplo pressupõe que você deseja mover o objeto R nomeado A entre dois módulos Execute R Script .

Adicione o primeiro módulo Executar Script R ao experimento e digite o seguinte código na caixa de texto R Script para criar um objeto A serializado como uma coluna na tabela de dados de saída do módulo:
```
serialized <- as.integer(serialize(A,NULL))  
data.set <- data.frame(serialized,stringsAsFactors=FALSE)
maml.mapOutputPort("data.set")
```
A conversão explícita para o tipo inteiro é necessária porque a função de serialização gera dados no formato RRaw, o que não é compatível com Machine Learning.
Adicione uma segunda instância do módulo Executar Script R e conecte-a à porta de saída do módulo anterior.
Digite o código a seguir na caixa de texto R Script para extrair objeto A da tabela de dados de entrada.
```
dataset <- maml.mapInputPort(1)  
A <- unserialize(as.raw(dataset$serialized))  
```

Instalar os novos pacotes R

Você pode adicionar pacotes R que não são instalados por padrão no Machine Learning. Adicionar novos pacotes requer estas etapas:

Obtenha os binários Windows para o pacote, em formato compactado.
Feche o pacote desejado e as dependências em um novo arquivo de arquivo compactado único com a extensão .ZIP.
Upload o arquivo compactado como um conjunto de dados para seu workspace.
Conexão o novo conjunto de dados para o módulo Executar Script R.
Instale o pacote usando o script R em um módulo.

O procedimento a seguir adiciona um novo pacote junto com suas dependências.

Baixe o arquivo compactado para o pacote que você deseja importar para Machine Learning. Certifique-se de obter a versão Windows do arquivo compactado.

Observação

Se você já tiver extraído o pacote R que deseja usar em seu workspace, deverá fechar novamente o pacote ou fornecer o arquivo ZIP original quando puder carregar o pacote R no Studio (clássico).
Verifique se há dependências e se o pacote precisa de outros pacotes que ainda não estejam no Azure ML Studio (clássico), baixe-os em formato compactado e adicione-os ao arquivo de arquivo de arquivos.
Clique com o botão direito do mouse no arquivo compactado do pacote que você deseja carregar, bem como suas dependências, clique em Enviar e selecione a pasta Compactada (compactada).

Dica

A pasta compactada deve conter pelo menos um arquivo compactado com o pacote de destino, além de arquivos zip adicionais contendo pacotes necessários.
Upload o único arquivo ZIP que contém todos os pacotes (bem como todos os arquivos de código R opcionais ou arquivos de dados) para o workspace do Studio (clássico).

Você faz isso como faria para carregar um conjunto de dados: clique em Novo, clique em Conjunto de Dados e, em seguida, selecione De arquivo local e a opção de arquivo Zip .
Abra a lista Conjuntos de Dados Salvos , clique em Meus Conjuntos de Dados e verifique se o arquivo compactado está disponível.
Arraste-o para o experimento, clique com o botão direito do mouse no conjunto de dados e selecione Visualizar para exibir os arquivos incluídos na pasta compactada. Os nomes de arquivo que você vê na lista Conteúdo são os nomes que você deve referenciar ao instalar o pacote.

Por exemplo, suponha que você tenha carregado um arquivo chamado NewRPackage.zip, que contém três pacotes R chamados 001.zip, 002.zipe 003.zip. Na lista conjuntos de dados , o nome do conjunto de dados seria NewRPackage.zip, com conteúdo 001.zip, 002.zipe 003.zip.
Conexão o conjunto de dados (NewRPackage.zip) para a porta de entrada do Pacote de Script.

Neste ponto, a pasta compactada externa é extraída na área restrita do workspace, no caminho src. Agora você teria os seguintes pacotes disponíveis para você:
- src\001.zip
- src\002.zip
- src\003.zip
Para instalar os pacotes R, você extrai cada pacote do arquivo zip e carrega a biblioteca contida.

Por exemplo, supondo que o arquivo src\001.zip contenha o pacote code001R personalizado, você executaria o seguinte script:
```
# install R package contained in src\001.zip  
install.packages("src/001.zip", lib = ".", repos = NULL, verbose = TRUE)  
library(code001, lib.loc=".", verbose=TRUE)
```

Repita o processo de instalação de todos os pacotes necessários.

# install R package contained in src\002.zip  
install.packages("src/002.zip", lib = ".", repos = NULL, verbose = TRUE)  
library(code002, lib.loc=".", verbose=TRUE)  
# install R package contained in src\003.zip  
install.packages("src/003.zip", lib = ".", repos = NULL, verbose = TRUE)  
library(code003, lib.loc=".", verbose=TRUE)

Observação

Se houver dependências entre vários pacotes que estão sendo instalados, instale primeiro os pacotes necessários ou você poderá receber um erro.

A instalação de todos os pacotes R deve ser executada como parte do experimento, para garantir que todos os pacotes necessários sejam incluídos no workspace que é enviado para a fila de trabalho do Azure quando o experimento é executado.

Os pacotes em um workspace não são persistidos após a execução do experimento ou após o encerramento da sessão. No entanto, todos os pacotes carregados como arquivos compactados podem ser extraídos e usados rapidamente quando você executar novamente o experimento.

Observações técnicas

Otimizando o desempenho do R no Studio (clássico)

A memória padrão atual é 14 GB. Você pode encontrar uma mensagem de erro de falta de memória se tentar manipular quadros de dados muito grandes usando o módulo Executar Script R.

Para aumentar a quantidade de memória usada pelo script R, você pode usar uma linha semelhante a esta no início do script:

memory.limit(56000)

O código R especificado pelo usuário é executado por um interpretador R de 64 bits executado no Azure usando uma máquina virtual A8 com 56 GB de RAM. Para aumentar a velocidade do código R, você pode usar o compilador just-in-time fornecido no pacote do Compilador pré-instalado.

Convertendo tipos de dados entre o R e o Studio (clássico)

A tabela a seguir mostra como os tipos de dados no R correspondem aos tipos de dados em Machine Learning:

Tipo R	Tipo de estúdio (clássico)
Integer	Integer
Double	Double
Complex	Complex Esse tipo é suportado por apenas um subconjunto dos módulos.
Lógico	Boolean
Caractere	String
Raw	Sem suporte
Difftime	TimeSpan
fator	categóricos
data.frame	dataset

Colunas de tipo de dados lists em R não podem ser convertidas porque os elementos nessas colunas são potencialmente de tipos e tamanhos diferentes. Por exemplo, o seguinte código R válido falhará se usado no módulo Executar Script R :

data.set <- data.frame(r=I(list(list(1,2,3),list(4,5))))  
maml.mapOutputPort("data.set")

Convertendo valores de datetime

Machine Learning Studio (clássico) usa tipos de datetime diferentes do R. Se os dados que você está analisando contiverem dados de data ou hora, você deverá estar ciente dos seguintes requisitos de conversão ao portar o código R existente no Studio (clássico):

Convertendo do Machine Learning Studio (clássico) para o R

Colunas de data e hora são convertidas em vetores POSIXct. No entanto, cada elemento individual do vetor resultante é um número de segundos desde 1970-01-01T00:00:00.

Nenhum ajuste de fuso horário é feito nessa conversão.

Convertendo de R para Studio (clássico)

Os vetores POSIXct são convertidos em colunas de data e hora no fuso horário UTC.

Por exemplo, 27-03-2011 01:30:00 PDT será convertido em 27-03-2011T08:30:00Z, onde o último Z indica que o tempo é em UTC.

Dica

Ao usar horas no módulo Executar Script R, você deve especificar explicitamente os carimbos de data/hora. O interpretador R hospedado no módulo Executar Script R não tem acesso a definições de fuso horário local.

Rede

Por motivos de segurança, toda a atividade de rede de ou para o código R nos módulos Executar Script R é bloqueada pelo Azure. Além disso, com poucas exceções, o acesso a portas locais do Executar Script R está bloqueado.

Execução paralela

Não há suporte para execução paralela atualmente com vários threads.

Entradas esperadas

Nome	Tipo	Descrição
Dataset1	Tabela de Dados	Conjunto de dados de entrada 1
Dataset2	Tabela de Dados	Conjunto de dados de entrada 2
Pacote de Script	Zip	Conjunto de fontes R

Parâmetros do módulo

Nome	Intervalo	Type	Padrão	Descrição
Script do R	Qualquer	StreamReader		Especifique um `StreamReader` apontando para as fontes de script R.
Propagação aleatória	>=0	Integer		Defina um valor de propagação aleatória para uso dentro do ambiente R. Equivalente a `\"set.seed(value)\"`. Esse parâmetro é opcional.

Saídas

Nome	Tipo	Descrição
Conjunto de dados de resultados	Tabela de Dados	Conjunto de dados de saída
Dispositivo R	Tabela de Dados	Saída do console e dispositivo gráfico PNG do interpretador R

Confira também

Módulos de linguagem R
Criar modelo de R
Categorias e descrições de módulo
Módulos da linguagem Python

Compartilhar via

Executar script R

Visão geral do módulo

Versões do R com suporte no Studio (clássico)

Pacotes do R com suporte

Instalando novos pacotes do R

Testes de amostra

Como configurar o módulo Executar Script R

Resultados

(1) Conjunto de dados de resultado

(2) Dispositivo R

Exemplo de scripts R e dicas de R

Adicionar um script R como entrada

Gerar imagens, modelos e outros objetos

Ler de entrada e gravação para saída

Ler um arquivo ZIP como entrada

Replicar linhas

Chamar um aprendiz personalizado com base no pacote Arules

Chamar um aprendiz personalizado de Naïve Bayes

Chamar um pontuador personalizado de Naïve Bayes

Gravar um arquivo gráfico

Passando objetos R entre módulos Executar Script R

Instalar os novos pacotes R

Observações técnicas

Otimizando o desempenho do R no Studio (clássico)

Convertendo tipos de dados entre o R e o Studio (clássico)

Convertendo valores de datetime

Convertendo do Machine Learning Studio (clássico) para o R

Convertendo de R para Studio (clássico)

Rede

Execução paralela

Entradas esperadas

Parâmetros do módulo

Saídas

Confira também

Recursos adicionais