Show Menu
ARGOMENTI×

Guida per gli sviluppatori di SDK

L’SDK per l’authoring dei modelli consente di sviluppare ricette di machine learning personalizzate e pipeline di funzionalità utilizzabili in Adobe Experience Platform Data Science Workspace, fornendo modelli implementabili in PySpark e Spark.
Questo documento fornisce informazioni sulle varie classi rilevate nell’SDK per l’authoring dei modelli.

DataLoader

La classe DataLoader racchiude qualsiasi elemento correlato al recupero, al filtraggio e alla restituzione di dati di input non elaborati. Esempi di dati di input includono quelli per la formazione, il punteggio o la progettazione di funzionalità. I caricatori di dati estendono la classe astratta DataLoader e devono sostituire il metodo abstract load .
PySpark
Nella tabella seguente sono descritti i metodi astratti di una classe PySpark Data Loader:
Metodo e descrizione Parametri
load(self, configProperties, spark)
Carica e restituisce i dati della piattaforma come dati Pandas DataFrame
  • self : Riferimento autonomo
  • configProperties : Mappa delle proprietà di configurazione
  • spark : Spark session
Spark
Nella tabella seguente sono descritti i metodi astratti di una classe Spark Data Loader:
Metodo e descrizione Parametri
load(configProperties, sparkSession)
Carica e restituisce i dati della piattaforma come DataFrame
  • configProperties : Mappa delle proprietà di configurazione
  • sparkSession : Spark session

Carica dati da un dataset piattaforma

L'esempio seguente recupera i dati della piattaforma per ID e restituisce un DataFrame, dove l'ID del set di dati ( datasetId ) è una proprietà definita nel file di configurazione.
PySpark
# PySpark

from sdk.data_loader import DataLoader

class MyDataLoader(DataLoader):
    """
    Implementation of DataLoader which loads a DataFrame and prepares data
    """

    def load(self, configProperties, spark):
        """
        Load and return dataset

        :param configProperties:    Configuration properties
        :param spark:               Spark session
        :return:                    DataFrame
        """

        # preliminary checks
        if configProperties is None :
            raise ValueError("configProperties parameter is null")
        if spark is None:
            raise ValueError("spark parameter is null")

        # prepare variables
        dataset_id = str(
            configProperties.get("datasetId"))
        service_token = str(
            spark.sparkContext.getConf().get("ML_FRAMEWORK_IMS_ML_TOKEN"))
        user_token = str(
            spark.sparkContext.getConf().get("ML_FRAMEWORK_IMS_TOKEN"))
        org_id = str(
            spark.sparkContext.getConf().get("ML_FRAMEWORK_IMS_ORG_ID"))
        api_key = str(
            spark.sparkContext.getConf().get("ML_FRAMEWORK_IMS_CLIENT_ID"))

        # validate variables
        for arg in ['dataset_id', 'service_token', 'user_token', 'org_id', 'api_key']:
            if eval(arg) == 'None':
                raise ValueError("%s is empty" % arg)

        # load dataset through Spark session
        pd = spark.read.format("com.adobe.platform.dataset") \
            .option('serviceToken', service_token) \
            .option('userToken', user_token) \
            .option('orgId', org_id) \
            .option('serviceApiKey', api_key) \
            .load(dataset_id)

        # return as DataFrame
        return pd

Spark
// Spark

import com.adobe.platform.ml.config.ConfigProperties
import com.adobe.platform.ml.sdk.DataLoader
import org.apache.spark.sql.{DataFrame, SparkSession}

/**
 * Implementation of DataLoader which loads a DataFrame and prepares data
 */
class MyDataLoader extends DataLoader {

    /**
     * @param configProperties  - Configuration properties
     * @param sparkSession      - Spark session
     * @return                  - DataFrame
     */
    override def load(configProperties: ConfigProperties, sparkSession: SparkSession): DataFrame = {

        // preliminary checks
        require(configProperties != null)
        require(sparkSession != null)

        // prepare variables
        val dataSetId: String = configProperties
            .get("datasetId").getOrElse("")
        val serviceToken: String = sparkSession.sparkContext.getConf
            .get("ML_FRAMEWORK_IMS_ML_TOKEN", "").toString
        val userToken: String = sparkSession.sparkContext.getConf
            .get("ML_FRAMEWORK_IMS_TOKEN", "").toString
        val orgId: String = sparkSession.sparkContext.getConf
            .get("ML_FRAMEWORK_IMS_ORG_ID", "").toString
        val apiKey: String = sparkSession.sparkContext.getConf
            .get("ML_FRAMEWORK_IMS_CLIENT_ID", "").toString

        // validate variables
        List(dataSetId, serviceToken, userToken, orgId, apiKey).foreach(
            value => required(value != "")
        )

        // load dataset through Spark session
        var df = sparkSession.read.format("com.adobe.platform.dataset")
            .option(DataSetOptions.orgId, orgId)
            .option(DataSetOptions.serviceToken, serviceToken)
            .option(DataSetOptions.userToken, userToken)
            .option(DataSetOptions.serviceApiKey, apiKey)
            .load(dataSetId)
        
        // return as DataFrame
        df
    }
}

DataSaver

La classe DataSaver racchiude qualsiasi elemento correlato alla memorizzazione dei dati di output, inclusi quelli derivanti dal punteggio o dalla progettazione di funzionalità. I salvatori di dati estendono la classe astratta DataSaver e devono ignorare il metodo abstract save .
PySpark
Nella tabella seguente sono descritti i metodi astratti di una classe PySpark Data Saver:
Metodo e descrizione Parametri
save(self, configProperties, dataframe)
Ricevi i dati di output come DataFrame e li memorizza in un dataset della piattaforma
  • self : Riferimento autonomo
  • configProperties : Mappa delle proprietà di configurazione
  • dataframe : Dati da memorizzare sotto forma di DataFrame
Spark
Nella tabella seguente sono descritti i metodi astratti di una classe Spark Data Saver:
Metodo e descrizione Parametri
save(configProperties, dataFrame)
Ricevi i dati di output come DataFrame e li memorizza in un dataset della piattaforma
  • configProperties : Mappa delle proprietà di configurazione
  • dataFrame : Dati da memorizzare sotto forma di DataFrame

Salvataggio di dati in un dataset piattaforma

Per memorizzare i dati in un set di dati della piattaforma, le proprietà devono essere fornite o definite nel file di configurazione:
  • ID set di dati valido della piattaforma in cui verranno memorizzati i dati
  • L'ID tenant appartenente alla tua organizzazione
Gli esempi seguenti memorizzano i dati ( prediction ) in un set di dati della piattaforma, dove l'ID del set di dati ( datasetId ) e l'ID tenant ( tenantId ) sono proprietà definite all'interno del file di configurazione.
PySpark
# PySpark

from sdk.data_saver import DataSaver
from pyspark.sql.types import StringType, TimestampType


class MyDataSaver(DataSaver):
    """
    Implementation of DataSaver which stores a DataFrame to a Platform dataset
    """

    def save(self, configProperties, prediction):
        """
        Store DataFrame to a Platform dataset

        :param configProperties:    Configuration properties
        :param prediction:          DataFrame to be stored to a Platform dataset
        """

        # Spark context
        sparkContext = prediction._sc

        # preliminary checks
        if configProperties is None:
            raise ValueError("configProperties parameter is null")
        if prediction is None:
            raise ValueError("prediction parameter is null")
        if sparkContext is None:
            raise ValueError("sparkContext parameter is null")

        # prepare variables
        timestamp = "2019-01-01 00:00:00"
        output_dataset_id = str(
            configProperties.get("datasetId"))
        tenant_id = str(
            configProperties.get("tenantId"))
        service_token = str(
            sparkContext.getConf().get("ML_FRAMEWORK_IMS_ML_TOKEN"))
        user_token = str(
            sparkContext.getConf().get("ML_FRAMEWORK_IMS_TOKEN"))
        org_id = str(
            sparkContext.getConf().get("ML_FRAMEWORK_IMS_ORG_ID"))
        api_key = str(
            sparkContext.getConf().get("ML_FRAMEWORK_IMS_CLIENT_ID"))

        # validate variables
        for arg in ['output_dataset_id', 'tenant_id', 'service_token', 'user_token', 'org_id', 'api_key']:
            if eval(arg) == 'None':
                raise ValueError("%s is empty" % arg)

        # store data into dataset
        prediction.write.format("com.adobe.platform.dataset") \
            .option('orgId', org_id) \
            .option('serviceToken', service_token) \
            .option('userToken', user_token) \
            .option('serviceApiKey', api_key) \
            .save(output_dataset_id)

Spark
// Spark

import com.adobe.platform.dataset.DataSetOptions
import com.adobe.platform.ml.config.ConfigProperties
import com.adobe.platform.ml.impl.Constants
import com.adobe.platform.ml.sdk.DataSaver
import org.apache.spark.sql.DataFrame
import org.apache.spark.sql.functions._
import org.apache.spark.sql.types.TimestampType

/**
 * Implementation of DataSaver which stores a DataFrame to a Platform dataset
 */
class ScoringDataSaver extends DataSaver {

    /**
     * @param configProperties  - Configuration properties
     * @param dataFrame         - DataFrame to be stored to a Platform dataset
     */
    override def save(configProperties: ConfigProperties, dataFrame: DataFrame): Unit =  {

        // Spark session
        val sparkSession = dataFrame.sparkSession
        import sparkSession.implicits._

        // preliminary checks
        require(configProperties != null)
        require(dataFrame != null)

        // prepare variables
        val predictionColumn = configProperties.get(Constants.PREDICTION_COL)
            .getOrElse(Constants.DEFAULT_PREDICTION)
        val timestamp:String = "2019-01-01 00:00:00"
        val output_dataset_id: String = configProperties
            .get("datasetId").getOrElse("")
        val tenant_id:String = configProperties
            .get("tenantId").getOrElse("")
        val serviceToken: String = sparkSession.sparkContext.getConf
            .get("ML_FRAMEWORK_IMS_ML_TOKEN", "").toString
        val userToken: String = sparkSession.sparkContext.getConf
            .get("ML_FRAMEWORK_IMS_TOKEN", "").toString
        val orgId: String = sparkSession.sparkContext.getConf
            .get("ML_FRAMEWORK_IMS_ORG_ID", "").toString
        val apiKey: String = sparkSession.sparkContext.getConf
            .get("ML_FRAMEWORK_IMS_CLIENT_ID", "").toString

        // validate variables
        List(output_dataset_id, tenant_id, serviceToken, userToken, orgId, apiKey).foreach(
            value => require(value != "")
        )

        // store data into dataset
        dataFrame.write.format("com.adobe.platform.dataset")
            .option(DataSetOptions.orgId, orgId)
            .option(DataSetOptions.serviceToken, serviceToken)
            .option(DataSetOptions.userToken, userToken)
            .option(DataSetOptions.serviceApiKey, apiKey)
            .save(output_dataset_id)
    }
}

DatasetTransformer

La classe DatasetTransformer modifica e trasforma la struttura di un dataset. Sensei Machine Learning Runtime non richiede la definizione di questo componente ed è implementato in base ai requisiti dell'utente.
Per quanto riguarda una tubazione di feature, i trasformatori di set di dati possono essere utilizzati in modo collaborativo con una fabbrica di tubazioni di feature per preparare i dati per la progettazione di feature.
PySpark
Nella tabella seguente sono descritti i metodi di classe di una classe di trasformatore di set di dati PySpark:
Metodo e descrizione Parametri
abstract transform(self, configProperties, dataset)
Assume un dataset come input e genera un nuovo dataset derivato
  • self : Riferimento autonomo
  • configProperties : Mappa delle proprietà di configurazione
  • dataset : Il set di dati di input per la trasformazione
Spark
Nella tabella seguente sono descritti i metodi astratti di una classe di trasformatore di set di dati Spark:
Metodo e descrizione Parametri
transform(configProperties, dataset)
Assume un dataset come input e genera un nuovo dataset derivato
  • configProperties : Mappa delle proprietà di configurazione
  • dataset : Il set di dati di input per la trasformazione

FeaturePipelineFactory

La classe FeaturePipelineFactory contiene algoritmi di estrazione delle feature e definisce le fasi di una feature Pipeline dall'inizio alla fine.
PySpark
Nella tabella seguente sono descritti i metodi di classe di una FeaturePipelineFactory di PySpark:
Metodo e descrizione Parametri
abstract create_pipeline(self, configProperties)
Creare e restituire una pipeline Spark che contiene una serie di trasformatori Spark
  • self : Riferimento autonomo
  • configProperties : Mappa delle proprietà di configurazione
abstract get_param_map(self, configProperties, sparkSession)
Recuperare e restituire la mappa param dalle proprietà di configurazione
  • self : Riferimento autonomo
  • configProperties : Proprietà di configurazione
  • sparkSession : Spark session
Spark
Nella tabella seguente sono descritti i metodi di classe di Spark FeaturePipelineFactory:
Metodo e descrizione Parametri
abstract createPipeline(configProperties)
Creare e restituire una tubazione contenente una serie di trasformatori
  • configProperties : Mappa delle proprietà di configurazione
abstract getParamMap(configProperties, sparkSession)
Recuperare e restituire la mappa param dalle proprietà di configurazione
  • configProperties : Proprietà di configurazione
  • sparkSession : Spark session

PipelineFactory

La classe PipelineFactory racchiude metodi e definizioni per la formazione e il punteggio dei modelli, in cui la logica e gli algoritmi di formazione sono definiti sotto forma di Spark Pipeline.
PySpark
Nella tabella seguente sono descritti i metodi di classe di una PipelineFactory di PySpark:
Metodo e descrizione Parametri
abstract apply(self, configProperties)
Creare e restituire una pipeline Spark che contiene la logica e l'algoritmo per la formazione e il punteggio dei modelli
  • self : Riferimento autonomo
  • configProperties : Proprietà di configurazione
abstract train(self, configProperties, dataframe)
Restituisce una pipeline personalizzata che contiene la logica e l'algoritmo per l'addestramento di un modello. Questo metodo non è richiesto se viene utilizzata una pipeline Spark
  • self : Riferimento autonomo
  • configProperties : Proprietà di configurazione
  • dataframe : Set di dati delle funzioni per l'input di formazione
abstract score(self, configProperties, dataframe, model)
Punteggio utilizzando il modello preparato e restituire i risultati
  • self : Riferimento autonomo
  • configProperties : Proprietà di configurazione
  • dataframe : Set di dati di input per il punteggio
  • model : Un modello qualificato utilizzato per il punteggio
abstract get_param_map(self, configProperties, sparkSession)
Recuperare e restituire la mappa param dalle proprietà di configurazione
  • self : Riferimento autonomo
  • configProperties : Proprietà di configurazione
  • sparkSession : Spark session
Spark
Nella tabella seguente sono descritti i metodi di classe di Spark PipelineFactory:
Metodo e descrizione Parametri
abstract apply(configProperties)
Creare e restituire una pipeline che contiene la logica e l'algoritmo per la formazione e il punteggio dei modelli
  • configProperties : Proprietà di configurazione
abstract getParamMap(configProperties, sparkSession)
Recuperare e restituire la mappa param dalle proprietà di configurazione
  • configProperties : Proprietà di configurazione
  • sparkSession : Spark session

MLEvalue

La classe MLEvalue fornisce metodi per definire le metriche di valutazione e determinare i set di dati di formazione e test.
PySpark
Nella tabella seguente sono descritti i metodi di classe di un oggetto PySpark MLEvalue:
Metodo e descrizione Parametri
abstract split(self, configProperties, dataframe)
Suddivide il set di dati di input in sottoinsiemi di formazione e test
  • self : Riferimento autonomo
  • configProperties : Proprietà di configurazione
  • dataframe : Set di dati di input da dividere
abstract evaluate(self, dataframe, model, configProperties)
Valuta un modello preparato e restituisce i risultati della valutazione
  • self : Riferimento autonomo
  • dataframe : Un DataFrame costituito da dati di formazione e test
  • model : Un modello preparato
  • configProperties : Proprietà di configurazione
Spark
Nella tabella seguente sono descritti i metodi di classe di un MLEvalue Spark:
Metodo e descrizione Parametri
abstract split(configProperties, data)
Suddivide il set di dati di input in sottoinsiemi di formazione e test
  • configProperties : Proprietà di configurazione
  • data : Set di dati di input da dividere
abstract evaluate(configProperties, model, data)
Valuta un modello preparato e restituisce i risultati della valutazione
  • configProperties : Proprietà di configurazione
  • model : Un modello preparato
  • data : Un DataFrame costituito da dati di formazione e test