Share via

Az ML.NET Automated Machine Tanulás (AutoML) API használata

  • Cikk

Ebből a cikkből megtudhatja, hogyan használhatja az ML.NET Automatizált ML -t (AutoML API).

Az AutoML API mintái a dotnet/machinelearning-samples adattárban találhatók.

Telepítés

Az AutoML API használatához telepítse a Microsoft.ML.AutoML NuGet-csomagot abban a .NET-projektben, amelyben hivatkozni szeretne rá.

Feljegyzés

Ez az útmutató a Microsoft.ML.AutoML NuGet-csomag 0.20.0-s és újabb verzióját használja. Bár a korábbi verziókból származó minták és kódok továbbra is működnek, erősen ajánlott az ebben a verzióban bevezetett API-kat használni az új projektekhez.

A NuGet-csomagok telepítésével kapcsolatos további információkért tekintse meg az alábbi útmutatókat:

Első lépések

Az AutoML számos alapértelmezett beállítást biztosít a gépi tanulási modellek gyors betanításához. Ebben a szakaszban megtanulhatja, hogyan:

  • Adatok betöltése
  • A folyamat definiálása
  • A kísérlet konfigurálása
  • A kísérlet futtatása
  • Előrejelzések készítése a legjobb modell használatával

A probléma definiálása

Adott egy taxi-fare-train.csv nevű vesszővel tagolt fájlban tárolt adatkészlet, amely a következőképpen néz ki:

vendor_id rate_code passenger_count trip_time_in_secs trip_distance payment_type fare_amount
CMT 0 0 1271 3,8 CRD 17.5
CMT 0 0 474 1,5 CRD 8
CMT 0 0 637 1.4 CRD 8.5

Adatok betöltése

Első lépésként inicializálja a MLContext. MLContext az összes ML.NET művelet kiindulópontja. Az mlContext inicializálása új ML.NET környezetet hoz létre, amely megosztható a modelllétrehozás munkafolyamat-objektumai között. Ez fogalmilag hasonló az Entity Frameworkhez DBContext .

Ezután az adatok betöltéséhez használja a metódust InferColumns .

// Initialize MLContext
MLContext ctx = new MLContext();

// Define data path
var dataPath = Path.GetFullPath(@"..\..\..\..\Data\taxi-fare-train.csv");

// Infer column information
ColumnInferenceResults columnInference =
    ctx.Auto().InferColumns(dataPath, labelColumnName: "fare_amount", groupColumns: false);

InferColumns betölt néhány sort az adathalmazból. Ezután vizsgálja meg az adatokat, és megpróbálja kitalálni vagy következtetni az egyes oszlopok adattípusát a tartalmuk alapján.

Az alapértelmezett viselkedés az azonos típusú oszlopok csoportosítása funkcióvektorokba vagy tömbökbe, amelyek az egyes oszlopok elemeit tartalmazzák. false A beállítás groupColumns felülírja az alapértelmezett viselkedést, és csak oszlopok csoportosítása nélkül hajtja végre az oszlopkövetkeztetést. Az oszlopok külön-külön tartásával különböző adatátalakításokat alkalmazhat az adatok egyéni oszlopszinten történő előfeldolgozásakor az oszlopcsoportozás helyett.

Ennek eredménye InferColumns egy ColumnInferenceResults olyan objektum, amely tartalmazza az oszlopinformációk létrehozásához TextLoader szükséges beállításokat.

A taxi-fare-train.csv mintaadatkészlete esetében az oszlopinformációk a következőhöz hasonlóan nézhetnek ki:

  • LabelColumnName: fare_amount
  • CategoricalColumnNames: vendor_id, payment_type
  • NumericColumnNames: rate_code, passenger_count, trip_time_in_secs, trip_distance

Miután megkapta az oszlopinformációkat, a TextLoader.Options megadott érték ColumnInferenceResults használatával hozzon létre egy TextLoader olyan elemet, amely betölti az adatokat egy IDataView.

// Create text loader
TextLoader loader = ctx.Data.CreateTextLoader(columnInference.TextLoaderOptions);

// Load data into IDataView
IDataView data = loader.Load(dataPath);

Gyakran ajánlott az adatokat betanítási és érvényesítési csoportokra felosztani. Az adathalmaz 80%-os betanítási és 20%-os érvényesítési felosztásának létrehozásához használható TrainTestSplit .

TrainTestData trainValidationData = ctx.Data.TrainTestSplit(data, testFraction: 0.2);

A folyamat definiálása

A folyamat meghatározza a modell betanításához használandó adatfeldolgozási lépéseket és gépi tanulási folyamatot.

SweepablePipeline pipeline =
    ctx.Auto().Featurizer(data, columnInformation: columnInference.ColumnInformation)
        .Append(ctx.Auto().Regression(labelColumnName: columnInference.ColumnInformation.LabelColumnName));

Az A SweepablePipeline a gyűjtemény.SweepableEstimator Az A SweepableEstimator egy ML.NET Estimator egy SearchSpace.

Ez Featurizer egy egyszerű API, amely az Ön által megadott oszlopadatok alapján készíti el az adatfeldolgozási és adatbecslők átfedő folyamatát. A folyamat létrehozása Featurizer helyett automatizálja az adatok előfeldolgozási lépését. Az ML.NET által támogatott átalakításokról az adatátalakítások útmutatójában talál további információt.

A Featurizer kimenet egyetlen oszlop, amely egy numerikus funkcióvektort tartalmaz, amely az egyes oszlopok átalakított adatait jelöli. Ezt a funkcióvektort használja a gépi tanulási modellek betanítása során használt algoritmusok bemeneteként.

Ha részletesebben szeretné szabályozni az adatok előfeldolgozását, létrehozhat egy folyamatot az egyes előfeldolgozási lépések mindegyikével. További információkért tekintse meg a modellútmutató készítéséhez szükséges adatok előkészítését.

Tipp.

ColumnInferenceResults Ezzel Featurizer maximalizálhatja az AutoML segédprogramját.

A betanításhoz az AutoML egy áttekinthető folyamatot biztosít az alapértelmezett oktatókkal és a keresési terület konfigurációival a következő gépi tanulási feladatokhoz:

A taxi viteldíj előrejelzési problémájához, mivel a cél egy numerikus érték előrejelzése, használja Regressiona . A feladat kiválasztásával kapcsolatos további információkért lásd : Gépi tanulási feladatok a ML.NET

A kísérlet konfigurálása

Először hozzon létre egy AutoML-kísérletet. Az An AutoMLExperiment a gyűjtemény.TrialResult

AutoMLExperiment experiment = ctx.Auto().CreateExperiment();

A kísérlet létrehozása után használja az általa biztosított bővítménymetelyeket a különböző beállítások konfigurálásához.

experiment
    .SetPipeline(pipeline)
    .SetRegressionMetric(RegressionMetric.RSquared, labelColumn: columnInference.ColumnInformation.LabelColumnName)
    .SetTrainingTimeInSeconds(60)
    .SetDataset(trainValidationData);

Ebben a példában a következőt adhatja meg:

  • Állítsa be a takarítási folyamatot úgy, hogy a kísérlet során fusson a hívással SetPipeline.
  • Válassza ki RSquared a metrika kiválasztását a betanítás során a hívással SetRegressionMetricoptimalizálni kívánt metrikaként. A kiértékelési metrikákkal kapcsolatos további információkért tekintse meg a ML.NET modell kiértékelését a metrikák útmutatójával.
  • Állítsa be a 60 másodpercet a hívással SetTrainingTimeInSecondsbetanított időtartamként. Az adatok mérete jó heurisztikus annak meghatározásához, hogy mennyi ideig kell betanítása. A nagyobb adathalmazok általában hosszabb betanítási időt igényelnek. További információkért tekintse meg a betanítási időről készült útmutatót.
  • Adja meg a hívással SetDatasethasználni kívánt betanítási és érvényesítési adatkészleteket.

A kísérlet definiálása után valamilyen módon nyomon kell követnie a folyamat előrehaladását. Az előrehaladás nyomon követésének leggyorsabb módja az esemény módosítása a Log következőből MLContext: .

// Log experiment trials
ctx.Log += (_, e) => {
    if (e.Source.Equals("AutoMLExperiment"))
    {
        Console.WriteLine(e.RawMessage);
    }
};

A kísérlet futtatása

Most, hogy definiálta a kísérletet, használja a RunAsync metódust a kísérlet elindításához.

TrialResult experimentResults = await experiment.RunAsync();

A betanítási idő lejárta után az eredmény a betanítás során talált legjobb modellnek adódik TrialResult .

Ezen a ponton mentheti a modellt, vagy használhatja előrejelzések készítésére. Az ML.NET modell használatáról az alábbi útmutatókban talál további információt:

Oszlopkövetkeztetési eredmények módosítása

Mivel InferColumns csak az adatok egy részhalmazát tölti be, előfordulhat, hogy az oszlopok következtetéséhez használt mintákon kívül található peremes esetek nem jelennek meg, és a helytelen adattípusok vannak beállítva az oszlopokhoz. Frissítheti a tulajdonságokat ColumnInformation , hogy figyelembe vegyék azokat az eseteket, amikor az oszlopkövető eredmények nem helyesek.

A taxi viteldíj adatkészletében például az oszlopban lévő rate_code adatok egy szám. Ez a számérték azonban egy kategóriát jelöl. Alapértelmezés szerint a hívás InferColumns nem a tulajdonságban, hanem a NumericColumnNames tulajdonságban lesz elhelyezve rate_codeCategoricalColumnNames. Mivel ezek a tulajdonságok .NET-gyűjtemények, standard műveletekkel adhat hozzá és távolíthat el elemeket.

A következőt elvégezve frissítheti a ColumnInformation következőt rate_code:

columnInference.ColumnInformation.NumericColumnNames.Remove("rate_code");
columnInference.ColumnInformation.CategoricalColumnNames.Add("rate_code");

Oktatók kizárása

Alapértelmezés szerint az AutoML a betanítási folyamat részeként több oktatóval is próbálkozik, hogy kiderüljön, melyik működik a legjobban az adataihoz. A betanítási folyamat során azonban előfordulhat, hogy vannak olyan oktatók, akik túl sok számítási erőforrást használnak fel, vagy nem biztosítanak megfelelő értékelési metrikákat. Lehetősége van arra, hogy kizárja az oktatókat a betanítási folyamatból. A feladatoktól függ, hogy mely oktatókat használják. A ML.NET támogatott oktatóinak listáját a gépi tanulási feladatok ML.NET útmutatójában találja.

A taxi viteldíj regressziós forgatókönyvében például a LightGBM algoritmus kizárásához állítsa a paramétert a useLgbm következőre false.

ctx.Auto().Regression(labelColumnName: columnInference.ColumnInformation.LabelColumnName, useLgbm:false)

Az oktatók kizárásának folyamata más feladatokban, például a bináris és a többosztályos besorolásban ugyanúgy működik.

Elsöprő becslés testreszabása

Ha részletesebben szeretné testre szabni a becslőbeállításokat a takarítási folyamat részeként, az alábbiakat kell elvégeznie:

  1. Keresési terület inicializálása
  2. Egyéni gyár definiálása a keresési terület használatával
  3. Takarítható becslő létrehozása
  4. A lesöprő becslés hozzáadása a lesöprő folyamathoz

Az AutoML előre konfigurált keresési helyeket biztosít az oktatók számára a következő gépi tanulási feladatokban:

Ebben a példában a használt keresési terület a SdcaRegressionTrainer. Inicializálása a következő használatával SdcaOption: .

var sdcaSearchSpace = new SearchSpace<SdcaOption>();

Ezután a keresőmezővel definiáljon egy egyéni gyári metódust a SdcaRegressionTrainerlétrehozáshoz. Ebben a példában a két érték L1RegularizationL2Regularization nem az alapértelmezett értékre van beállítva. Ebben L1Regularizationaz esetben az értékhalmazt a tuner határozza meg az egyes próbaverziók során. Az L2Regularization egyes próbaverziók esetében a rögzített értékre van javítva. Az egyes próbaverziók során az egyéni gyár kimenete SdcaRegressionTrainer a konfigurált hiperparaméterekkel rendelkezik.

// Use the search space to define a custom factory to create an SdcaRegressionTrainer
var sdcaFactory = (MLContext ctx, SdcaOption param) =>
{
    var sdcaOption = new SdcaRegressionTrainer.Options();
    sdcaOption.L1Regularization = param.L1Regularization;
    sdcaOption.L2Regularization = 0.02f;

    sdcaOption.LabelColumnName = columnInference.ColumnInformation.LabelColumnName;

    return ctx.Regression.Trainers.Sdca(sdcaOption);
};

A áttekinthető becslő egy becslő és egy keresési terület kombinációja. Most, hogy definiált egy keresési területet, és egy egyéni gyári metódus létrehozására használta a trénerek létrehozásához, a CreateSweepableEstimator metódus használatával hozzon létre egy új méretezhető becslést.

// Define Sdca sweepable estimator (SdcaRegressionTrainer + SdcaOption search space)
var sdcaSweepableEstimator = ctx.Auto().CreateSweepableEstimator(sdcaFactory, sdcaSearchSpace);

Ha a kísérletben használni szeretné a lesöprő becslőt, adja hozzá a seprhető folyamathoz.

SweepablePipeline pipeline =
    ctx.Auto().Featurizer(data, columnInformation: columnInference.ColumnInformation)
        .Append(sdcaSweepableEstimator);

Mivel a sweepable pipelines a söprhető becslési eszközök gyűjteménye, a lehető legtöbb ilyen elsöprő becslést konfigurálhatja és testre szabhatja.

A keresési terület testreszabása

Vannak olyan helyzetek, amikor a kísérletben használt méretezhető becslési eszközök testreszabásán túl szeretné szabályozni a keresési terület tartományát. Ezt a keresési terület tulajdonságainak kulcsokkal való elérésével teheti meg. Ebben az esetben a L1Regularization paraméter egy float. Ezért a keresési tartomány testreszabásához használja UniformSingleOptiona .

sdcaSearchSpace["L1Regularization"] = new UniformSingleOption(min: 0.01f, max: 2.0f, logBase: false, defaultValue: 0.01f);

A beállítani kívánt hiperparaméter adattípusától függően az alábbi lehetőségek közül választhat:

A keresőhelyek beágyazott keresőtereket is tartalmazhatnak.

var searchSpace = new SearchSpace();
searchSpace["SingleOption"] = new UniformSingleOption(min:-10f, max:10f, defaultValue=0f) 
var nestedSearchSpace = new SearchSpace();
nestedSearchSpace["IntOption"] = new UniformIntOption(min:-10, max:10, defaultValue=0);
searchSpace["Nest"] = nestedSearchSpace;

A keresési tartományok testreszabásának másik lehetősége az, hogy kibővíti őket. Például SdcaOption csak a paramétereket és L2Regularization a L1Regularization paramétereket adja meg. SdcaRegressionTrainer Azonban több paramétert is beállíthat, példáulBiasLearningRate.

A keresési terület kibővítéséhez hozzon létre egy új osztályt, például SdcaExtendedOptiona következőtől SdcaOptionöröklő osztályt:

public class SdcaExtendedOption : SdcaOption
{
    [Range(0.10f, 1f, 0.01f)]
    public float BiasLearningRate {get;set;}   
}

A keresési terület tartományának megadásához használja RangeAttributea következőnek Microsoft.ML.SearchSpace.Optionmegfelelőt: .

Ezután bárhol használhatja a keresési területet, hivatkozzon ahelyettSdcaOption, hogy a SdcaExtendedOption .

Ha például inicializálja a keresési területet, az alábbiak szerint teheti meg:

var sdcaSearchSpace = new SearchSpace<SdcaExtendedOption>();

Saját próbafuttató létrehozása

Az AutoML alapértelmezés szerint támogatja a bináris besorolást, a többosztályos besorolást és a regressziót. A ML.NET azonban számos további forgatókönyvet támogat, például:

  • Ajánlás
  • Előrejelzés
  • Rangsorolás
  • Képbesorolás
  • Szövegbesorolás
  • Mondatok hasonlósága

Az előre konfigurált keresési helyekkel és elsöprő becslésekkel nem rendelkező forgatókönyvek esetében létrehozhatja a sajátját, és egy próbafuttatóval engedélyezheti az AutoML-t az adott forgatókönyvhöz.

Például az alábbihoz hasonló éttermi felülvizsgálati adatok:

Wow... Imádtam ezt a helyet.

0

A kéreg nem jó.

0

A tréner segítségével elemezni szeretné a TextClassificationTrainer hangulatot, ahol a 0 negatív, az 1 pedig pozitív. ctx.Auto().TextClassification() Nincs azonban konfigurálás.

Ha az AutoML-t a szövegbesorolási trénerrel szeretné használni, a következőkkel kell rendelkeznie:

  1. Hozzon létre saját keresési területet.

    // Define TextClassification search space
public class TCOption
{
    [Range(64, 128, 32)]
    public int BatchSize { get; set; }
}

    Ebben az esetben az AutoML a hiperparaméter különböző konfigurációit BatchSize keresi.

  2. Hozzon létre egy elsöprő becslést, és adja hozzá a folyamathoz.

    // Initialize search space
var tcSearchSpace = new SearchSpace<TCOption>();

// Create factory for Text Classification trainer
var tcFactory = (MLContext ctx, TCOption param) =>
{
    return ctx.MulticlassClassification.Trainers.TextClassification(
        sentence1ColumnName: textColumnName,
        batchSize:param.BatchSize);
};

// Create text classification sweepable estimator
var tcEstimator = 
    ctx.Auto().CreateSweepableEstimator(tcFactory, tcSearchSpace);

// Define text classification pipeline
var pipeline =
    ctx.Transforms.Conversion.MapValueToKey(columnInference.ColumnInformation.LabelColumnName)
        .Append(tcEstimator);

    Ebben a példában a TCOption keresési területet és egy egyéni TextClassificationTrainer gyárat használunk egy elsöprő becslő létrehozásához.

  3. Egyéni próbaverziós futó létrehozása

    Egyéni próbaverzió létrehozásához implementálja ITrialRunnera következőt:

    public class TCRunner : ITrialRunner
{
    private readonly MLContext _context;
    private readonly TrainTestData _data;
    private readonly IDataView _trainDataset;
    private readonly IDataView _evaluateDataset;
    private readonly SweepablePipeline _pipeline;
    private readonly string _labelColumnName;
    private readonly MulticlassClassificationMetric _metric;

    public TCRunner(
        MLContext context, 
        TrainTestData data, 
        SweepablePipeline pipeline,
        string labelColumnName = "Label", 
        MulticlassClassificationMetric metric = MulticlassClassificationMetric.MicroAccuracy)
    {
        _context = context;
        _data = data;
        _trainDataset = data.TrainSet;
        _evaluateDataset = data.TestSet;
        _labelColumnName = labelColumnName;
        _pipeline = pipeline;
        _metric = metric;
    }

    public void Dispose()
    {
        return;
    }

    // Run trial asynchronously
    public Task<TrialResult> RunAsync(TrialSettings settings, CancellationToken ct)
    {
        try
        {
            return Task.Run(() => Run(settings));
        }
        catch (Exception ex) when (ct.IsCancellationRequested)
        {
            throw new OperationCanceledException(ex.Message, ex.InnerException);
        }
        catch (Exception)
        {
            throw;
        }
    }

    // Helper function to define trial run logic
    private TrialResult Run(TrialSettings settings)
    {
        try
        {
            // Initialize stop watch to measure time
            var stopWatch = new Stopwatch();
            stopWatch.Start();

            // Get pipeline parameters
            var parameter = settings.Parameter["_pipeline_"];

            // Use parameters to build pipeline
            var pipeline = _pipeline.BuildFromOption(_context, parameter);

            // Train model
            var model = pipeline.Fit(_trainDataset);

            // Evaluate the model
            var predictions = model.Transform(_evaluateDataset);

            // Get metrics
            var evaluationMetrics = _context.MulticlassClassification.Evaluate(predictions, labelColumnName: _labelColumnName);
            var chosenMetric = GetMetric(evaluationMetrics);

            return new TrialResult()
            {
                Metric = chosenMetric,
                Model = model,
                TrialSettings = settings,
                DurationInMilliseconds = stopWatch.ElapsedMilliseconds
            };
        }
        catch (Exception)
        {
            return new TrialResult()
            {
                Metric = double.MinValue,
                Model = null,
                TrialSettings = settings,
                DurationInMilliseconds = 0,
            };
        }
    }

    // Helper function to choose metric used by experiment
    private double GetMetric(MulticlassClassificationMetrics metric)
    {
        return _metric switch
        {
            MulticlassClassificationMetric.MacroAccuracy => metric.MacroAccuracy,
            MulticlassClassificationMetric.MicroAccuracy => metric.MicroAccuracy,
            MulticlassClassificationMetric.LogLoss => metric.LogLoss,
            MulticlassClassificationMetric.LogLossReduction => metric.LogLossReduction,
            MulticlassClassificationMetric.TopKAccuracy => metric.TopKAccuracy,
            _ => throw new NotImplementedException(),
        };
    }
}

    Az TCRunner ebben a példában szereplő megvalósítás:

    • Kinyeri a próbaverzióhoz kiválasztott hiperparamétereket
    • A hiperparaméterek használatával hoz létre ML.NET-folyamatot
    • Modell betanítása a ML.NET folyamat használatával
    • Kiértékeli a modellt
    • Egy objektumot ad TrialResult vissza az adott próbaverzióra vonatkozó információkkal

  4. Egyéni próbaverziós futó inicializálása

    var tcRunner = new TCRunner(context: ctx, data: trainValidationData, pipeline: pipeline);

  5. Hozza létre és konfigurálja a kísérletet. SetTrialRunner A bővítménymetódus használatával hozzáadhatja az egyéni próbafuttatót a kísérlethez.

    AutoMLExperiment experiment = ctx.Auto().CreateExperiment();

// Configure AutoML experiment
experiment
    .SetPipeline(pipeline)
    .SetMulticlassClassificationMetric(MulticlassClassificationMetric.MicroAccuracy, labelColumn: columnInference.ColumnInformation.LabelColumnName)
    .SetTrainingTimeInSeconds(120)
    .SetDataset(trainValidationData)
    .SetTrialRunner(tcRunner);

  6. A kísérlet futtatása

    var tcCts = new CancellationTokenSource();
TrialResult textClassificationExperimentResults = await experiment.RunAsync(tcCts.Token);

Másik hangoló kiválasztása

Az AutoML számos finomhangolási algoritmust támogat a keresési terület iterálásához az optimális hiperparaméterek keresése során. Alapértelmezés szerint az Eci Cost Frugal tunert használja. Kísérletbővítményi módszerek használatával választhat egy másik, a forgatókönyvnek leginkább megfelelő hangolót.

A tuner beállításához használja az alábbi módszereket:

A rácsos keresőhangoló használatához például a kód a következőhöz hasonlóan nézhet ki:

experiment.SetGridSearchTuner();

Kísérletfigyelés konfigurálása

A kísérlet előrehaladásának figyelésének leggyorsabb módja az esemény MLContextmeghatározása.Log Az Log esemény azonban nyers memóriaképet ad ki az AutoML által az egyes próbaverziók során létrehozott naplókról. A nagy mennyiségű formázatlan információ miatt nehéz.

Az ellenőrzöttebb figyelési élmény érdekében implementáljon egy osztályt a IMonitor felülettel.

public class AutoMLMonitor : IMonitor
{
    private readonly SweepablePipeline _pipeline;

    public AutoMLMonitor(SweepablePipeline pipeline)
    {
        _pipeline = pipeline;
    }

    public IEnumerable<TrialResult> GetCompletedTrials() => _completedTrials;

    public void ReportBestTrial(TrialResult result)
    {
        return;
    }

    public void ReportCompletedTrial(TrialResult result)
    {
        var trialId = result.TrialSettings.TrialId;
        var timeToTrain = result.DurationInMilliseconds;
        var pipeline = _pipeline.ToString(result.TrialSettings.Parameter);
        Console.WriteLine($"Trial {trialId} finished training in {timeToTrain}ms with pipeline {pipeline}");
    }

    public void ReportFailTrial(TrialSettings settings, Exception exception = null)
    {
        if (exception.Message.Contains("Operation was canceled."))
        {
            Console.WriteLine($"{settings.TrialId} cancelled. Time budget exceeded.");
        }
        Console.WriteLine($"{settings.TrialId} failed with exception {exception.Message}");
    }

    public void ReportRunningTrial(TrialSettings setting)
    {
        return;
    }
}

A IMonitor felület négy életciklus-eseményből áll:

Tipp.

Bár ez nem kötelező, vegye fel a SweepablePipeline monitorba, hogy megvizsgálhassa a próbaverzióhoz létrehozott folyamatot a Parameter tulajdonság használatával TrialSettings.

Ebben a példában csak az ReportCompletedTrial és ReportFailTrial implementálva van.

Miután implementálta a monitort, állítsa be a kísérletkonfiguráció SetMonitorrészeként.

var monitor = new AutoMLMonitor(pipeline);
experiment.SetMonitor(monitor);

Ezután futtassa a kísérletet:

var cts = new CancellationTokenSource();
TrialResult experimentResults = await experiment.RunAsync(cts.Token);

Ha ezzel a megvalósítással futtatja a kísérletet, a kimenetnek a következőhöz hasonlóan kell kinéznie:

Trial 0 finished training in 5835ms with pipeline ReplaceMissingValues=>OneHotEncoding=>Concatenate=>FastForestRegression
Trial 1 finished training in 15080ms with pipeline ReplaceMissingValues=>OneHotEncoding=>Concatenate=>SdcaRegression
Trial 2 finished training in 3941ms with pipeline ReplaceMissingValues=>OneHotHashEncoding=>Concatenate=>FastTreeRegression

Próbaverziók megőrzése

Alapértelmezés szerint az AutoML csak a TrialResult legjobb modellt tárolja. Ha azonban meg szeretné őrizni az egyes kísérleteket, ezt a monitoron belül teheti meg.

A monitoron belül:

  1. Adjon meg egy tulajdonságot a befejezett próbaverziókhoz, és adjon meg egy hozzáférési módot.

    private readonly List<TrialResult> _completedTrials;

public IEnumerable<TrialResult> GetCompletedTrials() => _completedTrials;

  2. Inicializálása a konstruktorban

    public AutoMLMonitor(SweepablePipeline pipeline)
{
    //...
    _completedTrials = new List<TrialResult>();
    //...
}

  3. Fűzze hozzá az egyes próbaeredményeket az ReportCompletedTrial életciklus-metódushoz.

    public void ReportCompletedTrial(TrialResult result)
{
    //...
    _completedTrials.Add(result);
}

  4. Amikor a betanítás befejeződik, az összes befejezett próbaidőszakot elérheti a GetCompletedTrials

    var completedTrials = monitor.GetCompletedTrials();

Ezen a ponton további feldolgozást végezhet a befejezett próbaverziók gyűjtésén. Kiválaszthatja például az AutoML által kiválasztotttól eltérő modellt, naplózhatja a próbaeredményeket egy adatbázisba, vagy újraépítheti a folyamatot bármelyik befejezett próbaidőszakból.

Kísérletek megszakítása

Ha aszinkron módon futtat kísérleteket, győződjön meg arról, hogy teljesen leállítja a folyamatot. Ehhez használjon egy CancellationToken.

Figyelmeztetés

A kísérlet megszakítása nem menti a köztes kimeneteket. Állítson be egy ellenőrzőpontot a közbenső kimenetek mentéséhez.

var cts = new CancellationTokenSource();
TrialResult experimentResults = await experiment.RunAsync(cts.Token);

Ellenőrzőpontok beállítása

Az ellenőrzőpontok lehetővé teszik a közbenső kimenetek mentését a betanítási folyamatból korai leállás vagy hiba esetén. Az ellenőrzőpont beállításához használja a SetCheckpoint bővítménymetódust, és adjon meg egy könyvtárat a közbenső kimenetek tárolásához.

var checkpointPath = Path.Join(Directory.GetCurrentDirectory(), "automl");
experiment.SetCheckpoint(checkpointPath);

A funkció fontosságának meghatározása

Mivel a gépi tanulás a mindennapi élet több aspektusába, például az egészségügybe kerül, rendkívül fontos megérteni, hogy egy gépi tanulási modell miért hozza meg a döntéseket. A permutációs funkció fontossága (PFI) a besorolási, rangsorolási és regressziós modellek magyarázatára szolgáló technika. Magas szinten úgy működik, hogy véletlenszerűen összeadja az adatokat egyszerre egy funkcióval a teljes adatkészlethez, és kiszámítja, hogy mennyivel csökken az érdeklődési kör metrikája. Minél nagyobb a változás, annál fontosabb a funkció. A PFI-ről további információt a modellelőjelzések permutációs funkció fontosságát használó értelmezése című témakörben talál.

Feljegyzés

A PFI kiszámítása időigényes művelet lehet. A számításhoz szükséges idő arányos a szolgáltatásoszlopok számával. Minél több funkció, annál hosszabb ideig tart a PFI futtatása.

A funkció fontosságának meghatározása az AutoML használatával:

  1. Szerezze be a legjobb modellt.

    var bestModel = expResult.Model;

  2. Alkalmazza a modellt az adathalmazra.

    var transformedData = bestModel.Transform(trainValidationData.TrainSet);

  3. A funkció fontosságának kiszámítása a következő használatával: PermutationFeatureImportance

    Ebben az esetben a tevékenység regressziós, de ugyanez a fogalom vonatkozik más tevékenységekre, például a rangsorolásra és a besorolásra.

    var pfiResults = 
    mlContext.Regression.PermutationFeatureImportance(bestModel, transformedData, permutationCount:3);

  4. A szolgáltatás fontossága a kiértékelési metrikák módosításával.

    var featureImportance = 
    pfiResults.Select(x => Tuple.Create(x.Key, x.Value.Regression.RSquared))
        .OrderByDescending(x => x.Item2);