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, 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, 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):
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)
