private void InitParallelTraining()
{
Options = LightGbmTrainerOptions.ToDictionary(Host);
ParallelTraining = LightGbmTrainerOptions.ParallelTrainer != null?LightGbmTrainerOptions.ParallelTrainer.CreateComponent(Host) : new SingleTrainer();
if (ParallelTraining.ParallelType() != "serial" && ParallelTraining.NumMachines() > 1)
{
Options["tree_learner"] = ParallelTraining.ParallelType();
var otherParams = ParallelTraining.AdditionalParams();
if (otherParams != null)
{
foreach (var pair in otherParams)
{
Options[pair.Key] = pair.Value;
}
}
Contracts.CheckValue(ParallelTraining.GetReduceScatterFunction(), nameof(ParallelTraining.GetReduceScatterFunction));
Contracts.CheckValue(ParallelTraining.GetAllgatherFunction(), nameof(ParallelTraining.GetAllgatherFunction));
LightGbmInterfaceUtils.Check(WrappedLightGbmInterface.NetworkInitWithFunctions(
ParallelTraining.NumMachines(),
ParallelTraining.Rank(),
ParallelTraining.GetReduceScatterFunction(),
ParallelTraining.GetAllgatherFunction()
));
}
}
public ParallelNode(DocumentIdNode documentIdNode, IParallel parallel) : base(documentIdNode, GetChildNodes(initial: null, parallel.States, parallel.HistoryStates))
{
_parallel = parallel;
var id = parallel.Id ?? new IdentifierNode(Identifier.New());
var transitions = parallel.Transitions.AsArrayOf <ITransition, TransitionNode>(true);
var invokeList = parallel.Invoke.AsArrayOf <IInvoke, InvokeNode>(true);
Id = id;
States = parallel.States.AsArrayOf <IStateEntity, StateEntityNode>();
HistoryStates = parallel.HistoryStates.AsArrayOf <IHistory, HistoryNode>(true);
Transitions = transitions;
OnEntry = parallel.OnEntry.AsArrayOf <IOnEntry, OnEntryNode>(true);
OnExit = parallel.OnExit.AsArrayOf <IOnExit, OnExitNode>(true);
Invoke = invokeList;
DataModel = parallel.DataModel?.As <DataModelNode>();
foreach (var transition in transitions)
{
transition.SetSource(this);
}
foreach (var invoke in invokeList)
{
invoke.SetStateId(id);
}
}
protected BoolListPropertyPanel AddParallelProperty(IParallel parallelStyle, UIComponent parent)
{
var parallelProperty = ComponentPool.Get <BoolListPropertyPanel>(parent, nameof(parallelStyle.Parallel));
parallelProperty.Text = Localize.StyleOption_ParallelToLanes;
parallelProperty.Init(Localize.StyleOption_No, Localize.StyleOption_Yes);
parallelProperty.SelectedObject = parallelStyle.Parallel;
parallelProperty.OnSelectObjectChanged += (value) => parallelStyle.Parallel.Value = value;
return(parallelProperty);
}
private protected LightGbmTrainerBase(IHostEnvironment env, LightGbmArguments args, string name)
: base(env, name)
{
Host.CheckValue(args, nameof(args));
Args = args;
Options = Args.ToDictionary(Host);
ParallelTraining = Args.ParallelTrainer != null?Args.ParallelTrainer.CreateComponent(env) : new SingleTrainer();
InitParallelTraining();
}
/// <summary>
/// Initializes this instance.
/// </summary>
///
protected void Init(TExtractor detector, TClustering algorithm)
{
this.Clustering = algorithm;
this.Detector = detector;
IParallel p = algorithm as IParallel;
if (p != null)
{
this.ParallelOptions = p.ParallelOptions;
}
}
protected LightGbmTrainerBase(IHostEnvironment env, LightGbmArguments args, PredictionKind predictionKind, string name)
{
Contracts.CheckValue(env, nameof(env));
env.CheckNonWhiteSpace(name, nameof(name));
Host = env.Register(name);
Host.CheckValue(args, nameof(args));
Args = args;
Options = Args.ToDictionary(Host);
_predictionKind = predictionKind;
_env = env;
ParallelTraining = Args.ParallelTrainer != null?Args.ParallelTrainer.CreateComponent(env) : new SingleTrainer();
InitParallelTraining();
}
public override void DoTraining(DocumentSetCaseCollectionSet trainingSet, classifierTools tools, ILogBuilder logger)
{
var state = states.SetState(trainingSet, GetExperimentSufix());
if (isMultinominal)
{
NaiveBayesLearning <GeneralizedBetaDistribution> teacher = new NaiveBayesLearning <GeneralizedBetaDistribution>();
// Set options for the component distributions
teacher.Options.InnerOption = new NormalOptions
{
Regularization = 1e-5 // to avoid zero variances
};
// The following line is only needed to ensure reproducible results. Please remove it to enable full parallelization
teacher.ParallelOptions.MaxDegreeOfParallelism = 1; // (Remove, comment, or change this line to enable full parallelism)
_teacher = teacher;
// Learn a machine
// state.machine = teacher.Learn(state.data.inputs, state.data.outputs);
}
else
{
NaiveBayesLearning <NormalDistribution> teacher = new NaiveBayesLearning <NormalDistribution>();
// Set options for the component distributions
teacher.Options.InnerOption = new NormalOptions
{
Regularization = 1e-5 // to avoid zero variances
};
// The following line is only needed to ensure reproducible results. Please remove it to enable full parallelization
teacher.ParallelOptions.MaxDegreeOfParallelism = 1; // (Remove, comment, or change this line to enable full parallelism)
_teacher = teacher;
// Learn a machine
state.machine = teacher.Learn(state.data.inputs, state.data.outputs);
}
state.SaveState();
}
/// <summary>
/// Creates a new <see cref="GridSearch{TModel, TRange, TLearner, TInput, TOutput}"/> combined with
/// <see cref="CrossValidation{TModel, TInput, TOutput}"/> algorithms.
/// </summary>
///
/// <typeparam name="TModel">The type of the machine learning model whose parameters should be searched.</typeparam>
/// <typeparam name="TLearner">The type of the learning algorithm used to learn <typeparamref name="TModel"/>.</typeparam>
///
/// <param name="ranges">The range of parameters to consider during search.</param>
/// <param name="learner">A function that can create a <typeparamref name="TModel"/> given training parameters.</param>
/// <param name="loss">A function that can measure how far model predictions are from the expected ground-truth.</param>
/// <param name="fit">A function that specifies how to create a new model using the teacher learning algorirhm.</param>
/// <param name="folds">The number of folds in the k-fold cross-validation. Default is 10.</param>
///
/// <example>
/// <code source="Unit Tests\Accord.Tests.MachineLearning\GridSearchTest.cs" region="doc_learn_strongly_typed" />
/// </example>
///
/// <returns>A grid-search algorithm that has been configured with the given parameters.</returns>
///
public static GridSearch <CrossValidationResult <TModel, TInput, TOutput>, CrossValidation <TModel, TInput, TOutput>, TInput, TOutput> CrossValidate <TModel, TLearner>(
GridSearchRange[] ranges,
Func <GridSearchParameterCollection, DataSubset <TInput, TOutput>, TLearner> learner,
ComputeLoss <TOutput, TModel> loss,
LearnNewModel <TLearner, TInput, TOutput, TModel> fit, // necessary to auto-detect TModel,
int folds = 10)
where TModel : class, ITransform <TInput, TOutput>
where TLearner : ISupervisedLearning <TModel, TInput, TOutput>
{
GridSearch <CrossValidationResult <TModel, TInput, TOutput>, CrossValidation <TModel, TInput, TOutput>, TInput, TOutput> gs = null;
gs = Create <CrossValidationResult <TModel, TInput, TOutput>, CrossValidation <TModel, TInput, TOutput> >(ranges,
learner: (p) => new CrossValidation <TModel, TInput, TOutput>()
{
K = folds,
Learner = (ss) => learner(p, ss),
Fit = (teacher, x, y, w) => fit((TLearner)teacher, x, y, w), // necessary to auto-detect TModel
Loss = (expected, actual, r) => loss(expected, actual, r.Model),
},
fit: (teacher, x, y, w) =>
{
IParallel parallel = teacher as IParallel;
if (teacher != null)
{
parallel.ParallelOptions = gs.ParallelOptions;
}
return(teacher.Learn(x, y, w));
},
loss: (actual, expected, model) => model.Validation.Mean
);
return(gs);
}
