def test_retain_vars_attributes(self):
data = Table("iris")
attributes = {"foo": "foo", "baz": 1}
data.domain.attributes[0].attributes = attributes
self.assertDictEqual(
Normalize(norm_type=Normalize.NormalizeBySD)(
data).domain.attributes[0].attributes, attributes)
self.assertDictEqual(
Normalize(norm_type=Normalize.NormalizeBySpan)(
data).domain.attributes[0].attributes, attributes)
def createinstance(params):
method = params.get("method", Scale.NormalizeBySD)
if method == Scale.CenterByMean:
return _Scale(_Scale.CenteringType.Mean,
_Scale.ScalingType.NoScaling)
elif method == Scale.ScaleBySD:
return _Scale(_Scale.CenteringType.NoCentering,
_Scale.ScalingType.Std)
elif method == Scale.NormalizeBySD:
return Normalize(norm_type=Normalize.NormalizeBySD)
elif method == Scale.NormalizeBySpan_ZeroBased:
return Normalize(norm_type=Normalize.NormalizeBySpan)
else: # method == Scale.NormalizeSpan_NonZeroBased
return Normalize(norm_type=Normalize.NormalizeBySpan,
zero_based=False)
def _get_pca(self):
data = self.data
MAX_COMPONENTS = 2
ncomponents = 2
DECOMPOSITIONS = [PCA] # TruncatedSVD
cls = DECOMPOSITIONS[0]
pca_projector = cls(n_components=MAX_COMPONENTS)
pca_projector.component = ncomponents
pca_projector.preprocessors = cls.preprocessors + [Normalize()]
pca = pca_projector(data)
variance_ratio = pca.explained_variance_ratio_
cumulative = np.cumsum(variance_ratio)
self._pca = pca
if not np.isfinite(cumulative[-1]):
self.Warning.trivial_components()
coords = pca(data).X
valid_mask = ~np.isnan(coords).any(axis=1)
# scale axes
max_radius = np.min(
[np.abs(np.min(coords, axis=0)),
np.max(coords, axis=0)])
axes = pca.components_.T.copy()
axes *= max_radius / np.max(np.linalg.norm(axes, axis=1))
return valid_mask, coords, axes
class SGDRegressionLearner(LinearRegressionLearner):
__wraps__ = skl_linear_model.SGDRegressor
preprocessors = SklLearner.preprocessors + [Normalize()]
def __init__(
self,
loss="squared_loss",
penalty="l2",
alpha=0.0001,
l1_ratio=0.15,
fit_intercept=True,
max_iter=5,
tol=None,
shuffle=True,
epsilon=0.1,
n_jobs=1,
random_state=None,
learning_rate="invscaling",
eta0=0.01,
power_t=0.25,
class_weight=None,
warm_start=False,
average=False,
preprocessors=None,
):
super().__init__(preprocessors=preprocessors)
self.params = vars()
class NNBase:
"""Base class for neural network (classification and regression) learners
"""
preprocessors = SklLearner.preprocessors + [Normalize()]
def __init__(self,
hidden_layer_sizes=(100, ),
activation='relu',
solver='adam',
alpha=0.0001,
batch_size='auto',
learning_rate='constant',
learning_rate_init=0.001,
power_t=0.5,
max_iter=200,
shuffle=True,
random_state=None,
tol=0.0001,
verbose=False,
warm_start=False,
momentum=0.9,
nesterovs_momentum=True,
early_stopping=False,
validation_fraction=0.1,
beta_1=0.9,
beta_2=0.999,
epsilon=1e-08,
preprocessors=None):
super().__init__(preprocessors=preprocessors)
self.params = vars()
class SGDRegressionLearner(LinearRegressionLearner):
__wraps__ = skl_linear_model.SGDRegressor
preprocessors = SklLearner.preprocessors + [Normalize()]
# Arguments are needed for signatures, pylint: disable=unused-argument
def __init__(self,
loss='squared_loss',
penalty='l2',
alpha=0.0001,
l1_ratio=0.15,
fit_intercept=True,
max_iter=5,
tol=1e-3,
shuffle=True,
epsilon=0.1,
n_jobs=1,
random_state=None,
learning_rate='invscaling',
eta0=0.01,
power_t=0.25,
class_weight=None,
warm_start=False,
average=False,
preprocessors=None):
super().__init__(preprocessors=preprocessors)
self.params = vars()
def test_normalize_sparse(self):
domain = Domain([ContinuousVariable(str(i)) for i in range(3)])
# pylint: disable=bad-whitespace
X = np.array([
[0, -1, -2],
[0, 1, 2],
])
data = Table.from_numpy(domain, X).to_sparse()
# pylint: disable=bad-whitespace
solution = sp.csr_matrix(np.array([
[0, -1, -1],
[0, 1, 1],
]))
normalizer = Normalize()
normalized = normalizer(data)
self.assertEqual((normalized.X != solution).nnz, 0)
# raise error for non-zero offsets
data.X = sp.csr_matrix(np.array([
[0, 0, 0],
[0, 1, 3],
[0, 2, 4],
]))
with self.assertRaises(ValueError):
normalizer(data)
class SGDClassificationLearner(SklLearner):
name = 'sgd'
__wraps__ = SGDClassifier
__returns__ = LinearModel
preprocessors = SklLearner.preprocessors + [Normalize()]
def __init__(self,
loss='hinge',
penalty='l2',
alpha=0.0001,
l1_ratio=0.15,
fit_intercept=True,
max_iter=5,
tol=None,
shuffle=True,
epsilon=0.1,
random_state=None,
learning_rate='invscaling',
eta0=0.01,
power_t=0.25,
warm_start=False,
average=False,
preprocessors=None):
super().__init__(preprocessors=preprocessors)
self.params = vars()
def test_optimized(self):
"""
Test if optimized works well
"""
lr = self.linear_regression
lr.set_data(self.housing)
op_theta = lr.optimized()
self.assertEqual(len(op_theta), len(self.housing.domain.attributes))
# check if really minimal, function is monotonic so everywhere around
# j should be higher
attr_x = self.housing.domain['CRIM']
attr_y = self.housing.domain['ZN']
cols = []
for attr in (attr_x, attr_y) if attr_y is not None else (attr_x, ):
subset = self.housing[:, attr]
cols.append(subset.X)
x = np.column_stack(cols)
domain = Domain([attr_x, attr_y], self.housing.domain.class_var)
data = Normalize(transform_class=True)(Table(domain, x,
self.housing.Y))
lr.set_data(data)
op_theta = lr.optimized()
self.assertLessEqual(lr.j(op_theta), lr.j(op_theta + np.array([1, 0])))
self.assertLessEqual(lr.j(op_theta), lr.j(op_theta + np.array([0, 1])))
self.assertLessEqual(lr.j(op_theta),
lr.j(op_theta + np.array([-1, 0])))
self.assertLessEqual(lr.j(op_theta),
lr.j(op_theta + np.array([0, -1])))
def test_normalize_default(self):
normalizer = Normalize()
data_norm = normalizer(self.data)
solution = [[0., 1.225, 'a', 'a', '?', 'a', 1.225, 'a', '?', 'a', 2],
[0., -1.225, 'a', 'b', -1., '?', 0., 'b', '?', 'b', 0],
[0., 0., 'a', 'b', 1., 'b', -1.225, 'c', '?', 'c', 1]]
self.compare_tables(data_norm, solution)
def test_normalize_data(self):
# not normalized
self.widget.controls.normalize.setChecked(False)
data = Table("heart_disease")
self.send_signal(self.widget.Inputs.data, data)
kwargs = {
"eps": self.widget.eps,
"min_samples": self.widget.min_samples,
"metric": "euclidean"
}
clusters = DBSCAN(**kwargs)(data)
output = self.get_output(self.widget.Outputs.annotated_data)
output_clusters = output.metas[:, 0].copy()
output_clusters[np.isnan(output_clusters)] = -1
np.testing.assert_array_equal(output_clusters, clusters)
# normalized
self.widget.controls.normalize.setChecked(True)
kwargs = {
"eps": self.widget.eps,
"min_samples": self.widget.min_samples,
"metric": "euclidean"
}
for pp in (Continuize(), Normalize(), SklImpute()):
data = pp(data)
clusters = DBSCAN(**kwargs)(data)
output = self.get_output(self.widget.Outputs.annotated_data)
output_clusters = output.metas[:, 0].copy()
output_clusters[np.isnan(output_clusters)] = -1
np.testing.assert_array_equal(output_clusters, clusters)
def __init__(self,
preprocessors=None,
penalty=1,
opt_penalty=False,
rule_learner=None,
basic_attributes=True,
fit_intercept=True,
intercept_scaling=2,
penalize_rules=True):
"""
Parameters
----------
preprocessors :
A sequence of data preprocessors to apply on data prior to
fitting the model.
penalty : L2-penalty in loss function.
rule_learner: Rule learner used to construct new attributes.
fit_intercept: Should we add a constant column to data?
intercept_scaling: Value of constant in the intercept column. Note that
intercept column is appended after normalization, therefore higher
values will be less affected by penalization.
"""
super().__init__(preprocessors)
self.penalty = penalty
self.opt_penalty = opt_penalty
self.rule_learner = rule_learner
self.fit_intercept = fit_intercept
self.intercept_scaling = intercept_scaling
self.basic_attributes = basic_attributes
self.penalize_rules = penalize_rules
# Post rule learning preprocessing should not decrease the
# number of examples.
self.post_rule_preprocess = [Normalize(), Continuize()]
def fit(self):
self.clear()
self.start_button.setEnabled(False)
if self.data is None:
return
data = self.data
self._transformed = None
if isinstance(data, SqlTable): # data was big and remote available
self.sampling_box.setVisible(True)
self.start_button.setText("Start remote computation")
self.start_button.setEnabled(True)
else:
# TODO move the following normalization outside
# so it is applied for SqlTables as well (when it works on them)
if self.normalize:
data = Normalize(data)
self.sampling_box.setVisible(False)
pca = Orange.projection.PCA()
pca = pca(data)
variance_ratio = pca.explained_variance_ratio_
cumulative = numpy.cumsum(variance_ratio)
self.components_spin.setRange(0, len(cumulative))
self._pca = pca
self._variance_ratio = variance_ratio
self._cumulative = cumulative
self._setup_plot()
self.unconditional_commit()
def test_skip_normalization(self):
data = self.data.copy()
for attr in data.domain.attributes:
attr.attributes = {'skip-normalization': True}
normalizer = Normalize()
normalized = normalizer(data)
np.testing.assert_array_equal(data.X, normalized.X)
def preproces(self, data):
if self.normalize:
if sp.issparse(data.X):
self.Warning.no_sparse_normalization()
else:
data = Normalize()(data)
for preprocessor in KMeans.preprocessors: # use same preprocessors than
data = preprocessor(data)
return data
def test_normalize_transform_by_span_zero_class(self):
normalizer = Normalize(zero_based=True,
norm_type=Normalize.NormalizeBySpan,
transform_class=True)
data_norm = normalizer(self.data)
solution = [[0., 1., 'a', 'a', '?', 'a', 1., 'a', '?', 'a', 1.],
[0., 0., 'a', 'b', 0., '?', 0.5, 'b', '?', 'b', 0.],
[0., 0.5, 'a', 'b', 1., 'b', 0., 'c', '?', 'c', 0.5]]
self.compare_tables(data_norm, solution)
def test_normalize_default(self):
normalizer = Normalize()
data_norm = normalizer(self.data)
solution = [
[0.0, 1.225, "a", "a", "?", "a", 1.225, "a", "a", 2],
[0.0, -1.225, "a", "b", -1.0, "?", 0.0, "b", "b", 0],
[0.0, 0.0, "a", "b", 1.0, "b", -1.225, "c", "c", 1],
]
self.compare_tables(data_norm, solution)
def _update_normalize(self):
if self.normalize:
pp = self._pca_preprocessors + [Normalize()]
else:
pp = self._pca_preprocessors
self._pca_projector.preprocessors = pp
self.fit()
if self.data is None:
self._invalidate_selection()
def test_normalize_transform_by_sd(self):
normalizer = Normalize(zero_based=False,
norm_type=Normalize.NormalizeBySD,
transform_class=False)
data_norm = normalizer(self.data)
solution = [[0., 1.225, 'a', 'a', '?', 'a', 1.225, 'a', '?', 'a', 2],
[0., -1.225, 'a', 'b', -1., '?', 0., 'b', '?', 'b', 0],
[0., 0., 'a', 'b', 1., 'b', -1.225, 'c', '?', 'c', 1]]
self.compare_tables(data_norm, solution)
def setUp(self):
self.data = Table("iris")
self.data = Normalize()(self.data)
self.X, self.y = self.data.X, self.data.Y
self.m, self.n = self.X.shape
self.k = len(self.data.domain.class_var.values)
self.X1 = np.hstack((np.ones((self.m, 1)), self.X))
self.theta = np.ones((self.k, self.n + 1)).flatten()
self.sm = SoftmaxLearner()
self.sm_reg = SoftmaxLearner_reg()
def test_normalize_transform_by_span_class(self):
data = Table("test5.tab")
normalizer = Normalize(zero_based=False,
norm_type=Normalize.NormalizeBySpan,
transform_class=True)
data_norm = normalizer(data)
solution = [[0., 1., 'a', 'a', '?', 'a', 1., 'a', 'a', 1.],
[0., -1., 'a', 'b', -1., '?', 0., 'b', 'b', -1.],
[0., 0., 'a', 'b', 1., 'b', -1., 'c', 'c', 0.]]
self.compare_tables(data_norm, solution)
def test_datetime_normalization(self):
data = Table(test_filename("datasets/test10.tab"))
normalizer = Normalize(zero_based=False,
norm_type=Normalize.NormalizeBySD,
transform_class=False)
data_norm = normalizer(data)
solution = [[0., '1995-01-21', 'a', 'a', '?', 'a', 1.225, 'a', '?', 'a', 2],
[0., '2003-07-23', 'a', 'b', -1., '?', 0., 'b', '?', 'b', 0],
[0., '1967-03-12', 'a', 'b', 1., 'b', -1.225, 'c', '?', 'c', 1]]
self.compare_tables(data_norm, solution)
def test_abs_error_normalized(self):
tab = Table('housing')
normalizer = Normalize(zero_based=True,
norm_type=Normalize.NormalizeBySpan)
tab = normalizer(tab)
icr = InductiveRegressor(AbsError(LinearRegressionLearner()))
icr_knn = InductiveRegressor(AbsError(KNNRegressionLearner(4)))
icr_norm = InductiveRegressor(
AbsErrorNormalized(KNNRegressionLearner(4),
Euclidean,
4,
exp=False))
icr_norm_exp = InductiveRegressor(
AbsErrorNormalized(KNNRegressionLearner(4), Euclidean, 4,
exp=True))
icr_norm_rf = InductiveRegressor(
AbsErrorNormalized(KNNRegressionLearner(4),
Euclidean,
4,
rf=RandomForestRegressor()))
r, r_knn, r_norm, r_norm_exp, r_norm_rf = ResultsRegr(), ResultsRegr(
), ResultsRegr(), ResultsRegr(), ResultsRegr()
eps = 0.05
for rep in range(10):
for train, test in CrossSampler(tab, 10):
train, calibrate = next(
RandomSampler(train,
len(train) - 100, 100))
r.concatenate(run_train_test(icr, eps, train, test, calibrate))
r_knn.concatenate(
run_train_test(icr_knn, eps, train, test, calibrate))
r_norm.concatenate(
run_train_test(icr_norm, eps, train, test, calibrate))
r_norm_exp.concatenate(
run_train_test(icr_norm_exp, eps, train, test, calibrate))
r_norm_rf.concatenate(
run_train_test(icr_norm_rf, eps, train, test, calibrate))
print(r.median_range(), r.interdecile_mean(), 1 - r.accuracy())
print(r_knn.median_range(), r_knn.interdecile_mean(),
1 - r_knn.accuracy())
print(r_norm.median_range(), r_norm.interdecile_mean(),
1 - r_norm.accuracy())
print(r_norm_exp.median_range(), r_norm_exp.interdecile_mean(),
1 - r_norm_exp.accuracy())
print(r_norm_rf.median_range(), r_norm_rf.interdecile_mean(),
1 - r_norm_rf.accuracy())
self.assertGreater(r.accuracy(), 1 - eps - 0.03)
self.assertGreater(r_knn.accuracy(), 1 - eps - 0.03)
self.assertGreater(r_norm.accuracy(), 1 - eps - 0.03)
self.assertGreater(r_norm_exp.accuracy(), 1 - eps - 0.03)
self.assertGreater(r_norm_rf.accuracy(), 1 - eps - 0.03)
"""
def test_PCA_scorer(self):
data = self.iris
pca = PCA(preprocessors=[Normalize()])
pca.component = 1
scores = pca.score_data(data)
self.assertEqual(scores.shape[1], len(data.domain.attributes))
self.assertEqual(['petal length', 'petal width'],
sorted([data.domain.attributes[i].name
for i in np.argsort(scores[0])[-2:]]))
self.assertEqual([round(s, 4) for s in scores[0]],
[0.5224, 0.2634, 0.5813, 0.5656])
def test_normalize_transform_by_span_class(self):
normalizer = Normalize(zero_based=False,
norm_type=Normalize.NormalizeBySpan,
transform_class=True)
data_norm = normalizer(self.data)
solution = [
[0.0, 1.0, "a", "a", "?", "a", 1.0, "a", "a", 1.0],
[0.0, -1.0, "a", "b", -1.0, "?", 0.0, "b", "b", -1.0],
[0.0, 0.0, "a", "b", 1.0, "b", -1.0, "c", "c", 0.0],
]
self.compare_tables(data_norm, solution)
def init_projection(self):
if self.placement == Placement.Circular:
self.projector = CircularPlacement()
elif self.placement == Placement.LDA:
self.projector = LDA(solver="eigen", n_components=2)
elif self.placement == Placement.PCA:
self.projector = PCA(n_components=2)
self.projector.component = 2
self.projector.preprocessors = PCA.preprocessors + [Normalize()]
super().init_projection()
def test_number_of_decimals(self):
foo = ContinuousVariable("Foo", number_of_decimals=0)
data = Table.from_list(Domain((foo, )), [[1], [2], [3]])
normalized = Normalize()(data)
norm_foo: ContinuousVariable = normalized.domain.attributes[0]
self.assertGreater(norm_foo.number_of_decimals, 0)
for val1, val2 in zip(normalized[:, "Foo"],
["-1.225", "0.0", "1.225"]):
self.assertEqual(str(val1[0]), val2)
def test_PCA_scorer(self):
data = Orange.data.Table('iris')
pca = PCA(preprocessors=[Normalize()])
scores = pca.score_data(data)
self.assertEqual(len(scores), len(data.domain.attributes))
self.assertEqual(['petal length', 'petal width'],
sorted([
data.domain.attributes[i].name
for i in np.argsort(scores)[-2:]
]))
self.assertEqual([round(s, 4) for s in scores],
[0.5224, 0.2634, 0.5813, 0.5656])
def get_clusters_of_attributes(self):
"""
Generates groupes of attribute IDs, grouped by cluster. Clusters are
obtained by KMeans algorithm.
:return: generator of attributes grouped by cluster
"""
data = Normalize()(self.data).X.T
kmeans = KMeans(n_clusters=self.n_clusters, random_state=0).fit(data)
labels_attrs = sorted([(l, i) for i, l in enumerate(kmeans.labels_)])
return [Cluster(instances=list(pair[1] for pair in group),
centroid=kmeans.cluster_centers_[l])
for l, group in groupby(labels_attrs, key=lambda x: x[0])]
def get_clusters_of_attributes(self):
"""
Generates groupes of attribute IDs, grouped by cluster. Clusters are
obtained by KMeans algorithm.
:return: generator of attributes grouped by cluster
"""
data = Normalize()(self.data).X.T
kmeans = KMeans(n_clusters=self.n_clusters, random_state=0).fit(data)
labels_attrs = sorted([(l, i) for i, l in enumerate(kmeans.labels_)])
for _, group in groupby(labels_attrs, key=lambda x: x[0]):
group = list(group)
if len(group) > 1:
yield list(pair[1] for pair in group)
def test(datasets=(),
normalization="stdev", reorder='none', score='probability',
print_latex=True, k=10, eps=1e-15):
global results
#print("%% normalization=%s,reorder=%s,score=%s, %%" % (normalization, reorder, score))
if print_latex:
print(r"\begin{tabular}{ l r r r }")
print(r"dataset & S(k-means) & S(gmm)& S(lac) \\")
print(r"\hline")
results = []
#for ds in [Table('vehicle', name='vehicle')]:
#for ds in GDS_datasets():
for ds2 in datasets:
np.random.seed(42)
#for ds in temporal_datasets():
ds = impute(ds2)
ds.name = ds2.name
n_steps = 99
if normalization == 'none' or normalization is None:
pass
elif normalization == '01':
ds = Normalize(norm_type=Normalize.NormalizeBySpan)(ds)
elif normalization == 'stdev':
ds = Normalize(norm_type=Normalize.NormalizeBySD)(ds)
else:
raise AttributeError('Unknonwn normalization type "%s"' % (normalization,))
if reorder == 'none' or reorder is None:
pass
elif reorder == 'shuffle':
np.random.shuffle(x.T)
elif reorder == 'covariance':
ds = reorder_attributes_covariance(ds)
elif reorder == 'probability':
ds = reorder_attributes_probability_score(ds, k)
else:
raise AttributeError('Unknown feature reordering type "%s"' % (reorder,))
if score == 'covariance':
scorer = covariance_score
elif score == 'probability':
scorer = probability_score
elif score == 'global_probability':
scorer = global_probability_score
elif score == 'best_triplet':
scorer = best_triplet_variance_score
elif score == 'best_triplet_probability':
scorer = best_triplet_probability_score
elif score == 'silhouette':
scorer = silhouette_score
elif score == 'silhouette_d':
scorer = silhouette_d_score
else:
raise AttributeError('Unknown scorer type "%s"' % (score,))
all_lac_scores = []
for n in range(10,11):
#print('.', end='')
lac = LAC(ds, k)
all_lac_scores.append((lac.k, scorer(lac, ds.X)))
# print()
# for i in range(10, 11):
# lac_scores = [s for k, s in all_lac_scores if k == i]
# print("lac, %i, %f, %f, %f, %f" % (i, min(lac_scores or [0]), min([l for l in lac_scores if l] or [0]), max(lac_scores or [0]), sum([l for l in lac_scores if l] or [0]) / len([l for l in lac_scores if l] or [0])))
realk = max(k for k, s in all_lac_scores)
#if lac.k < 2:
# continue
try:
lac = LAC(ds, realk)
km = KM(ds.X, realk)
gmm = GMM(ds.X, realk)
except:
print("Error")
continue
lac_score = scorer(lac, ds.X)
opts = dict(defined_=lac_score.defined) if hasattr(lac_score, 'defined') else {}
km_score = scorer(km, ds.X)
km_score_d = scorer(km, ds.X, **opts)
gmm_score = scorer(gmm, ds.X)
gmm_score_d = scorer(gmm, ds.X, **opts)
knn_score = LouAUC(ds)
results.append((km_score, gmm_score, lac_score))
if not print_latex:
print("dataset: %s (%s rows, %s features)" % (ds.name, len(ds), len(ds.domain)))
print("normalization: ", normalization)
print("reorder: ", reorder)
print("scoring function: ", score)
print("----------------")
print("k-means: %.5f" % km_score)
print("gmm: %.5f" % gmm_score)
print("k-means (dropout): %.5f" % km_score_d)
print("gmm (dropout): %.5f" % gmm_score_d)
print("lac: %.5f" % lac_score)
print("----------------")
print("knn AUC (lou) %.5f" % knn_score)
print("----------------")
print("k=%s, dropout %s (%.1f%%)" % (realk, sum(~lac_score.defined), (sum(~lac_score.defined) / len(
ds.X)) *
100))
print()
print()
# print("%s,%s,%s,%s,%f,%f,%f,%i,%f,%f" % (normalization, reorder, score, ds.name, km_score, gmm_score,
# lac_score, realk, sum(~lac_score.defined), sum(~lac_score.defined) /
# len(ds.X)))
w1, _ = get_cluster_weights(lac.priors, lac.means, lac.covars, ds.X, crisp=False)
w2, _ = get_cluster_weights(lac.priors, lac.means, lac.covars, ds.X, crisp=True)
w2 = np.argmax(w2, axis=1)[:, None]
domain = Domain([ContinuousVariable("p%d" % i) for i in range(w1.shape[1])])
probs = Table(domain, w1)
labels = Table(Domain([DiscreteVariable("label", values=list(range(k)))]), w2)
ds2.name = ds2.name.replace("/", "_")
ds.name = ds2.name.replace("/", "_")
tbl = Table.concatenate((ds, probs, labels))
tbl.save(os.path.join('output', ds2.name + ".lac.tab"))
def annotate(minis):
def _annotate(ax):
for m in minis:
ax.plot([m-1, m, m+1], [.5, .5, .5])
return _annotate
parallel_coordinates_plot(ds.name + ".kmeans.pdf", ds.X,
means=km.means, stdevs=np.sqrt(km.covars), annotate=annotate(km.minis))
parallel_coordinates_plot(ds.name + ".lac.pdf", ds.X,
means=lac.means, stdevs=np.sqrt(lac.covars), annotate=annotate(lac.minis))
parallel_coordinates_plot(ds.name + ".gmm.pdf", ds.X,
means=gmm.means, stdevs=np.sqrt(gmm.covars), annotate=annotate(gmm.minis))
import matplotlib.pyplot as plt
import matplotlib.mlab as mlab
import math
#iris = Table("wine")
#for m in range(lac.means.shape[1]):
# plt.clf()
# for p, mean, variance, c in zip(lac.priors, lac.means[:, m], lac.covars[:, m], "grb"):
# sigma = math.sqrt(variance)
# x = np.linspace(0,1,100)
# plt.plot(x,p * mlab.normpdf(x, mean,sigma), color=c)
# plt.plot(ds.X[:, m].ravel() + np.random.random(len(ds)) * 0.02, [0.05]*len(ds.X) + iris.Y.ravel() * 0.1,
# "k|")
# plt.ylabel("pdf")
# plt.xlabel(iris.domain[m].name)
# plt.savefig("axis-%d.pdf" % m)
if print_latex:
print(r"\end{tabular}")
results = np.array(results)
