def __init__(self, deepnet, api=None): """The Deepnet constructor can be given as first argument: - a deepnet structure - a deepnet id - a path to a JSON file containing a deepnet structure """ self.resource_id = None self.regression = False self.network = None self.networks = None self.input_fields = [] self.class_names = [] self.preprocess = [] self.optimizer = None self.missing_numerics = False self.api = get_api_connection(api) self.resource_id, deepnet = get_resource_dict( \ deepnet, "deepnet", api=self.api) if 'object' in deepnet and isinstance(deepnet['object'], dict): deepnet = deepnet['object'] self.input_fields = deepnet['input_fields'] if 'deepnet' in deepnet and isinstance(deepnet['deepnet'], dict): status = get_status(deepnet) objective_field = deepnet['objective_fields'] deepnet = deepnet['deepnet'] if 'code' in status and status['code'] == FINISHED: self.fields = deepnet['fields'] missing_tokens = deepnet.get('missing_tokens') ModelFields.__init__( self, self.fields, objective_id=extract_objective(objective_field), terms=True, categories=True, missing_tokens=missing_tokens) self.regression = \ self.fields[self.objective_id]['optype'] == NUMERIC if not self.regression: self.class_names = [category for category, _ in \ self.fields[self.objective_id][ \ 'summary']['categories']] self.class_names.sort() # order matters self.objective_categories = [category for \ category, _ in self.fields[self.objective_id][ \ "summary"]["categories"]] self.missing_numerics = deepnet.get('missing_numerics', False) if 'network' in deepnet: network = deepnet['network'] self.network = network self.networks = network.get('networks', []) self.preprocess = network.get('preprocess') self.optimizer = network.get('optimizer', {}) else: raise Exception("The deepnet isn't finished yet") else: raise Exception("Cannot create the Deepnet instance. Could not" " find the 'deepnet' key in the resource:\n\n%s" % deepnet)
def __init__(self, linear_regression, api=None): self.resource_id = None self.input_fields = [] self.term_forms = {} self.tag_clouds = {} self.term_analysis = {} self.items = {} self.item_analysis = {} self.categories = {} self.coefficients = [] self.data_field_types = {} self.field_codings = {} self.bias = None self.xtx_inverse = [] self.mean_squared_error = None self.number_of_parameters = None self.number_of_samples = None self.resource_id, linear_regression = get_resource_dict( \ linear_regression, "linearregression", api=api) if 'object' in linear_regression and \ isinstance(linear_regression['object'], dict): linear_regression = linear_regression['object'] try: self.input_fields = linear_regression.get("input_fields", []) self.dataset_field_types = linear_regression.get( "dataset_field_types", {}) self.weight_field = linear_regression.get("weight_field") objective_field = linear_regression['objective_fields'] if \ linear_regression['objective_fields'] else \ linear_regression['objective_field'] except KeyError: raise ValueError("Failed to find the linear regression expected " "JSON structure. Check your arguments.") if 'linear_regression' in linear_regression and \ isinstance(linear_regression['linear_regression'], dict): status = get_status(linear_regression) if 'code' in status and status['code'] == FINISHED: linear_regression_info = linear_regression[ \ 'linear_regression'] fields = linear_regression_info.get('fields', {}) if not self.input_fields: self.input_fields = [ \ field_id for field_id, _ in sorted(fields.items(), key=lambda x: x[1].get("column_number"))] self.coeff_ids = self.input_fields[:] self.coefficients = linear_regression_info.get( \ 'coefficients', []) self.bias = linear_regression_info.get('bias', True) self.field_codings = linear_regression_info.get( \ 'field_codings', {}) self.number_of_parameters = linear_regression_info.get( \ "number_of_parameters") missing_tokens = linear_regression_info.get("missing_tokens") objective_id = extract_objective(objective_field) ModelFields.__init__(self, fields, objective_id=objective_id, terms=True, categories=True, numerics=True, missing_tokens=missing_tokens) self.field_codings = linear_regression_info.get( \ 'field_codings', {}) self.format_field_codings() for field_id in self.field_codings: if field_id not in fields and \ field_id in self.inverted_fields: self.field_codings.update( \ {self.inverted_fields[field_id]: \ self.field_codings[field_id]}) del self.field_codings[field_id] stats = linear_regression_info["stats"] if STATS and stats is not None and \ stats.get("xtx_inverse") is not None: self.xtx_inverse = stats["xtx_inverse"][:] self.mean_squared_error = stats["mean_squared_error"] self.number_of_samples = stats["number_of_samples"] # to be used in predictions self.t_crit = student_t.interval( \ CONFIDENCE, self.number_of_samples - self.number_of_parameters)[1] self.xtx_inverse = list( \ np.linalg.inv(np.array(self.xtx_inverse))) else: raise Exception("The linear regression isn't finished yet") else: raise Exception("Cannot create the LinearRegression instance." " Could not find the 'linear_regression' key" " in the resource:\n\n%s" % linear_regression)
def __init__(self, time_series, api=None): self.resource_id = None self.input_fields = [] self.objective_fields = [] self.all_numeric_objectives = False self.period = 1 self.ets_models = {} self.error = None self.damped_trend = None self.seasonality = None self.trend = None self.time_range = {} self.field_parameters = {} self._forecast = [] # checks whether the information needed for local predictions is in # the first argument if isinstance(time_series, dict) and \ not check_model_fields(time_series): # if the fields used by the logistic regression are not # available, use only ID to retrieve it again time_series = get_time_series_id( \ time_series) self.resource_id = time_series if not (isinstance(time_series, dict) and 'resource' in time_series and time_series['resource'] is not None): if api is None: api = BigML(storage=STORAGE) self.resource_id = get_time_series_id(time_series) if self.resource_id is None: raise Exception( api.error_message(time_series, resource_type='time_series', method='get')) query_string = ONLY_MODEL time_series = retrieve_resource( api, self.resource_id, query_string=query_string) else: self.resource_id = get_time_series_id(time_series) if 'object' in time_series and \ isinstance(time_series['object'], dict): time_series = time_series['object'] try: self.input_fields = time_series.get("input_fields", []) self._forecast = time_series.get("forecast") self.objective_fields = time_series.get( "objective_fields", []) objective_field = time_series['objective_field'] if \ time_series.get('objective_field') else \ time_series['objective_fields'] except KeyError: raise ValueError("Failed to find the time series expected " "JSON structure. Check your arguments.") if 'time_series' in time_series and \ isinstance(time_series['time_series'], dict): status = get_status(time_series) if 'code' in status and status['code'] == FINISHED: time_series_info = time_series['time_series'] fields = time_series_info.get('fields', {}) self.fields = fields if not self.input_fields: self.input_fields = [ \ field_id for field_id, _ in sorted(self.fields.items(), key=lambda x: x[1].get("column_number"))] self.all_numeric_objectives = time_series_info.get( \ 'all_numeric_objectives') self.period = time_series_info.get('period', 1) self.ets_models = time_series_info.get('ets_models', {}) self.error = time_series_info.get('error') self.damped_trend = time_series_info.get('damped_trend') self.seasonality = time_series_info.get('seasonality') self.trend = time_series_info.get('trend') self.time_range = time_series_info.get('time_range') self.field_parameters = time_series_info.get( \ 'field_parameters', {}) objective_id = extract_objective(objective_field) ModelFields.__init__( self, fields, objective_id=objective_id) else: raise Exception("The time series isn't finished yet") else: raise Exception("Cannot create the TimeSeries instance." " Could not find the 'time_series' key" " in the resource:\n\n%s" % time_series)
def __init__(self, logistic_regression, api=None): self.resource_id = None self.input_fields = [] self.term_forms = {} self.tag_clouds = {} self.term_analysis = {} self.items = {} self.item_analysis = {} self.categories = {} self.coefficients = {} self.data_field_types = {} self.field_codings = {} self.numeric_fields = {} self.bias = None self.missing_numerics = None self.c = None self.eps = None self.lr_normalize = None self.regularization = None old_coefficients = False if not (isinstance(logistic_regression, dict) and 'resource' in logistic_regression and logistic_regression['resource'] is not None): if api is None: api = BigML(storage=STORAGE) self.resource_id = get_logistic_regression_id(logistic_regression) if self.resource_id is None: raise Exception( api.error_message(logistic_regression, resource_type='logistic_regression', method='get')) query_string = ONLY_MODEL logistic_regression = retrieve_resource(api, self.resource_id, query_string=query_string) else: self.resource_id = get_logistic_regression_id(logistic_regression) if 'object' in logistic_regression and \ isinstance(logistic_regression['object'], dict): logistic_regression = logistic_regression['object'] try: self.input_fields = logistic_regression.get("input_fields", []) self.dataset_field_types = logistic_regression.get( "dataset_field_types", {}) objective_field = logistic_regression['objective_fields'] if \ logistic_regression['objective_fields'] else \ logistic_regression['objective_field'] except KeyError: raise ValueError("Failed to find the logistic regression expected " "JSON structure. Check your arguments.") if 'logistic_regression' in logistic_regression and \ isinstance(logistic_regression['logistic_regression'], dict): status = get_status(logistic_regression) if 'code' in status and status['code'] == FINISHED: logistic_regression_info = logistic_regression[ \ 'logistic_regression'] fields = logistic_regression_info.get('fields', {}) if not self.input_fields: self.input_fields = [ \ field_id for field_id, _ in sorted(self.fields.items(), key=lambda x: x[1].get("column_number"))] self.coefficients.update(logistic_regression_info.get( \ 'coefficients', [])) if (not isinstance(self.coefficients.values()[0][0], list)): old_coefficients = True self.bias = logistic_regression_info.get('bias', 0) self.c = logistic_regression_info.get('c') self.eps = logistic_regression_info.get('eps') self.lr_normalize = logistic_regression_info.get('normalize') self.regularization = logistic_regression_info.get( \ 'regularization') self.field_codings = logistic_regression_info.get( \ 'field_codings', {}) # old models have no such attribute, so we set it to False in # this case self.missing_numerics = logistic_regression_info.get( \ 'missing_numerics', False) objective_id = extract_objective(objective_field) for field_id, field in fields.items(): if field['optype'] == 'text': self.term_forms[field_id] = {} self.term_forms[field_id].update( field['summary']['term_forms']) self.tag_clouds[field_id] = [] self.tag_clouds[field_id] = [ tag for [tag, _] in field['summary']['tag_cloud'] ] self.term_analysis[field_id] = {} self.term_analysis[field_id].update( field['term_analysis']) if field['optype'] == 'items': self.items[field_id] = [] self.items[field_id] = [item for item, _ in \ field['summary']['items']] self.item_analysis[field_id] = {} self.item_analysis[field_id].update( field['item_analysis']) if field['optype'] == 'categorical': self.categories[field_id] = [category for \ [category, _] in field['summary']['categories']] if self.missing_numerics and field['optype'] == 'numeric': self.numeric_fields[field_id] = True ModelFields.__init__(self, fields, objective_id=objective_id) self.field_codings = logistic_regression_info.get( \ 'field_codings', {}) self.format_field_codings() for field_id in self.field_codings: if field_id not in fields and \ field_id in self.inverted_fields: self.field_codings.update( \ {self.inverted_fields[field_id]: \ self.field_codings[field_id]}) del self.field_codings[field_id] if old_coefficients: self.map_coefficients() else: raise Exception("The logistic regression isn't finished yet") else: raise Exception("Cannot create the LogisticRegression instance." " Could not find the 'logistic_regression' key" " in the resource:\n\n%s" % logistic_regression)
def __init__(self, time_series, api=None): self.resource_id = None self.input_fields = [] self.objective_fields = [] self.all_numeric_objectives = False self.period = 1 self.ets_models = {} self.error = None self.damped_trend = None self.seasonality = None self.trend = None self.time_range = {} self.field_parameters = {} self._forecast = {} self.resource_id, time_series = get_resource_dict( \ time_series, "timeseries", api=api) if 'object' in time_series and \ isinstance(time_series['object'], dict): time_series = time_series['object'] try: self.input_fields = time_series.get("input_fields", []) self._forecast = time_series.get("forecast") self.objective_fields = time_series.get( "objective_fields", []) objective_field = time_series['objective_field'] if \ time_series.get('objective_field') else \ time_series['objective_fields'] except KeyError: raise ValueError("Failed to find the time series expected " "JSON structure. Check your arguments.") if 'time_series' in time_series and \ isinstance(time_series['time_series'], dict): status = get_status(time_series) if 'code' in status and status['code'] == FINISHED: time_series_info = time_series['time_series'] fields = time_series_info.get('fields', {}) self.fields = fields if not self.input_fields: self.input_fields = [ \ field_id for field_id, _ in sorted(self.fields.items(), key=lambda x: x[1].get("column_number"))] self.all_numeric_objectives = time_series_info.get( \ 'all_numeric_objectives') self.period = time_series_info.get('period', 1) self.ets_models = time_series_info.get('ets_models', {}) self.error = time_series_info.get('error') self.damped_trend = time_series_info.get('damped_trend') self.seasonality = time_series_info.get('seasonality') self.trend = time_series_info.get('trend') self.time_range = time_series_info.get('time_range') self.field_parameters = time_series_info.get( \ 'field_parameters', {}) objective_id = extract_objective(objective_field) ModelFields.__init__( self, fields, objective_id=objective_id) else: raise Exception("The time series isn't finished yet") else: raise Exception("Cannot create the TimeSeries instance." " Could not find the 'time_series' key" " in the resource:\n\n%s" % time_series)
def __init__(self, logistic_regression, api=None): self.resource_id = None self.input_fields = [] self.term_forms = {} self.tag_clouds = {} self.term_analysis = {} self.items = {} self.item_analysis = {} self.categories = {} self.coefficients = {} self.data_field_types = {} self.numeric_fields = {} self.bias = None self.missing_numerics = None self.c = None self.eps = None self.lr_normalize = None self.regularization = None if not (isinstance(logistic_regression, dict) and 'resource' in logistic_regression and logistic_regression['resource'] is not None): if api is None: api = BigML(storage=STORAGE) self.resource_id = get_logistic_regression_id(logistic_regression) if self.resource_id is None: raise Exception( api.error_message(logistic_regression, resource_type='logistic_regression', method='get')) query_string = ONLY_MODEL logistic_regression = retrieve_resource( api, self.resource_id, query_string=query_string) else: self.resource_id = get_logistic_regression_id(logistic_regression) if 'object' in logistic_regression and \ isinstance(logistic_regression['object'], dict): logistic_regression = logistic_regression['object'] try: self.input_fields = logistic_regression.get("input_fields", []) self.dataset_field_types = logistic_regression.get( "dataset_field_types", {}) objective_field = logistic_regression['objective_fields'] if \ logistic_regression['objective_fields'] else \ logistic_regression['objective_field'] except KeyError: raise ValueError("Failed to find the logistic regression expected " "JSON structure. Check your arguments.") if 'logistic_regression' in logistic_regression and \ isinstance(logistic_regression['logistic_regression'], dict): status = get_status(logistic_regression) if 'code' in status and status['code'] == FINISHED: logistic_regression_info = logistic_regression[ \ 'logistic_regression'] fields = logistic_regression_info.get('fields', {}) if not self.input_fields: self.input_fields = [ \ field_id for field_id, _ in sorted(self.fields.items(), key=lambda x: x[1].get("column_number"))] self.coefficients.update(logistic_regression_info.get( \ 'coefficients', [])) self.bias = logistic_regression_info.get('bias', 0) self.c = logistic_regression_info.get('c') self.eps = logistic_regression_info.get('eps') self.lr_normalize = logistic_regression_info.get('normalize') self.regularization = logistic_regression_info.get( \ 'regularization') # old models have no such attribute, so we set it to False in # this case self.missing_numerics = logistic_regression_info.get( \ 'missing_numerics', False) objective_id = extract_objective(objective_field) for field_id, field in fields.items(): if field['optype'] == 'text': self.term_forms[field_id] = {} self.term_forms[field_id].update( field['summary']['term_forms']) self.tag_clouds[field_id] = [] self.tag_clouds[field_id] = [tag for [tag, _] in field[ 'summary']['tag_cloud']] self.term_analysis[field_id] = {} self.term_analysis[field_id].update( field['term_analysis']) if field['optype'] == 'items': self.items[field_id] = [] self.items[field_id] = [item for item, _ in \ field['summary']['items']] self.item_analysis[field_id] = {} self.item_analysis[field_id].update( field['item_analysis']) if field['optype'] == 'categorical': self.categories[field_id] = [category for \ [category, _] in field['summary']['categories']] if self.missing_numerics and field['optype'] == 'numeric': self.numeric_fields[field_id] = True ModelFields.__init__( self, fields, objective_id=objective_id) self.map_coefficients() else: raise Exception("The logistic regression isn't finished yet") else: raise Exception("Cannot create the LogisticRegression instance." " Could not find the 'logistic_regression' key" " in the resource:\n\n%s" % logistic_regression)
def __init__(self, logistic_regression, api=None, cache_get=None): if use_cache(cache_get): # using a cache to store the model attributes self.__dict__ = load(get_logistic_regression_id( \ logistic_regression), cache_get) return self.resource_id = None self.class_names = None self.input_fields = [] self.term_forms = {} self.tag_clouds = {} self.term_analysis = {} self.items = {} self.item_analysis = {} self.categories = {} self.coefficients = {} self.data_field_types = {} self.field_codings = {} self.numeric_fields = {} self.bias = None self.missing_numerics = None self.c = None self.eps = None self.lr_normalize = None self.balance_fields = None self.regularization = None api = get_api_connection(api) old_coefficients = False self.resource_id, logistic_regression = get_resource_dict( \ logistic_regression, "logisticregression", api=api) if 'object' in logistic_regression and \ isinstance(logistic_regression['object'], dict): logistic_regression = logistic_regression['object'] try: self.input_fields = logistic_regression.get("input_fields", []) self.dataset_field_types = logistic_regression.get( "dataset_field_types", {}) self.weight_field = logistic_regression.get("weight_field") objective_field = logistic_regression['objective_fields'] if \ logistic_regression['objective_fields'] else \ logistic_regression['objective_field'] except KeyError: raise ValueError("Failed to find the logistic regression expected " "JSON structure. Check your arguments.") if 'logistic_regression' in logistic_regression and \ isinstance(logistic_regression['logistic_regression'], dict): status = get_status(logistic_regression) if 'code' in status and status['code'] == FINISHED: logistic_regression_info = logistic_regression[ \ 'logistic_regression'] fields = logistic_regression_info.get('fields', {}) if not self.input_fields: self.input_fields = [ \ field_id for field_id, _ in sorted(list(fields.items()), key=lambda x: x[1].get("column_number"))] self.coefficients.update(logistic_regression_info.get( \ 'coefficients', [])) if not isinstance( list(self.coefficients.values())[0][0], list): old_coefficients = True self.bias = logistic_regression_info.get('bias', True) self.c = logistic_regression_info.get('c') self.eps = logistic_regression_info.get('eps') self.lr_normalize = logistic_regression_info.get('normalize') self.balance_fields = logistic_regression_info.get( \ 'balance_fields') self.regularization = logistic_regression_info.get( \ 'regularization') self.field_codings = logistic_regression_info.get( \ 'field_codings', {}) # old models have no such attribute, so we set it to False in # this case self.missing_numerics = logistic_regression_info.get( \ 'missing_numerics', False) objective_id = extract_objective(objective_field) missing_tokens = logistic_regression_info.get("missing_tokens") ModelFields.__init__(self, fields, objective_id=objective_id, terms=True, categories=True, numerics=True, missing_tokens=missing_tokens) self.field_codings = logistic_regression_info.get( \ 'field_codings', {}) self.format_field_codings() for field_id in self.field_codings: if field_id not in self.fields and \ field_id in self.inverted_fields: self.field_codings.update( \ {self.inverted_fields[field_id]: \ self.field_codings[field_id]}) del self.field_codings[field_id] if old_coefficients: self.map_coefficients() categories = self.fields[self.objective_id].get( \ "summary", {}).get('categories') if len(list(self.coefficients.keys())) > len(categories): self.class_names = [""] else: self.class_names = [] self.class_names.extend( sorted([category[0] for category in categories])) # order matters self.objective_categories = [ category[0] for category in categories ] else: raise Exception("The logistic regression isn't finished yet") else: raise Exception("Cannot create the LogisticRegression instance." " Could not find the 'logistic_regression' key" " in the resource:\n\n%s" % logistic_regression)
def __init__(self, time_series, api=None): self.resource_id = None self.input_fields = [] self.objective_fields = [] self.all_numeric_objectives = False self.period = 1 self.ets_models = {} self.error = None self.damped_trend = None self.seasonality = None self.trend = None self.time_range = {} self.field_parameters = {} self._forecast = {} # checks whether the information needed for local predictions is in # the first argument if isinstance(time_series, dict) and \ not check_model_fields(time_series): # if the fields used by the logistic regression are not # available, use only ID to retrieve it again time_series = get_time_series_id( \ time_series) self.resource_id = time_series if not (isinstance(time_series, dict) and 'resource' in time_series and time_series['resource'] is not None): if api is None: api = BigML(storage=STORAGE) self.resource_id = get_time_series_id(time_series) if self.resource_id is None: raise Exception( api.error_message(time_series, resource_type='time_series', method='get')) query_string = ONLY_MODEL time_series = retrieve_resource( api, self.resource_id, query_string=query_string) else: self.resource_id = get_time_series_id(time_series) if 'object' in time_series and \ isinstance(time_series['object'], dict): time_series = time_series['object'] try: self.input_fields = time_series.get("input_fields", []) self._forecast = time_series.get("forecast") self.objective_fields = time_series.get( "objective_fields", []) objective_field = time_series['objective_field'] if \ time_series.get('objective_field') else \ time_series['objective_fields'] except KeyError: raise ValueError("Failed to find the time series expected " "JSON structure. Check your arguments.") if 'time_series' in time_series and \ isinstance(time_series['time_series'], dict): status = get_status(time_series) if 'code' in status and status['code'] == FINISHED: time_series_info = time_series['time_series'] fields = time_series_info.get('fields', {}) self.fields = fields if not self.input_fields: self.input_fields = [ \ field_id for field_id, _ in sorted(self.fields.items(), key=lambda x: x[1].get("column_number"))] self.all_numeric_objectives = time_series_info.get( \ 'all_numeric_objectives') self.period = time_series_info.get('period', 1) self.ets_models = time_series_info.get('ets_models', {}) self.error = time_series_info.get('error') self.damped_trend = time_series_info.get('damped_trend') self.seasonality = time_series_info.get('seasonality') self.trend = time_series_info.get('trend') self.time_range = time_series_info.get('time_range') self.field_parameters = time_series_info.get( \ 'field_parameters', {}) objective_id = extract_objective(objective_field) ModelFields.__init__( self, fields, objective_id=objective_id) else: raise Exception("The time series isn't finished yet") else: raise Exception("Cannot create the TimeSeries instance." " Could not find the 'time_series' key" " in the resource:\n\n%s" % time_series)
def __init__(self, time_series, api=None): self.resource_id = None self.input_fields = [] self.objective_fields = [] self.all_numeric_objectives = False self.period = 1 self.ets_models = {} self.error = None self.damped_trend = None self.seasonality = None self.trend = None self.time_range = {} self.field_parameters = {} self._forecast = {} self.api = get_api_connection(api) self.resource_id, time_series = get_resource_dict( \ time_series, "timeseries", api=self.api) if 'object' in time_series and \ isinstance(time_series['object'], dict): time_series = time_series['object'] try: self.input_fields = time_series.get("input_fields", []) self._forecast = time_series.get("forecast") self.objective_fields = time_series.get("objective_fields", []) objective_field = time_series['objective_field'] if \ time_series.get('objective_field') else \ time_series['objective_fields'] except KeyError: raise ValueError("Failed to find the time series expected " "JSON structure. Check your arguments.") if 'time_series' in time_series and \ isinstance(time_series['time_series'], dict): status = get_status(time_series) if 'code' in status and status['code'] == FINISHED: time_series_info = time_series['time_series'] fields = time_series_info.get('fields', {}) self.fields = fields if not self.input_fields: self.input_fields = [ \ field_id for field_id, _ in sorted(self.fields.items(), key=lambda x: x[1].get("column_number"))] self.all_numeric_objectives = time_series_info.get( \ 'all_numeric_objectives') self.period = time_series_info.get('period', 1) self.ets_models = time_series_info.get('ets_models', {}) self.error = time_series_info.get('error') self.damped_trend = time_series_info.get('damped_trend') self.seasonality = time_series_info.get('seasonality') self.trend = time_series_info.get('trend') self.time_range = time_series_info.get('time_range') self.field_parameters = time_series_info.get( \ 'field_parameters', {}) objective_id = extract_objective(objective_field) ModelFields.__init__(self, fields, objective_id=objective_id) else: raise Exception("The time series isn't finished yet") else: raise Exception("Cannot create the TimeSeries instance." " Could not find the 'time_series' key" " in the resource:\n\n%s" % time_series)
def __init__(self, deepnet, api=None): """The Deepnet constructor can be given as first argument: - a deepnet structure - a deepnet id - a path to a JSON file containing a deepnet structure """ self.resource_id = None self.regression = False self.network = None self.networks = None self.input_fields = [] self.class_names = [] self.preprocess = [] self.optimizer = None self.missing_numerics = False # the string can be a path to a JSON file if isinstance(deepnet, basestring): try: with open(deepnet) as deepnet_file: deepnet = json.load(deepnet_file) self.resource_id = get_deepnet_id(deepnet) if self.resource_id is None: raise ValueError("The JSON file does not seem" " to contain a valid BigML deepnet" " representation.") except IOError: # if it is not a path, it can be a deepnet id self.resource_id = get_deepnet_id(deepnet) if self.resource_id is None: if deepnet.find('deepnet/') > -1: raise Exception( api.error_message(deepnet, resource_type='deepnet', method='get')) else: raise IOError("Failed to open the expected JSON file" " at %s" % deepnet) except ValueError: raise ValueError("Failed to interpret %s." " JSON file expected.") # checks whether the information needed for local predictions is in # the first argument if isinstance(deepnet, dict) and \ not check_model_fields(deepnet): # if the fields used by the deepenet are not # available, use only ID to retrieve it again deepnet = get_deepnet_id(deepnet) self.resource_id = deepnet if not (isinstance(deepnet, dict) and 'resource' in deepnet and deepnet['resource'] is not None): if api is None: api = BigML(storage=STORAGE) query_string = ONLY_MODEL deepnet = retrieve_resource(api, self.resource_id, query_string=query_string) else: self.resource_id = get_deepnet_id(deepnet) if 'object' in deepnet and isinstance(deepnet['object'], dict): deepnet = deepnet['object'] self.input_fields = deepnet['input_fields'] if 'deepnet' in deepnet and isinstance(deepnet['deepnet'], dict): status = get_status(deepnet) objective_field = deepnet['objective_fields'] deepnet = deepnet['deepnet'] if 'code' in status and status['code'] == FINISHED: self.fields = deepnet['fields'] ModelFields.__init__( self, self.fields, objective_id=extract_objective(objective_field), terms=True, categories=True) self.regression = \ self.fields[self.objective_id]['optype'] == NUMERIC if not self.regression: self.class_names = [category for category,_ in \ self.fields[self.objective_id][ \ 'summary']['categories']] self.class_names.sort() self.missing_numerics = deepnet.get('missing_numerics', False) if 'network' in deepnet: network = deepnet['network'] self.network = network self.networks = network.get('networks', []) self.preprocess = network.get('preprocess') self.optimizer = network.get('optimizer', {}) else: raise Exception("The deepnet isn't finished yet") else: raise Exception("Cannot create the Deepnet instance. Could not" " find the 'deepnet' key in the resource:\n\n%s" % deepnet)
def __init__(self, linear_regression, api=None): self.resource_id = None self.input_fields = [] self.term_forms = {} self.tag_clouds = {} self.term_analysis = {} self.items = {} self.item_analysis = {} self.categories = {} self.coefficients = [] self.data_field_types = {} self.field_codings = {} self.bias = None self.xtx_inverse = [] self.mean_squared_error = None self.number_of_parameters = None self.number_of_samples = None self.resource_id, linear_regression = get_resource_dict( \ linear_regression, "linearregression", api=api) if 'object' in linear_regression and \ isinstance(linear_regression['object'], dict): linear_regression = linear_regression['object'] try: self.input_fields = linear_regression.get("input_fields", []) self.dataset_field_types = linear_regression.get( "dataset_field_types", {}) self.weight_field = linear_regression.get("weight_field") objective_field = linear_regression['objective_fields'] if \ linear_regression['objective_fields'] else \ linear_regression['objective_field'] except KeyError: raise ValueError("Failed to find the linear regression expected " "JSON structure. Check your arguments.") if 'linear_regression' in linear_regression and \ isinstance(linear_regression['linear_regression'], dict): status = get_status(linear_regression) if 'code' in status and status['code'] == FINISHED: linear_regression_info = linear_regression[ \ 'linear_regression'] fields = linear_regression_info.get('fields', {}) if not self.input_fields: self.input_fields = [ \ field_id for field_id, _ in sorted(self.fields.items(), key=lambda x: x[1].get("column_number"))] self.coeff_ids = self.input_fields[:] self.coefficients = linear_regression_info.get( \ 'coefficients', []) self.bias = linear_regression_info.get('bias', True) self.field_codings = linear_regression_info.get( \ 'field_codings', {}) self.number_of_parameters = linear_regression_info.get( \ "number_of_parameters") objective_id = extract_objective(objective_field) ModelFields.__init__( self, fields, objective_id=objective_id, terms=True, categories=True, numerics=True) self.field_codings = linear_regression_info.get( \ 'field_codings', {}) self.format_field_codings() for field_id in self.field_codings: if field_id not in fields and \ field_id in self.inverted_fields: self.field_codings.update( \ {self.inverted_fields[field_id]: \ self.field_codings[field_id]}) del self.field_codings[field_id] stats = linear_regression_info["stats"] if stats is not None and stats.get("xtx_inverse") is not None: self.xtx_inverse = stats["xtx_inverse"][:] self.mean_squared_error = stats["mean_squared_error"] self.number_of_samples = stats["number_of_samples"] # to be used in predictions self.t_crit = student_t.interval( \ CONFIDENCE, self.number_of_samples - self.number_of_parameters)[1] self.xtx_inverse = list( \ np.linalg.inv(np.array(self.xtx_inverse))) else: raise Exception("The linear regression isn't finished yet") else: raise Exception("Cannot create the LinearRegression instance." " Could not find the 'linear_regression' key" " in the resource:\n\n%s" % linear_regression)
def __init__(self, logistic_regression, api=None): self.resource_id = None self.class_names = None self.input_fields = [] self.term_forms = {} self.tag_clouds = {} self.term_analysis = {} self.items = {} self.item_analysis = {} self.categories = {} self.coefficients = {} self.data_field_types = {} self.field_codings = {} self.numeric_fields = {} self.bias = None self.missing_numerics = None self.c = None self.eps = None self.lr_normalize = None self.balance_fields = None self.regularization = None old_coefficients = False # checks whether the information needed for local predictions is in # the first argument if isinstance(logistic_regression, dict) and \ not check_model_fields(logistic_regression): # if the fields used by the logistic regression are not # available, use only ID to retrieve it again logistic_regression = get_logistic_regression_id( \ logistic_regression) self.resource_id = logistic_regression if not (isinstance(logistic_regression, dict) and 'resource' in logistic_regression and logistic_regression['resource'] is not None): if api is None: api = BigML(storage=STORAGE) self.resource_id = get_logistic_regression_id(logistic_regression) if self.resource_id is None: raise Exception( api.error_message(logistic_regression, resource_type='logistic_regression', method='get')) query_string = ONLY_MODEL logistic_regression = retrieve_resource( api, self.resource_id, query_string=query_string) else: self.resource_id = get_logistic_regression_id(logistic_regression) if 'object' in logistic_regression and \ isinstance(logistic_regression['object'], dict): logistic_regression = logistic_regression['object'] try: self.input_fields = logistic_regression.get("input_fields", []) self.dataset_field_types = logistic_regression.get( "dataset_field_types", {}) objective_field = logistic_regression['objective_fields'] if \ logistic_regression['objective_fields'] else \ logistic_regression['objective_field'] except KeyError: raise ValueError("Failed to find the logistic regression expected " "JSON structure. Check your arguments.") if 'logistic_regression' in logistic_regression and \ isinstance(logistic_regression['logistic_regression'], dict): status = get_status(logistic_regression) if 'code' in status and status['code'] == FINISHED: logistic_regression_info = logistic_regression[ \ 'logistic_regression'] fields = logistic_regression_info.get('fields', {}) if not self.input_fields: self.input_fields = [ \ field_id for field_id, _ in sorted(self.fields.items(), key=lambda x: x[1].get("column_number"))] self.coefficients.update(logistic_regression_info.get( \ 'coefficients', [])) if not isinstance(self.coefficients.values()[0][0], list): old_coefficients = True self.bias = logistic_regression_info.get('bias', True) self.c = logistic_regression_info.get('c') self.eps = logistic_regression_info.get('eps') self.lr_normalize = logistic_regression_info.get('normalize') self.balance_fields = logistic_regression_info.get( \ 'balance_fields') self.regularization = logistic_regression_info.get( \ 'regularization') self.field_codings = logistic_regression_info.get( \ 'field_codings', {}) # old models have no such attribute, so we set it to False in # this case self.missing_numerics = logistic_regression_info.get( \ 'missing_numerics', False) objective_id = extract_objective(objective_field) ModelFields.__init__( self, fields, objective_id=objective_id, terms=True, categories=True, numerics=True) self.field_codings = logistic_regression_info.get( \ 'field_codings', {}) self.format_field_codings() for field_id in self.field_codings: if field_id not in fields and \ field_id in self.inverted_fields: self.field_codings.update( \ {self.inverted_fields[field_id]: \ self.field_codings[field_id]}) del self.field_codings[field_id] if old_coefficients: self.map_coefficients() categories = self.fields[self.objective_id].get( \ "summary", {}).get('categories') if len(self.coefficients.keys()) > len(categories): self.class_names = [""] else: self.class_names = [] self.class_names.extend(sorted([category[0] for category in categories])) else: raise Exception("The logistic regression isn't finished yet") else: raise Exception("Cannot create the LogisticRegression instance." " Could not find the 'logistic_regression' key" " in the resource:\n\n%s" % logistic_regression)