/// <summary>
        /// Gets a PredictionEngine for a named model.
        /// </summary>
        /// <param name="modelName">
        /// The name of the model which allows for uniquely identifying the model when
        /// multiple models have the same <typeparamref name="TData"/> and
        /// <typeparamref name="TPrediction"/> types.
        /// </param>
        public PredictionEngine <TData, TPrediction> GetPredictionEngine(string modelName)
        {
            if (_namedPools.TryGetValue(modelName, out var existingPool))
            {
                return(existingPool.PredictionEnginePool.Get());
            }

            //This is the case where someone has used string.Empty to get the default model.
            //We can throw all the time, but it seems reasonable that we would just do what
            //they are expecting if they know that an empty string means default.
            if (string.IsNullOrEmpty(modelName))
            {
                if (_defaultEnginePool == null)
                {
                    throw new ArgumentException("You need to configure a default, not named, model before you use this method.");
                }

                return(_defaultEnginePool.PredictionEnginePool.Get());
            }

            //Here we are in the world of named models where the model hasn't been built yet.
            var options = _predictionEngineOptions.Create(modelName);
            var pool    = new PoolLoader <TData, TPrediction>(_serviceProvider, options);

            pool = _namedPools.GetOrAdd(modelName, pool);
            return(pool.PredictionEnginePool.Get());
        }
Beispiel #2
0
        private PoolLoader <TData, TPrediction> AddPool(string modelName)
        {
            //Here we are in the world of named models where the model hasn't been built yet.
            var options = _predictionEngineOptions.Create(modelName);
            var pool    = new PoolLoader <TData, TPrediction>(_serviceProvider, options);

            pool = _namedPools.GetOrAdd(modelName, pool);
            return(pool);
        }
        public PredictionEnginePool(IServiceProvider serviceProvider,
                                    IOptions <MLOptions> mlContextOptions,
                                    IOptionsFactory <PredictionEnginePoolOptions <TData, TPrediction> > predictionEngineOptions)
        {
            _mlContextOptions        = mlContextOptions.Value;
            _predictionEngineOptions = predictionEngineOptions;
            _serviceProvider         = serviceProvider;

            var defaultOptions = _predictionEngineOptions.Create(string.Empty);

            if (defaultOptions.ModelLoader != null)
            {
                _defaultEnginePool = new PoolLoader <TData, TPrediction>(_serviceProvider, defaultOptions);
            }

            _namedPools = new ConcurrentDictionary <string, PoolLoader <TData, TPrediction> >();
        }