ML.NET使用动态类创建预测引擎 [英] ML.NET Create Prediction Engine using Dynamic Class

问题描述

我有一个ML.NET应用程序，必须在编译后动态创建接口IDataView，以用于培训.我发现了这个线程，我已经能够成功地为训练数据集创建一个动态界面，然后将其用于训练模型.当我尝试使用相同的界面以使用经过训练的模型创建预测时，就会出现我的问题.显示的文档应该创建一个预测引擎，在其中必须定义输入和输出类类型以创建引擎.像这样:

I have an ML.NET application where I have to create interface IDataView dynamically after compile time to be used for training. I found this thread and I've been able to successfully create a dynamic interface for the training data set and then use it to train a model. My problem comes in when I try to use that same interface in order to create a prediction using that trained model. The docs show that you should create a prediction engine where you have to define both the input and output class types in order to create the engine. Something like:

mlContext.Model.CreatePredictionEngine<TSrc,TDst>(ITransformer, DataViewSchema)

其中 TSrc 和 TDst 是在编译时已知的类类型.我的问题是，在编译时我不知道输入类类型的结构，因此必须为输入数据源创建动态接口.因为参数已知，所以可以定义输出类对象，但是我不确定如何进行动态输入.

where TSrc and TDst are class types that are known at compile time. My problem is that I don't know the structure of the input class type at compile time and have to create a dynamic interface for the input data source. The output class object can be defined since the parameters are known, but I'm unsure how to proceed with a dynamic input.

我以为我可以尝试在接口上使用类似 GetType()的方法，但是它说隐式变量不能有多个声明符".我的简化示例如下:

I thought I could maybe try to use something like GetType() on the interface but it says that "implicitly-typed variables cannot have multiple declarators". My simplified example looks like this:

public class ModelOutput
{
    public string PredictedLabel { get; set; }
    public float[] Score { get; set; }
}

public class MakePrediction
{
    protected void Solve(IDataView data, ITransformer model)
    {
        var mlContext = new MLContext();
        var engine = mlContext.Model.CreatePredictionEngine<data.GetType(), ModelOutput>(model, data.Schema);
    }
}

推荐答案

可以生成一个运行时类，该类具有DataViewSchema中列出的所有字段.这将使您可以创建PredictionEngine.

It's possible to generate a runtime class that has all the fields listed in the DataViewSchema. This will allow you to create a PredictionEngine.

您将无法直接创建PredictionEngine，必须调用它.这是一些示例代码:

You won't be able to create the PredictionEngine directly, you'll have to invoke it. Here is some sample code:

        // Create runtime type from fields and types in a DataViewSchema
        var runtimeType = ClassFactory.CreateType(dataViewSchema);

        dynamic dynamicPredictionEngine;
        var genericPredictionMethod = mlContext.Model.GetType().GetMethod("CreatePredictionEngine", new[] { typeof(ITransformer), typeof(DataViewSchema) });
        var predictionMethod = genericPredictionMethod.MakeGenericMethod(runtimeType, typeof(PricePrediction));
        dynamicPredictionEngine = predictionMethod.Invoke(mlContext.Model, new object[] { model, dataViewSchema });

要实际使用PredictionEngine(dynamicPredictionEngine)，请使用类似于以下的调用:

To actually use the PredictionEngine (dynamicPredictionEngine), use a call similar to this:

var predictMethod = dynamicPredictionEngine.GetType().GetMethod("Predict", new[] { runtimeType });
var predict = predictMethod.Invoke(dynamicPredictionEngine, new[] { inputObject });

我使用了创建运行时类的绝佳示例.我的副本接受DataViewSchema以自动生成require类.该代码如下:

I used modified copy (ClassFactory above) of the source from this wonderful example of creating runtime classes. My copy accepts a DataViewSchema to auto generate the requires class. That code is below:

using Microsoft.ML;
using System;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;

public static class ClassFactory
{
    private static AssemblyName _assemblyName;

    public static object CreateObject(string[] PropertyNames, Type[] Types)
    {
        _assemblyName = new AssemblyName("DynamicInput");

        if (PropertyNames.Length != Types.Length)
        {
            Console.WriteLine("The number of property names should match their corresponding types number");
        }

        TypeBuilder DynamicClass = CreateTypeBuilder();
        CreateConstructor(DynamicClass);
        for (int ind = 0; ind < PropertyNames.Count(); ind++)
            CreateProperty(DynamicClass, PropertyNames[ind], Types[ind]);
        Type type = DynamicClass.CreateType();

        return Activator.CreateInstance(type);
    }

    public static Type CreateType(DataViewSchema dataViewSchema)
    {
        _assemblyName = new AssemblyName("DynamicInput");

        TypeBuilder DynamicClass = CreateTypeBuilder();
        CreateConstructor(DynamicClass);
        foreach (var item in dataViewSchema)
        {
            CreateProperty(DynamicClass, item.Name, item.Type.RawType);
        }

        return DynamicClass.CreateType(); 
    }

    private static TypeBuilder CreateTypeBuilder()
    {
        AssemblyBuilder assemblyBuilder = AssemblyBuilder.DefineDynamicAssembly(_assemblyName, AssemblyBuilderAccess.Run);
        ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule("MainModule");
        TypeBuilder typeBuilder = moduleBuilder.DefineType(_assemblyName.FullName
                            , TypeAttributes.Public |
                            TypeAttributes.Class |
                            TypeAttributes.AutoClass |
                            TypeAttributes.AnsiClass |
                            TypeAttributes.BeforeFieldInit |
                            TypeAttributes.AutoLayout
                            , null);
        return typeBuilder;
    }

    private static void CreateConstructor(TypeBuilder typeBuilder)
    {
        typeBuilder.DefineDefaultConstructor(MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName);
    }

    private static void CreateProperty(TypeBuilder typeBuilder, string propertyName, Type propertyType)
    {
        FieldBuilder fieldBuilder = typeBuilder.DefineField("_" + propertyName, propertyType, FieldAttributes.Private);

        PropertyBuilder propertyBuilder = typeBuilder.DefineProperty(propertyName, PropertyAttributes.HasDefault, propertyType, null);
        MethodBuilder getPropMthdBldr = typeBuilder.DefineMethod("get_" + propertyName, MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig, propertyType, Type.EmptyTypes);
        ILGenerator getIl = getPropMthdBldr.GetILGenerator();

        getIl.Emit(OpCodes.Ldarg_0);
        getIl.Emit(OpCodes.Ldfld, fieldBuilder);
        getIl.Emit(OpCodes.Ret);

        MethodBuilder setPropMthdBldr = typeBuilder.DefineMethod("set_" + propertyName,
              MethodAttributes.Public |
              MethodAttributes.SpecialName |
              MethodAttributes.HideBySig,
              null, new[] { propertyType });

        ILGenerator setIl = setPropMthdBldr.GetILGenerator();
        Label modifyProperty = setIl.DefineLabel();
        Label exitSet = setIl.DefineLabel();

        setIl.MarkLabel(modifyProperty);
        setIl.Emit(OpCodes.Ldarg_0);
        setIl.Emit(OpCodes.Ldarg_1);
        setIl.Emit(OpCodes.Stfld, fieldBuilder);

        setIl.Emit(OpCodes.Nop);
        setIl.MarkLabel(exitSet);
        setIl.Emit(OpCodes.Ret);

        propertyBuilder.SetGetMethod(getPropMthdBldr);
        propertyBuilder.SetSetMethod(setPropMthdBldr);
    }
}

这篇关于ML.NET使用动态类创建预测引擎的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！