Esercitazione: Introduzione all'estensione di U-SQL con RTutorial: Get started with extending U-SQL with R

L'esempio seguente illustra i passaggi di base per la distribuzione del codice R:The following example illustrates the basic steps for deploying R code:

  • Usare l'istruzione REFERENCE ASSEMBLY per abilitare le estensioni R per lo script U-SQL.Use the REFERENCE ASSEMBLY statement to enable R extensions for the U-SQL Script.
  • Usare l'operazione REDUCE per partizionare i dati di input in una chiave.Use theREDUCE operation to partition the input data on a key.
  • Le estensioni R per U-SQL includono un riduttore predefinito (Extension.R.Reducer) che esegue il codice R in ogni vertice assegnato al riduttore.The R extensions for U-SQL include a built-in reducer (Extension.R.Reducer) that runs R code on each vertex assigned to the reducer.
  • Utilizzo dei frame di dati denominati dedicati chiamati rispettivamente inputFromUSQL e outputToUSQL per passare dati tra U-SQL e R. I nomi di input e di output dell'identificatore DataFrame sono fissi (vale a dire, gli utenti non possono modificare i nomi predefiniti di input e di output degli identificatori DataFrame).Usage of dedicated named data frames called inputFromUSQL and outputToUSQLrespectively to pass data between U-SQL and R. Input and output DataFrame identifier names are fixed (that is, users cannot change these predefined names of input and output DataFrame identifiers).

Incorporare il codice R nello script U-SQLEmbedding R code in the U-SQL script

È possibile incorporare il codice R nello script U-SQL usando il parametro del comando di Extension.R.Reducer.You can inline the R code your U-SQL script by using the command parameter of the Extension.R.Reducer. Ad esempio, è possibile dichiarare lo script R come una variabile di stringa e passarlo come parametro al Reducer.For example, you can declare the R script as a string variable and pass it as a parameter to the Reducer.

REFERENCE ASSEMBLY [ExtR];

DECLARE @myRScript = @"
inputFromUSQL$Species = as.factor(inputFromUSQL$Species)
lm.fit=lm(unclass(Species)~.-Par, data=inputFromUSQL)
#do not return readonly columns and make sure that the column names are the same in usql and r scripts,
outputToUSQL=data.frame(summary(lm.fit)$coefficients)
colnames(outputToUSQL) <- c(""Estimate"", ""StdError"", ""tValue"", ""Pr"")
outputToUSQL
";

@RScriptOutput = REDUCE … USING new Extension.R.Reducer(command:@myRScript, rReturnType:"dataframe");

Mantenere il codice R in un file separato e farvi riferimento nello script U-SQLKeep the R code in a separate file and reference it the U-SQL script

L'esempio seguente illustra un uso più complesso.The following example illustrates a more complex usage. In questo caso, il codice R è distribuito come una RISORSA che rappresenta lo script U-SQL.In this case, the R code is deployed as a RESOURCE that is the U-SQL script.

Salvare il codice R come file separato.Save this R code as a separate file.

load("my_model_LM_Iris.rda")
outputToUSQL=data.frame(predict(lm.fit, inputFromUSQL, interval="confidence")) 

Usare uno script U-SQL per distribuire lo script R con l'istruzione DEPLOY RESOURCE.Use a U-SQL script to deploy that R script with the DEPLOY RESOURCE statement.

REFERENCE ASSEMBLY [ExtR];

DEPLOY RESOURCE @"/usqlext/samples/R/RinUSQL_PredictUsingLinearModelasDF.R";
DEPLOY RESOURCE @"/usqlext/samples/R/my_model_LM_Iris.rda";
DECLARE @IrisData string = @"/usqlext/samples/R/iris.csv";
DECLARE @OutputFilePredictions string = @"/my/R/Output/LMPredictionsIris.txt";
DECLARE @PartitionCount int = 10;

@InputData =
    EXTRACT 
        SepalLength double,
        SepalWidth double,
        PetalLength double,
        PetalWidth double,
        Species string
    FROM @IrisData
    USING Extractors.Csv();

@ExtendedData =
    SELECT 
        Extension.R.RandomNumberGenerator.GetRandomNumber(@PartitionCount) AS Par,
        SepalLength,
        SepalWidth,
        PetalLength,
        PetalWidth
    FROM @InputData;

// Predict Species

@RScriptOutput = REDUCE @ExtendedData ON Par
    PRODUCE Par, fit double, lwr double, upr double
    READONLY Par
    USING new Extension.R.Reducer(scriptFile:"RinUSQL_PredictUsingLinearModelasDF.R", rReturnType:"dataframe", stringsAsFactors:false);
    OUTPUT @RScriptOutput TO @OutputFilePredictions USING Outputters.Tsv();

Come R si integra con U-SQLHow R Integrates with U-SQL

Tipi di datiDatatypes

  • Le colonne di tipo stringa e numeriche di U-SQL vengono convertite così come sono tra DataFrame R e U-SQL [tipi supportati: double, string, bool, integer, byte].String and numeric columns from U-SQL are converted as-is between R DataFrame and U-SQL [supported types: double, string, bool, integer, byte].
  • Il datatype Factor non è supportato in U-SQL.The Factor datatype is not supported in U-SQL.
  • byte[] deve essere serializzato come string con codifica Base 64.byte[] must be serialized as a base64-encoded string.
  • Le stringhe U-SQL possono essere convertite in fattori nel codice R, una volta che U SQL crea il frame di dati R di input o impostando il parametro riduttore stringsAsFactors: true.U-SQL strings can be converted to factors in R code, once U-SQL create R input dataframe or by setting the reducer parameter stringsAsFactors: true.

SchemiSchemas

  • I set di dati di U-SQL non possono avere nomi di colonna duplicati.U-SQL datasets cannot have duplicate column names.
  • I nomi di colonna dei set di dati di U-SQL devono essere stringhe.U-SQL datasets column names must be strings.
  • I nomi di colonna devono essere identici in U-SQL e negli script R.Column names must be the same in U-SQL and R scripts.
  • Le colonne di sola lettura non possono fare parte del frame di dati di output.Readonly column cannot be part of the output dataframe. Poiché le colonne di sola lettura vengono inserite automaticamente nella tabella U-SQL se fanno parte dello schema di output degli oggetti UDO.Because readonly columns are automatically injected back in the U-SQL table if it is a part of output schema of UDO.

Limitazioni funzionaliFunctional limitations

  • Non è possibile creare due volte un'istanza del motore R nello stesso processo.The R Engine can't be instantiated twice in the same process.
  • Attualmente, U-SQL non supporta UDO Combiner per la stima mediante modelli partizionati generati usando UDO Reducer.Currently, U-SQL does not support Combiner UDOs for prediction using partitioned models generated using Reducer UDOs. Gli utenti possono dichiarare i modelli partizionati come risorsa e usarli negli script R. Vedere il codice di esempio ExtR_PredictUsingLMRawStringReducer.usql.Users can declare the partitioned models as resource and use them in their R Script (see sample code ExtR_PredictUsingLMRawStringReducer.usql)

Versioni RR Versions

È supportato solo R 3.2.2.Only R 3.2.2 is supported.

Moduli R standardStandard R modules

base
boot
Class
Cluster
codetools
compiler
datasets
doParallel
doRSR
foreach
foreign
Graphics
grDevices
grid
iterators
KernSmooth
lattice
MASS
Matrix
Methods
mgcv
nlme
Nnet
Parallel
pkgXMLBuilder
RevoIOQ
revoIpe
RevoMods
RevoPemaR
RevoRpeConnector
RevoRsrConnector
RevoScaleR
RevoTreeView
RevoUtils
RevoUtilsMath
Rpart
RUnit
spatial
splines
Stats
stats4
survival
Tcltk
Tools
translations
utils
XML

Limitazioni delle dimensioni di input e outputInput and Output size limitations

A ogni vertice è assegnata una quantità di memoria limitata,Every vertex has a limited amount of memory assigned to it. Poiché devono esistere frame di dati di input e di output in memoria nel codice R, le dimensioni totali per l'input e per l'output non possono superare i 500 MB.Because the input and output DataFrames must exist in memory in the R code, the total size for the input and output cannot exceed 500 MB.

Codice di esempioSample Code

Altri esempi di codice sono disponibili nell'account Data Lake Store dopo aver installato le estensioni Advanced Analytics U-SQL.More sample code is available in your Data Lake Store account after you install the U-SQL Advanced Analytics extensions. Il percorso per il codice di esempio aggiuntivo è: <your_account_address>/usqlext/samples/R.The path for more sample code is: <your_account_address>/usqlext/samples/R.

Distribuzione dei moduli personalizzati R con U-SQLDeploying Custom R modules with U-SQL

Innanzitutto, creare un modulo personalizzato R fare lo zip e quindi caricare il file del modulo personalizzato R compresso in un archivio ADL.First, create an R custom module and zip it and then upload the zipped R custom module file to your ADL store. Nell'esempio, si caricherà magittr_1.5.zip nella radice dell'account predefinito ADLS dell'account ADLA che si sta usando.In the example, we will upload magittr_1.5.zip to the root of the default ADLS account for the ADLA account we are using. Dopo aver caricato il modulo nell'archivio ADL, dichiararlo come quando si usa DEPLOY RESOURCE per renderlo disponibile nello script U-SQL script e chiamare il metodo install.packages per installarlo.Once you upload the module to ADL store, declare it as use DEPLOY RESOURCE to make it available in your U-SQL script and call install.packages to install it.

REFERENCE ASSEMBLY [ExtR];
DEPLOY RESOURCE @"/magrittr_1.5.zip";

DECLARE @IrisData string =  @"/usqlext/samples/R/iris.csv";
DECLARE @OutputFileModelSummary string = @"/R/Output/CustomePackages.txt";

// R script to run
DECLARE @myRScript = @"
# install the magrittr package,
install.packages('magrittr_1.5.zip', repos = NULL),
# load the magrittr package,
require(magrittr),
# demonstrate use of the magrittr package,
2 %>% sqrt
";

@InputData =
EXTRACT SepalLength double,
SepalWidth double,
PetalLength double,
PetalWidth double,
Species string
FROM @IrisData
USING Extractors.Csv();

@ExtendedData =
SELECT 0 AS Par,
*
FROM @InputData;

@RScriptOutput = REDUCE @ExtendedData ON Par
PRODUCE Par, RowId int, ROutput string
READONLY Par
USING new Extension.R.Reducer(command:@myRScript, rReturnType:"charactermatrix");

OUTPUT @RScriptOutput TO @OutputFileModelSummary USING Outputters.Tsv();

Passaggi successiviNext Steps