Python Table.concatenate方法代码示例

# 需要导入模块: from Orange.data import Table [as 别名]
# 或者: from Orange.data.Table import concatenate [as 别名]
 def add_data(self, time=0.4):
     if self.data and len(self.data) > 2000:
         return self.__timer.stop()
     data_sample = self.sql_data.sample_time(time, no_cache=True)
     if data_sample:
         data_sample.download_data(2000, partial=True)
         data = Table(data_sample)
         self.data = Table.concatenate((self.data, data), axis=0)
         self.handleNewSignals()

# 需要导入模块: from Orange.data import Table [as 别名]
# 或者: from Orange.data.Table import concatenate [as 别名]
    def compute_distances(self):
        self.Error.diff_domains.clear()
        if self.data is None or len(self.data) == 0 \
                or self.reference is None or len(self.reference) == 0:
            self.distances = None
            return
        if self.reference.domain != self.data.domain:
            self.Error.diff_domains()
            self.distances = None
            return

        distance = METRICS[self.distance_index][1]
        n_ref = len(self.reference)
        all_data = Table.concatenate([self.reference, self.data], 0)
        pp_all_data = Impute()(RemoveNaNColumns()(all_data))
        pp_reference, pp_data = pp_all_data[:n_ref], pp_all_data[n_ref:]
        self.distances = distance(pp_data, pp_reference).min(axis=1)

# 需要导入模块: from Orange.data import Table [as 别名]
# 或者: from Orange.data.Table import concatenate [as 别名]
def add_results_to_items(G, lblhistory):
    items = G.items()
    if items is not None and CLUSTERING_LABEL in items.domain:
        domain = Domain([a for a in items.domain.attributes
                         if a.name != CLUSTERING_LABEL],
                        items.domain.class_vars,
                        items.domain.metas)
        items = Table.from_table(domain, items)

    attrs = [DiscreteVariable(CLUSTERING_LABEL,
                              values=list(set([l for l in lblhistory[-1]])))]
    domain = Domain(attrs)
    data = Table(domain, [[l] for l in lblhistory[-1]])

    if items is None:
        G.set_items(data)
    else:
        G.set_items(Table.concatenate((items, data)))

# 需要导入模块: from Orange.data import Table [as 别名]
# 或者: from Orange.data.Table import concatenate [as 别名]
 def apply(self):
     if self.data is None or self.reference is None:
         self.send("Neighbors", None)
         return
     distance = METRICS[self.distance_index][1]
     n_data, n_ref = len(self.data), len(self.reference)
     all_data = Table.concatenate([self.reference, self.data], 0)
     pp_all_data = Impute()(RemoveNaNColumns()(all_data))
     pp_data, pp_reference = pp_all_data[n_ref:], pp_all_data[:n_ref]
     dist = distance(np.vstack((pp_data, pp_reference)))[:n_data, n_data:]
     data = self._add_similarity(self.data, dist)
     sorted_indices = list(np.argsort(dist.flatten()))[::-1]
     indices = []
     while len(sorted_indices) > 0 and len(indices) < self.n_neighbors:
         index = int(sorted_indices.pop() / len(self.reference))
         if (self.data[index] not in self.reference or
                 not self.exclude_reference) and index not in indices:
             indices.append(index)
     neighbors = data[indices]
     neighbors.attributes = self.data.attributes
     self.send("Neighbors", neighbors)

# 需要导入模块: from Orange.data import Table [as 别名]
# 或者: from Orange.data.Table import concatenate [as 别名]
def add_history_to_items(G, lblhistory):
    items = G.items()
    if items is not None:
        domain = Domain([a for a in items.domain.attributes
                         if not _is_history_attr(a.name)],
                        items.domain.class_vars,
                        items.domain.metas)
        items = Table.from_table(domain, items)

    attrs = [DiscreteVariable('c' + str(i),
                              values=list(set(lblhistory[0])))
             for i in range(len(lblhistory))]

    domain = Domain(attrs)
    # transpose history
    data = [list(i) for i in zip(*lblhistory)]
    data = Table(domain, data)
    if items is None:
        G.set_items(data)
    else:
        G.set_items(Table.concatenate((items, data)))

# 需要导入模块: from Orange.data import Table [as 别名]
# 或者: from Orange.data.Table import concatenate [as 别名]
    def send_data(self):
        if len(self.job_queue) <= 0 and len(self.job_working) <= 0:
            self.btnCommit.setChecked(False)
            self.btnStopA.setEnabled(False)

            if self.analdata is not None and len(self.analdata) > 0 and \
                                                    len(self.analfeatures) > 0:
                vars = []
                analdata = []
                for name, var in self.analfeatures:
                    analdata.append(self.analdata[name])
                    vars.append(var)

                table  = Table(Domain(vars),
                                      [list(t) for t in zip(*analdata)])
                if self.items_analysis:
                    table = Table.concatenate((table, self.items_analysis))
                self.graph.set_items(table)

            self.send("Network", self.graph)
            self.send("Items", self.graph.items())

            self.clear_results()

# 需要导入模块: from Orange.data import Table [as 别名]
# 或者: from Orange.data.Table import concatenate [as 别名]
    def compute_distances(self):
        self.Error.diff_domains.clear()
        if not self.data or not self.reference:
            self.distances = None
            return
        if set(self.reference.domain.attributes) != \
                set(self.data.domain.attributes):
            self.Error.diff_domains()
            self.distances = None
            return

        metric = METRICS[self.distance_index][1]
        n_ref = len(self.reference)

        # comparing only attributes, no metas and class-vars
        new_domain = Domain(self.data.domain.attributes)
        reference = self.reference.transform(new_domain)
        data = self.data.transform(new_domain)

        all_data = Table.concatenate([reference, data], 0)
        pp_all_data = Impute()(RemoveNaNColumns()(all_data))
        pp_reference, pp_data = pp_all_data[:n_ref], pp_all_data[n_ref:]
        self.distances = metric(pp_data, pp_reference).min(axis=1)

# 需要导入模块: from Orange.data import Table [as 别名]
# 或者: from Orange.data.Table import concatenate [as 别名]

#.........这里部分代码省略.........
#        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)