def send_data(self):
if self.data is not None:
attributes = self.x_var_model[self.x_var_index]
class_var = self.y_var_model[self.y_var_index]
data_table = Table(Domain([attributes], class_vars=[class_var]),
self.data)
polyfeatures = skl_preprocessing.PolynomialFeatures(
int(self.polynomialexpansion))
x = data_table.X[~np.isnan(data_table.X).any(axis=1)]
x = polyfeatures.fit_transform(x)
x_label = data_table.domain.attributes[0].name
out_array = np.concatenate((x, data_table.Y[np.newaxis].T), axis=1)
out_domain = Domain(
[ContinuousVariable("1")] +
([data_table.domain.attributes[0]]
if self.polynomialexpansion > 0 else []) + [
ContinuousVariable("{}^{}".format(x_label, i))
for i in range(2,
int(self.polynomialexpansion) + 1)
],
class_vars=[class_var])
self.send("Data", Table(out_domain, out_array))
return
self.send("Data", None)
def __init__(self, parent=None, signalManager=None, settings=None):
super().__init__(parent, signalManager, settings)
self.data = None
self.undoStack = QtGui.QUndoStack(self)
self.plot = PaintDataPlot(self.mainArea, "Painted Plot", widget=self)
self.classValuesModel = ColoredListModel(
["Class-1", "Class-2"],
self,
self.plot,
flags=QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled
| QtCore.Qt.ItemIsEditable)
self.classValuesModel.dataChanged.connect(self.classNameChange)
self.data = Table(
Domain([
ContinuousVariable(self.attr1),
ContinuousVariable(self.attr2)
], DiscreteVariable("Class", values=self.classValuesModel)))
self.toolsStackCache = {}
self.initUI()
self.initPlot()
self.updatePlot()
def k_net_table(self, v_list):
values = [
ContinuousVariable(name='Distance', number_of_decimals=0),
ContinuousVariable(name='Knet score'),
]
domain = Domain(values)
return Table(domain, [[n, v] for n, v in enumerate(v_list)])
def k_node_table(self, v_list):
dist_values = {l[0] for l in v_list}
values = [
DiscreteVariable(name='Protein', values=dist_values),
ContinuousVariable(name='Knode score'),
ContinuousVariable(name='Distance', number_of_decimals=0),
]
domain = Domain(values)
return Table(domain, v_list)
def redo(self):
self.label = self.classValuesModel.pop(self.index)
examples = [
ex for ex in self.data if str(ex.get_class()) != self.label
]
newdomain = Domain([
ContinuousVariable(self.widget.attr1),
ContinuousVariable(self.widget.attr2)
], DiscreteVariable("Class", values=self.classValuesModel))
newdata = Table(newdomain)
for ex in examples:
if str(ex.get_class()) != self.label and \
str(ex.get_class()) in self.classValuesModel:
newdata.append(
Instance(newdomain,
[float(ex[a]) for a in ex.domain.attributes] +
[str(ex.get_class())]))
self.widget.data = newdata
self.widget.updatePlot()
self.widget.updateCursor()
def redo(self):
newdomain = Domain([
ContinuousVariable(self.widget.attr1),
ContinuousVariable(self.widget.attr2)
], DiscreteVariable("Class", values=self.classValuesModel))
newdata = Table(newdomain)
for ex in self.data:
print(ex.get_class())
if str(ex.get_class()) not in self.classValuesModel:
self.oldLabelName = str(ex.get_class())
instance = Instance(
newdomain,
[float(ex[a])
for a in ex.domain.attributes] + [self.changedLabel])
newdata.append(instance)
else:
newdata.append(
Instance(newdomain,
[float(ex[a]) for a in ex.domain.attributes] +
[str(ex.get_class())]))
self.widget.data = newdata
self.widget.updatePlot()
def redo(self):
self.classValuesModel.append(self.newClassLabel)
newdomain = Domain([
ContinuousVariable(self.widget.attr1),
ContinuousVariable(self.widget.attr2)
], DiscreteVariable("Class", values=self.classValuesModel))
newdata = Table(newdomain)
instances = [
Instance(newdomain,
[float(ex[a])
for a in ex.domain.attributes] + [str(ex.get_class())])
for ex in self.data
]
newdata.extend(instances)
self.widget.data = newdata
self.widget.removeClassLabel.setEnabled(len(self.classValuesModel) > 1)
newindex = self.classValuesModel.index(len(self.classValuesModel) - 1)
self.widget.classValuesView.selectionModel().select(
newindex, QtGui.QItemSelectionModel.ClearAndSelect)
self.widget.updatePlot()
self.widget.updateCursor()
def _create_table(words, scores: Mapping[str, np.array]) -> Table:
"""
Create an Orange table from the word scores
:param words: list of words
:param scores: mapping of {label: score_array}. Use ordereddict to preserve column order
:return: a Table object
"""
values = list(scores.values())
order = (-values[0]).argsort()
data = np.column_stack(values)[order]
words = np.array(words).reshape(len(words), 1)[order]
domain = Domain([ContinuousVariable(label) for label in scores],
metas=[StringVariable("term")])
return Table(domain, data, metas=words)
def apply(self):
learner = self.learner
predictor = None
if self.data is not None:
degree = int(self.polynomialexpansion)
learner = self.LEARNER(preprocessors=self.preprocessors,
degree=degree,
learner=LinearRegressionLearner()
if self.learner is None else learner)
attributes = self.x_var_model[self.x_var_index]
class_var = self.y_var_model[self.y_var_index]
data_table = Table(Domain([attributes], class_vars=[class_var]),
self.data)
learner.name = self.learner_name
predictor = learner(data_table)
preprocessed_data = data_table
if self.preprocessors is not None:
for preprocessor in self.preprocessors:
preprocessed_data = preprocessor(preprocessed_data)
x = preprocessed_data.X.ravel()
y = preprocessed_data.Y.ravel()
linspace = np.linspace(min(x), max(x), 1000).reshape(-1, 1)
values = predictor(linspace, predictor.Value)
self.plot_scatter_points(x, y)
self.plot_regression_line(linspace.ravel(), values.ravel())
x_label = self.x_var_model[self.x_var_index]
axis = self.plot.getAxis("bottom")
axis.setLabel(x_label)
y_label = self.y_var_model[self.y_var_index]
axis = self.plot.getAxis("left")
axis.setLabel(y_label)
self.set_range(x, y)
self.send("Learner", learner)
self.send("Predictor", predictor)
# Send model coefficents
model = None
if predictor is not None:
model = predictor.model
if hasattr(model, "model"):
model = model.model
elif hasattr(model, "skl_model"):
model = model.skl_model
if model is not None and hasattr(model, "coef_"):
domain = Domain([ContinuousVariable("coef", number_of_decimals=7)],
metas=[StringVariable("name")])
coefs = [model.intercept_ + model.coef_[0]] + list(model.coef_[1:])
names = ["1", x_label] + \
["{}^{}".format(x_label, i) for i in range(2, degree + 1)]
coef_table = Table(domain, list(zip(coefs, names)))
self.send("Coefficients", coef_table)
else:
self.send("Coefficients", None)
def apply(self):
degree = int(self.polynomialexpansion)
learner = self.LEARNER(preprocessors=self.preprocessors,
degree=degree,
learner=LinearRegressionLearner()
if self.learner is None else self.learner)
learner.name = self.learner_name
predictor = None
self.Error.all_none.clear()
if self.data is not None:
attributes = self.x_var_model[self.x_var_index]
class_var = self.y_var_model[self.y_var_index]
data_table = Table(Domain([attributes], class_vars=[class_var]),
self.data)
# all lines has nan
if sum(
math.isnan(line[0]) or math.isnan(line.get_class())
for line in data_table) == len(data_table):
self.Error.all_none()
self.clear_plot()
return
predictor = learner(data_table)
preprocessed_data = data_table
for preprocessor in learner.active_preprocessors:
preprocessed_data = preprocessor(preprocessed_data)
x = preprocessed_data.X.ravel()
y = preprocessed_data.Y.ravel()
linspace = np.linspace(np.nanmin(x), np.nanmax(x),
1000).reshape(-1, 1)
values = predictor(linspace, predictor.Value)
# calculate prediction for x from data
predicted = TestOnTrainingData(preprocessed_data, [learner])
self.rmse = round(RMSE(predicted)[0], 6)
self.mae = round(MAE(predicted)[0], 6)
# plot error bars
self.plot_error_bars(x, predicted.actual,
predicted.predicted.ravel())
# plot data points
self.plot_scatter_points(x, y)
# plot regression line
self.plot_regression_line(linspace.ravel(), values.ravel())
x_label = self.x_var_model[self.x_var_index]
axis = self.plot.getAxis("bottom")
axis.setLabel(x_label)
y_label = self.y_var_model[self.y_var_index]
axis = self.plot.getAxis("left")
axis.setLabel(y_label)
self.set_range(x, y)
self.send("Learner", learner)
self.send("Predictor", predictor)
# Send model coefficents
model = None
if predictor is not None:
model = predictor.model
if hasattr(model, "model"):
model = model.model
elif hasattr(model, "skl_model"):
model = model.skl_model
if model is not None and hasattr(model, "coef_"):
domain = Domain([ContinuousVariable("coef", number_of_decimals=7)],
metas=[StringVariable("name")])
coefs = [model.intercept_ + model.coef_[0]] + list(model.coef_[1:])
names = ["1", x_label] + \
["{}^{}".format(x_label, i) for i in range(2, degree + 1)]
coef_table = Table(domain, list(zip(coefs, names)))
self.send("Coefficients", coef_table)
else:
self.send("Coefficients", None)
self.send_data()
def get_variable(c_type, name, column):
if c_type == "nominal":
values = [v for v in np.unique(column)]
return DiscreteVariable(name, values=values)
else:
return ContinuousVariable(name)