craft-ai/lib/interpreter_v2.js

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.decide = exports.reduceDecisionRules = exports.formatProperty = exports.formatDecisionRules = undefined;

var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();

exports.distribution = distribution;
exports.computeMeanValues = computeMeanValues;
exports.computeMeanDistributions = computeMeanDistributions;

var _lodash = require('lodash');

var _lodash2 = _interopRequireDefault(_lodash);

var _reducer = require('./reducer');

var _time = require('./time');

var _errors = require('./errors');

var _formatter = require('./formatter');

var _timezones = require('./timezones');

var _timezones2 = _interopRequireDefault(_timezones);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }

var DECISION_FORMAT_VERSION = '2.0.0';

var OPERATORS = {
  'is': function is(context, value) {
    if (_lodash2.default.isObject(context) && _lodash2.default.isObject(value)) {
      return _lodash2.default.isEmpty(context) && _lodash2.default.isEmpty(value);
    } else {
      return context === value;
    }
  },
  '>=': function _(context, value) {
    return !_lodash2.default.isNull(context) && context * 1 >= value;
  },
  '<': function _(context, value) {
    return !_lodash2.default.isNull(context) && context * 1 < value;
  },
  '[in[': function _in(context, value) {
    var context_val = context * 1;
    var from = value[0];
    var to = value[1];
    //the interval is not looping
    if (from < to) {
      return !_lodash2.default.isNull(context) && context_val >= from && context_val < to;
    }
    //the interval IS looping
    else {
        return !_lodash2.default.isNull(context) && (context_val >= from || context_val < to);
      }
  },
  'in': function _in(context, value) {
    return value.indexOf(context) > -1;
  }
};

var VALUE_VALIDATOR = {
  continuous: function continuous(value) {
    return _lodash2.default.isFinite(value);
  },
  enum: function _enum(value) {
    return _lodash2.default.isString(value);
  },
  boolean: function boolean(value) {
    return _lodash2.default.isBoolean(value);
  },
  timezone: function timezone(value) {
    return (0, _timezones2.default)(value);
  },
  time_of_day: function time_of_day(value) {
    return _lodash2.default.isFinite(value) && value >= 0 && value < 24;
  },
  day_of_week: function day_of_week(value) {
    return _lodash2.default.isInteger(value) && value >= 0 && value <= 6;
  },
  day_of_month: function day_of_month(value) {
    return _lodash2.default.isInteger(value) && value >= 1 && value <= 31;
  },
  month_of_year: function month_of_year(value) {
    return _lodash2.default.isInteger(value) && value >= 1 && value <= 12;
  }
};

function decideRecursion(node, context, configuration, outputType, outputValues) {
  // Leaf
  if (!(node.children && node.children.length)) {
    var prediction = node.prediction;
    if (prediction.value == null) {
      return {
        predicted_value: undefined,
        confidence: undefined,
        decision_rules: [],
        error: {
          name: 'CraftAiNullDecisionError',
          message: 'Unable to take decision: the decision tree has no valid predicted value for the given context.'
        }
      };
    }

    var leafNode = {
      predicted_value: prediction.value,
      confidence: prediction.confidence || 0,
      decision_rules: [],
      nb_samples: prediction.nb_samples
    };

    if (!_lodash2.default.isUndefined(prediction.distribution.standard_deviation)) {
      leafNode.standard_deviation = prediction.distribution.standard_deviation;
      var min_value = prediction.distribution.min;
      var max_value = prediction.distribution.max;
      if (!_lodash2.default.isUndefined(min_value)) {
        leafNode.min = min_value;
      }
      if (!_lodash2.default.isUndefined(max_value)) {
        leafNode.max = max_value;
      }
    } else {
      leafNode.distribution = prediction.distribution;
    }

    return leafNode;
  }

  // Regular node
  var matchingChild = _lodash2.default.find(node.children, function (child) {
    var decision_rule = child.decision_rule;
    var property = decision_rule.property;
    if (configuration.deactivate_missing_values && _lodash2.default.isNull(property)) {
      return {
        predicted_value: undefined,
        confidence: undefined,
        error: {
          name: 'CraftAiUnknownError',
          message: 'Unable to take decision: property \'' + property + '\' is missing from the given context.'
        }
      };
    }
    return OPERATORS[decision_rule.operator](context[property], decision_rule.operand);
  });

  // matching child property error
  if (matchingChild && matchingChild.error) {
    return matchingChild;
  }

  if (_lodash2.default.isUndefined(matchingChild)) {
    if (!configuration.deactivate_missing_values) {
      var _distribution = distribution(node),
          value = _distribution.value,
          standard_deviation = _distribution.standard_deviation,
          size = _distribution.size;

      var _finalResult = {};
      // If it is a classification problem we return the class with the highest
      // probability. Otherwise, if the current output type is continuous/periodic
      // then the returned value corresponds to the subtree weighted output values.
      if (outputType === 'enum' || outputType === 'boolean') {
        // Compute the argmax function on the returned distribution:
        var argmax = value.map(function (x, i) {
          return [x, i];
        }).reduce(function (r, a) {
          return a[0] > r[0] ? a : r;
        })[1];

        var predicted_value = outputValues[argmax];
        _finalResult = {
          predicted_value: predicted_value,
          distribution: value
        };
      } else {
        _finalResult = {
          predicted_value: value,
          standard_deviation: standard_deviation
        };
      }
      return _lodash2.default.extend(_finalResult, {
        confidence: null,
        decision_rules: [],
        nb_samples: size
      });
    } else {
      // Should only happens when an unexpected value for an enum is encountered
      var operandList = _lodash2.default.uniq(_lodash2.default.map(_lodash2.default.values(node.children), function (child) {
        return child.decision_rule.operand;
      }));
      var property = _lodash2.default.head(node.children).decision_rule.property;
      return {
        predicted_value: undefined,
        confidence: undefined,
        decision_rules: [],
        error: {
          name: 'CraftAiNullDecisionError',
          message: 'Unable to take decision: value \'' + context[property] + '\' for property \'' + property + '\' doesn\'t validate any of the decision rules.',
          metadata: {
            property: property,
            value: context[property],
            expected_values: operandList
          }
        }
      };
    }
  }
  // matching child found: recurse !
  var result = decideRecursion(matchingChild, context, configuration, outputType, outputValues);

  var finalResult = _lodash2.default.extend(result, {
    decision_rules: [matchingChild.decision_rule].concat(result.decision_rules)
  });

  return finalResult;
}

function checkContext(configuration) {
  // Extract the required properties (i.e. those that are not the output)
  var expectedProperties = _lodash2.default.difference(_lodash2.default.keys(configuration.context), configuration.output);

  // Build a context validator
  var validators = _lodash2.default.map(expectedProperties, function (property) {
    var otherValidator = function otherValidator() {
      console.warn('WARNING: "' + configuration.context[property].type + '" is not a supported type. Please refer to the documention to see what type you can use');
      return true;
    };
    return {
      property: property,
      type: configuration.context[property].type,
      is_optional: configuration.context[property].is_optional,
      validator: VALUE_VALIDATOR[configuration.context[property].type] || otherValidator
    };
  });

  return function (context) {
    var _$reduce = _lodash2.default.reduce(validators, function (_ref, _ref2) {
      var badProperties = _ref.badProperties,
          missingProperties = _ref.missingProperties;
      var property = _ref2.property,
          type = _ref2.type,
          is_optional = _ref2.is_optional,
          validator = _ref2.validator;

      var value = context[property];
      var isNullAuthorized = _lodash2.default.isNull(value) && !configuration.deactivate_missing_values;
      var isOptionalAuthorized = _lodash2.default.isEmpty(value) && is_optional;
      if (value === undefined) {
        missingProperties.push(property);
      } else if (!validator(value) && !isNullAuthorized && !isOptionalAuthorized) {
        badProperties.push({ property: property, type: type, value: value });
      }
      return { badProperties: badProperties, missingProperties: missingProperties };
    }, { badProperties: [], missingProperties: [] }),
        badProperties = _$reduce.badProperties,
        missingProperties = _$reduce.missingProperties;

    if (missingProperties.length || badProperties.length) {
      var messages = _lodash2.default.concat(_lodash2.default.map(missingProperties, function (property) {
        return 'expected property \'' + property + '\' is not defined';
      }), _lodash2.default.map(badProperties, function (_ref3) {
        var property = _ref3.property,
            type = _ref3.type,
            value = _ref3.value;
        return '\'' + value + '\' is not a valid value for property \'' + property + '\' of type \'' + type + '\'';
      }));
      throw new _errors.CraftAiDecisionError({
        message: 'Unable to take decision, the given context is not valid: ' + messages.join(', ') + '.',
        metadata: _lodash2.default.assign({}, missingProperties.length && { missingProperties: missingProperties }, badProperties.length && { badProperties: badProperties })
      });
    }
  };
}

function distribution(node) {
  if (!(node.children && node.children.length)) {
    // If the distribution attribute is an array it means that it is
    // a classification problem. We therefore compute the distribution of
    // the classes in this leaf and return the branch size.
    if (_lodash2.default.isArray(node.prediction.distribution)) {
      return {
        value: node.prediction.distribution,
        size: node.prediction.nb_samples
      };
    }
    // Otherwise it is a regression problem, and we return the mean value 
    // of the leaf, the standard_deviation and the branch size.
    return {
      value: node.prediction.value,
      standard_deviation: node.prediction.distribution.standard_deviation,
      size: node.prediction.nb_samples,
      min: node.prediction.distribution.min,
      max: node.prediction.distribution.max
    };
  }

  // If it is not a leaf, we recurse into the children and store the distributions
  // and sizes of each child branch.

  var _$map$reduce = _lodash2.default.map(node.children, function (child) {
    return distribution(child);
  }).reduce(function (acc, _ref4) {
    var value = _ref4.value,
        standard_deviation = _ref4.standard_deviation,
        size = _ref4.size,
        min = _ref4.min,
        max = _ref4.max;

    acc.values.push(value);
    acc.sizes.push(size);
    if (!_lodash2.default.isUndefined(standard_deviation)) {
      acc.stds.push(standard_deviation);
      acc.mins.push(min);
      acc.maxs.push(max);
    }
    return acc;
  }, {
    values: [],
    stds: [],
    sizes: [],
    mins: [],
    maxs: []
  }),
      values = _$map$reduce.values,
      stds = _$map$reduce.stds,
      sizes = _$map$reduce.sizes,
      mins = _$map$reduce.mins,
      maxs = _$map$reduce.maxs;

  if (_lodash2.default.isArray(values[0])) {
    return computeMeanDistributions(values, sizes);
  }
  return computeMeanValues(values, sizes, stds, mins, maxs);
}

function computeMeanValues(values, sizes, stds, mins, maxs) {
  // Compute the weighted mean of the given array of values.
  // Example, for values = [ 4, 3, 6 ], sizes = [1, 2, 1]
  // This function computes (4*1 + 3*2 + 1*6) / (1+2+1) = 16/4 = 4
  // If no standard deviation array is given, use classical weighted mean formula:
  if (_lodash2.default.isUndefined(stds)) {
    var totalSize = _lodash2.default.sum(sizes);
    var newMean = _lodash2.default.zip(values, sizes).map(function (_ref5) {
      var _ref6 = _slicedToArray(_ref5, 2),
          mean = _ref6[0],
          size = _ref6[1];

      return mean * (1.0 * size) / (1.0 * totalSize);
    }).reduce(_lodash2.default.add);
    return {
      value: newMean,
      size: totalSize
    };
  }
  // Otherwise, to compute the weighted standard deviation the following formula is used:
  // https://math.stackexchange.com/questions/2238086/calculate-variance-of-a-subset

  var _$zip$map$reduce = _lodash2.default.zip(values, stds, sizes, mins, maxs).map(function (_ref7) {
    var _ref8 = _slicedToArray(_ref7, 5),
        mean = _ref8[0],
        std = _ref8[1],
        size = _ref8[2],
        min = _ref8[3],
        max = _ref8[4];

    return {
      mean: mean,
      variance: std * std,
      size: size,
      min: min,
      max: max
    };
  }).reduce(function (acc, _ref9) {
    var mean = _ref9.mean,
        variance = _ref9.variance,
        size = _ref9.size,
        min = _ref9.min,
        max = _ref9.max;

    if (_lodash2.default.isUndefined(acc.mean)) {
      return {
        mean: mean,
        variance: variance,
        size: size,
        min: min,
        max: max
      };
    }
    var totalSize = 1.0 * (acc.size + size);
    if (!totalSize > 0.0) {
      return {
        mean: acc.mean,
        variance: acc.variance,
        size: acc.size
      };
    }
    var newVariance = 1.0 / (totalSize - 1) * ((acc.size - 1) * acc.variance + (size - 1) * variance + acc.size * size / totalSize * (acc.mean - mean) * (acc.mean - mean));
    var newMean = 1.0 / totalSize * (acc.size * acc.mean + size * mean);
    var newMin = min < acc.min ? min : acc.min;
    var newMax = max > acc.max ? max : acc.max;
    return {
      mean: newMean,
      variance: newVariance,
      size: totalSize,
      min: newMin,
      max: newMax
    };
  }, {
    mean: undefined,
    variance: undefined,
    size: undefined,
    min: undefined,
    max: undefined
  }),
      mean = _$zip$map$reduce.mean,
      variance = _$zip$map$reduce.variance,
      size = _$zip$map$reduce.size,
      min = _$zip$map$reduce.min,
      max = _$zip$map$reduce.max;

  return {
    value: mean,
    standard_deviation: Math.sqrt(variance),
    size: size,
    min: min,
    max: max
  };
}

function computeMeanDistributions(values, sizes) {
  // Compute the weighted mean of the given array of distributions (array of probabilities).
  // Example, for values = [[ 4, 3, 6 ], [1, 2, 3], [3, 4, 5]], sizes = [1, 2, 1]
  // This function computes ([ 4, 3, 6]*1 + [1, 2, 3]*2 + [3, 4, 5]*6) / (1+2+1) = ...
  var totalSize = _lodash2.default.sum(sizes);
  var multiplyByBranchRatio = _lodash2.default.zip(values, sizes).map(function (zipped) {
    return _lodash2.default.map(zipped[0], function (val) {
      return val * zipped[1] / totalSize;
    });
  });
  var sumArrays = _sumArrays(multiplyByBranchRatio);
  return { value: sumArrays, size: totalSize };
}

function _sumArrays(arrays) {
  return _lodash2.default.reduce(arrays, function (acc_sum, array) {
    return _lodash2.default.map(array, function (val, i) {
      return (acc_sum[i] || 0.) + val;
    });
  }, new Array(arrays[0].length));
}

function decide(configuration, trees, context) {
  checkContext(configuration)(context);
  // Convert timezones as integers to the standard +/-hh:mm format
  // This should only happen when no Time() object is passed to the interpreter
  var timezoneProperty = (0, _timezones.getTimezoneKey)(configuration.context);
  if (!_lodash2.default.isUndefined(timezoneProperty)) {
    context[timezoneProperty] = (0, _time.tzFromOffset)(context[timezoneProperty]);
  }
  return {
    _version: DECISION_FORMAT_VERSION,
    context: context,
    output: _lodash2.default.assign.apply(_lodash2.default, _toConsumableArray(_lodash2.default.map(configuration.output, function (output) {
      var outputType = configuration.context[output].type;
      var decision = decideRecursion(trees[output], context, configuration, outputType, trees[output].output_values);
      if (decision.error) {
        switch (decision.error.name) {
          case 'CraftAiNullDecisionError':
            throw new _errors.CraftAiNullDecisionError({
              message: decision.error.message,
              metadata: _lodash2.default.extend(decision.error.metadata, {
                decision_rules: decision.decision_rules
              })
            });
          default:
            throw new _errors.CraftAiUnknownError({
              message: decision.error.message
            });
        }
      }
      return _defineProperty({}, output, decision);
    })))
  };
}

exports.formatDecisionRules = _formatter.formatDecisionRules;
exports.formatProperty = _formatter.formatProperty;
exports.reduceDecisionRules = _reducer.reduceDecisionRules;
exports.decide = decide;