def __init__(self, parent, id, arg_list, dtype=float):
     ModelBase.__init__(self, parent, id, arg_list[0], type)
     arg_list.pop(0)
     [self.raw_value] = arg_list.pop(0)
     self.dtype = dtype
     self.data = None
     return

 def __init__(self, parent, id, arg_list, dtype='float'):
     ModelBase.__init__(self, parent, id, arg_list[1], 'Param List')
     self.domain = arg_list.pop(0)
     self.raw_list = arg_list[-1]
     self.dtype = dtype
     self.shape = []
     self.data = array([])
     return

 def __init__(self, parent, id, arg_list, dtype='float'):
     ModelBase.__init__(self, parent, id, arg_list[1], 'Variable')
     self.domain = arg_list.pop(0)
     arg_list.pop(0)
     self.variable_type = arg_list.pop()
     self.upper_bound = 10**30
     self.lower_bound = -10**30
     self.dtype = dtype
     return

 def __init__(self, parent, id, arg_list, dtype='float'):
     ModelBase.__init__(self, parent, id, arg_list[1], 'Table')
     self.domain = arg_list.pop(0)
     arg_list.pop(0)
     self.dtype = dtype
     arg_list.pop(0)
     self.raw_table = arg_list.pop()
     self.data = array([])
     return

    def __init__(self):
        """
        Constructor
        """
        ModelBase.__init__(self, "Components")
        
        self.AddAllowedAssociation(Unit = {"cid" : "C_DEVICE", "id" : "EACH"}, Part = {"cid" : "C_DEVICE_CHANNEL", "id" : "ANY"})
        self.AddAllowedAssociation(Unit = {"cid" : "C_DEVICE_TYPE", "id" : "EACH"}, Part = {"cid" : "C_DEVICE_CHANNEL_GROUP", "id" : "ANY"})

        self.GenerateValidator()

def h2o_median_absolute_error(y_actual, y_predicted):
  """
  Median absolute error regression loss

  :param y_actual: H2OFrame of actual response.
  :param y_predicted: H2OFrame of predicted response.
  :return: loss (float) (best is 0.0)
  """
  ModelBase._check_targets(y_actual, y_predicted)
  return (y_predicted-y_actual).abs().median()

    def __init__(self):
        """
        Constructor
        """
        ModelBase.__init__(self, "Responsibilities")
        
        self.AddAllowedAssociation(Responsible = {"cid" : "C_SERVER", "id" : "ANY"}, Subject = {"cid" : "C_IOC", "id" : "EACH"}, multiplicity=1)
        self.AddAllowedAssociation(Responsible = {"cid" : "C_IOC", "id" : "ANY"}, Subject = {"cid" : "C_DEVICE", "id" : "EACH"}, multiplicity=1)


        self.GenerateValidator()

    def __init__(self):
        """
        Constructor
        """
        ModelBase.__init__(self, "Types")
        
        self.AddAllowedAssociation(Type = {"cid" : "C_BUS_TYPE", "id" : "ANY"}, Subject = {"cid" : "C_BUS", "id" : "EACH"}, multiplicity = 1)
        self.AddAllowedAssociation(Type = {"cid" : "C_BUS_CONTROLLER_TYPE", "id" : "ANY"}, Subject = {"cid" : "C_BUS_CONTROLLER", "id" : "EACH"}, multiplicity = 1)
        self.AddAllowedAssociation(Type = {"cid" : "C_DEVICE_TYPE", "id" : "ANY"}, Subject = {"cid" : "C_DEVICE", "id" : "EACH"}, multiplicity = 1)

        self.GenerateValidator()

def h2o_mean_squared_error(y_actual, y_predicted, weights=None):
  """
  Mean squared error regression loss

  :param y_actual: H2OFrame of actual response.
  :param y_predicted: H2OFrame of predicted response.
  :param weights: (Optional) sample weights
  :return: loss (float) (best is 0.0)
  """
  ModelBase._check_targets(y_actual, y_predicted)
  return ((y_predicted-y_actual)**2).mean()

    def __init__(self):
        """
        Constructor
        """
        ModelBase.__init__(self, "Tagging")
        
        self.AddAllowedAssociation(Tag = {"cid" : "C_TAG", "id" : "ANY"}, Subject = {"cid" : "C_TAG", "id" : "EACH"}, multiplicity=1)
        self.AddAllowedAssociation(Tag = {"cid" : "C_TAG", "id" : "ANY"}, Subject = {"cid" : "ANY", "id" : "ANY"})


        self.GenerateValidator()

    def __init__(self):
        """
        Constructor
        """
        ModelBase.__init__(self, "Physical Connections")
        
        self.AddAllowedAssociation(From = {"cid" : "C_SERVER", "id" : "EACH"}, To = {"cid" : "C_BUS_CONTROLLER", "id" : "ANY"})
        self.AddAllowedAssociation(From = {"cid" : "C_BUS_CONTROLLER", "id" : "EACH"}, To = {"cid" : "C_BUS", "id" : "ANY"})
        self.AddAllowedAssociation(From = {"cid" : "C_BUS", "id" : "EACH"}, To = {"cid" : "C_DEVICE", "id" : "ANY"})

        self.GenerateValidator()

    def __init__(self):
        """
        Constructor
        """
        ModelBase.__init__(self, "Logical Connections")
        
        self.AddAllowedAssociation(From = {"cid" : "C_DEVICE_LINK", "id" : "EACH"}, To = {"cid" : "C_DEVICE_CHANNEL", "id" : "ANY"}, multiplicity=1)

        self.specific_validator = ValidatorConnectorsMatch(self)

        self.GenerateValidator()

    def __init__(self, parent, id, args, type):
        ModelBase.__init__(self, parent, id, args[1], 'Equation')
        self.identifier = id
        self.domain = args[1]
        # These values should be of the form: (rel_path.module, function_name)
        self.imports = []
        self.eqn_slash_eqns = args[3]
        self.declared_variables = parent.declared_variables
        self.declared_parameters = parent.declared_parameters
        self.declared_equations = parent.declared_equations
        self.warning_list = []
        self.processed_eqs = []
        self.domain_checking = parent.domain_checking

        return

def h2o_r2_score(y_actual, y_predicted, weights=1.):
  """
  R^2 (coefficient of determination) regression score function

  :param y_actual: H2OFrame of actual response.
  :param y_predicted: H2OFrame of predicted response.
  :param weights: (Optional) sample weights
  :return: R^2 (float) (best is 1.0, lower is worse)
  """
  ModelBase._check_targets(y_actual, y_predicted)
  numerator   = (weights * (y_actual - y_predicted) ** 2).sum()
  denominator = (weights * (y_actual - y_actual.mean()) ** 2).sum()

  if denominator == 0.0:
    return 1. if numerator == 0. else 0.  # 0/0 => 1, else 0
  return 1 - numerator / denominator

def h2o_explained_variance_score(y_actual, y_predicted, weights=None):
  """
  Explained variance regression score function

  :param y_actual: H2OFrame of actual response.
  :param y_predicted: H2OFrame of predicted response.
  :param weights: (Optional) sample weights
  :return: the explained variance score (float)
  """
  ModelBase._check_targets(y_actual, y_predicted)

  _, numerator   = _mean_var(y_actual - y_predicted, weights)
  _, denominator = _mean_var(y_actual, weights)
  if denominator == 0.0:
    return 1. if numerator == 0 else 0.  # 0/0 => 1, otherwise, 0
  return 1 - numerator / denominator

    def size(self, train=False, valid=False, xval=False):
        """
    Get the sizes of each cluster.

    If all are False (default), then return the training metric value.
    If more than one options is set to True, then return a dictionary of metrics where
    the keys are "train", "valid", and "xval"

    Parameters
    ----------
      train : bool, optional
        If True, then return cluster sizes for the training data.
      valid : bool, optional
        If True, then return the cluster sizes for the validation data.
      xval : bool, optional
        If True, then return the cluster sizes for each of the cross-validated splits.

    Returns
    -------
      Returns the cluster sizes for the specified key(s).
    """
        tm = ModelBase._get_metrics(self, train, valid, xval)
        m = {}
        for k, v in zip(tm.keys(), tm.values()):
            m[k] = None if v is None else [v[2] for v in v._metric_json["centroid_stats"].cell_values]
        return m.values()[0] if len(m) == 1 else m

    def totss(self, train=False, valid=False, xval=False):
        """
    Get the total sum of squares.

    If all are False (default), then return the training metric value.
    If more than one options is set to True, then return a dictionary of metrics where
    the keys are "train", "valid", and "xval".

    Parameters
    ----------
      train : bool, optional
        If True, then return the total sum of squares value for the training
        data.
      valid : bool, optional
        If True, then return the total sum of squares value for the validation
        data.
      xval : bool, optional
        If True, then return the total sum of squares value for each of the
        cross-validated splits.

    Returns
    -------
      Returns the total sum of squares values for the specified key(s).
    """
        tm = ModelBase._get_metrics(self, train, valid, xval)
        m = {}
        for k, v in zip(tm.keys(), tm.values()):
            m[k] = None if v is None else v._metric_json["totss"]
        return m.values()[0] if len(m) == 1 else m

 def cat_err(self):
   """
   :return: the Number of Misclassified categories over non-missing categorical entries, or None if not present.
   """
   if ModelBase._has(self._metric_json, "caterr"):
     return self._metric_json["caterr"]
   return None

 def null_deviance(self):
   """
   :return: the null deviance if the model has residual deviance, or None if no null deviance.
   """
   if ModelBase._has(self._metric_json, "null_deviance"):
     return self._metric_json["null_deviance"]
   return None

 def num_err(self):
   """
   :return: the Sum of Squared Error over non-missing numeric entries, or None if not present.
   """
   if ModelBase._has(self._metric_json, "numerr"):
     return self._metric_json["numerr"]
   return None