ML.NET Otomatik Makine Öğrenmesi (AutoML) API'sini kullanma

Makale
05/10/2023

Bu makalede, ML.NET Otomatik ML'yi (AutoML API) kullanmayı öğreneceksiniz.

AutoML API örnekleri dotnet/machinelearning-samples deposunda bulunabilir.

Yükleme

AutoML API'sini kullanmak için, NuGet paketini başvurmak istediğiniz .NET projesine yükleyin Microsoft.ML.AutoML .

Not

Bu kılavuzda NuGet paketinin 0.20.0 ve sonraki sürümleri Microsoft.ML.AutoML kullanılır. Önceki sürümlerdeki örnekler ve kodlar çalışmaya devam etse de, yeni projeler için bu sürümde tanıtılan API'leri kullanmanız kesinlikle önerilir.

NuGet paketlerini yükleme hakkında daha fazla bilgi için aşağıdaki kılavuzlara bakın:

Hızlı Başlangıç

AutoML, makine öğrenmesi modellerini hızlı bir şekilde eğitmak için çeşitli varsayılanlar sağlar. Bu bölümde şunların nasıl yapılacağını öğreneceksiniz:

Verilerinizi yükleme
İşlem hattınızı tanımlama
Denemenizi yapılandırma
Denemenizi çalıştırma
Tahminde bulunmak için en iyi modeli kullanma

Sorununuzu tanımlama

Aşağıdakine benzer şekilde taxi-fare-train.csv adlı virgülle ayrılmış bir dosyada depolanan veri kümesi göz önünde bulundurulduğunda:

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

Verilerinizi yükleme

başlangıç olarak öğesini başlatın MLContext. MLContext tüm ML.NET işlemleri için bir başlangıç noktasıdır. mlContext'in başlatılması, model oluşturma iş akışı nesneleri arasında paylaşılabilen yeni bir ML.NET ortamı oluşturur. Entity Framework'tekine DBContext benzer, kavramsal olarak.

Ardından verilerinizi yüklemek için yöntemini kullanın 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 veri kümesinden birkaç satır yükler. Ardından verileri inceler ve sütunların her biri için içeriklerine göre veri türünü tahmin etmeye veya çıkarmaya çalışır.

Varsayılan davranış, aynı türdeki sütunları tek tek sütunların her biri için öğeleri içeren özellik vektörleri veya diziler halinde gruplandırmaktır. ayarı groupColumnsfalse bu varsayılan davranışı geçersiz kılar ve sütunları gruplandırmadan yalnızca sütun çıkarımı gerçekleştirir. Sütunları ayrı tutarak, verileri sütun gruplandırması yerine tek tek sütun düzeyinde ön işleme yaparken farklı veri dönüştürmeleri uygulamanıza olanak tanır.

sonucuInferColumns, sütun bilgilerinin yanı sıra oluşturmak için gereken seçenekleri içeren bir TextLoader nesnedirColumnInferenceResults.

taxi-fare-train.csv'daki örnek veri kümesi için sütun bilgileri aşağıdaki gibi görünebilir:

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

Sütun bilgilerinize sahip olduktan sonra , tarafından ColumnInferenceResults tanımlanan öğesini kullanarak TextLoader.Options verilerinizi bir IDataViewiçine yüklemek için öğesini TextLoader oluşturun.

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

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

Verilerinizi eğitmek ve doğrulama kümelerine bölmek genellikle iyi bir uygulamadır. Veri kümenizde %80 eğitim ve %20 doğrulama bölümü oluşturmak için kullanın TrainTestSplit .

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

İşlem hattınızı tanımlama

İşlem hattınız, modelinizi eğitmek için kullanılacak veri işleme adımlarını ve makine öğrenmesi işlem hattını tanımlar.

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

A SweepablePipeline , bir koleksiyonudur SweepableEstimator. ASweepableEstimator, ile SearchSpacebir ML.NETEstimator.

, Featurizer sağladığınız sütun bilgilerine göre süpürilebilir bir veri işleme tahmin aracı işlem hattı oluşturan kullanışlı bir API'dir. Sıfırdan işlem hattı oluşturmak yerine veri Featurizer ön işleme adımını otomatikleştirir. ML.NET tarafından desteklenen dönüşümler hakkında daha fazla bilgi için veri dönüştürmeleri kılavuzuna bakın.

Çıktı Featurizer , sütunların her biri için dönüştürülen verileri temsil eden sayısal bir özellik vektörü içeren tek bir sütundur. Bu özellik vektöru daha sonra bir makine öğrenmesi modelini eğitmek için kullanılan algoritmalar için giriş olarak kullanılır.

Veri ön işlemeniz üzerinde daha ayrıntılı bir denetim istiyorsanız, tek tek ön işleme adımlarının her biriyle bir işlem hattı oluşturabilirsiniz. Daha fazla bilgi için bkz . Model oluşturmak için verileri hazırlama kılavuzu.

İpucu

AutoML yardımcı programını en üst düzeye çıkarmak için ile ColumnInferenceResults kullanınFeaturizer.

Eğitim için AutoML, aşağıdaki makine öğrenmesi görevleri için varsayılan eğitmenleri ve arama alanı yapılandırmalarını içeren süpürilebilir bir işlem hattı sağlar:

Taksi ücreti tahmini sorunu için, amaç sayısal bir değer tahmin etmek olduğundan kullanın Regression. Görev seçme hakkında daha fazla bilgi için bkz . ML.NET'de makine öğrenmesi görevleri

Denemenizi yapılandırma

İlk olarak bir AutoML denemesi oluşturun. Bir AutoMLExperiment , bir koleksiyonudur TrialResult.

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

Denemeniz oluşturulduktan sonra, farklı ayarları yapılandırmak için sağladığı uzantı yöntemlerini kullanın.

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

Bu örnekte şunları yapmak için:

çağrısı SetPipelineyaparak, süpürilebilir işlem hattını deneme sırasında çalışacak şekilde ayarlayın.
öğesini çağırarak SetRegressionMetriceğitim sırasında iyileştirme yapmak için ölçüm olarak öğesini seçinRSquared. Değerlendirme ölçümleri hakkında daha fazla bilgi için ölçümlerle ML.NET modelinizi değerlendirme kılavuzuna bakın.
çağrısı SetTrainingTimeInSecondsyaparak eğitmek istediğiniz süre olarak 60 saniye ayarlayın. Ne kadar süreyle eğitileceğini belirlemek için iyi bir buluşsal özellik, verilerinizin boyutudur. Genellikle daha büyük veri kümeleri daha uzun eğitim süresi gerektirir. Daha fazla bilgi için bkz . eğitim zamanı kılavuzu.
çağrısı SetDatasetyaparak kullanılacak eğitim ve doğrulama veri kümelerini sağlayın.

Denemeniz tanımlandıktan sonra ilerleme durumunu izlemek için bir yol bulmak istersiniz. İlerleme durumunu izlemenin en hızlı yolu, olayını 'den MLContextdeğiştirmektirLog.

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

Denemenizi çalıştırma

Artık denemenizi tanımladığınıza göre, denemenizi başlatmak için yöntemini kullanın RunAsync .

TrialResult experimentResults = await experiment.RunAsync();

Eğitim süresi dolduğunda, sonuç eğitim sırasında bulunan en iyi modele yöneliktir TrialResult .

Bu noktada modelinizi kaydedebilir veya tahmin yapmak için kullanabilirsiniz. ML.NET modeli kullanma hakkında daha fazla bilgi için aşağıdaki kılavuzlara bakın:

Sütun çıkarımı sonuçlarını değiştirme

Verilerinizin yalnızca bir alt kümesini yüklediğinden InferColumns , sütunları çıkarsamak için kullanılan örneklerin dışında yer alan uç durumlarının yakalanmamış olması ve sütunlarınız için yanlış veri türlerinin ayarlanması mümkündür. Sütun çıkarımı sonuçlarının doğru olmadığı durumlarda hesaba eklemek için özelliklerini ColumnInformation güncelleştirebilirsiniz.

Örneğin, taksi ücreti veri kümesinde sütundaki rate_code veriler bir sayıdır. Ancak bu sayısal değer bir kategoriyi temsil eder. Varsayılan olarak, çağrısı InferColumns yerine özelliğine NumericColumnNamesCategoricalColumnNamesyer alırrate_code. Bu özellikler .NET koleksiyonları olduğundan, standart işlemleri kullanarak öğeleri ekleyebilir ve bunlardan kaldırabilirsiniz.

için öğesini güncelleştirmek ColumnInformation için rate_codeaşağıdakileri yapabilirsiniz.

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

Eğitmenleri dışla

Varsayılan olarak AutoML, verileriniz için en uygun eğitim eğitmenini görmek için eğitim sürecinin bir parçası olarak birden çok eğitmeni dener. Ancak, eğitim süreci boyunca çok fazla işlem kaynağı kullanan veya iyi değerlendirme ölçümleri sağlamayan bazı eğitmenler olduğunu keşfedebilirsiniz. Eğitimcileri eğitim sürecinin dışında tutma seçeneğiniz vardır. Hangi eğitmenlerin kullanıldığı göreve bağlıdır. ML.NET'da desteklenen eğitmenlerin listesi için ML.NET makine öğrenmesi görevleri kılavuzuna bakın.

Örneğin, taksi ücreti regresyon senaryosunda LightGBM algoritmasını dışlamak için parametresini useLgbm olarak falseayarlayın.

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

İkili ve çok sınıflı sınıflandırma gibi diğer görevlerde eğitmenleri dışlama işlemi aynı şekilde çalışır.

Süpürilebilir tahmin aracını özelleştirme

Süpürilebilir işlem hattınıza dahil edilen tahmin aracı seçeneklerini daha ayrıntılı özelleştirmek istediğinizde şunları yapmanız gerekir:

Arama alanı başlatma
Özel fabrika tanımlamak için arama alanını kullanma
Süpürilebilir tahmin aracı oluşturma
Süpürilebilir tahmin aracınızı süpürebilir işlem hattınıza ekleyin

AutoML, aşağıdaki makine öğrenmesi görevlerinde eğitmenler için önceden yapılandırılmış bir dizi arama alanı sağlar:

Bu örnekte, kullanılan arama alanı için SdcaRegressionTrainerkullanılır. kullanarak SdcaOptionbaşlatın.

var sdcaSearchSpace = new SearchSpace<SdcaOption>();

Ardından, arama alanını kullanarak oluşturmak SdcaRegressionTraineriçin özel bir fabrika yöntemi tanımlayın. Bu örnekte, ve L2Regularization değerlerinin L1Regularization her ikisi de varsayılan değer dışında bir değere ayarlanıyor. için L1Regularization, değer kümesi her deneme sırasında tarayıcı tarafından belirlenir. L2Regularization sabit kodlanmış değere her deneme için sabittir. Her deneme sırasında özel fabrikanın çıkışı, yapılandırılan hiper parametrelerle bir SdcaRegressionTrainer olur.

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

Süpürilebilir tahmin aracı, tahmin aracı ve arama alanının birleşimidir. Artık bir arama alanı tanımladığınıza ve eğitmen oluşturmak için özel bir fabrika yöntemi oluşturmak için kullandığınıza göre, yeni bir süpürilebilir tahmin aracı oluşturmak için yöntemini kullanın CreateSweepableEstimator .

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

Denemenizde süpürilebilir tahmin aracınızı kullanmak için süpürilebilir işlem hattınıza ekleyin.

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

Süpürilebilir işlem hatları, süpürilebilir tahmin araçları koleksiyonu olduğundan, bu süpürilebilir tahmin aracılarını gerektiği kadar yapılandırabilir ve özelleştirebilirsiniz.

Arama alanınızı özelleştirme

Denemenizde kullanılan süpürilebilir tahmin edicileri özelleştirmenin ötesine geçmek ve arama alanı aralığını denetlemek istediğiniz senaryolar vardır. Bunu yapmak için anahtarları kullanarak arama alanı özelliklerine erişebilirsiniz. Bu durumda L1Regularization parametresi bir floatolur. Bu nedenle, arama aralığını özelleştirmek için kullanın UniformSingleOption.

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

Ayarlamak istediğiniz hiper parametrenin veri türüne bağlı olarak, aşağıdaki seçenekler arasından seçim yapabilirsiniz:

Numara
Boole'lar ve dizeler
- ChoiceOption

Arama alanları iç içe arama alanları da içerebilir.

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;

Arama aralıklarını özelleştirmek için bir diğer seçenek de bunları genişletmektir. Örneğin, SdcaOption yalnızca ve L2Regularization parametrelerini sağlarL1Regularization. Ancak, SdcaRegressionTrainer gibi BiasLearningRateayarlayabileceğiniz daha fazla parametre vardır.

Arama alanını genişletmek için, öğesinden SdcaOptiondevralan gibi SdcaExtendedOptionyeni bir sınıf oluşturun.

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

Arama alanı aralığını belirtmek için, RangeAttributeile eşdeğer Microsoft.ML.SearchSpace.Optionolan kullanın.

Ardından, arama alanınızı kullandığınız her yerde yerine SdcaOptionöğesine SdcaExtendedOption başvurun.

Örneğin, arama alanınızı başlatırken bunu aşağıdaki gibi yapabilirsiniz:

var sdcaSearchSpace = new SearchSpace<SdcaExtendedOption>();

Kendi deneme çalıştırıcınızı oluşturma

AutoML varsayılan olarak ikili sınıflandırmayı, çok sınıflı sınıflandırmayı ve regresyonu destekler. Ancak ML.NET aşağıdakiler gibi çok daha fazla senaryo destekler:

Öneri
Tahmin
Derecelendirme
Resim sınıflandırması
Metin sınıflandırması
Cümle benzerliği

Önceden yapılandırılmış arama alanları ve süpürilebilir tahmin araçları olmayan senaryolar için kendi arama alanınızı oluşturabilir ve bu senaryo için AutoML'yi etkinleştirmek üzere bir deneme çalıştırıcısı kullanabilirsiniz.

Örneğin, verilen restoran gözden geçirme verileri aşağıdakine benzer:

Wow... Burayı sevdim.

Kabuk iyi değil.

Eğitmeni TextClassificationTrainer kullanarak 0'ın negatif, 1'in pozitif olduğu yaklaşımı analiz etmek istiyorsunuz. Ancak yapılandırma yoktur ctx.Auto().TextClassification() .

AutoML'yi metin sınıflandırma eğitmeniyle kullanmak için şunları kullanmanız gerekir:

Kendi arama alanınızı oluşturun.

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

Bu durumda, AutoML hiper parametrenin BatchSize farklı yapılandırmalarını arar.

Süpürebilir bir tahmin aracı oluşturun ve işlem hattınıza ekleyin.

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

Bu örnekte, TCOption süpürilebilir tahmin aracı oluşturmak için arama alanı ve özel TextClassificationTrainer bir fabrika kullanılır.

Özel deneme çalıştırıcısı oluşturma

Özel deneme çalıştırıcısı oluşturmak için uygulayın 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(),
        };
    }
}

TCRunner Bu örnekteki uygulama:

Bu deneme için seçilen hiper parametreleri ayıklar
ML.NET işlem hattı oluşturmak için hiper parametreleri kullanır
Modeli eğitmek için ML.NET işlem hattını kullanır
Modeli değerlendirir
Bu deneme için bilgileri içeren bir TrialResult nesne döndürür

Özel deneme çalıştırıcınızı başlatma

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

Denemenizi oluşturun ve yapılandırın. SetTrialRunner Denemenize özel deneme çalıştırıcınızı eklemek için uzantı yöntemini kullanın.

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

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

Denemenizi çalıştırma

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

Farklı bir tarayıcı seçin

AutoML, en uygun hiper parametre aramasında arama alanında yineleme yapmak için çeşitli ayarlama algoritmalarını destekler. Varsayılan olarak, Eci Maliyet Frugal tarayıcısını kullanır. Deneme uzantısı yöntemlerini kullanarak senaryonuza en uygun başka bir tarayıcı seçebilirsiniz.

Tarayıcınızı ayarlamak için aşağıdaki yöntemleri kullanın:

SMAC - SetSmacTuner
Kılavuz Arama - SetGridSearchTuner
Rastgele Arama - SetRandomSearchTuner
Maliyet Frugal - SetCostFrugalTuner
Eci Maliyet Tutumlu - SetEciCostFrugalTuner

Örneğin, kılavuz arama tarayıcısını kullanmak için kodunuz aşağıdaki gibi görünebilir:

experiment.SetGridSearchTuner();

Deneme izlemeyi yapılandırma

Denemenin ilerleme durumunu izlemenin en hızlı yolu, 'den MLContextolayı tanımlamaktırLog. Ancak olay, Log her deneme sırasında AutoML tarafından oluşturulan günlüklerin ham dökümünü oluşturur. Büyük miktarda biçimlendirilmemiş bilgi nedeniyle bu zordur.

Daha denetimli bir izleme deneyimi için arabirimiyle IMonitor bir sınıf uygulayın.

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

Arabirimin IMonitor dört yaşam döngüsü olayı vardır:

İpucu

Gerekli olmasa da, özelliğini kullanarak bir deneme için oluşturulan işlem hattını inceleyebilmeniz için monitörünüzü monitörünüze SweepablePipeline Parameter TrialSettingsekleyin.

Bu örnekte, yalnızca ReportCompletedTrial ve ReportFailTrial uygulanır.

monitörünüzü uyguladıktan sonra kullanarak SetMonitordeneme yapılandırmanızın bir parçası olarak ayarlayın.

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

Ardından denemenizi çalıştırın:

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

Denemeyi bu uygulamayla çalıştırdığınızda, çıktı aşağıdakine benzer görünmelidir:

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

Kalıcı denemeler

Varsayılan olarak, AutoML yalnızca en iyi model için öğesini TrialResult depolar. Ancak, denemelerin her birini kalıcı hale getirmek istiyorsanız bunu monitörünüzün içinden yapabilirsiniz.

Monitörünüzün içinde:

Tamamlanmış denemeleriniz için bir özellik ve bunlara erişmek için bir yöntem tanımlayın.

private readonly List<TrialResult> _completedTrials;

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

Oluşturucunuzda başlatın

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

Her deneme sonucunu yaşam döngüsü yönteminizin ReportCompletedTrial içine ekleyin.

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

Eğitim tamamlandığında, tüm tamamlanmış denemelere arayarak erişebilirsiniz GetCompletedTrials
```
var completedTrials = monitor.GetCompletedTrials();
```

Bu noktada, tamamlanmış denemelerin koleksiyonu üzerinde ek işlem gerçekleştirebilirsiniz. Örneğin, AutoML tarafından seçilenden başka bir model seçebilir, deneme sonuçlarını bir veritabanına kaydedebilir veya tamamlanan denemelerden herhangi birinden işlem hattını yeniden oluşturabilirsiniz.

Denemeleri iptal etme

Denemeleri zaman uyumsuz olarak çalıştırdığınızda, işlemi temiz bir şekilde sonlandırdığınızdan emin olun. Bunu yapmak için kullanın CancellationToken.

Uyarı

Deneme iptal edilirken aracı çıkışların hiçbiri kaydedilmez. Aracı çıkışları kaydetmek için bir denetim noktası ayarlayın.

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

Denetim noktalarını ayarlama

Denetim noktaları, erken sonlandırma veya hata durumunda eğitim işleminden aracı çıkışları kaydetmeniz için bir yol sağlar. Denetim noktası ayarlamak için uzantı yöntemini kullanın SetCheckpoint ve aracı çıkışları depolamak için bir dizin sağlayın.

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

Özellik önemini belirleme

Makine öğrenmesi, sağlık gibi günlük yaşamın daha önemli yönlerine sunulduğundan, makine öğrenmesi modelinin aldığı kararları neden yaptığını anlamak son derece önemlidir. Permütasyon Özelliği Önemi (PFI), sınıflandırma, derecelendirme ve regresyon modellerini açıklamak için kullanılan bir tekniktir. Yüksek düzeyde, veri kümesinin tamamı için verileri bir kerede bir özelliği rastgele karıştırmak ve ilgi çekici performans ölçümünün ne kadar azaldığını hesaplamaktır. Değişiklik ne kadar büyük olursa bu özellik o kadar önemlidir. PFI hakkında daha fazla bilgi için bkz . Permütasyon Özelliği Önemini kullanarak model tahminlerini yorumlama.

Not

PFI'yi hesaplamak zaman alan bir işlem olabilir. Hesaplamanın ne kadar süreceği, sahip olduğunuz özellik sütunlarının sayısıyla orantılıdır. Ne kadar fazla özellik olursa PFI'nin çalışması o kadar uzun sürer.

AutoML kullanarak özellik önemini belirlemek için:

En iyi modeli edinin.
```
var bestModel = expResult.Model;
```

Modeli veri kümenize uygulayın.

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

kullanarak özellik önemini hesaplama PermutationFeatureImportance

Bu durumda, görev regresyondur, ancak aynı kavram derecelendirme ve sınıflandırma gibi diğer görevler için de geçerlidir.
```
var pfiResults = 
    mlContext.Regression.PermutationFeatureImportance(bestModel, transformedData, permutationCount:3);
```

Değerlendirme ölçümlerinde yapılan değişikliklere göre özellik önem derecesini sıralama.

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

Share via

ML.NET Otomatik Makine Öğrenmesi (AutoML) API'sini kullanma

Yükleme

Hızlı Başlangıç

Sorununuzu tanımlama

Verilerinizi yükleme

İşlem hattınızı tanımlama

Denemenizi yapılandırma

Denemenizi çalıştırma

Sütun çıkarımı sonuçlarını değiştirme

Eğitmenleri dışla

Süpürilebilir tahmin aracını özelleştirme

Arama alanınızı özelleştirme

Kendi deneme çalıştırıcınızı oluşturma

Farklı bir tarayıcı seçin

Deneme izlemeyi yapılandırma

Kalıcı denemeler

Denemeleri iptal etme

Denetim noktalarını ayarlama

Özellik önemini belirleme

Geri Bildirim

Ek kaynaklar