public void TestCreation()
{
var modelRunner = new ModelRunner(continuous2vis8vec2actionModel, GetContinuous2vis8vec2actionBrainParameters());
modelRunner.Dispose();
modelRunner = new ModelRunner(discrete1vis0vec_2_3action_recurrModel, GetDiscrete1vis0vec_2_3action_recurrModelBrainParameters());
modelRunner.Dispose();
}
/// <inheritdoc />
public BarracudaPolicy(
BrainParameters brainParameters,
NNModel model,
InferenceDevice inferenceDevice)
{
var modelRunner = Academy.Instance.GetOrCreateModelRunner(model, brainParameters, inferenceDevice);
m_ModelRunner = modelRunner;
}
public void ModelRunner_FileNotExistsValidModelRun()
{
var model = new ModelRunner();
var response = model.RunModel(new ArgumentResponseItem(new List <BaseArgument>()));
Assert.IsNotNull(response);
Assert.IsFalse(response.Prediction);
}
public void TestHasModel()
{
var modelRunner = new ModelRunner(continuousONNXModel, GetContinuous2vis8vec2actionActionSpec(), InferenceDevice.CPU);
Assert.True(modelRunner.HasModel(continuousONNXModel, InferenceDevice.CPU));
Assert.False(modelRunner.HasModel(continuousONNXModel, InferenceDevice.GPU));
Assert.False(modelRunner.HasModel(discreteONNXModel, InferenceDevice.CPU));
modelRunner.Dispose();
}
// Need to detemine how the evolution engine and this class
// are to interact
// i.e. when does the evolution engine execute pest
// is it before this class is created? What time frame do
// I have before the messages are sent from the pest executable
// to processing the message here
public MessageQueueModelRunner(string outputFile, ModelRunner mr, string recordVar)
{
this.outputTimeSeriesName = recordVar;
this.outputTimeSeriesFile = outputFile;
// possibly build this up earlier (maybe pass a SimulationXml
this.modelRunner = mr;
// setup the message passing system
queues = MessageQueueHelper.GetTridentMessageQueue();
}
public void TestHasModel()
{
var modelRunner = new ModelRunner(continuous2vis8vec2actionModel, GetContinuous2vis8vec2actionBrainParameters(), InferenceDevice.CPU);
Assert.True(modelRunner.HasModel(continuous2vis8vec2actionModel, InferenceDevice.CPU));
Assert.False(modelRunner.HasModel(continuous2vis8vec2actionModel, InferenceDevice.GPU));
Assert.False(modelRunner.HasModel(discrete1vis0vec_2_3action_recurrModel, InferenceDevice.CPU));
modelRunner.Dispose();
}
/// <inheritdoc />
public BarracudaPolicy(
ActionSpec actionSpec,
NNModel model,
InferenceDevice inferenceDevice)
{
var modelRunner = Academy.Instance.GetOrCreateModelRunner(model, actionSpec, inferenceDevice);
m_ModelRunner = modelRunner;
m_ActionSpec = actionSpec;
}
/// <inheritdoc />
public BarracudaPolicy(
ActionSpec actionSpec,
NNModel model,
InferenceDevice inferenceDevice)
{
var modelRunner = Academy.Instance.GetOrCreateModelRunner(model, actionSpec, inferenceDevice);
m_ModelRunner = modelRunner;
actionSpec.CheckNotHybrid();
m_SpaceType = actionSpec.NumContinuousActions > 0 ? SpaceType.Continuous : SpaceType.Discrete;
}
/// <summary>
/// Creates or retrieves an existing ModelRunner that uses the same
/// NNModel and the InferenceDevice as provided.
/// </summary>
/// <param name="model">The NNModel the ModelRunner must use.</param>
/// <param name="actionSpec"> Description of the actions for the Agent.</param>
/// <param name="inferenceDevice">
/// The inference device (CPU or GPU) the ModelRunner will use.
/// </param>
/// <returns> The ModelRunner compatible with the input settings.</returns>
internal ModelRunner GetOrCreateModelRunner(
NNModel model, ActionSpec actionSpec, InferenceDevice inferenceDevice)
{
var modelRunner = m_ModelRunners.Find(x => x.HasModel(model, inferenceDevice));
if (modelRunner == null)
{
modelRunner = new ModelRunner(model, actionSpec, inferenceDevice, m_InferenceSeed);
m_ModelRunners.Add(modelRunner);
m_InferenceSeed++;
}
return modelRunner;
}
/// <inheritdoc />
public BarracudaPolicy(
BrainParameters brainParameters,
NNModel model,
InferenceDevice inferenceDevice)
{
var aca = Object.FindObjectOfType <Academy>();
aca.LazyInitialization();
var modelRunner = aca.GetOrCreateModelRunner(model, brainParameters, inferenceDevice);
m_ModelRunner = modelRunner;
}
public TemplateFileCreator
(
String templateFileName,
ModelRunner mr,
int precision,
String delimiter
)
{
this.fileName = templateFileName;
this.modelRunner = mr;
this.valuePrecision = precision;
this.pestDelimiter = delimiter;
}
public void ModelRunner_EXETest()
{
var model = new ModelRunner();
var argumentResponseItem = new ArgumentResponseItem(new List <BaseArgument>());
argumentResponseItem.FileNameForClassification = Path.Combine(Environment.GetEnvironmentVariable("windir") ?? string.Empty, "explorer.exe");
var response = model.RunModel(argumentResponseItem);
Assert.IsNotNull(response);
Assert.IsFalse(response.Prediction);
}
public void ModelRunner_PCAPTest()
{
var model = new ModelRunner();
var argumentResponseItem = new ArgumentResponseItem(new List <BaseArgument>());
argumentResponseItem.FileNameForClassification = Path.Combine(AppContext.BaseDirectory, @"..\..\..\Samples\pcap\benign_pcap.pcap");
var response = model.RunModel(argumentResponseItem);
Assert.IsNotNull(response);
Assert.IsFalse(response.Prediction);
}
/// <summary>
/// Creates or retrieves an existing ModelRunner that uses the same
/// NNModel and the InferenceDevice as provided.
/// </summary>
/// <param name="model"> The NNModel the ModelRunner must use </param>
/// <param name="brainParameters"> The brainParameters used to create
/// the ModelRunner </param>
/// <param name="inferenceDevice"> The inference device (CPU or GPU)
/// the ModelRunner will use </param>
/// <returns> The ModelRunner compatible with the input settings</returns>
internal ModelRunner GetOrCreateModelRunner(
NNModel model, BrainParameters brainParameters, InferenceDevice inferenceDevice)
{
var modelRunner = m_ModelRunners.Find(x => x.HasModel(model, inferenceDevice));
if (modelRunner == null)
{
modelRunner = new ModelRunner(
model, brainParameters, inferenceDevice);
m_ModelRunners.Add(modelRunner);
}
return(modelRunner);
}
/// <inheritdoc />
public BarracudaPolicy(
BrainParameters brainParameters,
NNModel model,
InferenceDevice inferenceDevice,
string behaviorName
)
{
var modelRunner = Academy.Instance.GetOrCreateModelRunner(model, brainParameters, inferenceDevice);
m_ModelRunner = modelRunner;
m_BehaviorName = behaviorName;
m_BrainParameters = brainParameters;
}
private string createPESTFiles(
IHyperCube <double> startingPoint,
String outputFolder,
TimeSeries observedTimeSeries,
string modelOutputName,
string PestToMetaheuristicsCommandLine,
ModelRunner modelRunner,
int Iterations,
string controlSettings,
out string resultFile
)
{
String templateFile;
String instructionFile;
String controlFile;
String parameterFile;
String calculatedResultFile;
createFileNames(outputFolder, out templateFile, out instructionFile, out controlFile, out parameterFile, out calculatedResultFile);
const int precision = 23;
// create the three files using the helper classes
TemplateFileCreator templateCreator = new TemplateFileCreator(templateFile, modelRunner, precision, PESTDELIMITER);
templateCreator.CreateFile();
InstructionFileCreator instructionCreator = new InstructionFileCreator(observedTimeSeries, instructionFile);
instructionCreator.CreateFile();
ControlFileCreator controlCreator =
new ControlFileCreator(
startingPoint,
PestToMetaheuristicsCommandLine,
templateFile,
parameterFile,
instructionFile,
calculatedResultFile,
modelRunner,
controlFile,
observedTimeSeries,
Iterations,
controlSettings
);
controlCreator.CreateFile();
resultFile = calculatedResultFile;
return(controlFile);
}
public void TestCreation()
{
var modelRunner = new ModelRunner(continuousONNXModel, GetContinuous2vis8vec2actionActionSpec());
modelRunner.Dispose();
modelRunner = new ModelRunner(discreteONNXModel, GetDiscrete1vis0vec_2_3action_recurrModelActionSpec());
modelRunner.Dispose();
modelRunner = new ModelRunner(hybridONNXModel, GetHybrid0vis53vec_3c_2dActionSpec());
modelRunner.Dispose();
modelRunner = new ModelRunner(continuousNNModel, GetContinuous2vis8vec2actionActionSpec());
modelRunner.Dispose();
modelRunner = new ModelRunner(discreteNNModel, GetDiscrete1vis0vec_2_3action_recurrModelActionSpec());
modelRunner.Dispose();
}
/// <summary>
/// Instantiate a BarracudaPolicy with the necessary objects for it to run.
/// </summary>
/// <param name="actionSpec">The action spec of the behavior.</param>
/// <param name="actuators">The actuators used for this behavior.</param>
/// <param name="model">The Neural Network to use.</param>
/// <param name="inferenceDevice">Which device Barracuda will run on.</param>
/// <param name="behaviorName">The name of the behavior.</param>
public BarracudaPolicy(
ActionSpec actionSpec,
IList <IActuator> actuators,
NNModel model,
InferenceDevice inferenceDevice,
string behaviorName
)
{
var modelRunner = Academy.Instance.GetOrCreateModelRunner(model, actionSpec, inferenceDevice);
m_ModelRunner = modelRunner;
m_BehaviorName = behaviorName;
m_ActionSpec = actionSpec;
m_Actuators = actuators;
}
public void TestRunModel()
{
var actionSpec = GetDiscrete1vis0vec_2_3action_recurrModelActionSpec();
var modelRunner = new ModelRunner(discrete1vis0vec_2_3action_recurrModel, actionSpec);
var info1 = new AgentInfo();
info1.episodeId = 1;
modelRunner.PutObservations(info1, new[] { sensor_21_20_3.CreateSensor() }.ToList());
var info2 = new AgentInfo();
info2.episodeId = 2;
modelRunner.PutObservations(info2, new[] { sensor_21_20_3.CreateSensor() }.ToList());
modelRunner.DecideBatch();
Assert.IsNotNull(modelRunner.GetAction(1));
Assert.IsNotNull(modelRunner.GetAction(2));
Assert.IsNull(modelRunner.GetAction(3));
Assert.AreEqual(actionSpec.NumDiscreteActions, modelRunner.GetAction(1).Count());
modelRunner.Dispose();
}
public void TestRunModel()
{
var brainParameters = GetDiscrete1vis0vec_2_3action_recurrModelBrainParameters();
var modelRunner = new ModelRunner(discrete1vis0vec_2_3action_recurrModel, brainParameters);
var info1 = new AgentInfo();
info1.episodeId = 1;
modelRunner.PutObservations(info1, new ISensor[] { sensor_21_20_3.CreateSensor() }.ToList());
var info2 = new AgentInfo();
info2.episodeId = 2;
modelRunner.PutObservations(info2, new ISensor[] { sensor_21_20_3.CreateSensor() }.ToList());
modelRunner.DecideBatch();
Assert.IsNotNull(modelRunner.GetAction(1));
Assert.IsNotNull(modelRunner.GetAction(2));
Assert.IsNull(modelRunner.GetAction(3));
Assert.AreEqual(brainParameters.vectorActionSize.Count(), modelRunner.GetAction(1).Count());
modelRunner.Dispose();
}
public void TestRunModel()
{
var actionSpec = GetDiscrete1vis0vec_2_3action_recurrModelActionSpec();
var modelRunner = new ModelRunner(discreteONNXModel, actionSpec);
var info1 = new AgentInfo();
info1.episodeId = 1;
modelRunner.PutObservations(info1, new[] { sensor_21_20_3.CreateSensor() }.ToList());
var info2 = new AgentInfo();
info2.episodeId = 2;
modelRunner.PutObservations(info2, new[] { sensor_21_20_3.CreateSensor() }.ToList());
modelRunner.DecideBatch();
Assert.IsFalse(modelRunner.GetAction(1).Equals(ActionBuffers.Empty));
Assert.IsFalse(modelRunner.GetAction(2).Equals(ActionBuffers.Empty));
Assert.IsTrue(modelRunner.GetAction(3).Equals(ActionBuffers.Empty));
Assert.AreEqual(actionSpec.NumDiscreteActions, modelRunner.GetAction(1).DiscreteActions.Length);
modelRunner.Dispose();
}
public void TestCreation()
{
var inferenceDevice = InferenceDevice.Burst;
var modelRunner = new ModelRunner(continuousONNXModel, GetContinuous2vis8vec2actionActionSpec(), inferenceDevice);
modelRunner.Dispose();
Assert.Throws <UnityAgentsException>(() =>
{
// Cannot load a model trained with 1.x that has an LSTM
modelRunner = new ModelRunner(discreteONNXModel, GetDiscrete1vis0vec_2_3action_recurrModelActionSpec(), inferenceDevice);
modelRunner.Dispose();
});
modelRunner = new ModelRunner(hybridONNXModel, GetHybrid0vis53vec_3c_2dActionSpec(), inferenceDevice);
modelRunner.Dispose();
modelRunner = new ModelRunner(continuousNNModel, GetContinuous2vis8vec2actionActionSpec(), inferenceDevice);
modelRunner.Dispose();
Assert.Throws <UnityAgentsException>(() =>
{
// Cannot load a model trained with 1.x that has an LSTM
modelRunner = new ModelRunner(discreteNNModel, GetDiscrete1vis0vec_2_3action_recurrModelActionSpec(), inferenceDevice);
modelRunner.Dispose();
});
// This one was trained with 2.0 so it should not raise an error:
modelRunner = new ModelRunner(hybridONNXModelV2, new ActionSpec(2, new[] { 2, 3 }), inferenceDevice);
modelRunner.Dispose();
// V2.0 Model that has serialized deterministic action tensors, discrete
modelRunner = new ModelRunner(deterministicDiscreteNNModel, new ActionSpec(0, new[] { 7 }), inferenceDevice);
modelRunner.Dispose();
// V2.0 Model that has serialized deterministic action tensors, continuous
modelRunner = new ModelRunner(deterministicContinuousNNModel,
GetContinuous2vis8vec2actionActionSpec(), inferenceDevice,
deterministicInference: true);
modelRunner.Dispose();
}
public PestEngine(
IObjectiveEvaluator <T> objectiveEvaluator,
IHyperCube <double> startingPoint,
ModelRunner modelRunner,
string outputFolder,
TimeSeries observationTimeSeries,
string modelOutputParameterName,
string PestToMetaheuristicsCommandLine,
int MaxNumberOfIterations,
string controlSettings = null
)
{
string resultFile;
this.evaluator = objectiveEvaluator;
this.observationData = observationTimeSeries;
this.currentGeneration = 0;
string pestFile = createPESTFiles(
startingPoint,
outputFolder,
observationTimeSeries,
modelOutputParameterName,
PestToMetaheuristicsCommandLine,
modelRunner,
MaxNumberOfIterations,
controlSettings,
out resultFile);
this.resultFileName = resultFile;
this.mr = modelRunner;
this.pestFileName = pestFile;
this.modelOutputName = modelOutputParameterName;
//Execute(modelOutputParameterName, modelRunner, resultFile, pestFile);
}
public PestObjectiveEvaluator(TimeSeries observationData, ModelRunner mr, string outputTimeSeriesName)
{
this.observedData = observationData;
this.modelRunner = mr;
this.modelOutputTimeSeriesName = outputTimeSeriesName;
}
public GridCellModel(ModelRunner modelRunner, CellDefinition cell)
{
this.modelRunner = modelRunner;
Cell = cell;
}
public static ICatchmentCellModelRunner CreateCellEvaluator(CellDefinition cellDefinition)
{
ModelRunner runner = SimulationXmlFilesRepository.BuildModelRunner(cellDefinition.ModelRunDefinition);
return(new GridCellModel(runner, cellDefinition));
}
static void Main(string[] args)
{
Console.WriteLine("ICM PREDICTION MODEL");
Console.WriteLine("=============================================");
Console.WriteLine("Preparing model...");
IUserDataProvider inMemDataProvider = new InMemoryUserDataProvider();
IDataPointFactory dataPointFactory = new DataPointFactory(inMemDataProvider);
IModel naiveBayesModel = new NaiveBayesModel();
ModelRunner runner = new ModelRunner(naiveBayesModel, dataPointFactory);
runner.Prepare();
Console.WriteLine("Model prepared");
do
{
var userData = new UserData();
Console.WriteLine("Enter Issue details: ");
Console.Write("\tIs it a partner user (y/n): ");
ConsoleKeyInfo key = Console.ReadKey();
userData.IsPartner = ConvertKeyToBool(key);
Console.WriteLine();
Console.Write("\tDoes user have profile in AAD (y/n): ");
key = Console.ReadKey();
userData.ProfileExistsInAAD = ConvertKeyToBool(key);
Console.WriteLine();
Console.Write("\tDoes user have profile in One Profile (y/n): ");
key = Console.ReadKey();
userData.ProfileExistyInOP = ConvertKeyToBool(key);
Console.WriteLine();
Console.Write("\tDoes claims exists for user (y/n): ");
key = Console.ReadKey();
userData.ClaimsExists = ConvertKeyToBool(key);
Console.WriteLine();
Console.Write("\tIs the Login Expired Windows appearing continously for the user (y/n): ");
key = Console.ReadKey();
userData.LoginExpiredMessage = ConvertKeyToBool(key);
Console.WriteLine();
Console.Write("\tDoes application insights have a lot of result code 0 logged for the user (y/n): ");
key = Console.ReadKey();
userData.ResultCodeZero = ConvertKeyToBool(key);
Console.WriteLine();
Console.Write("\tIs the error AADSTS525 logged in Application Insights for the user (y/n): ");
key = Console.ReadKey();
userData.AADSTS525Issue = ConvertKeyToBool(key);
Console.WriteLine();
Console.WriteLine("Is this correct (y/n)?");
Console.WriteLine(JsonConvert.SerializeObject(userData));
key = Console.ReadKey();
if (!ConvertKeyToBool(key))
{
continue;
}
Console.WriteLine();
Console.WriteLine("Predicting issue...");
string issue = runner.PredictIssue(userData);
Console.WriteLine($"PREDICTED ISSUE: {issue}");
Console.WriteLine("=============================================");
Console.WriteLine("Do you want to continue");
key = Console.ReadKey();
if (!ConvertKeyToBool(key))
{
break;
}
} while (true);
}
