/// <summary>
/// Invoke this hook with a certain parameter registry.
/// </summary>
/// <param name="registry">The registry containing the required values for this hook's execution.</param>
/// <param name="resolver">A helper resolver for complex registry entries (automatically cached).</param>
public override void SubInvoke(IRegistry registry, IRegistryResolver resolver)
{
int epoch = registry.Get <int>("epoch");
int iteration = registry.Get <int>("iteration");
Report(epoch, iteration);
}
protected virtual void SetupTest()
{
_reg = new Registry <IModel>();
_reg.Bind <Service.ICardTemplateService, Service.Impl.CardTemplateService>(new Service.Impl.CardTemplateService());
_reg.Bind <IBoardModel, BoardModel>(new BoardModel(8, 8));
_reg.Bind <IArbiterModel, ArbiterModel>(new ArbiterModel());
_reg.Bind <IWhitePlayerModel, WhitePlayerModel>();
_reg.Bind <IBlackPlayerModel, BlackPlayerModel>();
_reg.Bind <ICardModel, CardModel>();
_reg.Bind <IDeckModel, MockDeck>();
_reg.Bind <IHandModel, MockHand>();
_reg.Bind <IPieceModel, PieceModel>();
_reg.Bind <IEndTurnButtonModel, EndTurnButtonModel>();
_reg.Resolve();
_board = _reg.Get <IBoardModel>();
_arbiter = _reg.Get <IArbiterModel>();
_white = _reg.Get <IWhitePlayerModel>();
_black = _reg.Get <IBlackPlayerModel>();
foreach (var model in _reg.Instances.ToList())
{
model.PrepareModels();
}
}
/// <inheritdoc />
public FullyConnectedLayer(string name, IRegistry parameters, IComputationHandler handler) : base(name, parameters, handler)
{
int size = parameters.Get <int>("size");
int inputSize = parameters.Get <int>("default_input_size");
parameters["weights"] = handler.NDArray(inputSize, size);
parameters["biases"] = handler.NDArray(size);
TrainableParameters = new[] { "weights", "biases" };
}
public Resource(ResourceData data, IRegistry registry) : base(data, registry)
{
_qty = data.Value;
try {
Capacity = registry.Get <IStat>(data.Capacity);
} catch (StatNotFoundException) {
throw new StatNotFoundException(data.Capacity + " (Resource::.output) ");
}
try {
Output = registry.Get <IStat>(data.Output);
} catch (StatNotFoundException) {
throw new StatNotFoundException(data.Output + " (Resource::.output) ");
}
}
///<inheritdoc cref="FromPrefab{TIView}(UnityEngine.Object)"/>
public TIView FromPrefab <TIView, TIAgent, TIModel>(Object prefab, IRegistry <TIModel> models, IRegistry <TIAgent> agents = null)
where TIView : class, IViewBase
where TIAgent : class, IAgent, IHasDestroyHandler <TIAgent>, IHasRegistry <TIAgent>
where TIModel : class, IModel, IHasDestroyHandler <TIModel>, IHasRegistry <TIModel>
{
Assert.IsNotNull(prefab);
var view = Object.Instantiate(prefab) as TIView;
Assert.IsNotNull(view);
view = Prepare(Inject(typeof(TIView), view)) as TIView;
Assert.IsNotNull(view);
var model = models.Get <TIModel>();
if (agents != null)
{
TIAgent agent = agents.Get <TIAgent>(model);
view.SetAgent(agent);
agent.AddSubscriptions();
agent.BaseModel.AddSubscriptions();
view.AddSubscriptions();
}
Assert.IsTrue(view.IsValid);
return(view);
}
public OutputLayer(string name, IRegistry parameters, IComputationHandler handler) : base(name, parameters, handler)
{
// external to indicate that these parameters are not only external (which should already be indicate with the InputsExternal flag in the layer construct and buffer)
// but also that they mark the boundaries of the entire network (thereby external to the network, not only external as in external source)
// default is the pass-through to next layer
ExpectedOutputs = new[] { parameters.Get <string>("external_output_alias"), "default" };
}
public ElementwiseLayer(string name, IRegistry parameters, IComputationHandler handler) : base(name, parameters, handler)
{
int size = parameters.Get <int>("size");
parameters["weights"] = handler.NDArray(size);
parameters["bias"] = handler.Number(0);
TrainableParameters = new[] { "weights", "bias" };
}
/// <summary>
/// Get the current interval of a certain time scale out of a registry.
/// Note: Time scale can only be epoch or iteration.
/// </summary>
/// <param name="registry">The registry.</param>
/// <param name="timeScale">The time scale.</param>
/// <returns>The current interval of the given time scale as it is in the given registry.</returns>
public static int GetCurrentInterval(IRegistry registry, TimeScale timeScale)
{
if (registry == null)
{
throw new ArgumentNullException(nameof(registry));
}
if (timeScale == TimeScale.Epoch)
{
return(registry.Get <int>("epoch"));
}
else if (timeScale == TimeScale.Iteration)
{
return(registry.Get <int>("iteration"));
}
else
{
throw new ArgumentException($"Cannot get current interval of time scale {timeScale}, must be either {nameof(TimeScale.Epoch)} or {nameof(TimeScale.Iteration)}.");
}
}
public Multistat(MultistatData data, IRegistry registry) : base(data, registry)
{
if (data.Stats != null && data.Stats.Length > 0)
{
List <IStat> list = new List <IStat>();
foreach (string code in data.Stats)
{
list.Add(registry.Get <IStat>(code));
}
Stats = list.ToArray();
}
}
public override bool CheckCriteria(IRegistry registry, IRegistryResolver resolver)
{
string parameter = ParameterRegistry.Get <string>("parameter_identifier");
object rawValue = SimpleDirectEntries[0] ? registry.Get(parameter) : resolver.ResolveGetSingle <object>(parameter);
double value = (double)Convert.ChangeType(rawValue, typeof(double));
bool thresholdReached = _InternalThresholdReached(value, ParameterRegistry.Get <double>("threshold_value"), ParameterRegistry.Get <ComparisonTarget>("target"));
bool fire = thresholdReached && (!ParameterRegistry.Get <bool>("last_check_met") || ParameterRegistry.Get <bool>("fire_continously"));
ParameterRegistry["last_check_met"] = thresholdReached;
return(fire);
}
public Stat(StatData data, IRegistry registry) : base(data, registry)
{
// process for serialization
if (data.Dependencies != null)
{
foreach (StatData.Dependency dep in data.Dependencies)
{
IStat stat = registry.Get <IStat>(dep.Code);
_dependencies.Add(stat, dep.Value);
}
}
ResetModifierTotals();
}
/// <summary>
/// Get the total cost from a certain network using a certain computation handler and put the relevant information in the cost registry (total, partial, importances).
/// </summary>
/// <param name="network">The network to get the costs from.</param>
/// <param name="handler">The handler to use.</param>
/// <param name="costRegistry">The registry to put relevant information in.</param>
/// <returns>The total cost of the given network (0.0 if none).</returns>
protected virtual INumber GetTotalCost(INetwork network, IComputationHandler handler, IRegistry costRegistry)
{
INumber totalCost = handler.Number(0);
foreach (ILayerBuffer layerBuffer in network.YieldExternalOutputsLayerBuffers())
{
if (layerBuffer.Outputs.ContainsKey(ExternalCostAlias))
{
IRegistry externalCostRegistry = layerBuffer.Outputs[ExternalCostAlias];
INumber partialCost = externalCostRegistry.Get <INumber>("cost");
double partialImportance = externalCostRegistry.Get <double>("importance");
costRegistry["partial_" + layerBuffer.Layer.Name] = partialCost.GetValueAs <double>();
costRegistry["partial_" + layerBuffer.Layer.Name + "_importance"] = partialImportance;
totalCost = handler.Add(totalCost, handler.Multiply(partialCost, partialImportance));
}
}
costRegistry["total"] = totalCost.GetValueAs <double>();
return(totalCost);
}
public object Resolve(string key)
{
if (!_registry.Contains(key))
{
throw new InvalidOperationException(
string.Format(@"Component cannot be
resolved from key {0} because nothing was registered under that name.", key));
}
var reg = _registry.Get(key);
var resolverList = (IEnumerable <IResolveObjects>)InternalResolver
.ResolveAll(typeof(IResolveObjects));
var resolver = resolverList.ToList().Find(r => r.CanProcess(reg.ResolutionType));
return(resolver.Resolve(reg));
}
///<inheritdoc cref="FromPrefab{TIView}(UnityEngine.Object)"/>
public TIView FromPrefab <TIView, TIAgent>(Object prefab, IRegistry <TIAgent> agents)
where TIView : class, IViewBase
where TIAgent : class, IAgent, IHasDestroyHandler <TIAgent>, IHasRegistry <TIAgent>
{
var view = FromPrefab <TIView>(prefab);
Assert.IsNotNull(view);
var agent = agents.Get <TIAgent>();
view.SetAgent(agent);
view.AddSubscriptions();
agent.AddSubscriptions();
agent.BaseModel.AddSubscriptions();
Assert.IsTrue(view.IsValid);
return(view);
}
public override bool CheckCriteria(IRegistry registry, IRegistryResolver resolver)
{
ExtremaTarget target = ParameterRegistry.Get <ExtremaTarget>("target");
string parameter = ParameterRegistry.Get <string>("parameter_identifier");
double value = SimpleDirectEntries[0] ? registry.Get <double>(parameter) : resolver.ResolveGetSingle <double>(parameter);
double currentExtremum = ParameterRegistry.Get <double>("current_extremum");
bool reachedExtremum = target == ExtremaTarget.Min && value <currentExtremum || target == ExtremaTarget.Max && value> currentExtremum;
if (double.IsNaN(currentExtremum) || reachedExtremum)
{
ParameterRegistry["current_extremum"] = value;
return(true);
}
return(false);
}
private void AddMatchingIdentifiersFromRegistryTree(int hierarchyLevel, int lastHierarchySearchLevel, IRegistry currentRootAtLevel, string currentFullIdentifier, string[] parsedMatchIdentifierParts, ISet <string>[] conditionalTagsPerLevel, MatchIdentifierRequestCacheEntry newCacheEntry)
{
Regex regex = new Regex(parsedMatchIdentifierParts[hierarchyLevel]);
bool noneMatched = true;
foreach (string identifier in currentRootAtLevel.Keys.ToArray()) // TODO ugly hack, toarray is inefficient and is just to prevent "random" concurrent modification exception
{
if (regex.IsMatch(identifier))
{
object value = currentRootAtLevel.Get(identifier);
if (hierarchyLevel < lastHierarchySearchLevel && value is IRegistry)
{
IRegistry subRegistry = (IRegistry)value;
if (RegistryMatchesAllTags(subRegistry, conditionalTagsPerLevel[hierarchyLevel]))
{
string nextFullIdentifier = String.IsNullOrEmpty(currentFullIdentifier) ? identifier : (currentFullIdentifier + "." + identifier);
AddMatchingIdentifiersFromRegistryTree(hierarchyLevel + 1, lastHierarchySearchLevel, subRegistry, nextFullIdentifier, parsedMatchIdentifierParts, conditionalTagsPerLevel, newCacheEntry);
}
}
else if (hierarchyLevel == lastHierarchySearchLevel)
{
if (value is IRegistry && !RegistryMatchesAllTags((IRegistry)value, conditionalTagsPerLevel[hierarchyLevel]))
{
continue;
}
string globalFullIdentifier = (String.IsNullOrEmpty(currentFullIdentifier) ? "" : currentFullIdentifier + ".") + identifier;
newCacheEntry.FullMatchedIdentifierRegistries.Add(globalFullIdentifier, currentRootAtLevel);
newCacheEntry.FullMatchedIdentifierLocals.Add(globalFullIdentifier, identifier);
}
noneMatched = false;
}
}
if (noneMatched && hierarchyLevel == lastHierarchySearchLevel && !newCacheEntry.LastUnmatchedIdentifierRegistries.ContainsKey(currentFullIdentifier))
{
// keep last unmatched identifiers in case there is a (direct) resolve set
newCacheEntry.LastUnmatchedIdentifierRegistries.Add(currentFullIdentifier, currentRootAtLevel);
}
}
/// <summary>
/// Get a registry copy containing a copy of given required values.
/// </summary>
/// <param name="registry">The registry.</param>
/// <param name="resolvedRegistryEntries">The RESOLVED registry entries.</param>
/// <returns>A registry copy containing a copy of given required values.</returns>
public static IRegistry GetRegistryCopyForResolvedEntries(IRegistry registry, ISet <string> resolvedRegistryEntries)
{
IRegistry rootCopy = new Registry(tags: registry.Tags.ToArray());
foreach (string entry in resolvedRegistryEntries)
{
string[] parts = entry.Split('.');
IRegistry currentRoot = registry;
IRegistry currentRootCopy = rootCopy;
for (int i = 0; i < parts.Length - 1; i++)
{
string part = parts[i];
if (!currentRoot.ContainsKey(part))
{
throw new InvalidOperationException($"Cannot access non-existing registry \"{part}\" from full entry \"{entry}\" (level {i}).");
}
IRegistry nextRoot = currentRoot[part] as IRegistry;
if (nextRoot == null)
{
throw new InvalidOperationException($"Cannot access non-registry entry \"{part}\" from full entry \"{entry}\" (level {i}), should be instance of {nameof(IRegistry)}.");
}
if (!currentRootCopy.ContainsKey(part))
{
currentRootCopy[part] = new Registry(parent: currentRootCopy, tags: nextRoot.Tags.ToArray());
currentRootCopy = currentRootCopy.Get <IRegistry>(part);
}
currentRoot = nextRoot;
}
string lastPart = parts[parts.Length - 1];
object copiedValue = RegistryUtils.DeepestCopy(currentRoot[lastPart]);
currentRootCopy[lastPart] = copiedValue;
}
return(rootCopy);
}
/// <summary>
/// Try to retrieve a value from this source (if existent).
/// </summary>
/// <typeparam name="T">The type of the value that will be retrieved.</typeparam>
/// <param name="key">The key of the value.</param>
/// <param name="val">The value itself that will be assigned if it could be retrieved, <c>null</c> otherwise.</param>
/// <returns><c>True</c> if the source could retrieve given key, <c>false</c> otherwise.</returns>
public bool TryGet <T>(string key, out T val)
{
IRegistry values = (IRegistry)ParameterRegistry[ValueIdentifier];
IRegistryResolver resolver = values.Get <IRegistryResolver>(RegistryResolver);
//TODO: validate lock requirement, probably it is required
lock (values)
{
T[] vals = resolver.ResolveGet <T>(key);
if (vals.Length > 0)
{
val = vals[0];
return(true);
}
val = default(T);
return(false);
}
}
/// <summary>
/// Invoke this hook with a certain parameter registry.
/// </summary>
/// <param name="registry">The registry containing the required values for this hook's execution.</param>
/// <param name="resolver">A helper resolver for complex registry entries (automatically cached).</param>
public override void SubInvoke(IRegistry registry, IRegistryResolver resolver)
{
string[] valueIdentifiers = ParameterRegistry.Get <string[]>("value_identifiers");
IDictionary <string, object> valuesByIdentifier = ParameterRegistry.Get <IDictionary <string, object> >("value_buffer");
valuesByIdentifier.Clear();
for (int i = 0; i < valueIdentifiers.Length; i++)
{
string[] resolvedIdentifiers;
object[] values = resolver.ResolveGet <object>(valueIdentifiers[i], out resolvedIdentifiers);
for (int y = 0; y < resolvedIdentifiers.Length; y++)
{
valuesByIdentifier.Add(resolvedIdentifiers[y], values[y]);
}
}
ReportValues(valuesByIdentifier, ParameterRegistry.Get <bool>("report_epoch_iteration"), registry.Get <int>("epoch"), registry.Get <int>("iteration"));
}
/// <summary>
/// Create a base layer with a certain unique name.
/// </summary>
/// <param name="name">The unique name of this layer.</param>
/// <param name="parameters">The parameters to this layer.</param>
/// <param name="handler">The handler to use for ndarray parameter creation.</param>
public DropoutLayer(string name, IRegistry parameters, IComputationHandler handler) : base(name, parameters, handler)
{
parameters["dropout_mask"] = handler.NDArray(parameters.Get <int>("size"));
}
/// <summary>
/// Create a base layer with a certain unique name.
/// </summary>
/// <param name="name">The unique name of this layer.</param>
/// <param name="parameters">The parameters to this layer.</param>
/// <param name="handler">The handler to use for ndarray parameter creation.</param>
protected BaseCostLayer(string name, IRegistry parameters, IComputationHandler handler) : base(name, parameters, handler)
{
ExpectedInputs = new[] { parameters.Get <string>("external_targets_alias"), "default" };
ExpectedOutputs = new[] { parameters.Get <string>("external_cost_alias") };
}
/// <summary>
/// Invoke this hook with a certain parameter registry.
/// </summary>
/// <param name="registry">The registry containing the required values for this hook's execution.</param>
/// <param name="resolver">A helper resolver for complex registry entries (automatically cached).</param>
public override void SubInvoke(IRegistry registry, IRegistryResolver resolver)
{
string[] accumulatedIdentifiers = ParameterRegistry.Get <string[]>("accumulated_identifiers");
string[] valueIdentifiers = ParameterRegistry.Get <string[]>("value_identifiers");
IDictionary <string, object> valuesByIdentifier = ParameterRegistry.Get <IDictionary <string, object> >("value_buffer");
for (int i = 0; i < valueIdentifiers.Length; i++)
{
// TODO let callee decide if it's a number (double) / something else
object value = resolver.ResolveGetSingle <double>(accumulatedIdentifiers[i]);
valuesByIdentifier[valueIdentifiers[i]] = value;
}
ReportValues(valuesByIdentifier, ParameterRegistry.Get <bool>("report_epoch_iteration"), registry.Get <int>("epoch"), registry.Get <int>("iteration"));
}
/// <summary>
/// Gets an environment with a given name, if previously created (null otherwise).
/// </summary>
/// <param name="environmentName">The environment name.</param>
/// <returns>The existing with the given name or null.</returns>
public static SigmaEnvironment Get(string environmentName)
{
return(ActiveSigmaEnvironments.Get <SigmaEnvironment>(environmentName));
}
public override void Invoke(IRegistry reg, Stack <object> stack)
{
var obj = stack.Pop();
stack.Push(_fun(reg.Get <T>(obj)));
}
private string GetInstalledFilePath()
{
return(_registry.Get(FilePathLocationRegistry, FilePathLocationRegistryKey));
}
