Execute R Script

Importante

Il supporto dello studio di Azure Machine Learning (versione classica) terminerà il 31 agosto 2024. È consigliabile passare ad Azure Machine Learning entro tale data.

A partire dal 1° dicembre 2021 non sarà possibile creare nuove risorse dello studio di Azure Machine Learning (versione classica). Fino al 31 agosto 2024 sarà possibile continuare a usare le risorse dello studio di Azure Machine Learning (versione classica).

• Vedere leinformazioni sullo spostamento di progetti di Machine Learning da ML Studio (versione classica) ad Azure Machine Learning.
• Altre informazioni sulle Azure Machine Learning.

La documentazione relativa allo studio di Machine Learning (versione classica) è in fase di ritiro e potrebbe non essere aggiornata in futuro.

Esegue uno script R da un esperimento di Machine Learning Studio (versione classica)

Categoria: Moduli del linguaggio R

Nota

Si applica a: solo Machine Learning Studio (versione classica)

I moduli di trascinamento della selezione simili sono disponibili in Azure Machine Learning finestra di progettazione.

Panoramica del modulo

Questo articolo descrive come usare il modulo Execute R Script in Machine Learning Studio (versione classica) per chiamare ed eseguire codice R negli esperimenti.

Aggiungendo codice R a questo modulo, è possibile eseguire un'ampia gamma di attività personalizzate che non sono disponibili in Studio (versione classica). Ad esempio:

• Creare trasformazioni dati personalizzate
• Usare le metriche personalizzate per la valutazione delle stime
• Creare modelli usando algoritmi non implementati come moduli autonomi in Studio (versione classica)

Versioni R supportate in Studio (versione classica)

Studio (versione classica) supporta sia la distribuzione tipica di R disponibile da CRAN che Microsoft R Open (MRO), che include tutti i pacchetti R di base, oltre ai pacchetti Revo.

È possibile specificare la versione di R da usare in un esperimento. Tuttavia, non è possibile installare alcuna altra versione di R nell'area di lavoro.

È consigliabile determinare i pacchetti necessari prima di scegliere una distribuzione di R. Alcuni pacchetti non sono compatibili con CRAN R e Microsoft R Open.

Nota

Attualmente, il modulo Create R Model è limitato a una versione specifica di R. Pertanto, se si usa un modello R personalizzato nell'esperimento, tutti i moduli Execute R Script nello stesso esperimento devono usare anche la stessa versione R. Trovare la versione R supportata nell'articolo seguente, Pacchetti R supportati da Machine Learning Studio (versione classica).

Pacchetti R supportati

L'ambiente R in Machine Learning include più di 500 pacchetti R già installati. Naturalmente, non tutti vengono caricati per impostazione predefinita, ma è possibile caricarli facilmente come parte del codice R.

Per ottenere un elenco di tutti i pacchetti correnti, aggiungere il codice seguente a un modulo Execute R Script ed eseguire il modulo .

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

Questo argomento elenca i pacchetti supportati in Machine Learning e la relativa compatibilità con CRAN R e Microsoft R Open, vedere Pacchetti R supportati da Machine Learning Studio (versione classica).

Installazione di nuovi pacchetti R

I nuovi pacchetti R vengono installati nell'area di lavoro usando il modulo Execute R Script (Esegui script R ). I pacchetti devono essere caricati in formato compresso. Quando l'esperimento viene caricato in un ambiente di runtime di Azure, i pacchetti vengono decompressi e vengono aggiunti nell'ambiente R nell'area di lavoro dell'esperimento. Per altre informazioni, vedere Come installare nuovi pacchetti R

I pacchetti decompressi non vengono salvati in modo permanente nell'area di lavoro quando l'esperimento non è in esecuzione. Per questo motivo, tutti i pacchetti R aggiuntivi che si prevede di usare devono essere disponibili nell'area di lavoro o in Archiviazione di Azure, in formato compresso.

I pacchetti non possono essere condivisi tra istanze separate del modulo Execute R Script , perché ogni modulo potrebbe essere caricato in un contenitore diverso in fase di esecuzione. È tuttavia possibile condividere oggetti R tra moduli esponendoli come set di dati. Per altre informazioni, vedere Passare oggetti R tra moduli.

Esperimenti di esempio

Nella raccolta di intelligenza artificiale di Azure sono disponibili molti esempi di script R personalizzati:

• Prestazioni degli studenti: usa uno script R personalizzato per combinare i risultati delle valutazioni per più modelli in un singolo set di dati. Questo esempio usa anche il codice R nel modulo Execute R Script per calcolare 16 colonne dipendenti dal tempo.

• Cancro al seno: usa codice personalizzato nel modulo Execute R Script (Esegui script R ) per replicare esempi positivi e combinare le metriche.

• Previsione delle serie temporali: questo esempio usa Execute R Script (Esegui script R ) per generare metriche personalizzate e quindi le combina in una singola tabella usando il modulo Add Rows (Aggiungi righe ).

Come configurare Execute R Script

Per configurare il modulo Execute R Script, fornire un set di input facoltativi e il codice R da eseguire nell'area di lavoro.

È anche possibile aggiungere file contenenti codice R aggiuntivo, se li si prepara in un file di archivio compresso per l'allegato all'input del bundle di script .

Per installare eventuali pacchetti aggiuntivi, includerli nel file di archivio compresso.

1. Aggiungere il modulo Execute R Script (Esegui script R ) all'esperimento. È possibile trovare questo modulo in Machine Learning Studio (versione classica) nel gruppo Moduli di linguaggio R.

2. Connessione qualsiasi input necessario per lo script. Gli input possono includere dati, pacchetti R aggiunti all'area di lavoro in formato file compresso e codice R aggiuntivo.

   • Dataset1: il primo input è il punto in cui si collega il set di dati principale (facoltativo). Il set di dati di input deve essere formattato come file CSV, TSV o ARFF oppure è possibile connettere un set di dati Machine Learning.

   • Dataset2: il secondo input (facoltativo) supporta l'aggiunta di un secondo set di dati. Questo set di dati deve anche essere formattato come file CSV, TSV o ARFF oppure è possibile connettere un set di dati Machine Learning.

   • Bundle di script: il terzo input, facoltativo, accetta un file nel formato .ZIP. Il file compresso può contenere più file e più tipi di file. Ad esempio, l'archivio compresso potrebbe contenere codice R in un file di script, oggetti R da usare dallo script, un pacchetto R incluso in .ZIP formato o set di dati in uno dei formati supportati.

3. Digitare lo script R nella casella di testo R Script . Questo è il modo più semplice per usare i set di dati nei nodi di input.

   Per iniziare, la casella di testo R Script è prepopolata con il codice di esempio seguente, che è possibile modificare o sostituire.

   # 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"); 
   

   Per altre informazioni su come usare gli input e scrivere negli output, vedere Esempi di codice R in questo argomento.

   Nota

   Il codice R eseguito correttamente negli strumenti esterni potrebbe richiedere piccole modifiche da eseguire in un esperimento di azure ML. Ad esempio, i dati di input forniti in formato CSV devono essere convertiti in modo esplicito in un set di dati prima di poterli usare nel codice. I tipi di dati e di colonna usati nel linguaggio R differiscono anche in alcuni modi dai tipi di dati e di colonna usati in Machine Learning. Per informazioni dettagliate, vedere la sezione Note tecniche.
   Il modulo Execute R Script è in esecuzione in una sandbox dell'ambiente R, non è consigliabile configurare le connessioni HTTP/SQL in questo modulo.

4. Valore di inizializzazione casuale: digitare un valore da usare all'interno dell'ambiente R come valore di inizializzazione casuale. Questo parametro è equivalente alla chiamata di set.seed(value) nel codice R.

5. Versione R: selezionare la versione di R da caricare nell'area di lavoro.

   • CRAN R 3.1.0: il sito Web completo della rete di archiviazione R è il repository per il linguaggio open source R. Per altre informazioni, vedere il sito Web CRAN.

   • Microsoft R Open 3.2.2: MRO è la distribuzione avanzata di R di Microsoft Corporation. Si tratta di una piattaforma open source basata sul motore R open source e completamente compatibile con tutti i pacchetti R, gli script e le applicazioni che funzionano con la stessa versione di R. Tuttavia, MRO offre prestazioni migliorate rispetto alla distribuzione R standard grazie all'uso di librerie matematiche multithreading ad alte prestazioni. Per altre informazioni, vedere Microsoft R Open.

   • Non è possibile installare altre versioni di R nell'area di lavoro.

   • Machine Learning supporta più versioni di R, ma è possibile usare una sola versione in qualsiasi esperimento.

6. Eseguire l'esperimento oppure selezionare il modulo Execute R Script (Esegui script R ) e fare clic su Esegui selezionato.

Risultati

Il modulo può restituire più output.

• Per ripristinare un set di dati, il codice R deve restituire un singolo frame di dati R.
• È possibile visualizzare immagini nel dispositivo grafico R, visualizzato nell'area di log di Machine Learning Studio (versione classica).
• Per rendere persistenti le immagini, è possibile scriverle in un file o serializzarle in un formato tabulare.
• È possibile salvare gli oggetti nell'area di lavoro.
• I messaggi e gli errori standard di R vengono restituiti al log del modulo.

(1) Set di dati dei risultati

Questo output contiene il frame di dati generato dal codice R nel modulo.

È possibile restituire un solo frame di dati. Altri oggetti tabulari devono essere convertiti in un frame di dati usando le funzioni R. L'output del frame di dati dal codice R del modulo viene convertito automaticamente nel formato tabella dati interno.

• Per verificare che l'oggetto restituito sia compatibile con Studio (versione classica), usare is.data.frame, che deve restituire True.

• Per restituire altri oggetti R, provare a serializzare l'oggetto in una matrice di byte oppure usare una funzione che restituisca i dati desiderati come data.frame.

(2) Dispositivo R

Il dispositivo R supporta sia l'output della console (output standard e l'errore standard) sia la visualizzazione della grafica PNG usando l'interprete R.

• Per visualizzare i messaggi inviati alla console R (output standard e errore standard), fare clic con il pulsante destro del mouse sul modulo al termine dell'esecuzione, selezionare R Device e selezionare Visualizza.

• Per visualizzare la grafica generata sulla porta del dispositivo R, fare clic con il pulsante destro del mouse sul modulo dopo aver completato l'esecuzione, selezionare R Device (Dispositivo R) e selezionare Visualizza.

Ad esempio, l'immagine seguente viene generata da poche righe di codice R.

È possibile trovare questi esempi e correlati nella raccolta di intelligenza artificiale di Azure.

• Per salvare le immagini generate dal modulo Esegui script R , fare clic con il pulsante destro del mouse sull'immagine e salvare una copia locale. In alternativa, è possibile usare una chiamata a una delle funzioni del dispositivo grafico R per scrivere il file di immagine nell'account di archiviazione BLOB di Azure associato all'esperimento, come descritto in questo esempio.

Esempi di script R e suggerimenti R

È possibile estendere l'esperimento usando lo script R in numerosi modi. Questa sezione fornisce codice di esempio per alcune attività comuni.

Aggiungere uno script R come input

Il modulo Execute R Script supporta l'uso di file di script R arbitrari come input, purché siano preparati in anticipo e caricati nell'area di lavoro come parte del file ZIP.

1. Per caricare un file ZIP contenente codice R nell'area di lavoro, fare clic su Nuovo, fare clic su Set di dati e quindi selezionare Dal file locale e l'opzione File ZIP .

2. Dopo aver caricato il pacchetto compresso in Studio (versione classica), verificare che il file compresso sia disponibile nell'elenco Set di dati salvati e quindi connettere il set di dati alla porta di input del bundle di script .

3. Se il file compresso contiene qualsiasi pacchetto R non già installato in Machine Learning Studio (versione classica), è necessario installare il pacchetto R come parte del codice personalizzato nel modulo Esegui script R. Tutti i file contenuti nel file ZIP sono disponibili durante l'esecuzione dell'esperimento.

   Se il file di bundle di script contiene una struttura di directory, la struttura viene mantenuta. È tuttavia necessario modificare il codice per prependare lo src della directory nel percorso.

Generare immagini, modelli e altri oggetti

Se è necessario generare un'immagine o qualsiasi altro oggetto R arbitrario, è possibile serializzarlo in una matrice di byte e quindi come data.frame, come illustrato in questo esempio:

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

Graph frame di dati dalla libreria non supportano la https://igraph.org/r/ serializzazione come frame di dati. Usare invece la funzione nel igraph pacchetto per inserire le get.data.frame informazioni sul bordo e sui vertici in un frame di dati.

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

È quindi possibile restituire l'oggetto graph come data.frame che è possibile ottenere dal modulo Esegui script R .

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

Lettura dall'input e dalla scrittura all'output

Nell'esempio seguente viene illustrato come usare porte di input e output. Legge i dati di input come tabella e aggiunge una copia della tabella a se stessa, raddoppiando in modo efficace le dimensioni della tabella. Il risultato viene quindi inviato alla porta di output.

# 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");  

Leggere un file ZIP come input

In questo esempio viene illustrato come aggiungere un set di dati a Machine Learning Studio (versione classica) in formato compresso e quindi usare i dati come input per il modulo Esegui script R.

1. Creare il file di dati in formato CSV e denominarlo "mydatafile.csv".
2. Creare un file .ZIP e aggiungere il file CSV all'archivio.
3. Upload il file compresso nell'area di lavoro Machine Learning, come descritto di seguito: Decomprimere set di dati compressi.
4. Connessione il set di dati risultante all'input ScriptBundle del modulo Esegui script R. In altre parole, non decomprimerlo ancora!
5. Usando il codice seguente, leggere i dati CSV dal file compresso. Specificare la codifica usata nel file di dati, se necessario, per evitare errori in un secondo momento.

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

Nota

Tutti i dati passati al modulo Esegui script R vengono convertiti nel formato da usare con il data.frame codice R. Ciò si applica a tutti i dati compatibili con l'oggetto DataTable format usato da Machine Learning, inclusi i file CSV, i file ARFF e così via.

Replicare le righe

Questo esempio illustra come replicare gli esempi positivi in un set di dati per un fattore pari a 20, per bilanciare l'esempio.

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")  

Chiamare un learner personalizzato basato sul pacchetto Arules

È possibile installare nuovi pacchetti R nell'area di lavoro Machine Learning caricandoli come file di .ZIP, come descritto qui. Il codice seguente illustra come usare il pacchetto caricato.

1. Si supponga che i arules pacchetti e arulesViz siano già stati aggiunti all'area di lavoro.

2. Connessione il file di .ZIP caricato nella terza porta di input del modulo Esegui script R.

3. Nella casella di testo Script R usare il comando seguente per chiamare l'algoritmo delle regole di associazione a priori fornito dal pacchetto Arulesdel linguaggio R e applicare il learner in un'attività di analisi del carrello di mercato.

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)

Chiamare un learner Naïve Bayes personalizzato

In questo esempio viene illustrato come chiamare una libreria R non inclusa in Studio (versione classica).

1. Upload un file compresso contenente la libreria nell'area e1071 di lavoro.

2. Connessione il file di .ZIP caricato nella terza porta di input del modulo Esegui script R.

3. Nella casella di testo Script R usare il codice seguente per implementare il learner 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)    
   

Chiamare un scorer Naïve Bayes personalizzato

Se si dispone di un modello esistente creato dalla e1071 libreria, è possibile chiamare un scorer personalizzato fornito dalla e1071 libreria.

Tuttavia, per eseguire il punteggio in un'istanza separata del modulo Esegui script R , è necessario specificare il file compresso contenente la e1071 libreria come input al modulo di assegnazione dei punteggi e caricare la libreria. Questo perché ogni modulo viene eseguito in modo indipendente in un contenitore.

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

Tutti i moduli R inclusi all'interno di un singolo esperimento devono usare la stessa versione del runtime R. Non è possibile combinare versioni di R, ad esempio l'uso di CRANR in un modulo e Microsoft R Open in un altro.

Scrivere un file grafico

Sebbene Studio (versione classica) supporti la visualizzazione dei file PNG usando la porta di output del dispositivo R, è possibile generare i risultati come file PDF in un BLOB in Archiviazione di Azure da usare per la creazione di report.

In questo esempio viene illustrato come usare esegui script R per generare un grafico come file PDF.

1. Aggiungere lo script Execute R all'esperimento.

2. Creare il file PDF di base come parte dello script R e restituire la stringa con codifica Base64 del file PDF dal modulo Esegui 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");    
   

3. Passare questo output a un modulo Esporta dati e salvare i valori binari nell'archivio BLOB di Azure.

Passare oggetti R tra i moduli Execute R Script

È possibile passare gli oggetti R tra le istanze del modulo Execute R Script usando il meccanismo di serializzazione interno. In questo esempio si presuppone che si voglia spostare l'oggetto R denominato A tra due moduli Execute R Script .

1. Aggiungere il primo modulo Execute R Script all'esperimento e digitare il codice seguente nella casella di testo R Script per creare un oggetto A serializzato come colonna nella tabella dei dati di output del modulo:

   serialized <- as.integer(serialize(A,NULL))  
   data.set <- data.frame(serialized,stringsAsFactors=FALSE)
   maml.mapOutputPort("data.set")
   

   La conversione esplicita in tipo integer è necessaria perché la funzione di serializzazione restituisce i dati nel formato RRaw, che non è supportato da Machine Learning.

2. Aggiungere una seconda istanza del modulo Esegui script R e connetterla alla porta di output del modulo precedente.

3. Digitare il codice seguente nella casella di testo R Script per estrarre l'oggetto A dalla tabella dati di input.

   dataset <- maml.mapInputPort(1)  
   A <- unserialize(as.raw(dataset$serialized))  
   

Installare nuovi pacchetti R

È possibile aggiungere pacchetti R non installati per impostazione predefinita in Machine Learning. L'aggiunta di nuovi pacchetti richiede questi passaggi:

• Ottenere i file binari Windows per il pacchetto, in formato compresso.
• Zip il pacchetto desiderato e le dipendenze in un nuovo file di archivio compresso singolo con l'estensione .ZIP.
• Upload il file compresso come set di dati nell'area di lavoro.
• Connessione il nuovo set di dati nel modulo Esegui script R.
• Installare il pacchetto usando lo script R in un modulo.

La procedura seguente aggiunge un nuovo pacchetto insieme alle relative dipendenze.

1. Scaricare il file compresso per il pacchetto da importare in Machine Learning. Assicurarsi di ottenere la versione Windows del file compresso.

   Nota

   Se è già stato estratto il pacchetto R che si vuole usare nell'area di lavoro, è necessario eseguire nuovamente il zip del pacchetto oppure specificare il file ZIP originale quando è possibile caricare il pacchetto R in Studio (versione classica).

2. Verificare le dipendenze e se il pacchetto richiede altri pacchetti non già presenti in Azure ML Studio (versione classica), scaricarli in formato compresso e aggiungerli al file di archivio.

3. Fare clic con il pulsante destro del mouse sul file compresso per il pacchetto da caricare, nonché sulle relative dipendenze, scegliere Invia a e quindi selezionare Compressed (compresso) cartella.

   Suggerimento

   La cartella compressa deve contenere almeno un file compresso con il pacchetto di destinazione, oltre a file zip aggiuntivi contenenti pacchetti obbligatori.

4. Upload il singolo file ZIP contenente tutti i pacchetti (nonché tutti i file di codice R o i file di dati facoltativi) nell'area di lavoro studio (classica).

   Si desidera caricare un set di dati: fare clic su Nuovo, fare clic su Set di dati e quindi selezionare Dal file locale e l'opzione File Zip .

5. Aprire l'elenco Set di dati salvati , fare clic su Set di dati personali e verificare che il file compresso sia disponibile.

6. Trascinarla nell'esperimento, fare clic con il pulsante destro del mouse sul set di dati e selezionare Visualizza per visualizzare i file inclusi nella cartella compressa. I nomi di file visualizzati nell'elenco Contenuto sono i nomi che è necessario fare riferimento quando si installa il pacchetto.

   Si supponga, ad esempio, di aver caricato un file denominato NewRPackage.zip, che contiene tre pacchetti R denominati 001.zip, 002.zipe 003.zip. Nell'elenco Set di dati il nome del set di dati sarebbe NewRPackage.zip, con contenuto 001.zip, 002.zipe 003.zip.

7. Connessione il set di dati (NewRPackage.zip) alla porta di input del bundle di script.

   A questo punto, la cartella esterna caricata viene estratta nella sandbox dell'area di lavoro, nel percorso src. A questo momento sono disponibili i pacchetti seguenti:

   • src\001.zip
   • src\002.zip
   • src\003.zip

8. Per installare i pacchetti R, estrarre ogni pacchetto dal relativo file ZIP e quindi caricare la libreria contenuta.

   Si supponga, ad esempio, che il file src\001.zip contenga il pacchetto code001R personalizzato , si eseguirà lo script seguente:

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

9. Ripetere il processo di installazione per tutti i pacchetti necessari.

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

   Nota

   Se sono presenti dipendenze tra più pacchetti in fase di installazione, assicurarsi di installare prima i pacchetti necessari o che venga visualizzato un errore.

L'installazione di tutti i pacchetti R deve essere eseguita come parte dell'esperimento, per assicurarsi che tutti i pacchetti necessari siano inclusi nell'area di lavoro inviata alla coda di processi di Azure quando viene eseguito l'esperimento.

I pacchetti in un'area di lavoro non vengono salvati in modo permanente dopo l'esecuzione dell'esperimento o dopo la chiusura della sessione. Tuttavia, tutti i pacchetti caricati come file compressi possono essere estratti e usati rapidamente quando si esegue di nuovo l'esperimento.

Note tecniche

Ottimizzazione delle prestazioni di R in Studio (versione classica)

La memoria predefinita corrente è 14 GB. Potrebbe venire visualizzato un messaggio di errore di memoria esaurita se si prova a modificare frame di dati di grandi dimensioni mediante il modulo Execute R Script.

Per aumentare la quantità di memoria usata dallo script R, è possibile usare una riga simile alla seguente all'inizio dello script:

memory.limit(56000)  

Il codice R specificato dall'utente viene eseguito da un interprete R a 64 bit eseguito in Azure usando una macchina virtuale A8 con 56 GB di RAM. Per aumentare la velocità del codice R, è possibile usare il compilatore JIR fornito nel pacchetto del compilatore preinstallato.

Conversione dei tipi di dati tra R e Studio (versione classica)

La tabella seguente illustra come i tipi di dati in R corrispondono ai tipi di dati in Machine Learning:

Tipo R	Tipo Studio (versione classica)
Integer	Integer
Double	Double
Complex	Complex Questo tipo è supportato solo da un sottoinsieme di moduli.
Logico	Boolean
Carattere	string
Notifica non elaborata	Non supportato
Difftime	TimeSpan
factor	categorical
data.frame	dataset

Le colonne con tipo di dati lists in R non possono essere convertite, in quanto gli elementi contenuti in tali colonne sono potenzialmente di dimensioni e tipi diversi. Ad esempio, il codice R valido seguente ha esito negativo se usato nel modulo Execute R Script (Esegui script R ):

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

Conversione di valori datetime

Machine Learning Studio (versione classica) usa tipi datetime diversi rispetto a R. Se i dati che si stanno analizzando contengono dati di data o ora, è necessario tenere presenti i requisiti di conversione seguenti durante la conversione del codice R esistente in Studio (versione classica):

Conversione da Machine Learning Studio (versione classica) a R

Le colonne di tipo DateTime vengono convertite in vettori POSIXct. Tuttavia, ogni singolo elemento del vettore risultante è un numero di secondi dal 1970-01-01T00:00:00:00.

In questa conversione non vengono effettuate regolazioni del fuso orario.

Conversione da R a Studio (versione classica)

I vettori POSIXct vengono convertiti in colonne di tipo DateTime nel fuso orario UTC.

Ad esempio, 2011-03-27 01:30:00 PDT verrà convertito in 2011-03-27T08:30:00Z, dove la Z indica che l'ora è in formato UTC.

Suggerimento

Quando si usano le ore nel modulo Execute R Script, è necessario specificare i timestamp in modo esplicito. L'interprete R ospitato nel modulo Execute R Script non ha accesso alle definizioni del fuso orario locale.

Rete

Per motivi di sicurezza, tutte le operazioni di rete da o verso il codice R nei moduli Execute R Script vengono bloccate da Azure. Inoltre, con pochissime eccezioni, è bloccato l'accesso alle porte locali dal modulo Execute R Script.

Esecuzione parallela

Attualmente l'esecuzione parallela con più thread non è supportata.

Input previsti

Nome	Tipo	Descrizione
Set di dati1	Tabella dati	Set di dati di Input 1
Dataset2	Tabella dati	Set di dati di input 2
Script Bundle	Zip	Set di origini R

Parametri del modulo

Name	Intervallo	Type	Predefinito	Descrizione
Script R	Qualsiasi	StreamReader		Specificare uno StreamReader che punti alle origini di script R.
Random Seed	>=0	Integer		Definire un valore di inizializzazione casuale da usare nell'ambiente R. Equivalente a \"set.seed(value)\". Questo parametro è facoltativo.

Output

Nome	Tipo	Descrizione
Result Dataset	Tabella dati	Set di dati di output
R Device	Tabella dati	Output della console e dispositivo di grafica PNG dall'interprete R

Vedi anche

Moduli del linguaggio R
Create R Model
Categorie e descrizioni dei moduli
Moduli del linguaggio Python