public void Run()
{
Evaluate();
var req = new TrainRequest();
for (var g = 0; g < 1000; g++)
{
var timer = Stopwatch.StartNew();
//Parallel.For(0, 8, (i) =>
for (var i = 0; i < 8; i++)
{
Console.WriteLine("Starting game " + i);
var p0Samples = new List <TrainSample>();
var p1Samples = new List <TrainSample>();
var state = new SimulationState(SimulationHelpers.GetRandomPieces(), 0);
state.Fidelity = SimulationFidelity.NoPiecePlacing;
while (!state.GameHasEnded)
{
var sampleSet = state.ActivePlayer == 0 ? p0Samples : p1Samples;
var sample = _ai.MakeMoveWithResult(state);
sampleSet.Add(sample);
}
//Set the winner on the samples from the winner
var winningSamples = state.WinningPlayer == 0 ? p0Samples : p1Samples;
for (var j = 0; j < winningSamples.Count; j++)
{
winningSamples[j].IsWin = true;
}
//TODO: AddRange is terrible performance
lock (req)
{
req.Samples.AddRange(p0Samples);
req.Samples.AddRange(p1Samples);
}
} //);
timer.Stop();
Console.WriteLine("Took " + timer.ElapsedMilliseconds);
//if (req.Samples.Count >= 256)
{
Console.WriteLine("Training " + req.Samples.Count);
_client.Train(req);
req.Samples.Clear();
Evaluate();
}
}
Console.WriteLine("Hi");
Console.ReadLine();
}
/// <summary>
/// Trains a model from a collection of custom forms in a blob storage container.
/// </summary>
/// <param name="trainingFilesUri">An externally accessible Azure storage blob container Uri.
/// For more information see <a href="https://docs.microsoft.com/azure/cognitive-services/form-recognizer/build-training-data-set#upload-your-training-data"/>.</param>
/// <param name="useTrainingLabels">If <c>true</c>, use a label file created in the <link-to-label-tool-doc> to provide training-time labels for training a model. If <c>false</c>, the model will be trained from forms only.</param>
/// <param name="trainingOptions">A set of options available for configuring the training request.</param>
/// <param name="cancellationToken">A <see cref="CancellationToken"/> controlling the request lifetime.</param>
/// <returns>
/// <para>A <see cref="TrainingOperation"/> to wait on this long-running operation. Its Value upon successful
/// completion will contain meta-data about the trained model.</para>
/// <para>Even if training fails, a model is created in the Form Recognizer account with an "invalid" status.
/// A <see cref="RequestFailedException"/> will be raised containing the modelId to access this invalid model.</para>
/// </returns>
public virtual async Task <TrainingOperation> StartTrainingAsync(Uri trainingFilesUri, bool useTrainingLabels, TrainingOptions trainingOptions = default, CancellationToken cancellationToken = default)
{
Argument.AssertNotNull(trainingFilesUri, nameof(trainingFilesUri));
trainingOptions ??= new TrainingOptions();
using DiagnosticScope scope = Diagnostics.CreateScope($"{nameof(FormTrainingClient)}.{nameof(StartTraining)}");
scope.Start();
try
{
var trainRequest = new TrainRequest(trainingFilesUri.AbsoluteUri)
{
SourceFilter = trainingOptions.TrainingFileFilter,
UseLabelFile = useTrainingLabels,
ModelName = trainingOptions.ModelName
};
ResponseWithHeaders <FormRecognizerTrainCustomModelAsyncHeaders> response = await ServiceClient.TrainCustomModelAsyncAsync(trainRequest).ConfigureAwait(false);
return(new TrainingOperation(response.Headers.Location, ServiceClient, Diagnostics));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public async Task <IActionResult> TrainAndSaveModel([FromBody] TrainRequest trainModel)
{
var dateString = DateTime.Now.ToString("dd_MM_yyyy_HHmm");
// @"../CodeGen.MLNET/Data/heart-dataset.csv", "../CodeGen.MLNET/Data/heart-model-"+ dateString + ".zip",',');
var model = await MachineLearningCore.TrainAndSaveModel <HeartData, HeartPrediction>(trainModel);
return(Ok(true));
}
private void DownloadTrainProblems(IEnumerable <Problem> problems)
{
foreach (Problem problem in problems.Where(p => p.Size > 3).Shuffle())
{
var trainRequest = new TrainRequest(problem.Size, problem.FoldOperators);
TrainResponse trainProblem = webApi.Train(trainRequest);
Source.SaveTrainProblem(trainProblem, problem);
}
}
/// <summary>
/// Train and Save model by TrainRequest obj.
/// </summary>
/// <typeparam name="TData"></typeparam>
/// <typeparam name="TPrediction"></typeparam>
/// <param name="request"></param>
/// <returns></returns>
public static async Task <bool> TrainAndSaveModel <TData, TPrediction>(TrainRequest request) where TData : class where TPrediction : class, new()
{
if (File.Exists(request.ModelFilePath))
{
File.Delete(request.ModelFilePath);
}
var model = await CreateModelWithPipeline <TData, TPrediction>(request);
await model.WriteAsync(request.ModelFilePath);
return(true);
}
public TrainResponse Train(TrainProblemType trainProblemType = TrainProblemType.Any, int?size = null)
{
var request = new TrainRequest(size);
switch (trainProblemType)
{
case TrainProblemType.Any:
request.operators = null;
break;
case TrainProblemType.Simple:
request.operators = new string[0];
break;
case TrainProblemType.Fold:
request.operators = new[] { "fold" };
break;
case TrainProblemType.Tfold:
request.operators = new[] { "tfold" };
break;
case TrainProblemType.Bonus42:
request.size = 42;
break;
case TrainProblemType.Bonus137:
request.size = 137;
break;
default:
throw new ArgumentOutOfRangeException("trainProblemType");
}
var response = webApi.Train(request);
return(response);
}
/// <summary>
/// Trains a model from a collection of custom forms in a blob storage container.
/// </summary>
/// <param name="trainingFilesUri">An externally accessible Azure storage blob container Uri.
/// For more information see <a href="https://docs.microsoft.com/azure/cognitive-services/form-recognizer/build-training-data-set#upload-your-training-data"/>.</param>
/// <param name="useTrainingLabels">If <c>true</c>, use a label file created in the <link-to-label-tool-doc> to provide training-time labels for training a model. If <c>false</c>, the model will be trained from forms only.</param>
/// <param name="trainingFileFilter">Filter to apply to the documents in the source path for training.</param>
/// <param name="cancellationToken">A <see cref="CancellationToken"/> controlling the request lifetime.</param>
/// <returns>
/// <para>A <see cref="TrainingOperation"/> to wait on this long-running operation. Its <see cref="TrainingOperation.Value"/> upon successful
/// completion will contain meta-data about the trained model.</para>
/// <para>Even if training fails, a model is created in the Form Recognizer account with an "invalid" status.
/// A <see cref="RequestFailedException"/> will be raised containing the modelId to access this invalid model.</para>
/// </returns>
public virtual TrainingOperation StartTraining(Uri trainingFilesUri, bool useTrainingLabels, TrainingFileFilter trainingFileFilter = default, CancellationToken cancellationToken = default)
{
Argument.AssertNotNull(trainingFilesUri, nameof(trainingFilesUri));
using DiagnosticScope scope = Diagnostics.CreateScope($"{nameof(FormTrainingClient)}.{nameof(StartTraining)}");
scope.Start();
try
{
var trainRequest = new TrainRequest(trainingFilesUri.AbsoluteUri)
{
SourceFilter = trainingFileFilter, UseLabelFile = useTrainingLabels
};
ResponseWithHeaders <ServiceTrainCustomModelAsyncHeaders> response = ServiceClient.TrainCustomModelAsync(trainRequest);
return(new TrainingOperation(response.Headers.Location, ServiceClient, Diagnostics));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
/// <summary>
/// Create the pipeline with data send in request
/// </summary>
/// <typeparam name="TData"></typeparam>
/// <typeparam name="TPrediction"></typeparam>
/// <param name="request"></param>
/// <returns></returns>
private static async Task <PredictionModel> CreateModelWithPipeline <TData, TPrediction>(TrainRequest request) where TData : class where TPrediction : class, new()
{
List <string> properties = GetPropertiesFromDataSetByType <TData>();
try
{
// Pipeline build.
var learningPipeline = new LearningPipeline
{
new TextLoader(request.FilePath).CreateFrom <TData>(useHeader: request.UseHeader, separator: request.Separator),
new ColumnConcatenator("Features", properties.ToArray()),
request.Algorythm,
};
var model = learningPipeline.Train <TData, TPrediction>();
return(model);
}
catch (Exception ex)
{
return(null);
}
}
/// <summary>
/// Train Model
/// </summary>
/// <remarks>
/// Create and train a custom model. The train request must include a source
/// parameter that is either an externally accessible Azure Storage blob
/// container Uri (preferably a Shared Access Signature Uri) or valid path to a
/// data folder in a locally mounted drive. When local paths are specified,
/// they must follow the Linux/Unix path format and be an absolute path rooted
/// to the input mount configuration
/// setting value e.g., if '{Mounts:Input}' configuration setting value is
/// '/input' then a valid source path would be '/input/contosodataset'. All
/// data to be trained is expected to be directly under the source folder.
/// Subfolders are not supported. Models are trained using documents that are
/// of the following content type - 'application/pdf', 'image/jpeg' and
/// 'image/png'."
/// Other type of content is ignored.
/// </remarks>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='trainRequest'>
/// Request object for training.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <TrainResult> TrainCustomModelAsync(this IFormRecognizerClient operations, TrainRequest trainRequest, CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.TrainCustomModelWithHttpMessagesAsync(trainRequest, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
private static async Task checkRequestsAsyncHelper()
{
IEnumerable <Request> requests = AppDataManager.RetrieveRequests();
int addedForRequests = 0;
try
{
foreach (Request req in requests)
{
bool found = false;
TrainRequest trainReq = new TrainRequest()
{
from = req.from,
to = req.to,
date = req.depDateFrame.since,
time = req.depTimeFrame.since,
roundTrip = false
};
TrainResponse trainResp;
try
{
trainResp = Factory.Instance.getTrainResponse(
await Requests.makeRequestAsync(Requests.TRAIN_URL, trainReq.getParameters()));
}
catch (Exception) { continue; }
foreach (Train train in trainResp.Trains)
{
int available = 0;
foreach (CoachType type in train.CoachTypes)
{
try
{
CoachResponse coachResp = Factory.Instance.getCoachResponse(
await Requests.makeRequestAsync(Requests.COACH_URL, train.getParameters(type, false)));
foreach (Coach coach in coachResp.Wrapper.Coaches)
{
CarriageResponse carResp = Factory.Instance.getCarriageResponse(
await Requests.makeRequestAsync(Requests.CARRIAGE_URL, train.getParameters(coach)));
available += countAvailavle(req, train, type, coach, carResp.Value.Places);
}
}
catch (Exception) { }
}
if (!req.available.ContainsKey(train.Number))
{
req.available[train.Number] = 0;
}
if (available > req.available[train.Number] + 1)
{
Notification.SendToast(
"З'явилось " + (available - req.available[train.Number]) + " місць",
train.Number + " " + req.from.Name + " - " + req.to.Name + ", " + train.From.Date,
DateTimeOffset.Now.AddSeconds(15),
"UZTracer.TrainPage?" + JsonConvert.SerializeObject(train));
found = true;
}
req.available[train.Number] = available;
}
addedForRequests += found ? 1 : 0;
}
}
catch (Exception) { }
finally
{
Notification.UpdateBadge(addedForRequests);
AppDataManager.SaveRequests(requests);
}
}
void Train(TrainRequest req, Func <bool> cancelled)
{
TrainerCommon.Train(Database, new ObjectId(req.MixtureId), TrainingSet, req.Chromosome, cancelled);
}
public TrainReply Train(TrainRequest request)
{
return(Train(request, null));
}
void Handle(TrainRequest req)
{
TrainerCommon.Train(Database, new ObjectId(req.MixtureId), TrainingSet, req.Chromosome);
}
