public static Model create(DescriptionConfigModel modelConfig) { Type modelClass = null; if (modelConfig.model == "CLA") { modelClass = typeof(CLAModel); } else if (modelConfig.model == "TwoGram") { } else if (modelConfig.model == "PreviousValue") { } else { throw new NotSupportedException("ModelFactory received unsupported Model type: " + modelConfig.model); } return((Model)Activator.CreateInstance(modelClass, modelConfig.modelParams)); }
public void updateConfigFromSubConfig(DescriptionConfigModel config) { }
public SimpleV2DescriptionFile() { var config = new DescriptionConfigModel { // Type of model that the rest of these parameters apply to. model = "CLA", // Version that specifies the format of the config. version = 1, // Intermediate variables used to compute fields in modelParams and also // referenced from the control section. aggregationInfo = new Map <string, object> { { "days", 0 }, { "fields", new Map <string, object> { { "timestamp", "first" }, { "gym", "first" }, { "consumption", "mean" }, { "address", "first" } } }, { "hours", 0 }, { "microseconds", 0 }, { "milliseconds", 0 }, { "minutes", 0 }, { "months", 0 }, { "seconds", 0 }, { "weeks", 0 }, { "years", 0 } }, predictAheadTime = null, // Model parameter dictionary. modelParams = new ModelDescriptionParamsDescrModel { // The type of inference that this model will perform inferenceType = InferenceType.TemporalNextStep, sensorParams = new SensorParamsDescrModel { // Sensor diagnostic output verbosity control; // if > 0: sensor region will print out on screen what it"s sensing // at each step 0: silent; >=1: some info; >=2: more info; // >=3: even more info (see compute() in py/regions/RecordSensor.py) verbosity = 0, // Example: // dsEncoderSchema = [ // DeferredDictLookup("__field_name_encoder"), // ], // // (value generated from DS_ENCODER_SCHEMA) encoders = new Map <string, Map <string, object> > { { "address", new Map <string, object> { { "fieldname", "address" }, { "n", 300 }, { "name", "address" }, { "type", "SDRCategoryEncoder" }, { "w", 21 }, { "categoryList", new List <string>() } } }, { "consumption", new Map <string, object> { { "clipInput", true }, { "fieldname", "consumption" }, { "maxval", 200 }, { "minval", 0 }, { "n", 1500 }, { "name", "consumption" }, { "type", "ScalarEncoder" }, { "w", 21 } } }, { "gym", new Map <string, object> { { "fieldname", "gym" }, { "n", 300 }, { "name", "gym" }, { "type", "SDRCategoryEncoder" }, { "w", 21 }, { "categoryList", new List <string>() } } }, { "timestamp_dayOfWeek", new Map <string, object> { { "dayOfWeek", new Tuple(7, 3) }, { "fieldname", "timestamp" }, { "name", "timestamp_dayOfWeek" }, { "type", "DateEncoder" } } }, { "timestamp_timeOfDay", new Map <string, object> { { "fieldname", "timestamp" }, { "name", "timestamp_timeOfDay" }, { "timeOfDay", new Tuple(7, 8) }, { "type", "DateEncoder" } } } }, // A dictionary specifying the period for automatically-generated // resets from a RecordSensor; // // None = disable automatically-generated resets (also disabled if // all of the specified values evaluate to 0). // Valid keys is the desired combination of the following: // days, hours, minutes, seconds, milliseconds, microseconds, weeks // // Example for 1.5 days: sensorAutoReset = dict(days=1,hours=12), // // (value generated from SENSOR_AUTO_RESET) sensorAutoReset = null, }, spEnable = true, spParams = new SpatialParamsDescr { // SP diagnostic output verbosity control; // 0: silent; >=1: some info; >=2: more info; spVerbosity = 0, globalInhibition = true, // Number of cell columns in the cortical region (same number for // SP and TP) // (see also tpNCellsPerCol) columnCount = new int[] { 2048 }, inputWidth = new int[] { 0 }, // SP inhibition control (absolute value); // Maximum number of active columns in the SP region"s output (when // there are more, the weaker ones are suppressed) numActiveColumnsPerInhArea = 40.0, seed = 1956, // potentialPct // What percent of the columns"s receptive field is available // for potential synapses. At initialization time, we will // choose potentialPct * (2*potentialRadius+1)^2 potentialPct = 0.5, // The default connected threshold. Any synapse whose // permanence value is above the connected threshold is // a "connected synapse", meaning it can contribute to the // cell"s firing. Typical value is 0.10. Cells whose activity // level before inhibition falls below minDutyCycleBeforeInh // will have their own internal synPermConnectedCell // threshold set below this default value. // (This concept applies to both SP and TP and so "cells" // is correct here as opposed to "columns") synPermConnected = 0.1, synPermActiveInc = 0.1, synPermInactiveDec = 0.01, }, // Controls whether TP is enabled or disabled; // TP is necessary for making temporal predictions, such as predicting // the next inputs. Without TP, the model is only capable of // reconstructing missing sensor inputs (via SP). tpEnable = true, tpParams = new TemporalParamsDescr { // TP diagnostic output verbosity control; // 0: silent; [1..6]: increasing levels of verbosity // (see verbosity in nupic/trunk/py/nupic/research/TP.py and TP10X*.py) verbosity = 0, // Number of cell columns in the cortical region (same number for // SP and TP) // (see also tpNCellsPerCol) columnCount = new[] { 2048 }, // The number of cells (i.e., states), allocated per column. cellsPerColumn = 32, inputWidth = new[] { 2048 }, seed = 1960, // Temporal Pooler implementation selector (see _getTPClass in // CLARegion.py). temporalImp = "cpp", // New Synapse formation count // NOTE: If None, use spNumActivePerInhArea // // TODO: need better explanation newSynapseCount = 15, // Maximum number of synapses per segment // > 0 for fixed-size CLA // -1 for non-fixed-size CLA // // TODO: for Ron: once the appropriate value is placed in TP // constructor, see if we should eliminate this parameter from // description.py. maxSynapsesPerSegment = 32, // Maximum number of segments per cell // > 0 for fixed-size CLA // -1 for non-fixed-size CLA // // TODO: for Ron: once the appropriate value is placed in TP // constructor, see if we should eliminate this parameter from // description.py. maxSegmentsPerCell = 128, // Initial Permanence // TODO: need better explanation initialPerm = 0.21, // Permanence Increment permanenceInc = 0.1, // Permanence Decrement // If set to None, will automatically default to tpPermanenceInc // value. permanenceDec = 0.1, globalDecay = 0.0, maxAge = 0, // Minimum number of active synapses for a segment to be considered // during search for the best-matching segments. // None=use default // Replaces: tpMinThreshold minThreshold = 12, // Segment activation threshold. // A segment is active if it has >= tpSegmentActivationThreshold // connected synapses that are active due to infActiveState // None=use default // Replaces: tpActivationThreshold activationThreshold = 16, outputType = "normal", // "Pay Attention Mode" length. This tells the TP how many new // elements to append to the end of a learned sequence at a time. // Smaller values are better for datasets with short sequences, // higher values are better for datasets with long sequences. pamLength = 1, }, clEnable = true, clParams = new ClassifierParamsDescr { regionName = typeof(CLAClassifier).AssemblyQualifiedName,// "CLAClassifierRegion", // Classifier diagnostic output verbosity control; // 0: silent; [1..6]: increasing levels of verbosity clVerbosity = 0, // This controls how fast the classifier learns/forgets. Higher values // make it adapt faster and forget older patterns faster. alpha = 0.001, // This is set after the call to updateConfigFromSubConfig and is // computed from the aggregationInfo and predictAheadTime. steps = 1, }, trainSPNetOnlyIfRequested = false, } }; // end of config dictionary // Adjust base config dictionary for any modifications if imported from a // sub-experiment updateConfigFromSubConfig(config); modelConfig = config; // Compute predictionSteps based on the predictAheadTime and the aggregation // period, which may be permuted over. if (config.predictAheadTime != null) { int predictionSteps = (int)Math.Round(Utils.aggregationDivide(config.predictAheadTime, config.aggregationInfo)); Debug.Assert(predictionSteps >= 1); config.modelParams.clParams.steps = predictionSteps; } // Adjust config by applying ValueGetterBase-derived // futures. NOTE: this MUST be called after updateConfigFromSubConfig() in order // to support value-getter-based substitutions from the sub-experiment (if any) //applyValueGettersToContainer(config); control = new DescriptionControlModel { // The environment that the current model is being run in environment = "nupic", // Input stream specification per py/nupicengine/cluster/database/StreamDef.json. // dataset = new Map <string, object> { { "info", "test_NoProviders" }, { "streams", new Map <string, object> { { "columns", new[] { "*" } }, { "info", "test data" }, { "source", "rec-center-hourly.csv" } } }, { "version", 1 } }, // Iteration count: maximum number of iterations. Each iteration corresponds // to one record from the (possibly aggregated) dataset. The task is // terminated when either number of iterations reaches iterationCount or // all records in the (possibly aggregated) database have been processed, // whichever occurs first. // // iterationCount of -1 = iterate over the entire dataset //"iterationCount" : ITERATION_COUNT, // Metrics: A list of MetricSpecs that instantiate the metrics that are // computed for this experiment metrics = new[] { new MetricSpec(field: "consumption", inferenceElement: InferenceElement.Prediction, metric: "rmse") }, // Logged Metrics: A sequence of regular expressions that specify which of // the metrics from the Inference Specifications section MUST be logged for // every prediction. The regex"s correspond to the automatically generated // metric labels. This is similar to the way the optimization metric is // specified in permutations.py. loggedMetrics = new[] { ".*nupicScore.*" } }; }