示例#1
0
    public PredictRequestTS GetPredict(string predictorId, [Required, FromBody] Dictionary <string, object?> mainKeys)
    {
        var p = Lite.ParsePrimaryKey <PredictorEntity>(predictorId);

        PredictorPredictContext pctx = PredictorPredictLogic.GetPredictContext(p);

        PredictDictionary?fromEntity      = mainKeys == null ? null : pctx.GetInputsFromParentKeys(pctx.ParseMainKeys(mainKeys));
        PredictDictionary inputs          = fromEntity ?? pctx.GetInputsEmpty();
        PredictDictionary?originalOutputs = fromEntity;

        PredictDictionary predictedOutputs = inputs.PredictBasic();

        PredictRequestTS pmodel = pctx.CreatePredictModel(inputs, originalOutputs, predictedOutputs);

        return(pmodel);
    }
示例#2
0
    public PredictRequestTS UpdatePredict([Required, FromBody] PredictRequestTS request)
    {
        PredictorPredictContext pctx = PredictorPredictLogic.GetPredictContext(request.predictor);

        PredictDictionary inputs = pctx.GetInputsFromRequest(request);

        if (request.alternativesCount != null)
        {
            inputs.Options = new PredictionOptions {
                AlternativeCount = request.alternativesCount
            }
        }
        ;

        PredictDictionary predictedOutputs = inputs.PredictBasic();

        request.SetOutput(predictedOutputs);

        return(request);
    }
示例#3
0
        public static PredictDictionary GetInputsFromRequest(this PredictorPredictContext pctx, PredictRequestTS request)
        {
            ParseValues(request, pctx);

            return(new PredictDictionary(pctx.Predictor, null, null)
            {
                MainQueryValues = pctx.Predictor.MainQuery.Columns
                                  .Select((col, i) => new { col, request.columns[i].value })
                                  .Where(a => a.col !.Usage == PredictorColumnUsage.Input)
                                  .Select(a => KeyValuePair.Create(a.col !, (object?)a.value))
                                  .ToDictionaryEx(),

                SubQueries = pctx.Predictor.SubQueries.Select(sq =>
                {
                    var sqt = request.subQueries.Single(a => a.subQuery.Is(sq));
                    SplitColumns(sq, out var splitKeys, out var values);

                    return new PredictSubQueryDictionary(sq)
                    {
                        SubQueryGroups = sqt.rows.Select(array => KeyValuePair.Create(
                                                             array.Slice(0, splitKeys.Count),
                                                             values.Select((a, i) => KeyValuePair.Create(a, array[splitKeys.Count + i])).ToDictionary()
                                                             )).ToDictionary(ObjectArrayComparer.Instance)
                    };
                }).ToDictionaryEx(a => a.SubQuery)
            });