(Orange.data.Table(newdomain, data), weight_id),
indices)
newStat = self.stat(res)[0]
newStats = [
self.stat(x)[0] for x in
Orange.evaluation.scoring.split_by_iterations(res)
]
print "+", newStat, newdomain
## If stat has increased (ie newStat is better than bestStat)
if cmp(newStat,
bestStat) == self.statsign and statc.wilcoxont(
oldStats, newStats)[1] < self.add_threshold:
bestStat, bestStats, bestAttr = newStat, newStats, attr
if bestAttr:
domain = Orange.data.Domain(domain.attributes + [bestAttr],
classVar)
oldStat, oldStats = bestStat, bestStats
stop = False
print "added", bestAttr.name
return self.learner(Orange.data.Table(domain, data), weight_id)
StepwiseLearner = deprecated_members(
{
"removeThreshold": "remove_threshold",
"addThreshold": "add_threshold"
}, )(StepwiseLearner)
j = i + 1 if self.intercept else i
dict_model[var.name] = (coefficients[j], \
std_error[j],\
t_scores[j],\
p_vals[j])
return LinearRegression(domain.class_var, domain, coefficients, F,
std_error=std_error, t_scores=t_scores, p_vals=p_vals, dict_model=dict_model,
fitted=fitted, residuals=residuals, m=m, n=n, mu_y=mu_y,
r2=r2, r2adj=r2adj, sst=sst, sse=sse, ssr=ssr,
std_coefficients=std_coefficients, intercept=self.intercept)
deprecated_members({"ridgeLambda": "ridge_lambda",
"computeStats": "compute_stats",
"useVars": "use_vars",
"addSig": "add_sig",
"removeSig": "remove_sig",
}
, ["__init__"],
in_place=True)(LinearRegressionLearner)
class LinearRegression(Orange.classification.Classifier):
"""Linear regression predicts value of the response variable
based on the values of independent variables.
.. attribute:: F
F-statistics of the model.
.. attribute:: coefficients
domain = Orange.data.Domain(filter(lambda x: x!=bestAttr, domain.attributes), classVar)
oldStat, oldStats = bestStat, bestStats
stop = False
print "removed", bestAttr.name
bestStat, bestAttr = oldStat, None
for attr in data.domain.attributes:
if not attr in domain.attributes:
newdomain = Orange.data.Domain(domain.attributes + [attr], classVar)
res = Orange.evaluation.testing.test_with_indices([self.learner], (Orange.data.Table(newdomain, data), weight_id), indices)
newStat = self.stat(res)[0]
newStats = [self.stat(x)[0] for x in Orange.evaluation.scoring.split_by_iterations(res)]
print "+", newStat, newdomain
## If stat has increased (ie newStat is better than bestStat)
if cmp(newStat, bestStat) == self.statsign and statc.wilcoxont(oldStats, newStats)[1] < self.add_threshold:
bestStat, bestStats, bestAttr = newStat, newStats, attr
if bestAttr:
domain = Orange.data.Domain(domain.attributes + [bestAttr], classVar)
oldStat, oldStats = bestStat, bestStats
stop = False
print "added", bestAttr.name
return self.learner(Orange.data.Table(domain, data), weight_id)
StepwiseLearner = deprecated_members(
{"removeThreshold": "remove_threshold",
"addThreshold": "add_threshold"},
)(StepwiseLearner)
d = nd
# normalizing multiplier
sum = 0.0
for i in d:
sum += i[2]*i[2]*i[1]
f = numpy.sqrt(distnorm/numpy.max(sum,1e-6))
# transform O
k = 0
for i in d:
for j in range(i[1]):
(ii,jj) = o[k][1]
self.distances[ii,jj] = f*i[2]
k += 1
assert(len(o) == k)
self.freshD = 0
return effect
MDS = deprecated_members({"projectedDistances": "projected_distances",
"originalDistances": "original_distances",
"avgStress": "avg_stress",
"progressCallback": "progress_callback",
"getStress": "calc_stress",
"get_stress": "calc_stress",
"calcStress": "calc_stress",
"getDistance": "calc_distance",
"get_distance": "calc_distance",
"calcDistance": "calc_distance",
"Torgerson": "torgerson",
"SMACOFstep": "smacof_step",
"LSMT": "lsmt"})(MDS)
dict_model[var.name] = (coefficients[i], std_errors_fixed_t[i],
p_vals[i])
return LassoRegression(domain=domain,
class_var=domain.class_var,
coef0=coef0,
coefficients=coefficients,
std_errors_fixed_t=std_errors_fixed_t,
p_vals=p_vals,
dict_model=dict_model,
mu_x=mu_x)
deprecated_members({
"nBoot": "n_boot",
"nPerm": "n_perm"
},
wrap_methods=["__init__"],
in_place=True)(LassoRegressionLearner)
class LassoRegression(Orange.classification.Classifier):
"""Lasso regression predicts value of the response variable
based on the values of independent variables.
.. attribute:: coef0
Intercept (sample mean of the response variable).
.. attribute:: coefficients
Regression coefficients, sotred in list.
if True or self.deflation_mode == "regression":
# Estimate regression coefficient
# Y = TQ' + E = X W(P'W)^-1Q' + E = XB + E
# => B = W*Q' (p x q)
coefs = dot(xRotations, Q.T)
coefs = 1. / sigmaX.reshape((p, 1)) * \
coefs * sigmaY
return {"mu_x": muX, "mu_y": muY, "sigma_x": sigmaX,
"sigma_y": sigmaY, "T": T, "U":U, "W":U,
"C": C, "P":P, "Q":Q, "x_rotations": xRotations,
"y_rotations": yRotations, "coefs": coefs}
deprecated_members({"nComp": "n_comp",
"deflationMode": "deflation_mode",
"maxIter": "max_iter"},
wrap_methods=["__init__"],
in_place=True)(PLSRegressionLearner)
class PLSRegression(Orange.classification.Classifier):
""" PLSRegression predicts value of the response variables
based on the values of independent variables.
Basic notations:
n - number of data instances
p - number of independent variables
q - number of reponse variables
.. attribute:: T
A n x n_comp numpy array of x-scores
if isinstance(aclass, (list, tuple)):
self.classes[i] = aclass
self.probabilities[i] = aprob
elif type(aclass.value) == float:
self.classes[i] = float(aclass)
self.probabilities[i] = aprob
else:
self.classes[i] = int(aclass)
self.probabilities[i] = list(aprob)
def __repr__(self):
return str(self.__dict__)
TestedExample = deprecated_members({
"iterationNumber": "iteration_number",
"actualClass": "actual_class"
})(TestedExample)
class ExperimentResults(object):
"""
``ExperimentResults`` stores results of one or more repetitions of
some test (cross validation, repeated sampling...) under the same
circumstances.
:var results: A list of instances of :obj:`TestedExample`, one for each example in the dataset.
:var classifiers: A list of classifiers, one element for each repetition (eg. fold). Each element is a list
of classifiers, one for each learner. This field is used only if storing is enabled by ``storeClassifiers=1``.
:var number_of_iterations: Number of iterations. This can be the number of folds (in cross validation)
or the number of repetitions of some test. :obj:`TestedExample`'s attribute ``iteration_number`` should
be in range ``[0, number_of_iterations-1]``.
setattr(self, name, value)
self.__init__(**argkw)
return self.__call__(data, weight_id)
else:
return self
def findobj(self, name):
import string
names = string.split(name, ".")
lastobj = self.object
for i in names[:-1]:
lastobj = getattr(lastobj, i)
return lastobj, names[-1]
TuneParameters = deprecated_members(
{"returnWhat": "return_what",
"object": "learner"},
)(TuneParameters)
class Tune1Parameter(TuneParameters):
"""Class :obj:`Orange.optimization.Tune1Parameter` tunes a single parameter.
.. attribute:: parameter
The name of the parameter (or a list of names, if the same parameter is
stored at multiple places - see the examples) to be tuned.
.. attribute:: values
A list of parameter's values to be tried.
return self.__call__(data, weight_id)
else:
return self
def findobj(self, name):
import string
names = string.split(name, ".")
lastobj = self.object
for i in names[:-1]:
lastobj = getattr(lastobj, i)
return lastobj, names[-1]
TuneParameters = deprecated_members(
{
"returnWhat": "return_what",
"object": "learner"
}, )(TuneParameters)
class Tune1Parameter(TuneParameters):
"""Class :obj:`Orange.optimization.Tune1Parameter` tunes a single parameter.
.. attribute:: parameter
The name of the parameter (or a list of names, if the same parameter is
stored at multiple places - see the examples) to be tuned.
.. attribute:: values
A list of parameter's values to be tried.
attributes = data.domain.features[:]
if lr in attributes:
attributes.remove(lr)
else:
attributes.remove(lr.getValueFrom.variable)
new_domain = Orange.data.Domain(attributes,
data.domain.class_var)
new_domain.addmetas(data.domain.getmetas())
data = data.select(new_domain)
lr = learner.fit_model(data, weight)
return lr
LogRegLearner = deprecated_members({"removeSingular": "remove_singular",
"weightID": "weight_id",
"stepwiseLR": "stepwise_lr",
"addCrit": "add_crit",
"deleteCrit": "delete_crit",
"numFeatures": "num_features",
"removeMissing": "remove_missing"
})(LogRegLearner)
class UnivariateLogRegLearner(Orange.classification.Learner):
def __new__(cls, data=None, **argkw):
self = Orange.classification.Learner.__new__(cls, **argkw)
if data:
self.__init__(**argkw)
return self.__call__(data)
else:
return self
def __init__(self, **kwds):
self.__dict__.update(kwds)
return self.best
def winner_index(self):
"""Return the index of the optimal object within the sequence of
the candidates.
:rtype: int
"""
if self.best is not None:
return self.best_index
else:
return None
BestOnTheFly = deprecated_members({"callCompareOn1st": "call_compare_on_1st",
"winnerIndex": "winner_index",
"randomGenerator": "random_generator",
"bestIndex": "best_index"
},
wrap_methods=["__init__"])(BestOnTheFly)
@deprecated_keywords({"callCompareOn1st": "call_compare_on_1st"})
def select_best(x, compare=cmp, seed = 0, call_compare_on_1st = False):
"""Return the optimal object from list x. The function is used if the candidates
are already in the list, so using the more complicated :obj:`BestOnTheFly` directly is
not needed.
To demonstrate the use of :obj:`BestOnTheFly` see the implementation of
:obj:`selectBest`::
def selectBest(x, compare=cmp, seed = 0, call_compare_on_1st = False):
bs=BestOnTheFly(compare, seed, call_compare_on_1st)
sum = 0.0
for i in d:
sum += i[2] * i[2] * i[1]
f = numpy.sqrt(distnorm / numpy.max(sum, 1e-6))
# transform O
k = 0
for i in d:
for j in range(i[1]):
(ii, jj) = o[k][1]
self.distances[ii, jj] = f * i[2]
k += 1
assert (len(o) == k)
self.freshD = 0
return effect
MDS = deprecated_members({
"projectedDistances": "projected_distances",
"originalDistances": "original_distances",
"avgStress": "avg_stress",
"progressCallback": "progress_callback",
"getStress": "calc_stress",
"get_stress": "calc_stress",
"calcStress": "calc_stress",
"getDistance": "calc_distance",
"get_distance": "calc_distance",
"calcDistance": "calc_distance",
"Torgerson": "torgerson",
"SMACOFstep": "smacof_step",
"LSMT": "lsmt"
})(MDS)
attributes = data.domain.features[:]
if lr in attributes:
attributes.remove(lr)
else:
attributes.remove(lr.getValueFrom.variable)
new_domain = Orange.data.Domain(attributes, data.domain.class_var)
new_domain.addmetas(data.domain.getmetas())
data = data.select(new_domain)
lr = learner.fit_model(data, weight)
return lr
LogRegLearner = deprecated_members({
"removeSingular": "remove_singular",
"weightID": "weight_id",
"stepwiseLR": "stepwise_lr",
"addCrit": "add_crit",
"deleteCrit": "delete_crit",
"numFeatures": "num_features",
"removeMissing": "remove_missing"
})(LogRegLearner)
class UnivariateLogRegLearner(Orange.classification.Learner):
def __new__(cls, data=None, **argkw):
self = Orange.classification.Learner.__new__(cls, **argkw)
if data:
self.__init__(**argkw)
return self.__call__(data)
else:
return self
def winner_index(self):
"""Return the index of the optimal object within the sequence of
the candidates.
:rtype: int
"""
if self.best is not None:
return self.best_index
else:
return None
BestOnTheFly = deprecated_members(
{
"callCompareOn1st": "call_compare_on_1st",
"winnerIndex": "winner_index",
"randomGenerator": "random_generator",
"bestIndex": "best_index"
},
wrap_methods=["__init__"])(BestOnTheFly)
@deprecated_keywords({"callCompareOn1st": "call_compare_on_1st"})
def select_best(x, compare=cmp, seed=0, call_compare_on_1st=False):
"""Return the optimal object from list x. The function is used if the candidates
are already in the list, so using the more complicated :obj:`BestOnTheFly` directly is
not needed.
To demonstrate the use of :obj:`BestOnTheFly` see the implementation of
:obj:`selectBest`::
def selectBest(x, compare=cmp, seed = 0, call_compare_on_1st = False):
n=n,
mu_y=mu_y,
r2=r2,
r2adj=r2adj,
sst=sst,
sse=sse,
ssr=ssr,
std_coefficients=std_coefficients,
intercept=self.intercept)
deprecated_members(
{
"ridgeLambda": "ridge_lambda",
"computeStats": "compute_stats",
"useVars": "use_vars",
"addSig": "add_sig",
"removeSig": "remove_sig",
}, ["__init__"],
in_place=True)(LinearRegressionLearner)
class LinearRegression(Orange.classification.Classifier):
"""Linear regression predicts value of the response variable
based on the values of independent variables.
.. attribute:: F
F-statistics of the model.
.. attribute:: coefficients
# dictionary of regression coefficients with standard errors
# and p-values
dict_model = {}
for i, var in enumerate(domain.attributes):
dict_model[var.name] = (coefficients[i], std_errors_fixed_t[i], p_vals[i])
return LassoRegression(domain=domain, class_var=domain.class_var,
coef0=coef0, coefficients=coefficients,
std_errors_fixed_t=std_errors_fixed_t,
p_vals=p_vals,
dict_model=dict_model,
mu_x=mu_x)
deprecated_members({"nBoot": "n_boot",
"nPerm": "n_perm"},
wrap_methods=["__init__"],
in_place=True)(LassoRegressionLearner)
class LassoRegression(Orange.classification.Classifier):
"""Lasso regression predicts value of the response variable
based on the values of independent variables.
.. attribute:: coef0
Intercept (sample mean of the response variable).
.. attribute:: coefficients
Regression coefficients, sotred in list.
.. attribute:: std_errors_fixed_t
