def __call__(self, data): # creates function for transforming data common = _EMSC(self.reference, self.badspectra, self.weights, self.order, self.scaling, data.domain) # takes care of domain column-wise, by above transformation function atts = [a.copy(compute_value=EMSCFeature(i, common)) for i, a in enumerate(data.domain.attributes)] model_metas = [] n_badspec = len(self.badspectra) if self.badspectra is not None else 0 used_names = set([var.name for var in data.domain.variables + data.domain.metas]) if self.output_model: i = len(data.domain.attributes) for o in range(self.order+1): n = get_unique_names(used_names, "EMSC parameter " + str(o)) model_metas.append( Orange.data.ContinuousVariable(name=n, compute_value=EMSCModel(i, common))) i += 1 for o in range(n_badspec): n = get_unique_names(used_names, "EMSC parameter bad spec " + str(o)) model_metas.append( Orange.data.ContinuousVariable(name=n, compute_value=EMSCModel(i, common))) i += 1 n = get_unique_names(used_names, "EMSC scaling parameter") model_metas.append( Orange.data.ContinuousVariable(name=n, compute_value=EMSCModel(i, common))) domain = Orange.data.Domain(atts, data.domain.class_vars, data.domain.metas + tuple(model_metas)) return data.from_table(domain, data)
def commit(self): map_data = None if self.data and self.xpoints is not None and self.ypoints is not None \ and self.xpoints * self.ypoints == len(self.data): used_names = [ var.name for var in self.data.domain.variables + self.data.domain.metas ] xmeta = Orange.data.ContinuousVariable.make( get_unique_names(used_names, "X")) ymeta = Orange.data.ContinuousVariable.make( get_unique_names(used_names, "Y")) # add new variables for X and Y dimension ot the data domain metas = self.data.domain.metas + (xmeta, ymeta) domain = Orange.data.Domain(self.data.domain.attributes, self.data.domain.class_vars, metas) map_data = Orange.data.Table(domain, self.data) map_data[:, xmeta] = np.tile(np.arange(self.xpoints), len(self.data) // self.xpoints).reshape( -1, 1) map_data[:, ymeta] = np.repeat(np.arange(self.ypoints), len(self.data) // self.ypoints).reshape(-1, 1) self.Outputs.map.send(map_data)
def __call__(self, data): # creates function for transforming data common = _ME_EMSC(reference=self.reference, weights=self.weights, ncomp=self.ncomp, alpha0=self.alpha0, gamma=self.gamma, maxNiter=self.maxNiter, fixedNiter=self.fixedNiter, positiveRef=self.positiveRef, domain=data.domain) # takes care of domain column-wise, by above transformation function atts = [ a.copy(compute_value=ME_EMSCFeature(i, common)) for i, a in enumerate(data.domain.attributes) ] model_metas = [] n_badspec = self.ncomp # Check if function knows about bad spectra used_names = set( [var.name for var in data.domain.variables + data.domain.metas]) if self.output_model: i = len(data.domain.attributes) for o in range(1): n = get_unique_names(used_names, "EMSC parameter " + str(o)) model_metas.append( Orange.data.ContinuousVariable(name=n, compute_value=ME_EMSCModel( i, common))) i += 1 for o in range(n_badspec): n = get_unique_names(used_names, "EMSC parameter bad spec " + str(o)) model_metas.append( Orange.data.ContinuousVariable(name=n, compute_value=ME_EMSCModel( i, common))) i += 1 n = get_unique_names(used_names, "EMSC scaling parameter") model_metas.append( Orange.data.ContinuousVariable(name=n, compute_value=ME_EMSCModel( i, common))) i += 1 n = get_unique_names(used_names, "Number of iterations") model_metas.append( Orange.data.ContinuousVariable(name=n, compute_value=ME_EMSCModel( i, common))) i += 1 n = get_unique_names(used_names, "RMSE") model_metas.append( Orange.data.ContinuousVariable(name=n, compute_value=ME_EMSCModel( i, common))) domain = Orange.data.Domain(atts, data.domain.class_vars, data.domain.metas + tuple(model_metas)) return data.from_table(domain, data)
def commit(self): map_data = None if self.data and self.xpoints is not None and self.ypoints is not None \ and self.xpoints * self.ypoints == len(self.data): used_names = [var.name for var in self.data.domain.variables + self.data.domain.metas] xmeta = Orange.data.ContinuousVariable.make(get_unique_names(used_names, "X")) ymeta = Orange.data.ContinuousVariable.make(get_unique_names(used_names, "Y")) # add new variables for X and Y dimension ot the data domain metas = self.data.domain.metas + (xmeta, ymeta) domain = Orange.data.Domain(self.data.domain.attributes, self.data.domain.class_vars, metas) map_data = Orange.data.Table(domain, self.data) map_data[:, xmeta] = np.tile(np.arange(self.xpoints), len(self.data)//self.xpoints).reshape(-1, 1) map_data[:, ymeta] = np.repeat(np.arange(self.ypoints), len(self.data)//self.ypoints).reshape(-1, 1) self.Outputs.map.send(map_data)
def commit(self): if self.embedding is not None: names = get_unique_names( [v.name for v in self.data.domain.variables], ["mds-x", "mds-y"]) output = embedding = Orange.data.Table.from_numpy( Orange.data.Domain([ ContinuousVariable(names[0]), ContinuousVariable(names[1]) ]), self.embedding) else: output = embedding = None if self.embedding is not None and self.data is not None: domain = self.data.domain domain = Orange.data.Domain( domain.attributes, domain.class_vars, domain.metas + embedding.domain.attributes) output = self.data.transform(domain) output.metas[:, -2:] = embedding.X selection = self.graph.get_selection() if output is not None and len(selection) > 0: selected = output[selection] else: selected = None if self.graph.selection is not None and np.max( self.graph.selection) > 1: annotated = create_groups_table(output, self.graph.selection) else: annotated = create_annotated_table(output, selection) self.Outputs.selected_data.send(selected) self.Outputs.annotated_data.send(annotated)
def commit(self): if self.embedding is not None: names = get_unique_names([v.name for v in self.data.domain.variables], ["mds-x", "mds-y"]) output = embedding = Orange.data.Table.from_numpy( Orange.data.Domain([ContinuousVariable(names[0]), ContinuousVariable(names[1])]), self.embedding ) else: output = embedding = None if self.embedding is not None and self.data is not None: domain = self.data.domain domain = Orange.data.Domain(domain.attributes, domain.class_vars, domain.metas + embedding.domain.attributes) output = self.data.transform(domain) output.metas[:, -2:] = embedding.X selection = self.graph.get_selection() if output is not None and len(selection) > 0: selected = output[selection] else: selected = None if self.graph.selection is not None and np.max(self.graph.selection) > 1: annotated = create_groups_table(output, self.graph.selection) else: annotated = create_annotated_table(output, selection) self.Outputs.selected_data.send(selected) self.Outputs.annotated_data.send(annotated)
def test_get_unique_names(self): names = [ "charlie", "bravo", "charlie (2)", "charlie (3)", "bravo (2)", "charlie (4)", "bravo (3)" ] self.assertEqual(get_unique_names(names, ["bravo", "charlie"]), ["bravo (5)", "charlie (5)"])
def __call__(self, data): common = _IntegrateCommon(data.domain) atts = [] if self.limits: methods = self.methods if not isinstance(methods, Iterable): methods = [methods] * len(self.limits) names = self.names if not names: names = [" - ".join("{0}".format(e) for e in l) for l in self.limits] # no names in data should be repeated used_names = [var.name for var in data.domain.variables + data.domain.metas] for i, n in enumerate(names): n = get_unique_names(used_names, n) names[i] = n used_names.append(n) for limits, method, name in zip(self.limits, methods, names): atts.append(Orange.data.ContinuousVariable( name=name, compute_value=method(limits, common))) if not self.metas: domain = Orange.data.Domain(atts, data.domain.class_vars, metas=data.domain.metas) else: domain = Orange.data.Domain(data.domain.attributes, data.domain.class_vars, metas=data.domain.metas + tuple(atts)) return data.from_table(domain, data)
def __call__(self, data): # creates function for transforming data common = _EMSC(self.reference, self.badspectra, self.weights, self.order, self.scaling, data.domain) # takes care of domain column-wise, by above transformation function atts = [ a.copy(compute_value=EMSCFeature(i, common)) for i, a in enumerate(data.domain.attributes) ] model_metas = [] n_badspec = len(self.badspectra) if self.badspectra is not None else 0 used_names = set( [var.name for var in data.domain.variables + data.domain.metas]) if self.output_model: i = len(data.domain.attributes) for o in range(self.order + 1): n = get_unique_names(used_names, "EMSC parameter " + str(o)) model_metas.append( Orange.data.ContinuousVariable(name=n, compute_value=EMSCModel( i, common))) i += 1 for o in range(n_badspec): n = get_unique_names(used_names, "EMSC parameter bad spec " + str(o)) model_metas.append( Orange.data.ContinuousVariable(name=n, compute_value=EMSCModel( i, common))) i += 1 n = get_unique_names(used_names, "EMSC scaling parameter") model_metas.append( Orange.data.ContinuousVariable(name=n, compute_value=EMSCModel( i, common))) domain = Orange.data.Domain(atts, data.domain.class_vars, data.domain.metas + tuple(model_metas)) return data.from_table(domain, data)
def _setup_plot(self): self._clear_plot() if self.data is None: return self.__replot_requested = False names = get_unique_names( [ v.name for v in chain(self.data.domain.variables, self.data.domain.metas) ], [ "{}-x".format(self.Variable_name[self.placement]), "{}-y".format(self.Variable_name[self.placement]), ], ) self.variable_x = ContinuousVariable(names[0]) self.variable_y = ContinuousVariable(names[1]) if self.placement in [self.Placement.Circular, self.Placement.LDA]: variables = list(self.model_selected) elif self.placement == self.Placement.Projection: variables = self.model_selected[:] + self.model_other[:] elif self.placement == self.Placement.PCA: variables = [ var for var in self.data.domain.attributes if var.is_continuous ] if not variables: self.graph.new_data(None) return if self.placement == self.Placement.PCA: valid_mask, ec, axes = self._get_pca() variables = self._pca.orig_domain.attributes else: valid_mask, ec, axes = self.prepare_plot_data(variables) self.plotdata.variables = variables self.plotdata.valid_mask = valid_mask self.plotdata.embedding_coords = ec self.plotdata.axes = axes if any(e is None for e in (valid_mask, ec, axes)): return if not sum(valid_mask): self.Error.no_valid_data() self.graph.new_data(None, None) return self.Error.no_valid_data.clear() self._anchor_circle(variables=variables) self._plot()
def _setup_plot(self): self._clear_plot() if self.data is None: return self.__replot_requested = False names = get_unique_names([v.name for v in chain(self.data.domain.variables, self.data.domain.metas)], ["{}-x".format(self.Variable_name[self.placement]), "{}-y".format(self.Variable_name[self.placement])]) self.variable_x = ContinuousVariable(names[0]) self.variable_y = ContinuousVariable(names[1]) if self.placement in [self.Placement.Circular, self.Placement.LDA]: variables = list(self.model_selected) elif self.placement == self.Placement.Projection: variables = self.model_selected[:] + self.model_other[:] elif self.placement == self.Placement.PCA: variables = [var for var in self.data.domain.attributes if var.is_continuous] if not variables: self.graph.new_data(None) return if self.placement == self.Placement.PCA: valid_mask, ec, axes = self._get_pca() variables = self._pca.orig_domain.attributes else: valid_mask, ec, axes = self.prepare_plot_data(variables) self.plotdata.variables = variables self.plotdata.valid_mask = valid_mask self.plotdata.embedding_coords = ec self.plotdata.axes = axes if any(e is None for e in (valid_mask, ec, axes)): return if not sum(valid_mask): self.Error.no_valid_data() self.graph.new_data(None, None) return self.Error.no_valid_data.clear() self._anchor_circle(variables=variables) self._plot()
def test_get_unique_names(self): names = ["charlie", "bravo", "charlie (2)", "charlie (3)", "bravo (2)", "charlie (4)", "bravo (3)"] self.assertEqual(get_unique_names(names, ["bravo", "charlie"]), ["bravo (5)", "charlie (5)"])
def _get_projection_variables(self): domain = self.data.domain names = get_unique_names( [v.name for v in domain.variables + domain.metas], self.embedding_variables_names) return ContinuousVariable(names[0]), ContinuousVariable(names[1])