Bagikan melalui

Cara menggunakan API Pembelajaran Mesin Otomatis (AutoML) ML.NET

Dalam artikel ini, Anda mempelajari cara menggunakan ML.NET Automated ML (AutoML API).

Sampel untuk API AutoML dapat ditemukan di repositori dotnet/machinelearning-samples .

Penginstalan

Untuk menggunakan API AutoML, instal Microsoft.ML.AutoML paket NuGet di proyek .NET tempat Anda ingin mereferensikannya.

Catatan

Panduan ini menggunakan paket NuGet versi 0.20.0 dan yang lebih baru Microsoft.ML.AutoML . Meskipun sampel dan kode dari versi sebelumnya masih berfungsi, sangat disarankan Anda menggunakan API yang diperkenalkan dalam versi ini untuk proyek baru.

Untuk informasi selengkapnya tentang menginstal paket NuGet, lihat panduan berikut:

Mulai Cepat

AutoML menyediakan beberapa default untuk melatih model pembelajaran mesin dengan cepat. Di bagian ini Anda akan mempelajari cara:

  • Memuat data Anda
  • Tentukan alur Anda
  • Konfigurasikan percobaan Anda
  • Jalankan eksperimen Anda
  • Gunakan model terbaik untuk membuat prediksi

Tentukan masalah Anda

Mengingat himpunan data yang disimpan dalam file yang dipisahkan koma yang disebut taxi-fare-train.csv yang terlihat seperti berikut ini:

vendor_id rate_code passenger_count trip_time_in_secs trip_distance payment_type fare_amount
CMT 1 1 1271 3.8 CRD 17.5
CMT 1 1 474 1.5 CRD 8
CMT 1 1 637 1.4 CRD 8.5

Memuat data Anda

Mulailah dengan menginisialisasi MLContext. MLContext adalah titik awal untuk semua operasi ML.NET. Menginisialisasi mlContext membuat lingkungan ML.NET baru yang dapat dibagikan di seluruh objek alur kerja pembuatan model. Ini mirip, secara konseptual, hingga DBContext di Entity Framework.

Kemudian, untuk memuat data Anda, gunakan metode .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 memuat beberapa baris dari himpunan data. Kemudian memeriksa data dan mencoba menebak atau menyimpulkan jenis data untuk setiap kolom berdasarkan kontennya.

Perilaku defaultnya adalah mengelompokkan kolom dengan jenis yang sama ke dalam vektor fitur atau array yang berisi elemen untuk masing-masing kolom individual. Pengaturan groupColumns untuk false mengambil alih perilaku default tersebut dan hanya melakukan inferensi kolom tanpa mengelompokkan kolom. Dengan memisahkan kolom, memungkinkan Anda menerapkan transformasi data yang berbeda saat melakukan praproses data di tingkat kolom individual daripada pengelompokan kolom.

Hasilnya InferColumns adalah ColumnInferenceResults objek yang berisi opsi yang diperlukan untuk membuat TextLoader serta informasi kolom.

Untuk himpunan data sampel di taxi-fare-train.csv, informasi kolom mungkin terlihat seperti berikut ini:

Setelah Anda memiliki informasi kolom, gunakan yang TextLoader.Options ditentukan oleh ColumnInferenceResults untuk membuat TextLoader untuk memuat data Anda ke dalam IDataView.

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

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

Seringkali praktik yang baik untuk membagi data Anda menjadi kumpulan pelatihan dan validasi. Gunakan TrainTestSplit untuk membuat pelatihan 80% dan pemisahan validasi 20% dari himpunan data Anda.

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

Tentukan alur Anda

Alur Anda menentukan langkah-langkah pemrosesan data dan alur pembelajaran mesin yang akan digunakan untuk melatih model Anda.

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

A SweepablePipeline adalah kumpulan SweepableEstimator. adalah SweepableEstimator ML.NET Estimator dengan SearchSpace.

Featurizer adalah API kenyamanan yang membangun alur estimator yang dapat disapu pemrosesan data berdasarkan informasi kolom yang Anda berikan. Alih-alih membangun alur dari awal, Featurizer mengotomatiskan langkah pra-pemrosesan data. Untuk informasi selengkapnya tentang transformasi yang didukung oleh ML.NET, lihat panduan transformasi data.

Output Featurizer adalah kolom tunggal yang berisi vektor fitur numerik yang mewakili data yang diubah untuk setiap kolom. Vektor fitur ini kemudian digunakan sebagai input untuk algoritma yang digunakan untuk melatih model pembelajaran mesin.

Jika Anda ingin kontrol yang lebih baik atas pra-pemrosesan data, Anda dapat membuat alur dengan setiap langkah pra-pemrosesan individual. Untuk informasi selengkapnya, lihat panduan menyiapkan data untuk membangun model.

Tip

Gunakan Featurizer dengan ColumnInferenceResults untuk memaksimalkan utilitas AutoML.

Untuk pelatihan, AutoML menyediakan alur yang dapat disapu dengan pelatih default dan konfigurasi ruang pencarian untuk tugas pembelajaran mesin berikut:

Untuk masalah prediksi tarif taksi, karena tujuannya adalah untuk memprediksi nilai numerik, gunakan Regression. Untuk informasi selengkapnya tentang memilih tugas, lihat Tugas pembelajaran mesin di ML.NET.

Konfigurasikan percobaan Anda

Pertama, buat eksperimen AutoML. AutoMLExperiment Adalah kumpulan TrialResult.

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

Setelah eksperimen Anda dibuat, gunakan metode ekstensi yang disediakannya untuk mengonfigurasi pengaturan yang berbeda.

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

Dalam contoh ini, Anda:

  • Atur alur yang dapat disapu untuk dijalankan selama eksperimen dengan memanggil SetPipeline.
  • Pilih RSquared sebagai metrik untuk dioptimalkan selama pelatihan dengan memanggil SetRegressionMetric. Untuk informasi selengkapnya tentang metrik evaluasi, lihat mengevaluasi model ML.NET Anda dengan panduan metrik .
  • Atur 60 detik sebagai jumlah waktu yang ingin Anda latih dengan memanggil SetTrainingTimeInSeconds. Heuristik yang baik untuk menentukan berapa lama untuk melatih adalah ukuran data Anda. Biasanya, himpunan data yang lebih besar memerlukan waktu pelatihan yang lebih lama. Untuk informasi selengkapnya, lihat panduan waktu pelatihan.
  • Berikan himpunan data pelatihan dan validasi untuk digunakan dengan memanggil SetDataset.

Setelah eksperimen ditentukan, Anda akan menginginkan beberapa cara untuk melacak kemajuannya. Cara tercepat untuk melacak kemajuan adalah dengan memodifikasi Log peristiwa dari MLContext.

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

Jalankan eksperimen Anda

Sekarang setelah Anda menentukan eksperimen Anda, gunakan RunAsync metode untuk memulai eksperimen Anda.

TrialResult experimentResults = await experiment.RunAsync();

Setelah waktu untuk melatih kedaluwarsa, hasilnya adalah untuk model terbaik yang TrialResult ditemukan selama pelatihan.

Pada titik ini, Anda dapat menyimpan model Anda atau menggunakannya untuk membuat prediksi. Untuk informasi selengkapnya tentang cara menggunakan model ML.NET, lihat panduan berikut:

Mengubah hasil inferensi kolom

Karena InferColumns hanya memuat subset data Anda, ada kemungkinan bahwa kasus edge yang terkandung di luar sampel yang digunakan untuk menyimpulkan kolom tidak tertangkap dan jenis data yang salah diatur untuk kolom Anda. Anda dapat memperbarui properti untuk ColumnInformation memperhitungkan kasus-kasus di mana hasil inferensi kolom tidak benar.

Misalnya, dalam himpunan data tarif taksi, data di rate_code kolom adalah angka. Namun, nilai numerik tersebut mewakili kategori. Secara default, panggilan InferColumns akan dilakukan rate_code di properti alih-alih NumericColumnNamesCategoricalColumnNames. Karena properti ini adalah koleksi .NET, Anda dapat menggunakan operasi standar untuk menambahkan dan menghapus item darinya.

Anda dapat melakukan hal berikut untuk memperbarui ColumnInformation untuk rate_code.

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

Mengecualikan pelatih

Secara default, AutoML mencoba beberapa pelatih sebagai bagian dari proses pelatihan untuk melihat mana yang paling sesuai untuk data Anda. Namun, sepanjang proses pelatihan Anda mungkin menemukan ada beberapa pelatih yang menggunakan terlalu banyak sumber daya komputasi atau tidak memberikan metrik evaluasi yang baik. Anda memiliki opsi untuk mengecualikan pelatih dari proses pelatihan. Pelatih mana yang digunakan tergantung pada tugas. Untuk daftar pelatih yang didukung di ML.NET, lihat Tugas pembelajaran mesin di panduan ML.NET.

Misalnya, dalam skenario regresi tarif taksi, untuk mengecualikan algoritma LightGBM, atur useLgbm parameter ke false.

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

Proses untuk mengecualikan pelatih dalam tugas lain seperti klasifikasi biner dan multikelas bekerja dengan cara yang sama.

Menyesuaikan estimator yang dapat dibersihkan

Ketika Anda ingin kustomisasi opsi estimator yang lebih terperinci disertakan sebagai bagian dari alur yang dapat dibersihkan, Anda perlu:

  1. Menginisialisasi ruang pencarian
  2. Menggunakan ruang pencarian untuk menentukan pabrik kustom
  3. Membuat estimator yang dapat dibersihkan
  4. Tambahkan estimator yang dapat dibersihkan ke alur yang dapat dibersihkan

AutoML menyediakan serangkaian ruang pencarian yang telah dikonfigurasi sebelumnya untuk pelatih dalam tugas pembelajaran mesin berikut:

Dalam contoh ini, ruang pencarian yang digunakan adalah untuk SdcaRegressionTrainer. Inisialisasi dengan menggunakan SdcaOption.

var sdcaSearchSpace = new SearchSpace<SdcaOption>();

Kemudian, gunakan ruang pencarian untuk menentukan metode pabrik kustom untuk membuat SdcaRegressionTrainer. Dalam contoh ini, nilai L1Regularization dan L2Regularization keduanya diatur ke sesuatu selain default. Untuk L1Regularization, kumpulan nilai ditentukan oleh tuner selama setiap uji coba. L2Regularization diperbaiki untuk setiap percobaan ke nilai yang dikodekan secara permanen. Selama setiap percobaan, output pabrik kustom adalah dengan hiperparameter yang SdcaRegressionTrainer dikonfigurasi.

// 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);
};

Estimator yang dapat dibersihkan adalah kombinasi estimator dan ruang pencarian. Sekarang setelah Anda menentukan ruang pencarian dan menggunakannya untuk membuat metode pabrik kustom untuk menghasilkan pelatih, gunakan CreateSweepableEstimator metode untuk membuat estimator baru yang dapat disapu.

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

Untuk menggunakan estimator yang dapat dibersihkan dalam eksperimen Anda, tambahkan ke alur yang dapat dibersihkan.

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

Karena alur yang dapat disapu adalah kumpulan estimator yang dapat dibersihkan, Anda dapat mengonfigurasi dan menyesuaikan sebanyak mungkin estimator yang dapat dibersihkan ini sesuai kebutuhan Anda.

Mengkustomisasi ruang pencarian Anda

Ada skenario di mana Anda ingin melampaui penyesuaian estimator yang dapat disapu yang digunakan dalam eksperimen Anda dan ingin mengontrol rentang ruang pencarian. Anda dapat melakukannya dengan mengakses properti ruang pencarian menggunakan kunci. Dalam hal ini, L1Regularization parameternya adalah float. Oleh karena itu, untuk menyesuaikan rentang pencarian, gunakan UniformSingleOption.

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

Bergantung pada jenis data hiperparameter yang ingin Anda atur, Anda bisa memilih dari opsi berikut:

Ruang pencarian juga dapat berisi ruang pencarian berlapis.

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;

Opsi lain untuk menyesuaikan rentang pencarian adalah dengan memperluasnya. Misalnya, SdcaOption hanya menyediakan L1Regularization parameter dan L2Regularization . Namun, SdcaRegressionTrainer memiliki lebih banyak parameter yang dapat Anda atur seperti BiasLearningRate.

Untuk memperluas ruang pencarian, buat kelas baru, seperti SdcaExtendedOption, yang mewarisi dari SdcaOption.

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

Untuk menentukan rentang ruang pencarian, gunakan RangeAttribute, yang setara dengan Microsoft.ML.SearchSpace.Option.

Kemudian, di mana saja Anda menggunakan ruang pencarian Anda, referensikan alih-alih SdcaExtendedOptionSdcaOption.

Misalnya, saat menginisialisasi ruang pencarian, Anda dapat melakukannya sebagai berikut:

var sdcaSearchSpace = new SearchSpace<SdcaExtendedOption>();

Membuat runner uji coba Anda sendiri

Secara default, AutoML mendukung klasifikasi biner, klasifikasi multikelas, dan regresi. Namun, ML.NET mendukung lebih banyak skenario seperti:

  • Rekomendasi
  • Prakiraan
  • Peringkat teratas
  • Klasifikasi gambar
  • Klasifikasi teks
  • Kesamaan kalimat

Untuk skenario yang tidak memiliki ruang pencarian yang telah dikonfigurasi sebelumnya dan estimator yang dapat disapu, Anda dapat membuat sendiri dan menggunakan runner uji coba untuk mengaktifkan AutoML untuk skenario tersebut.

Misalnya, data ulasan restoran yang diberikan terlihat seperti berikut ini:

Wow... Menyukai tempat ini.

1

Kerak tidak baik.

0

Anda ingin menggunakan TextClassificationTrainer pelatih untuk menganalisis sentimen di mana 0 negatif dan 1 positif. Namun, tidak ctx.Auto().TextClassification() ada konfigurasi.

Untuk menggunakan AutoML dengan pelatih klasifikasi teks, Anda harus:

  1. Buat ruang pencarian Anda sendiri.

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

    Dalam hal ini, AutoML akan mencari konfigurasi hyperparameter yang BatchSize berbeda.

  2. Buat estimator yang dapat dibersihkan dan tambahkan ke alur Anda.

    // 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);

    Dalam contoh ini, TCOption ruang pencarian dan pabrik kustom TextClassificationTrainer digunakan untuk membuat estimator yang dapat disapu.

  3. Membuat runner uji coba kustom

    Untuk membuat runner uji coba kustom, terapkan ITrialRunner:

    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(),
        };
    }
}

    Implementasi TCRunner dalam contoh ini:

    • Mengekstrak hiperparameter yang dipilih untuk uji coba tersebut
    • Menggunakan hyperparameter untuk membuat alur ML.NET
    • Menggunakan alur ML.NET untuk melatih model
    • Mengevaluasi model
    • Mengembalikan TrialResult objek dengan informasi untuk uji coba tersebut

  4. Menginisialisasi runner uji coba kustom Anda

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

  5. Buat dan konfigurasikan eksperimen Anda. SetTrialRunner Gunakan metode ekstensi untuk menambahkan runner uji coba kustom Anda ke eksperimen Anda.

    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. Jalankan eksperimen Anda

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

Pilih penyetel yang berbeda

AutoML mendukung berbagai algoritma penyetelan untuk melakukan iterasi melalui ruang pencarian untuk mencari hiperparameter optimal. Secara default, ia menggunakan tuner Eci Cost Frugal. Dengan menggunakan metode ekstensi eksperimen, Anda dapat memilih tuner lain yang paling sesuai dengan skenario Anda.

Gunakan metode berikut untuk mengatur tuner Anda:

Misalnya, untuk menggunakan penyetel pencarian kisi, kode Anda mungkin terlihat seperti berikut:

experiment.SetGridSearchTuner();

Mengonfigurasi pemantauan eksperimen

Cara tercepat untuk memantau kemajuan eksperimen adalah dengan menentukan Log peristiwa dari MLContext. Namun, peristiwa menghasilkan Log cadangan mentah log yang dihasilkan oleh AutoML selama setiap uji coba. Karena banyaknya informasi yang tidak diformat, sulit.

Untuk pengalaman pemantauan yang lebih terkontrol, terapkan kelas dengan IMonitor antarmuka.

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;
    }
}

Antarmuka IMonitor memiliki empat peristiwa siklus hidup:

Tip

Meskipun tidak diperlukan, sertakan SweepablePipeline dalam monitor Anda sehingga Anda dapat memeriksa alur yang dihasilkan untuk uji coba menggunakan Parameter properti .TrialSettings

Dalam contoh ini, hanya ReportCompletedTrial dan ReportFailTrial yang diimplementasikan.

Setelah Anda menerapkan monitor, atur sebagai bagian dari konfigurasi eksperimen Anda menggunakan SetMonitor.

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

Kemudian, jalankan eksperimen Anda:

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

Saat Anda menjalankan eksperimen dengan implementasi ini, output akan terlihat mirip dengan yang berikut ini:

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

Pertahankan uji coba

Secara default, AutoML hanya menyimpan TrialResult untuk model terbaik. Namun, jika Anda ingin mempertahankan setiap uji coba, Anda dapat melakukannya dari dalam monitor Anda.

Di dalam monitor Anda:

  1. Tentukan properti untuk uji coba anda yang telah selesai dan metode untuk mengaksesnya.

    private readonly List<TrialResult> _completedTrials;

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

  2. Menginisialisasinya di konstruktor Anda

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

  3. Tambahkan setiap hasil uji coba di dalam metode siklus hidup Anda ReportCompletedTrial .

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

  4. Saat pelatihan selesai, Anda dapat mengakses semua uji coba yang telah selesai dengan memanggil GetCompletedTrials

    var completedTrials = monitor.GetCompletedTrials();

Pada titik ini, Anda dapat melakukan pemrosesan tambahan pada kumpulan uji coba yang telah selesai. Misalnya, Anda dapat memilih model selain model yang dipilih oleh AutoML, mencatat hasil uji coba ke database, atau membangun kembali alur dari salah satu uji coba yang telah selesai.

Batalkan eksperimen

Saat Anda menjalankan eksperimen secara asinkron, pastikan untuk menghentikan proses dengan bersih. Untuk melakukannya, gunakan CancellationToken.

Peringatan

Membatalkan eksperimen tidak akan menyimpan salah satu output perantara. Atur titik pemeriksaan untuk menyimpan output perantara.

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

Mengatur titik pemeriksaan

Titik pemeriksaan menyediakan cara bagi Anda untuk menyimpan output perantara dari proses pelatihan jika terjadi penghentian atau kesalahan dini. Untuk mengatur titik pemeriksaan, gunakan SetCheckpoint metode ekstensi dan berikan direktori untuk menyimpan output perantara.

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

Menentukan kepentingan fitur

Karena pembelajaran mesin diperkenalkan ke dalam lebih banyak aspek kehidupan sehari-hari seperti perawatan kesehatan, sangat penting untuk memahami mengapa model pembelajaran mesin membuat keputusan yang dilakukannya. Pentingnya Fitur Permutasi (PFI) adalah teknik yang digunakan untuk menjelaskan model klasifikasi, peringkat, dan regresi. Pada tingkat tinggi, cara kerjanya adalah dengan mengacak data satu fitur secara acak pada satu waktu untuk seluruh himpunan data dan menghitung berapa banyak metrik performa minat menurun. Semakin besar perubahan, semakin penting fitur itu. Untuk informasi selengkapnya tentang PFI, lihat menginterpretasikan prediksi model menggunakan Kepentingan Fitur Permutasi.

Catatan

Menghitung PFI dapat menjadi operasi yang memakan waktu. Berapa banyak waktu yang diperlukan untuk menghitung sebanding dengan jumlah kolom fitur yang Anda miliki. Semakin banyak fitur, semakin lama PFI akan berjalan.

Untuk menentukan kepentingan fitur menggunakan AutoML:

  1. Dapatkan model terbaik.

    var bestModel = expResult.Model;

  2. Terapkan model ke himpunan data Anda.

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

  3. Menghitung kepentingan fitur menggunakan PermutationFeatureImportance

    Dalam hal ini, tugas adalah regresi tetapi konsep yang sama berlaku untuk tugas lain seperti peringkat dan klasifikasi.

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

  4. Mengurutkan kepentingan fitur berdasarkan perubahan pada metrik evaluasi.

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