/// <summary>
/// Gets or sets the blender.
/// </summary>
/// <value>
/// The blender.
/// </value>
//public DocumentBlenderFunction blender { get; set; } = new DocumentBlenderFunction();
/// <summary>
/// Prepares everything for operation
/// </summary>
/// <param name="settings">The settings.</param>
/// <param name="logger">The logger.</param>
public void DeploySettings(EntityPlaneMethodSettings settings, ToolkitExperimentNotes _notes, ILogBuilder logger)
{
DeploySettingsBase(_notes);
settings.cachePath = imbACE.Core.appManager.Application.folder_cache.path + Path.DirectorySeparatorChar + "BEC"; //.Add("BEC", "BEC", "Cached content for BEC experiments").path;
SetSetupSignature(settings);
render.instructions = new System.Collections.Generic.List <DocumentRenderInstruction>();
render.instructions.AddRange(settings.instructions);
if (settings.filterLimit > 0)
{
filter.function = TypeProviders.InputDocumentFunctions.GetInstance(settings.filterFunctionName);
filter.limit = settings.filterLimit;
filter.IsEnabled = true;
}
else
{
filter.IsEnabled = false;
}
// blender.options = settings.blenderOptions;
// Describe(_notes);
CloseDeploySettingsBase();
}
/// <summary>
/// Deploys the folder.
/// </summary>
/// <param name="folds">The folds.</param>
/// <param name="setup">The setup.</param>
/// <param name="_notes">The notes.</param>
public void DeployFolder(IList <ExperimentDataSetFold> folds, T setup, ToolkitExperimentNotes _notes)
{
name = _notes.folder.name;
notes = _notes;
if (folds is ExperimentDataSetFolds experiment_folds)
{
completeFold = experiment_folds.dataset;
}
CacheProvider.Deploy(imbACE.Core.appManager.Application.folder_cache.Add(name, name, "CacheFolder"));
Int32 i = 0;
foreach (ExperimentDataSetFold fold in folds)
{
TP procedure = new TP();
procedure.index = i;
procedure.SetCacheProvider(CacheProvider);
procedure.name += setup.OutputFilename;
procedure.Deploy(setup.CloneViaXML(_notes), fold, _notes);
Add(procedure);
i++;
}
procedureForFinalStep = new TP();
procedureForFinalStep.index = -1;
procedureForFinalStep.name += setup.OutputFilename;
procedureForFinalStep.IsFinalStepInstance = true;
procedureForFinalStep.Deploy(setup, completeFold, notes);
}
/// <summary>
/// Prepares everything for operation
/// </summary>
/// <param name="settings">The settings.</param>
/// <param name="logger">The logger.</param>
public void DeploySettings(IPlaneSettings settings, ToolkitExperimentNotes _notes, ILogBuilder logger)
{
DeploySettingsBase(_notes);
SetSetupSignature(settings);
EntityPlaneMethodSettings entitySettings = (EntityPlaneMethodSettings)settings;
render.instructions = new System.Collections.Generic.List <DocumentRenderInstruction>();
render.instructions.AddRange(entitySettings.instructions);
if (entitySettings.filterLimit > 0)
{
filter.function = TypeProviders.InputDocumentFunctions.GetInstance(entitySettings.filterFunctionName);
filter.limit = entitySettings.filterLimit;
filter.IsEnabled = true;
}
else
{
filter.IsEnabled = false;
}
blender.options = entitySettings.blenderOptions;
if (notes != null)
{
entitySettings.Describe(notes);
render.Describe(notes);
filter.Describe(notes);
blender.Describe(notes);
}
CloseDeploySettingsBase();
}
/// <summary>
/// Initializes a new instance of the <see cref="ProceduralFolderFor{TP, T, TCMAIN, TCEXTRA}"/> class.
/// </summary>
/// <param name="folds">The folds.</param>
/// <param name="setup">The setup.</param>
/// <param name="_notes">The notes.</param>
public ProceduralFolderFor(IList <ExperimentDataSetFold> folds, T setup, ToolkitExperimentNotes _notes, IAceOperationSetExecutor __executor)
{
executor = __executor;
DeployFolder(folds, setup, _notes);
#if DEBUG
EnableParallel = false;
#endif
}
public void DeploySettingsBase(ToolkitExperimentNotes _notes)
{
notes = _notes;
name = this.GetType().Name.Replace("MethodDesign", "");
if (notes != null)
{
notes.AppendLine(name + " Settings");
notes.nextTabLevel();
}
}
/// <summary>
/// Prepares everything for operation
/// </summary>
/// <param name="settings">The settings.</param>
/// <param name="_notes">The notes.</param>
/// <param name="logger">The logger.</param>
public void DeploySettings(FeaturePlaneMethodSettings featureSettings, ToolkitExperimentNotes _notes, ILogBuilder logger)
{
DeploySettingsBase(_notes);
classifier = featureSettings.classifierSettings.GetClassifier();
featureSettings.Describe(notes);
classifier.Describe(notes);
CloseDeploySettingsBase();
}
public void DeploySettings(IPlaneSettings settings, ToolkitExperimentNotes _notes, ILogBuilder logger)
{
DeploySettingsBase(_notes);
VectorPlaneMethodSettings vectorPlaneSettings = (VectorPlaneMethodSettings)settings;
// constructorSettings = vectorPlaneSettings.constructor;
if (notes != null)
{
vectorPlaneSettings.Describe(notes);
}
CloseDeploySettingsBase();
}
public void DeploySettings(IPlaneSettings settings, ToolkitExperimentNotes _notes, ILogBuilder logger)
{
DeploySettingsBase(_notes);
PlanesMethodSettings mainSettings = (PlanesMethodSettings)settings;
EntityMethod.DeploySettings(mainSettings.entityMethod, notes, logger);
CorpusMethod.DeploySettings(mainSettings.corpusMethod, notes, logger);
VectorMethod.DeploySettings(mainSettings.vectorMethod, notes, logger);
FeatureMethod.DeploySettings(mainSettings.featureMethod, notes, logger);
CacheProvider.Deploy(new System.IO.DirectoryInfo(mainSettings.cachePath));
EntityMethod.CacheProvider = CacheProvider;
CorpusMethod.CacheProvider = CacheProvider;
VectorMethod.CacheProvider = CacheProvider;
FeatureMethod.CacheProvider = CacheProvider;
CloseDeploySettingsBase();
}
public void Deploy(T _setup, ExperimentDataSetFold _fold, ToolkitExperimentNotes _notes)
{
setup = _setup;
fold = _fold;
notes = _notes;
if (!IsFinalStepInstance)
{
fold_notes = fold.StartNote(_notes, name);
notes = fold_notes;
}
else
{
fold_notes = notes;
}
DeployCustom();
}
/// <summary>
/// Prepares everything for operation
/// </summary>
/// <param name="settings">The settings.</param>
/// <param name="_notes">The notes.</param>
/// <param name="logger">The logger.</param>
public void DeploySettings(IPlaneSettings settings, ToolkitExperimentNotes _notes, ILogBuilder logger)
{
DeploySettingsBase(_notes);
CorpusPlaneMethodSettings corpusSettings = settings as CorpusPlaneMethodSettings;
stemmer = TypeProviders.stemmerTypes.GetInstance(corpusSettings.stemmer);
tokenizer = TypeProviders.tokenizerTypes.GetInstance(corpusSettings.tokenizer);
if (!corpusSettings.transliterationRuleSetId.isNullOrEmpty())
{
transliteration = Transliteration.ruleSet.transliteration.GetTransliterationPairSet(corpusSettings.transliterationRuleSetId);
}
filter = corpusSettings.filter;
// filter.limit = corpusSettings.filterLimit;
filter.Deploy(logger);
weightModel = corpusSettings.weightModel;
weightModel.Deploy(logger);
corpusSettings.Describe(notes);
CloseDeploySettingsBase();
}
/// <summary>
/// Prepares everything for operation
/// </summary>
/// <param name="settings">The settings.</param>
/// <param name="_notes">The notes.</param>
/// <param name="logger">The logger.</param>
public void DeploySettings(CorpusPlaneMethodSettings corpusSettings, FeatureVectorConstructorSettings __constructorSettings, ToolkitExperimentNotes _notes, ILogBuilder logger)
{
DeploySettingsBase(_notes);
stemmer = TypeProviders.stemmerTypes.GetInstance(corpusSettings.stemmer);
tokenizer = TypeProviders.tokenizerTypes.GetInstance(corpusSettings.tokenizer);
if (!corpusSettings.transliterationRuleSetId.isNullOrEmpty())
{
transliteration = Transliteration.ruleSet.transliteration.GetTransliterationPairSet(corpusSettings.transliterationRuleSetId);
}
filter = corpusSettings.filter.CloneViaXML(logger);
filter.Deploy(logger);
filter.Describe(logger);
blender = corpusSettings.blender.CloneViaXML(logger);
blender.Describe(logger);
weightModel = corpusSettings.WeightModel.CloneViaXML(logger);
weightModel.Deploy(logger);
weightModel.Describe(logger);
if (__constructorSettings != null)
{
constructorSettings = __constructorSettings.CloneViaXML(logger);
}
// Describe(_notes);
CloseDeploySettingsBase();
}
/// <summary>
/// Initializes a new instance of the <see cref="OperationCorpusEngine"/> class.
/// </summary>
/// <param name="settings">The settings.</param>
/// <param name="_notes">The notes.</param>
/// <param name="logger">The logger.</param>
public OperationCorpusEngine(CorpusPlaneMethodSettings corpusSettings, FeatureVectorConstructorSettings __constructorSettings, ToolkitExperimentNotes _notes, ILogBuilder logger)
{
DeploySettings(corpusSettings, __constructorSettings, _notes, logger);
}
protected ProcedureBaseFor(T _setup, ExperimentDataSetFold _fold, ToolkitExperimentNotes _notes)
{
Deploy(_setup, _fold, _notes);
}
/// <summary>
/// Analysises the specified notes.
/// </summary>
/// <param name="notes">The notes.</param>
public void Analysis(ToolkitExperimentNotes notes)
{
folderNode folder = notes.folder_corpus;
Analysis(folder, notes);
}
public OperationClassificationEngine(FeaturePlaneMethodSettings featureSettings, ToolkitExperimentNotes _notes, ILogBuilder logger)
{
DeploySettings(featureSettings, _notes, logger);
}
void IProceduralFolderFor.DeployFolder <T1>(ExperimentDataSetFold _completeFold, IList <ExperimentDataSetFold> folds, T1 setup, ToolkitExperimentNotes _notes)
{
completeFold = _completeFold;
notes = _notes;
DeployFolder(folds, setup as T, _notes);
}
public OperationEntityEngine(EntityPlaneMethodSettings settings, ToolkitExperimentNotes _notes, ILogBuilder logger)
{
DeploySettings(settings, _notes, logger);
}
