public ExperimentCommandHandlers(IExperimentRepository repository, IKafkaProducer kafkaProducer, IConfiguration configuration)
{
_repository = repository;
_kafkaProducer = kafkaProducer;
Configuration = configuration;
EXPERIMENT_TOPIC = Configuration["ExperimentsTopic"];
}
public ExperimentsController(IExperimentRepository experimentRepository,
IMapper mapper)
{
_experimentRepository = experimentRepository ??
throw new ArgumentNullException(nameof(experimentRepository));
_mapper = mapper ??
throw new ArgumentNullException(nameof(mapper));
}
/// <summary>
/// Ctor
/// </summary>
/// <param name="deploymentRepository"></param>
/// <param name="modelRepository"></param>
/// <param name="experimentRepository"></param>
public DeploymentCatalog(IDeploymentRepository deploymentRepository,
IModelRepository modelRepository,
IExperimentRepository experimentRepository)
{
this.deploymentRepository = deploymentRepository;
this.modelRepository = modelRepository;
this.experimentRepository = experimentRepository;
}
/// <summary>
/// Configures the builder to use a repository
/// </summary>
/// <returns>The current builder for chaining</returns>
public MLOpsBuilder UseMetaDataRepositories(IDbContextFactory contextFactory)
{
this.experimentRepository = new ExperimentRepository(contextFactory);
this.runRepository = new RunRepository(contextFactory, new Clock());
this.dataRepository = new DataRepository(contextFactory);
this.metricRepository = new MetricRepository(contextFactory);
this.confusionMatrixRepository = new ConfusionMatrixRepository(contextFactory);
this.hyperParameterRepository = new HyperParameterRepository(contextFactory);
return(this);
}
internal MLOpsContext(IModelRepository modelRepository,
IExperimentRepository experimentRepository,
IRunRepository runRepository,
IDataRepository dataRepository,
IMetricRepository metricRepository,
IConfusionMatrixRepository confusionMatrixRepository,
IHyperParameterRepository hyperParameterRepository,
IDeploymentRepository deploymentRepository)
{
if (modelRepository == null)
{
throw new ArgumentNullException(nameof(modelRepository));
}
if (experimentRepository == null)
{
throw new ArgumentNullException(nameof(experimentRepository));
}
if (runRepository == null)
{
throw new ArgumentNullException(nameof(runRepository));
}
if (dataRepository == null)
{
throw new ArgumentNullException(nameof(dataRepository));
}
if (metricRepository == null)
{
throw new ArgumentNullException(nameof(metricRepository));
}
if (confusionMatrixRepository == null)
{
throw new ArgumentNullException(nameof(confusionMatrixRepository));
}
if (hyperParameterRepository == null)
{
throw new ArgumentNullException(nameof(hyperParameterRepository));
}
if (deploymentRepository == null)
{
throw new ArgumentNullException(nameof(deploymentRepository));
}
this.LifeCycle = new LifeCycleCatalog(experimentRepository, runRepository, new Clock());
this.Data = new DataCatalog(dataRepository);
this.Evaluation = new EvaluationCatalog(metricRepository, confusionMatrixRepository);
this.Model = new ModelCatalog(modelRepository, runRepository);
this.Training = new TrainingCatalog(hyperParameterRepository);
this.Deployment = new DeploymentCatalog(deploymentRepository, modelRepository, experimentRepository);
}
/// <summary>
/// Initializes a new instance of the <see cref="ExperimentService"/> class
/// </summary>
/// <param name="experimentRepository">The experiment repository to use</param>
/// <param name="configurationRepository">The configuration repository to use</param>
public ExperimentService(IExperimentRepository experimentRepository, IConfigurationRepository configurationRepository)
{
if (experimentRepository == null)
{
throw new ArgumentNullException("Experiment Repository");
}
if (configurationRepository == null)
{
throw new ArgumentNullException("Configuration Repository");
}
this.experimentRepository = experimentRepository;
this.configurationRepository = configurationRepository;
}
/// <summary>
/// Configures the builder to use a repository
/// </summary>
/// <returns>The current builder for chaining</returns>
public MLOpsBuilder UseMetaDataRepositories(IDbContextFactory contextFactory)
{
var runResolver = new RunResolver();
var experimentResolver = new ExperimentResolver(runResolver);
this.experimentRepository = new ExperimentRepository(contextFactory, experimentResolver);
this.runRepository = new RunRepository(contextFactory, new Clock(), runResolver, new RegisteredModelResolver());
this.dataRepository = new DataRepository(contextFactory, new DataResolver(), new DataCalculator());
this.metricRepository = new MetricRepository(contextFactory);
this.confusionMatrixRepository = new ConfusionMatrixRepository(contextFactory);
this.hyperParameterRepository = new HyperParameterRepository(contextFactory);
this.deploymentRepository = new DeploymentRepository(contextFactory, new Clock(), new DeploymentTargetResolver());
return(this);
}
public ExperimentController(
IExperimentRepository experimentRepository,
IExperimentPreprocessRepository experimentPreprocessRepository,
IAquariumDataSetRepository aquariumDataSetRepository,
IDataSetRepository dataSetRepository,
IGitRepository gitRepository,
IRegistryRepository registryRepository,
ITrainingHistoryRepository trainingHistoryRepository,
ITemplateRepository templateRepository,
ITemplateVersionRepository templateVersionRepository,
ITenantRepository tenantRepository,
INodeRepository nodeRepository,
ITemplateLogic templateLogic,
ITagLogic tagLogic,
IGitLogic gitLogic,
IClusterManagementLogic clusterManagementLogic,
IDataSetLogic dataSetLogic,
IRegistryLogic registryLogic,
IUnitOfWork unitOfWork,
IInferenceHistoryRepository inferenceHistoryRepository,
ITensorBoardContainerRepository tensorBoardContainerRepository,
ITagRepository tagRepository,
IStorageLogic storageLogic,
IHttpContextAccessor accessor) : base(accessor)
{
this.trainingHistoryRepository = trainingHistoryRepository;
this.experimentRepository = experimentRepository;
this.experimentPreprocessRepository = experimentPreprocessRepository;
this.aquariumDataSetRepository = aquariumDataSetRepository;
this.dataSetRepository = dataSetRepository;
this.gitRepository = gitRepository;
this.registryRepository = registryRepository;
this.templateRepository = templateRepository;
this.templateVersionRepository = templateVersionRepository;
this.tenantRepository = tenantRepository;
this.nodeRepository = nodeRepository;
this.templateLogic = templateLogic;
this.tagLogic = tagLogic;
this.gitLogic = gitLogic;
this.clusterManagementLogic = clusterManagementLogic;
this.dataSetLogic = dataSetLogic;
this.registryLogic = registryLogic;
this.inferenceHistoryRepository = inferenceHistoryRepository;
this.tensorBoardContainerRepository = tensorBoardContainerRepository;
this.tagRepository = tagRepository;
this.storageLogic = storageLogic;
this.unitOfWork = unitOfWork;
}
/// <summary>
/// コンストラクタ
/// </summary>
public TemplateController(
IExperimentRepository experimentRepository,
IExperimentPreprocessRepository experimentPreprocessRepository,
ITemplateRepository templateRepository,
ITemplateVersionRepository templateVersionRepository,
ITemplateLogic templateLogic,
IGitLogic gitLogic,
IUnitOfWork unitOfWork,
IHttpContextAccessor accessor) : base(accessor)
{
this.experimentRepository = experimentRepository;
this.experimentPreprocessRepository = experimentPreprocessRepository;
this.templateRepository = templateRepository;
this.templateVersionRepository = templateVersionRepository;
this.templateLogic = templateLogic;
this.unitOfWork = unitOfWork;
this.gitLogic = gitLogic;
}
public AquariumDataSetController(
IAquariumDataSetRepository aquariumDataSetRepository,
IAquariumDataSetVersionRepository aquariumDataSetVersionRepository,
IExperimentRepository experimentRepository,
IExperimentPreprocessRepository experimentPreprocessRepository,
IDataSetRepository dataSetRepository,
IDataTypeRepository dataTypeRepository,
IDataSetLogic dataSetLogic,
IUnitOfWork unitOfWork,
IHttpContextAccessor accessor) : base(accessor)
{
this.aquariumDataSetRepository = aquariumDataSetRepository;
this.aquariumDataSetVersionRepository = aquariumDataSetVersionRepository;
this.experimentRepository = experimentRepository;
this.experimentPreprocessRepository = experimentPreprocessRepository;
this.dataSetRepository = dataSetRepository;
this.dataTypeRepository = dataTypeRepository;
this.dataSetLogic = dataSetLogic;
this.unitOfWork = unitOfWork;
}
public ExperimentsController(IExperimentRepository experimentRepository, ICohortRepository cohortRepository, IGoalRepository goalRepository)
{
this.experimentRepository = experimentRepository;
this.cohortRepository = cohortRepository;
this.goalRepository = goalRepository;
}
static AB()
{
ExperimentRepository = new ExperimentRepository();
}
static Experiments()
{
ExperimentRepository = new ExperimentRepository();
MetricRepository = new MetricRepository();
}
public ExperimentsController(IExperimentRepository experimentRepository, ICohortRepository cohortRepository, IGoalRepository goalRepository)
{
this.experimentRepository = experimentRepository;
this.cohortRepository = cohortRepository;
this.goalRepository = goalRepository;
}
static AB()
{
ExperimentRepository = new ExperimentRepository();
}
/// <summary>
/// ctor
/// </summary>
/// <param name="experimentRepository"></param>
/// <param name="runRepository"></param>
/// <param name="clock">Abstraction of DateTime</param>
public LifeCycleCatalog(IExperimentRepository experimentRepository, IRunRepository runRepository, IClock clock)
{
this.experimentRepository = experimentRepository;
this.runRepository = runRepository;
this.clock = clock;
}
public MeshController(IMeshService meshService, IMeshRepository meshRepository, IExperimentRepository experimentRepository)
{
MeshService = meshService;
MeshRepository = meshRepository;
ExperimentRepository = experimentRepository;
}
public AnalysisService(IExperimentRepository experimentRepository)
{
_experimentRepository = experimentRepository;
}
/// <summary>
/// Default constructor with dependencies
/// </summary>
/// <param name="repository">Experiment Repository interface dependency</param>
/// <param name="unitOfWork">UnitOfWork interface dependency</param>
public ExperimentService(IExperimentRepository repository, IUnitOfWork unitOfWork, IPatientRepository patientRepository)
{
_experimentRepository = repository;
_unitOfWork = unitOfWork;
_patientRepository = patientRepository;
}
public ExperimentController(IExperimentRepository experimentRepository)
{
_experimentRepository = experimentRepository;
}
public ExperimentService(IExperimentRepository experimentRepository, IUserRepository userRepository)
{
_experimentRepository = experimentRepository;
_userRepository = userRepository;
}
public ExperimentService(IExperimentRepository experimentRepository, IMeshRepository meshRepository, IExperimentSettingsRepository experimentSettingsRepository)
{
ExperimentRepository = experimentRepository;
MeshRepository = meshRepository;
ExperimentSettingsRepository = experimentSettingsRepository;
}
static Experiments()
{
ExperimentRepository = new ExperimentRepository();
MetricRepository = new MetricRepository();
}
public ExperimentService(IExperimentRepository experimentRepository)
{
this._experimentRepository = experimentRepository;
}
public ExperimentsController(IExperimentService experimentService, IExperimentRepository experimentRepository, IUserRepository userRepository)
{
ExperimentService = experimentService;
ExperimentRepository = experimentRepository;
UserRepository = userRepository;
}