def __init__(self):
super().__init__()
self.data = None
self.preprocessors = None
box = gui.widgetBox(self.controlArea, "Learner/Classifier Name")
gui.lineEdit(box, self, "learner_name")
box = gui.widgetBox(self.controlArea, "Neighbors")
gui.spin(box, self, "n_neighbors", 1, 100, label="Number of neighbors",
alignment=Qt.AlignRight)
gui.comboBox(box, self, "metric_index", label="Metric",
orientation="horizontal",
items=[i.capitalize() for i in self.metrics])
gui.comboBox(box, self, "weight_type", label='Weight',
orientation="horizontal",
items=[i.capitalize() for i in self.weights])
g = QHBoxLayout()
self.controlArea.layout().addLayout(g)
apply = gui.button(None, self, "Apply",
callback=self.apply, default=True)
g.layout().addWidget(self.report_button)
g.layout().addWidget(apply)
self.apply()
def __init__(self):
super().__init__()
box = gui.widgetBox(self.controlArea, "Movie Selection (from %d)" % len(movielens.get_all_movie_names()))
methodbox = gui.radioButtons(box, self, "method", callback=self._on_method_changed)
gui.appendRadioButton(methodbox, "Fraction of movies")
percent = gui.hSlider(
gui.indentedBox(methodbox), self, "percent", minValue=1, maxValue=100, step=1, ticks=10, labelFormat="%d %%"
)
gui.appendRadioButton(methodbox, "Time period:")
ibox = gui.indentedBox(methodbox)
start = gui.spin(ibox, self, "start", 1907, 2015, 1, label="Starting year: ")
end = gui.spin(ibox, self, "end", 1907, 2015, 1, label="Ending year: ")
self.method_params = [percent, start, end]
gui.button(self.controlArea, self, "&Apply", callback=self.send_output, default=True)
self.setSizePolicy(QtGui.QSizePolicy(QtGui.QSizePolicy.Fixed, QtGui.QSizePolicy.Fixed))
self.setMinimumWidth(250)
self.setMaximumWidth(250)
self._on_method_changed()
self.send_output()
def __init__(self):
super().__init__()
self.net = None
self.method = 0
self.iterationHistory = 0
self.autoApply = 0
self.iterations = 1000
self.hop_attenuation = 0.1
commit = lambda: self.commit()
gui.spin(self.controlArea, self, "iterations", 1,
100000, 1, label="Iterations: ",
callback=commit)
ribg = gui.radioButtonsInBox(
self.controlArea, self, "method",
btnLabels=["Label propagation clustering (Raghavan et al., 2007)",
"Label propagation clustering (Leung et al., 2009)"],
label="Method", callback=commit)
gui.doubleSpin(gui.indentedBox(ribg), self, "hop_attenuation",
0, 1, 0.01, label="Hop attenuation (delta): ")
self.info = gui.widgetLabel(self.controlArea, ' ')
gui.checkBox(self.controlArea, self, "iterationHistory",
"Append clustering data on each iteration",
callback=commit)
gui.auto_commit(self.controlArea, self, "autoApply", 'Commit',
checkbox_label='Auto-commit')
commit()
def __init__(self, parent=None):
super().__init__(parent)
self.train_data = None
self.test_data = None
#: An Ordered dictionary with current inputs and their testing
#: results.
self.learners = OrderedDict()
sbox = gui.widgetBox(self.controlArea, "Sampling")
rbox = gui.radioButtons(
sbox, self, "resampling", callback=self._param_changed
)
gui.appendRadioButton(rbox, "Cross validation")
ibox = gui.indentedBox(rbox)
gui.spin(ibox, self, "k_folds", 2, 50, label="Number of folds:",
callback=self.kfold_changed)
gui.appendRadioButton(rbox, "Leave one out")
gui.appendRadioButton(rbox, "Random sampling")
ibox = gui.indentedBox(rbox)
gui.spin(ibox, self, "n_repeat", 2, 50, label="Repeat train/test",
callback=self.bootstrap_changed)
gui.widgetLabel(ibox, "Relative training set size:")
gui.hSlider(ibox, self, "sample_p", minValue=1, maxValue=100,
ticks=20, vertical=False, labelFormat="%d %%",
callback=self.bootstrap_changed)
gui.appendRadioButton(rbox, "Test on train data")
gui.appendRadioButton(rbox, "Test on test data")
rbox.layout().addSpacing(5)
gui.button(rbox, self, "Apply", callback=self.apply)
self.cbox = gui.widgetBox(self.controlArea, "Target class")
self.class_selection_combo = gui.comboBox(self.cbox, self, "class_selection",
items=[],
callback=self._select_class,
sendSelectedValue=True, valueType=str)
gui.rubber(self.controlArea)
self.view = QTreeView(
rootIsDecorated=False,
uniformRowHeights=True,
wordWrap=True,
editTriggers=QTreeView.NoEditTriggers
)
header = self.view.header()
header.setResizeMode(QHeaderView.ResizeToContents)
header.setDefaultAlignment(Qt.AlignCenter)
header.setStretchLastSection(False)
self.result_model = QStandardItemModel()
self.view.setModel(self.result_model)
self.view.setItemDelegate(ItemDelegate())
self._update_header()
box = gui.widgetBox(self.mainArea, "Evaluation Results")
box.layout().addWidget(self.view)
def __init__(self):
self.data = None
box = gui.vBox(self.controlArea, 'Differencing')
self.order_spin = gui.spin(
box, self, 'diff_order', 1, 2,
label='Differencing order:',
callback=self.on_changed,
tooltip='The value corresponds to n-th order numerical '
'derivative of the series. \nThe order is fixed to 1 '
'if the shift period is other than 1.')
gui.spin(box, self, 'shift_period', 1, 100,
label='Shift:',
callback=self.on_changed,
tooltip='Set this to other than 1 if you don\'t want to '
'compute differences for subsequent values but for '
'values shifted number of spaces apart. \n'
'If this value is different from 1, differencing '
'order is fixed to 1.')
gui.checkBox(box, self, 'invert_direction',
label='Invert differencing direction',
callback=self.on_changed,
tooltip='Influences where the series is padded with nan '
'values — at the beginning or at the end.')
self.view = view = QListView(self,
selectionMode=QListView.ExtendedSelection)
self.model = model = VariableListModel(parent=self)
view.setModel(model)
view.selectionModel().selectionChanged.connect(self.on_changed)
box.layout().addWidget(view)
gui.auto_commit(box, self, 'autocommit', '&Apply')
def __init__(self):
super().__init__()
self.data = None
self.reference = None
self.distances = None
box = gui.vBox(self.controlArea, "Info")
self.data_info_label = gui.widgetLabel(box, "")
self.reference_info_label = gui.widgetLabel(box, "")
self._set_label_text("data")
self._set_label_text("reference")
box = gui.vBox(self.controlArea, box=True)
gui.comboBox(
box, self, "distance_index", orientation=Qt.Horizontal,
label="Distance: ", items=[d[0] for d in METRICS],
callback=self.recompute)
gui.spin(
box, self, "n_neighbors", label="Number of neighbors:",
step=1, spinType=int, minv=0, maxv=100, callback=self.apply)
gui.checkBox(
box, self, "exclude_reference",
label="Exclude rows (equal to) references",
callback=self.apply)
self.apply_button = gui.auto_commit(
self.controlArea, self, "auto_apply", "&Apply", commit=self.apply)
def _add_controls_start_box(self):
box = gui.vBox(self.controlArea, True)
form = QFormLayout(
labelAlignment=Qt.AlignLeft,
formAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QFormLayout.AllNonFixedFieldsGrow,
verticalSpacing=10
)
form.addRow(
"Max iterations:",
gui.spin(box, self, "max_iter", 1, 2000, step=50))
form.addRow(
"Perplexity:",
gui.spin(box, self, "perplexity", 1, 100, step=1))
box.layout().addLayout(form)
gui.separator(box, 10)
self.runbutton = gui.button(box, self, "Run", callback=self._toggle_run)
gui.separator(box, 10)
gui.hSlider(box, self, "pca_components", label="PCA components:",
minValue=2, maxValue=50, step=1)
def _add_algorithm_to_layout(self):
box = gui.widgetBox(self.controlArea, 'Algorithm')
# Classfication loss function
self.cls_loss_function_combo = gui.comboBox(
box, self, 'cls_loss_function_index', orientation=Qt.Horizontal,
label='Classificaton loss function: ',
items=list(zip(*self.cls_losses))[0],
callback=self._on_cls_loss_change)
param_box = gui.hBox(box)
gui.rubber(param_box)
self.cls_epsilon_spin = gui.spin(
param_box, self, 'cls_epsilon', 0, 1., 1e-2, spinType=float,
label='ε: ', controlWidth=80, alignment=Qt.AlignRight,
callback=self.settings_changed)
# Regression loss function
self.reg_loss_function_combo = gui.comboBox(
box, self, 'reg_loss_function_index', orientation=Qt.Horizontal,
label='Regression loss function: ',
items=list(zip(*self.reg_losses))[0],
callback=self._on_reg_loss_change)
param_box = gui.hBox(box)
gui.rubber(param_box)
self.reg_epsilon_spin = gui.spin(
param_box, self, 'reg_epsilon', 0, 1., 1e-2, spinType=float,
label='ε: ', controlWidth=80, alignment=Qt.AlignRight,
callback=self.settings_changed)
# Enable/disable appropriate controls
self._on_cls_loss_change()
self._on_reg_loss_change()
def __init__(self):
super().__init__()
self.preprocessors = None
self.data = None
box = gui.widgetBox(self.controlArea, "Learner/Model Name")
gui.lineEdit(box, self, "learner_name")
box = gui.widgetBox(self.controlArea, "Neighbors")
gui.spin(box, self, "n_neighbors", 1, 100, label="Number of neighbors")
box = gui.widgetBox(box, "Metric")
box.setFlat(True)
box.layout().setContentsMargins(0, 0, 0, 0)
gui.comboBox(box, self, "metric_index",
items=["Euclidean", "Manhattan", "Maximal", "Mahalanobis"])
self.metrics = ["euclidean", "manhattan", "chebyshev", "mahalanobis"]
gui.button(self.controlArea, self, "Apply",
callback=self.apply, default=True)
self.controlArea.layout().addWidget(self.report_button)
layout = self.layout()
self.layout().setSizeConstraint(layout.SetFixedSize)
self.apply()
def __init__(self):
super().__init__()
# sets self.curvePoints, self.steps equidistant points from
# 1/self.steps to 1
self.updateCurvePoints()
# [start-snippet-2]
self.scoring = [
("Classification Accuracy", Orange.evaluation.scoring.CA),
("AUC", Orange.evaluation.scoring.AUC),
("Precision", Orange.evaluation.scoring.Precision),
("Recall", Orange.evaluation.scoring.Recall)
]
# [end-snippet-2]
#: input data on which to construct the learning curve
self.data = None
#: A {input_id: Learner} mapping of current learners from input channel
self.learners = OrderedDict()
#: A {input_id: List[Results]} mapping of input id to evaluation
#: results list, one for each curve point
self.results = OrderedDict()
#: A {input_id: List[float]} mapping of input id to learning curve
#: point scores
self.curves = OrderedDict()
# GUI
box = gui.widgetBox(self.controlArea, "Info")
self.infoa = gui.widgetLabel(box, 'No data on input.')
self.infob = gui.widgetLabel(box, 'No learners.')
gui.separator(self.controlArea)
box = gui.widgetBox(self.controlArea, "Evaluation Scores")
gui.comboBox(box, self, "scoringF",
items=[x[0] for x in self.scoring],
callback=self._invalidate_curves)
gui.separator(self.controlArea)
box = gui.widgetBox(self.controlArea, "Options")
gui.spin(box, self, 'folds', 2, 100, step=1,
label='Cross validation folds: ', keyboardTracking=False,
callback=lambda:
self._invalidate_results() if self.commitOnChange else None
)
gui.spin(box, self, 'steps', 2, 100, step=1,
label='Learning curve points: ', keyboardTracking=False,
callback=[self.updateCurvePoints,
lambda: self._invalidate_results() if self.commitOnChange else None])
gui.checkBox(box, self, 'commitOnChange', 'Apply setting on any change')
self.commitBtn = gui.button(box, self, "Apply Setting",
callback=self._invalidate_results,
disabled=True)
gui.rubber(self.controlArea)
# table widget
self.table = gui.table(self.mainArea,
selectionMode=QTableWidget.NoSelection)
def add_main_layout(self):
box = gui.widgetBox(self.controlArea, "Parameters")
self.base_estimator = self.DEFAULT_BASE_ESTIMATOR
self.base_label = gui.label(
box, self, "Base estimator: " + self.base_estimator.name.title())
self.n_estimators_spin = gui.spin(
box, self, "n_estimators", 1, 100, label="Number of estimators:",
alignment=Qt.AlignRight, controlWidth=80,
callback=self.settings_changed)
self.learning_rate_spin = gui.doubleSpin(
box, self, "learning_rate", 1e-5, 1.0, 1e-5,
label="Learning rate:", decimals=5, alignment=Qt.AlignRight,
controlWidth=80, callback=self.settings_changed)
self.random_seed_spin = gui.spin(
box, self, "random_seed", 0, 2 ** 31 - 1, controlWidth=80,
label="Fixed seed for random generator:", alignment=Qt.AlignRight,
callback=self.settings_changed, checked="use_random_seed",
checkCallback=self.settings_changed)
# Algorithms
box = gui.widgetBox(self.controlArea, "Boosting method")
self.cls_algorithm_combo = gui.comboBox(
box, self, "algorithm_index", label="Classification algorithm:",
items=self.algorithms,
orientation=Qt.Horizontal, callback=self.settings_changed)
self.reg_algorithm_combo = gui.comboBox(
box, self, "loss_index", label="Regression loss function:",
items=self.losses,
orientation=Qt.Horizontal, callback=self.settings_changed)
def __init__(self):
super().__init__()
self.net = None
commit = lambda: self.commit()
gui.spin(self.controlArea, self, "iterations", 1, 100000, 1, label="Max. iterations:", callback=commit)
ribg = gui.radioButtonsInBox(
self.controlArea,
self,
"method",
btnLabels=[
"Label propagation clustering (Raghavan et al., 2007)",
"Label propagation clustering (Leung et al., 2009)",
],
box="Clustering method",
callback=commit,
)
gui.doubleSpin(gui.indentedBox(ribg), self, "hop_attenuation", 0, 1, 0.01, label="Hop attenuation (delta): ")
self.info = gui.widgetLabel(self.controlArea, " ")
gui.auto_commit(self.controlArea, self, "autoApply", "Commit", checkbox_label="Auto-commit")
commit()
def __init__(self):
super().__init__()
self.data = None
self.db = None
box = gui.widgetBox(self.controlArea, "Parameters")
gui.spin(box, self, "min_samples", 1, 100, 1, callback=self._invalidate,
label="Core point neighbors")
gui.doubleSpin(box, self, "eps", 0.1, 0.9, 0.1,
callback=self._invalidate,
label="Neighborhood distance")
box = gui.widgetBox(self.controlArea, self.tr("Distance Metric"))
gui.comboBox(box, self, "metric_idx",
items=list(zip(*self.METRICS))[0],
callback=self._invalidate)
box = gui.widgetBox(self.controlArea, "Output")
gui.comboBox(box, self, "place_cluster_ids",
label="Append cluster id as ", orientation="horizontal",
callback=self.send_data, items=self.OUTPUT_METHODS)
gui.lineEdit(box, self, "output_name",
label="Name: ", orientation="horizontal",
callback=self.send_data)
gui.auto_commit(self.controlArea, self, "auto_run", "Run",
checkbox_label="Run after any change ",
orientation="horizontal")
gui.rubber(self.controlArea)
self.controlArea.setMinimumWidth(self.controlArea.sizeHint().width())
self.layout().setSizeConstraint(QtGui.QLayout.SetFixedSize)
def __init__(self, parent=None):
super().__init__(parent)
self.data = None
self.preprocessors = None
box = gui.widgetBox(self.controlArea, "Learner/Classifier Name")
gui.lineEdit(box, self, "learner_name")
box = gui.widgetBox(self.controlArea, "Neighbors")
gui.spin(box, self, "n_neighbors", 1, 100, label="Number of neighbors")
box = gui.widgetBox(box, "Metric")
box.setFlat(True)
gui.comboBox(box, self, "metric_index",
items=["Euclidean", "Manhattan", "Maximal", "Mahalanobis"])
self.metrics = ["euclidean", "manhattan", "chebyshev", "mahalanobis"]
gui.button(self.controlArea, self, "Apply",
callback=self.apply, default=True)
self.setMinimumWidth(250)
layout = self.layout()
self.layout().setSizeConstraint(layout.SetFixedSize)
self.apply()
def add_main_layout(self):
box = gui.vBox(self.controlArea, 'Basic Properties')
self.n_estimators_spin = gui.spin(
box, self, "n_estimators", minv=1, maxv=10000, controlWidth=50,
label="Number of trees: ", callback=self.settings_changed)
self.max_features_spin = gui.spin(
box, self, "max_features", 2, 50, controlWidth=50,
label="Number of attributes considered at each split: ",
callback=self.settings_changed, checked="use_max_features",
checkCallback=self.settings_changed)
self.random_state_spin = gui.spin(
box, self, "random_state", 0, 2 ** 31 - 1, controlWidth=50,
label="Fixed seed for random generator: ",
callback=self.settings_changed, checked="use_random_state",
checkCallback=self.settings_changed)
box = gui.vBox(self.controlArea, "Growth Control")
self.max_depth_spin = gui.spin(
box, self, "max_depth", 1, 50, controlWidth=50,
label="Limit depth of individual trees: ",
callback=self.settings_changed, checked="use_max_depth",
checkCallback=self.settings_changed)
self.min_samples_split_spin = gui.spin(
box, self, "min_samples_split", 1, 1000, controlWidth=50,
label="Do not split subsets smaller than: ",
callback=self.settings_changed, checked="use_min_samples_split",
checkCallback=self.settings_changed)
def __init__(self):
super().__init__()
self.data = None
self.groups = None
self.CVSettings = (self.stratified, self.numberOfFolds)
infoBox = gui.widgetBox(self.controlArea, "Information")
self.dataInfoLabel = gui.widgetLabel(infoBox, 'No data on input.')
self.outputInfoLabel = gui.widgetLabel(infoBox, ' ')
optionsBox = gui.widgetBox(self.controlArea, "Options")
le = gui.lineEdit(optionsBox, self, "randomSeed", "Random seed: ",
orientation=0, controlWidth=60,
validator=QtGui.QIntValidator())
s = le.sizeHint().height() - 2
b = gui.toolButton(le.box, self, width=s, height=s,
callback=lambda: le.setText(""))
b.setIcon(b.style().standardIcon(b.style().SP_DialogCancelButton))
gui.rubber(le.box)
gui.checkBox(optionsBox, self, "stratified", "Stratified, if possible")
sampling = gui.radioButtons(
self.controlArea, self, "samplingType", box="Sampling type",
addSpace=True)
gui.appendRadioButton(sampling, "Random Sampling:")
indRndSmpl = gui.indentedBox(sampling)
sizeType = gui.radioButtons(
indRndSmpl, self, "sampleSizeType",
callback=lambda: self.chooseSampling(0))
gui.appendRadioButton(sizeType, "Sample size:", insertInto=indRndSmpl)
self.sampleSizeSpin = gui.spin(
gui.indentedBox(indRndSmpl), self, "sampleSizeNumber",
1, 1000000000, callback=[lambda: self.chooseSampling(0),
lambda: self.chooseSizeType(0)])
gui.appendRadioButton(sizeType, "Sample proportions:",
insertInto=indRndSmpl)
gui.hSlider(gui.indentedBox(indRndSmpl), self,
"sampleSizePercentage",
minValue=1, maxValue=100, ticks=10, labelFormat="%d%%",
callback=[lambda: self.chooseSampling(0),
lambda: self.chooseSizeType(1)])
gui.appendRadioButton(sampling, "Cross Validation:")
crossValidIndent = gui.indentedBox(sampling)
gui.spin(
crossValidIndent, self, "numberOfFolds", 2, 100,
label="Number of folds:",
callback=[self.updateSelectedFoldSpin,
lambda: self.chooseSampling(1)])
self.selectedFoldSpin = gui.spin(
crossValidIndent, self, "selectedFold", 1, 100,
label="Selected fold:",
callback=[self.updateSelectedFoldSpin,
lambda: self.chooseSampling(1)])
gui.button(self.controlArea, self, "Sample Data",
callback=self.sendData)
def add_main_layout(self):
box = gui.vBox(self.controlArea, True)
# the checkbox is put into vBox for alignemnt with other checkboxes
gui.checkBox(gui.vBox(box), self, "binary_trees", "Induce binary tree",
callback=self.settings_changed)
for label, check, setting, fromv, tov in self.spin_boxes:
gui.spin(box, self, setting, fromv, tov, label=label, checked=check,
alignment=Qt.AlignRight, callback=self.settings_changed,
checkCallback=self.settings_changed, controlWidth=80)
def add_bottom_buttons(self):
box = gui.vBox(self.controlArea, 'Forecast')
gui.spin(box, self, 'forecast_steps', 1, 100,
label='Forecast steps ahead:',
callback=self.apply)
gui.hSlider(box, self, 'forecast_confint',
None, 1, 99, label='Confidence intervals:',
callback=self.apply)
gui.auto_commit(self.controlArea, self, 'autocommit', "&Apply")
def addHistogramControls(self, parent=None):
if parent is None:
parent = self.controlArea
boxGeneral = gui.widgetBox(parent, box="Edges")
ribg = gui.widgetBox(boxGeneral, None, orientation="horizontal", addSpace=False)
ribg.layout().addWidget(QLabel("Distance threshold", self),
4, Qt.AlignVCenter | Qt.AlignLeft)
self.spin_low = gui.doubleSpin(ribg, self, "spinLowerThreshold",
0.0, float("inf"), 0.001, decimals=3,
callback=self.changeLowerSpin,
keyboardTracking=False)
ribg.layout().addWidget(QLabel("to", self), 1, Qt.AlignCenter)
self.spin_high = gui.doubleSpin(ribg, self, "spinUpperThreshold",
0.0, float("inf"), 0.001, decimals=3,
callback=self.changeUpperSpin,
keyboardTracking=False)
self.histogram.region.sigRegionChangeFinished.connect(self.spinboxFromHistogramRegion)
# gui.lineEdit(ribg, self, "spinLowerThreshold", "Distance threshold ", orientation='horizontal', callback=self.changeLowerSpin, valueType=float, validator=self.validator, enterPlaceholder=True, controlWidth=60)
# gui.lineEdit(ribg, self, "spinUpperThreshold", "", orientation='horizontal', callback=self.changeUpperSpin, valueType=float, validator=self.validator, enterPlaceholder=True, controlWidth=60)
# ribg.layout().addStretch(1)
#ribg = gui.radioButtonsInBox(boxGeneral, self, "andor", [], orientation='horizontal', callback = self.generateGraph)
#gui.appendRadioButton(ribg, self, "andor", "OR", callback = self.generateGraph)
#b = gui.appendRadioButton(ribg, self, "andor", "AND", callback = self.generateGraph)
#b.setEnabled(False)
#ribg.hide(False)
ribg = gui.widgetBox(boxGeneral, None, orientation="horizontal", addSpace=False)
gui.doubleSpin(boxGeneral, self, "percentil", 0, 100, 0.1, label="Percentile", orientation='horizontal', callback=self.setPercentil, callbackOnReturn=1, controlWidth=60)
gui.spin(boxGeneral, self, "kNN", 0, 1000, 1, label="Include closest neighbors", orientation='horizontal', callback=self.generateGraph, callbackOnReturn=1, controlWidth=60)
ribg.layout().addStretch(1)
# Options
self.attrColor = ""
ribg = gui.radioButtonsInBox(parent, self, "netOption", [], "Node selection", callback=self.generateGraph)
gui.appendRadioButton(ribg, "Keep all nodes")
hb = gui.widgetBox(ribg, None, orientation="horizontal", addSpace=False)
gui.appendRadioButton(ribg, "Components with at least nodes", insertInto=hb)
gui.spin(hb, self, "excludeLimit", 2, 100, 1, callback=(lambda h=True: self.generateGraph(h)), controlWidth=60)
gui.appendRadioButton(ribg, "Largest connected component")
#gui.appendRadioButton(ribg, self, "netOption", "Connected component with vertex")
self.attribute = None
### FILTER NETWORK BY ATTRIBUTE IS OBSOLETE - USE SELECT DATA WIDGET ###
#self.attributeCombo = gui.comboBox(parent, self, "attribute", box="Filter attribute", orientation='horizontal')#, callback=self.setVertexColor)
#self.label = ''
#self.searchString = gui.lineEdit(self.attributeCombo.box, self, "label", callback=self.setSearchStringTimer, callbackOnType=True)
#self.searchStringTimer = QTimer(self)
#self.connect(self.searchStringTimer, SIGNAL("timeout()"), self.generateGraph)
#if str(self.netOption) != '3':
# self.attributeCombo.box.setEnabled(False)
ribg = gui.radioButtonsInBox(parent, self, "dstWeight", [], "Edge weights", callback=self.generateGraph)
hb = gui.widgetBox(ribg, None, orientation="horizontal", addSpace=False)
gui.appendRadioButton(ribg, "Proportional to distance", insertInto=hb)
gui.appendRadioButton(ribg, "Inverted distance", insertInto=hb)
def add_main_layout(self):
# var models
self.x_var_model = itemmodels.VariableListModel()
self.y_var_model = itemmodels.VariableListModel()
# options box
self.options_box = gui.widgetBox(self.controlArea, "Options")
opts = dict(
widget=self.options_box, master=self, orientation=Qt.Horizontal)
opts_combo = dict(opts, **dict(sendSelectedValue=True,
maximumContentsLength=15))
self.cbx = gui.comboBox(
value='attr_x', label='X: ', callback=self.apply, **opts_combo)
self.cby = gui.comboBox(
value='attr_y', label='Y: ', callback=self.apply, **opts_combo)
self.target_class_combobox = gui.comboBox(
value='target_class', label='Target: ',
callback=self.apply, **opts_combo)
self.degree_spin = gui.spin(
value='degree', label='Polynomial expansion:',
minv=1, maxv=5, step=1, callback=self.init_learner,
alignment=Qt.AlignRight, controlWidth=70, **opts)
self.cbx.setModel(self.x_var_model)
self.cby.setModel(self.y_var_model)
# plot properties box
self.plot_properties_box = gui.widgetBox(
self.controlArea, "Plot Properties")
self.legend_enabled_checkbox = gui.checkBox(
self.plot_properties_box, self, 'legend_enabled',
label="Show legend", callback=self.replot)
self.contours_enabled_checkbox = gui.checkBox(
self.plot_properties_box, self, 'contours_enabled',
label="Show contours", callback=self.plot_contour)
self.contour_step_slider = gui.spin(
self.plot_properties_box, self, 'contour_step',
minv=0.10, maxv=0.50, step=0.05, callback=self.plot_contour,
label='Contour step:', decimals=2, spinType=float,
alignment=Qt.AlignRight, controlWidth=70)
gui.rubber(self.controlArea)
# chart
self.scatter = Scatterplot(
xAxis_gridLineWidth=0, yAxis_gridLineWidth=0,
xAxis_startOnTick=False, xAxis_endOnTick=False,
yAxis_startOnTick=False, yAxis_endOnTick=False,
xAxis_lineWidth=0, yAxis_lineWidth=0,
yAxis_tickWidth=1, title_text='', tooltip_shared=False)
# Just render an empty chart so it shows a nice 'No data to display'
self.scatter.chart()
self.mainArea.layout().addWidget(self.scatter)
self.init_learner()
def add_group_settings(self, parent):
box = gui.vBox(parent, "Groups")
box2 = gui.hBox(box)
gui.checkBox(box2, self, "graph.group_lines", "Group lines into", tooltip="Show clusters instead of lines",
callback=self.update_graph)
gui.spin(box2, self, "graph.number_of_groups", 0, 30, callback=self.update_graph)
gui.label(box2, self, "groups")
box2 = gui.hBox(box)
gui.spin(box2, self, "graph.number_of_steps", 0, 100, label="In no more than", callback=self.update_graph)
gui.label(box2, self, "steps")
def __init__(self):
self.tree = QTreeWidget(self.mainArea,
columnCount=2,
allColumnsShowFocus=True,
alternatingRowColors=True,
selectionMode=QTreeWidget.ExtendedSelection,
uniformRowHeights=True)
self.tree.setHeaderLabels(["Itemsets", "Support", "%"])
self.tree.header().setStretchLastSection(True)
self.tree.itemSelectionChanged.connect(self.selectionChanged)
self.mainArea.layout().addWidget(self.tree)
box = gui.widgetBox(self.controlArea, "Info")
self.nItemsets = self.nSelectedExamples = self.nSelectedItemsets = ''
gui.label(box, self, "Number of itemsets: %(nItemsets)s")
gui.label(box, self, "Selected itemsets: %(nSelectedItemsets)s")
gui.label(box, self, "Selected examples: %(nSelectedExamples)s")
hbox = gui.widgetBox(box, orientation='horizontal')
gui.button(hbox, self, "Expand all", callback=self.tree.expandAll)
gui.button(hbox, self, "Collapse all", callback=self.tree.collapseAll)
box = gui.widgetBox(self.controlArea, 'Find itemsets')
gui.hSlider(box, self, 'minSupport', minValue=1, maxValue=100,
label='Minimal support:', labelFormat="%d%%",
callback=lambda: self.find_itemsets())
gui.hSlider(box, self, 'maxItemsets', minValue=10000, maxValue=100000, step=10000,
label='Max. number of itemsets:', labelFormat="%d",
callback=lambda: self.find_itemsets())
gui.checkBox(box, self, 'filterSearch',
label='Apply below filters in search',
tooltip='If checked, the itemsets are filtered according '
'to below filter conditions already in the search '
'phase. \nIf unchecked, the only filters applied '
'during search are the ones above, '
'and the itemsets are \nfiltered afterwards only for '
'display, i.e. only the matching itemsets are shown.')
self.button = gui.auto_commit(
box, self, 'autoFind', 'Find itemsets', commit=self.find_itemsets)
box = gui.widgetBox(self.controlArea, 'Filter itemsets')
gui.lineEdit(box, self, 'filterKeywords', 'Contains:',
callback=self.filter_change, orientation='horizontal',
tooltip='A comma or space-separated list of regular '
'expressions.')
hbox = gui.widgetBox(box, orientation='horizontal')
gui.spin(hbox, self, 'filterMinItems', 1, 998, label='Min. items:',
callback=self.filter_change)
gui.spin(hbox, self, 'filterMaxItems', 2, 999, label='Max. items:',
callback=self.filter_change)
gui.rubber(hbox)
gui.rubber(self.controlArea)
gui.auto_commit(self.controlArea, self, 'autoSend', 'Send selection')
self.filter_change()
def add_main_layout(self):
box = gui.widgetBox(self.controlArea, "Parameters")
self.base_estimator = TreeLearner()
self.base_label = gui.label(box, self, "Base estimator: " + self.base_estimator.name)
gui.spin(box, self, "n_estimators", 1, 100, label="Number of estimators:",
alignment=Qt.AlignRight, callback=self.settings_changed)
gui.doubleSpin(box, self, "learning_rate", 1e-5, 1.0, 1e-5,
label="Learning rate:", decimals=5, alignment=Qt.AlignRight,
controlWidth=90, callback=self.settings_changed)
self.add_specific_parameters(box)
def __init__(self):
super().__init__()
self._nhops = 2
ib = gui.widgetBox(self.controlArea, "Preferences", orientation="vertical")
gui.spin(ib, self, "_nhops", 1, 6, 1, label="Number of hops: ", callback=self.update_view)
self.inside_view = NxInsideView(self._nhops)
self.send("Nx View", self.inside_view)
self.warning('This widget, at best, does nothing at the moment. Check back later.')
def add_main_layout(self):
box = gui.vBox(self.controlArea, "Neighbors")
gui.spin(box, self, "n_neighbors", 1, 100, label="Number of neighbors:",
alignment=Qt.AlignRight, callback=self.settings_changed)
gui.comboBox(box, self, "metric_index", label="Metric:",
orientation=Qt.Horizontal,
items=[i.capitalize() for i in self.metrics],
callback=self.settings_changed)
gui.comboBox(box, self, "weight_type", label="Weight:",
orientation=Qt.Horizontal,
items=[i.capitalize() for i in self.weights],
callback=self.settings_changed)
def create_configuration_layout(self):
layout = QFormLayout()
spin = gui.spin(self, self, 'f', minv=1,
maxv=SimhashVectorizer.max_f)
spin.editingFinished.connect(self.on_change)
layout.addRow('Simhash size:', spin)
spin = gui.spin(self, self, 'shingle_len', minv=1, maxv=100)
spin.editingFinished.connect(self.on_change)
layout.addRow('Shingle length:', spin)
return layout
def __init__(self, parent=None):
super().__init__(parent)
self.train_data = None
self.test_data = None
#: An Ordered dictionary with current inputs and their testing
#: results.
self.learners = OrderedDict()
sbox = gui.widgetBox(self.controlArea, "Sampling")
rbox = gui.radioButtons(
sbox, self, "resampling", callback=self._param_changed
)
gui.appendRadioButton(rbox, "Cross validation")
ibox = gui.indentedBox(rbox)
gui.spin(ibox, self, "k_folds", 2, 50, label="Number of folds:",
callback=self._param_changed)
gui.appendRadioButton(rbox, "Leave one out")
gui.appendRadioButton(rbox, "Random sampling")
ibox = gui.indentedBox(rbox)
gui.spin(ibox, self, "n_repeat", 2, 50, label="Repeat train/test",
callback=self._param_changed)
gui.widgetLabel(ibox, "Relative training set size:")
gui.hSlider(ibox, self, "sample_p", minValue=1, maxValue=100,
ticks=20, vertical=False,
callback=self._param_changed)
gui.appendRadioButton(rbox, "Test on train data")
gui.appendRadioButton(rbox, "Test on test data")
rbox.layout().addSpacing(5)
gui.button(rbox, self, "Apply", callback=self.apply)
gui.rubber(self.controlArea)
self.view = QTreeView(
rootIsDecorated=False,
uniformRowHeights=True,
wordWrap=True,
editTriggers=QTreeView.NoEditTriggers
)
self.result_model = QStandardItemModel()
self.result_model.setHorizontalHeaderLabels(
["Method"] + classification_stats.headers
)
self.view.setModel(self.result_model)
box = gui.widgetBox(self.mainArea, "Evaluation Results")
box.layout().addWidget(self.view)
def add_main_layout(self):
box = gui.vBox(self.controlArea, box='Parameters')
gui.spin(box, self, 'maxlags', 1, 100, label='Maximum auto-regression order:',
callback=self.apply)
gui.radioButtons(
box, self, 'ic',
btnLabels=tuple(self.IC_LABELS.keys()),
box='Information criterion', label='Optimize AR order by:',
callback=self.apply)
gui.radioButtons(
box, self, 'trend',
btnLabels=tuple(self.TREND_LABELS.keys()),
box='Trend', label='Add trend vector(s):',
callback=self.apply)
def __init__(self, parent=None):
super().__init__(parent)
self.data = None
self._invalidated = False
self._pca = None
self._variance_ratio = None
self._cumulative = None
self._line = False
box = gui.widgetBox(self.controlArea, "Components Selection")
form = QFormLayout()
box.layout().addLayout(form)
self.components_spin = gui.spin(
box, self, "max_components", 0, 1000,
callback=self._update_selection,
keyboardTracking=False
)
self.components_spin.setSpecialValueText("All")
self.variance_spin = gui.spin(
box, self, "variance_covered", 1, 100,
callback=self._update_selection,
keyboardTracking=False
)
self.variance_spin.setSuffix("%")
form.addRow("Max components", self.components_spin)
form.addRow("Variance covered", self.variance_spin)
self.controlArea.layout().addStretch()
box = gui.widgetBox(self.controlArea, "Commit")
cb = gui.checkBox(box, self, "auto_commit", "Commit on any change")
b = gui.button(box, self, "Commit", callback=self.commit, default=True)
gui.setStopper(self, b, cb, "_invalidated", callback=self.commit)
self.plot = pg.PlotWidget(background="w")
axis = self.plot.getAxis("bottom")
axis.setLabel("Principal Components")
axis = self.plot.getAxis("left")
axis.setLabel("Proportion of variance")
self.plot.getViewBox().setMenuEnabled(False)
self.plot.showGrid(True, True, alpha=0.5)
self.plot.setRange(xRange=(0.0, 1.0), yRange=(0.0, 1.0))
self.mainArea.layout().addWidget(self.plot)
def __init__(self, parent=None):
super().__init__(parent)
self.data = None
self._pca = None
self._transformed = None
self._variance_ratio = None
self._cumulative = None
self._line = False
box = gui.widgetBox(self.controlArea, "Components Selection")
form = QFormLayout()
box.layout().addLayout(form)
self.components_spin = gui.spin(
box, self, "ncomponents", 0, 1000,
callback=self._update_selection_component_spin,
keyboardTracking=False
)
self.components_spin.setSpecialValueText("All")
self.variance_spin = gui.spin(
box, self, "variance_covered", 1, 100,
callback=self._update_selection_variance_spin,
keyboardTracking=False
)
self.variance_spin.setSuffix("%")
form.addRow("Components", self.components_spin)
form.addRow("Variance covered", self.variance_spin)
self.controlArea.layout().addStretch()
gui.auto_commit(self.controlArea, self, "auto_commit", "Send data",
checkbox_label="Auto send on change")
self.plot = pg.PlotWidget(background="w")
axis = self.plot.getAxis("bottom")
axis.setLabel("Principal Components")
axis = self.plot.getAxis("left")
axis.setLabel("Proportion of variance")
self.plot.getViewBox().setMenuEnabled(False)
self.plot.getViewBox().setMouseEnabled(False, False)
self.plot.showGrid(True, True, alpha=0.5)
self.plot.setRange(xRange=(0.0, 1.0), yRange=(0.0, 1.0))
self.mainArea.layout().addWidget(self.plot)
def __init__(self):
super().__init__()
self.out_domain_desc = None
self.all_measures = SCORES
self.selectedMeasures = dict(
[(name, True) for name in _DEFAULT_SELECTED] +
[(m.name, False)
for m in self.all_measures[len(_DEFAULT_SELECTED):]])
# Discrete (0) or continuous (1) class mode
self.rankMode = 0
self.data = None
self.discMeasures = [
m for m in self.all_measures
if issubclass(DiscreteVariable, m.score.class_type)
]
self.contMeasures = [
m for m in self.all_measures
if issubclass(ContinuousVariable, m.score.class_type)
]
selMethBox = gui.vBox(self.controlArea,
"Select Attributes",
addSpace=True)
grid = QtGui.QGridLayout()
grid.setContentsMargins(6, 0, 6, 0)
self.selectButtons = QtGui.QButtonGroup()
self.selectButtons.buttonClicked[int].connect(self.setSelectMethod)
def button(text, buttonid, toolTip=None):
b = QtGui.QRadioButton(text)
self.selectButtons.addButton(b, buttonid)
if toolTip is not None:
b.setToolTip(toolTip)
return b
b1 = button(self.tr("None"), OWRank.SelectNone)
b2 = button(self.tr("All"), OWRank.SelectAll)
b3 = button(self.tr("Manual"), OWRank.SelectManual)
b4 = button(self.tr("Best ranked:"), OWRank.SelectNBest)
s = gui.spin(selMethBox,
self,
"nSelected",
1,
100,
callback=self.nSelectedChanged)
grid.addWidget(b1, 0, 0)
grid.addWidget(b2, 1, 0)
grid.addWidget(b3, 2, 0)
grid.addWidget(b4, 3, 0)
grid.addWidget(s, 3, 1)
self.selectButtons.button(self.selectMethod).setChecked(True)
selMethBox.layout().addLayout(grid)
gui.auto_commit(self.buttonsArea,
self,
"auto_apply",
"Send",
box=False)
gui.rubber(self.controlArea)
# Discrete and continuous table views are stacked
self.ranksViewStack = QtGui.QStackedLayout()
self.mainArea.layout().addLayout(self.ranksViewStack)
self.discRanksView = QtGui.QTableView()
self.ranksViewStack.addWidget(self.discRanksView)
self.discRanksView.setSelectionBehavior(QtGui.QTableView.SelectRows)
self.discRanksView.setSelectionMode(QtGui.QTableView.MultiSelection)
self.discRanksView.setSortingEnabled(True)
self.discRanksLabels = ["#"] + [m.shortname for m in self.discMeasures]
self.discRanksModel = QtGui.QStandardItemModel(self)
self.discRanksModel.setHorizontalHeaderLabels(self.discRanksLabels)
self.discRanksProxyModel = MySortProxyModel(self)
self.discRanksProxyModel.setSourceModel(self.discRanksModel)
self.discRanksView.setModel(self.discRanksProxyModel)
self.discRanksView.setColumnWidth(0, 20)
self.discRanksView.sortByColumn(1, Qt.DescendingOrder)
self.discRanksView.selectionModel().selectionChanged.connect(
self.commit)
self.discRanksView.pressed.connect(self.onSelectItem)
self.discRanksView.horizontalHeader().sectionClicked.connect(
self.headerClick)
self.discRanksView.verticalHeader().sectionClicked.connect(
self.onSelectItem)
if self.headerState[0] is not None:
self.discRanksView.horizontalHeader().restoreState(
self.headerState[0])
self.contRanksView = QtGui.QTableView()
self.ranksViewStack.addWidget(self.contRanksView)
self.contRanksView.setSelectionBehavior(QtGui.QTableView.SelectRows)
self.contRanksView.setSelectionMode(QtGui.QTableView.MultiSelection)
self.contRanksView.setSortingEnabled(True)
self.contRanksLabels = ["#"] + [m.shortname for m in self.contMeasures]
self.contRanksModel = QtGui.QStandardItemModel(self)
self.contRanksModel.setHorizontalHeaderLabels(self.contRanksLabels)
self.contRanksProxyModel = MySortProxyModel(self)
self.contRanksProxyModel.setSourceModel(self.contRanksModel)
self.contRanksView.setModel(self.contRanksProxyModel)
self.contRanksView.setColumnWidth(0, 20)
self.contRanksView.sortByColumn(1, Qt.DescendingOrder)
self.contRanksView.selectionModel().selectionChanged.connect(
self.commit)
self.contRanksView.pressed.connect(self.onSelectItem)
self.contRanksView.horizontalHeader().sectionClicked.connect(
self.headerClick)
self.contRanksView.verticalHeader().sectionClicked.connect(
self.onSelectItem)
if self.headerState[1] is not None:
self.contRanksView.horizontalHeader().restoreState(
self.headerState[1])
# Switch the current view to Discrete
self.switchRanksMode(0)
self.resetInternals()
self.updateDelegates()
self.updateVisibleScoreColumns()
self.resize(690, 500)
self.measure_scores = table((len(self.measures), 0), None)
self.learners = {}
def __init__(self):
super().__init__()
self.instances = None
self.domain = None
self.data = None
self.classifier = None
self.align = OWNomogram.ALIGN_ZERO
self.log_odds_ratios = []
self.log_reg_coeffs = []
self.log_reg_coeffs_orig = []
self.log_reg_cont_data_extremes = []
self.p = None
self.b0 = None
self.points = []
self.feature_items = {}
self.feature_marker_values = []
self.scale_marker_values = lambda x: x
self.nomogram_main = None
self.vertical_line = None
self.hidden_vertical_line = None
self.old_target_class_index = self.target_class_index
self.repaint = False
# GUI
box = gui.vBox(self.controlArea, "Target class")
self.class_combo = gui.comboBox(box,
self,
"target_class_index",
callback=self._class_combo_changed,
contentsLength=12)
self.norm_check = gui.checkBox(
box,
self,
"normalize_probabilities",
"Normalize probabilities",
hidden=True,
callback=self.update_scene,
tooltip="For multiclass data 1 vs. all probabilities do not"
" sum to 1 and therefore could be normalized.")
self.scale_radio = gui.radioButtons(self.controlArea,
self,
"scale",
["Point scale", "Log odds ratios"],
box="Scale",
callback=self.update_scene)
box = gui.vBox(self.controlArea, "Display features")
grid = QGridLayout()
radio_group = gui.radioButtonsInBox(box,
self,
"display_index", [],
orientation=grid,
callback=self.update_scene)
radio_all = gui.appendRadioButton(radio_group,
"All",
addToLayout=False)
radio_best = gui.appendRadioButton(radio_group,
"Best ranked:",
addToLayout=False)
spin_box = gui.hBox(None, margin=0)
self.n_spin = gui.spin(spin_box,
self,
"n_attributes",
1,
self.MAX_N_ATTRS,
label=" ",
controlWidth=60,
callback=self._n_spin_changed)
grid.addWidget(radio_all, 1, 1)
grid.addWidget(radio_best, 2, 1)
grid.addWidget(spin_box, 2, 2)
self.sort_combo = gui.comboBox(box,
self,
"sort_index",
label="Rank by:",
items=SortBy.items(),
orientation=Qt.Horizontal,
callback=self.update_scene)
self.cont_feature_dim_combo = gui.comboBox(
box,
self,
"cont_feature_dim_index",
label="Numeric features: ",
items=["1D projection", "2D curve"],
orientation=Qt.Horizontal,
callback=self.update_scene)
gui.rubber(self.controlArea)
class _GraphicsView(QGraphicsView):
def __init__(self, scene, parent, **kwargs):
for k, v in dict(
verticalScrollBarPolicy=Qt.ScrollBarAlwaysOff,
horizontalScrollBarPolicy=Qt.ScrollBarAlwaysOff,
viewportUpdateMode=QGraphicsView.
BoundingRectViewportUpdate,
renderHints=(QPainter.Antialiasing
| QPainter.TextAntialiasing
| QPainter.SmoothPixmapTransform),
alignment=(Qt.AlignTop | Qt.AlignLeft),
sizePolicy=QSizePolicy(
QSizePolicy.MinimumExpanding,
QSizePolicy.MinimumExpanding)).items():
kwargs.setdefault(k, v)
super().__init__(scene, parent, **kwargs)
class GraphicsView(_GraphicsView):
def __init__(self, scene, parent):
super().__init__(
scene,
parent,
verticalScrollBarPolicy=Qt.ScrollBarAlwaysOn,
styleSheet='QGraphicsView {background: white}')
self.viewport().setMinimumWidth(
300) # XXX: This prevents some tests failing
self._is_resizing = False
w = self
def resizeEvent(self, resizeEvent):
# Recompute main scene on window width change
if resizeEvent.size().width() != resizeEvent.oldSize().width():
self._is_resizing = True
self.w.update_scene()
self._is_resizing = False
return super().resizeEvent(resizeEvent)
def is_resizing(self):
return self._is_resizing
def sizeHint(self):
return QSize(400, 200)
class FixedSizeGraphicsView(_GraphicsView):
def __init__(self, scene, parent):
super().__init__(scene,
parent,
sizePolicy=QSizePolicy(
QSizePolicy.MinimumExpanding,
QSizePolicy.Minimum))
def sizeHint(self):
return QSize(400, 85)
scene = self.scene = QGraphicsScene(self)
top_view = self.top_view = FixedSizeGraphicsView(scene, self)
mid_view = self.view = GraphicsView(scene, self)
bottom_view = self.bottom_view = FixedSizeGraphicsView(scene, self)
for view in (top_view, mid_view, bottom_view):
self.mainArea.layout().addWidget(view)
def __init__(self):
self._task = None # type: Optional[self.Task]
self._executor = ThreadExecutor(self)
self.data = None
self.test_type = ''
self.discrete_model = DomainModel(separators=False,
valid_types=(DiscreteVariable, ),
parent=self)
self.domain_model = DomainModel(valid_types=DomainModel.PRIMITIVE,
parent=self)
box = gui.vBox(self.controlArea, 'Hypotheses Testing')
gui.listView(
box,
self,
'chosen_X',
model=self.discrete_model,
box='Grouping Variables',
selectionMode=QListView.ExtendedSelection,
callback=self.Error.no_vars_selected.clear,
toolTip='Select multiple variables with Ctrl+ or Shift+Click.')
target = gui.comboBox(
box,
self,
'chosen_y',
sendSelectedValue=True,
label='Test Variable',
callback=[self.set_test_type, self.Error.no_class_selected.clear])
target.setModel(self.domain_model)
gui.checkBox(box,
self,
'is_permutation',
label='Permutation test',
callback=self.set_test_type)
gui.comboBox(box,
self,
'test_statistic',
label='Statistic:',
items=tuple(self.TEST_STATISTICS),
orientation=Qt.Horizontal,
sendSelectedValue=True,
callback=self.set_test_type)
gui.label(box, self, 'Test: %(test_type)s')
box = gui.vBox(self.controlArea, 'Filter')
gui.spin(box,
self,
'min_count',
5,
1000,
5,
label='Minimum group size (count):')
self.btn_compute = gui.button(self.controlArea,
self,
'&Compute',
callback=self.compute)
gui.rubber(self.controlArea)
class Model(PyTableModel):
_n_vars = 0
_BACKGROUND = [QBrush(QColor('#eee')), QBrush(QColor('#ddd'))]
def setHorizontalHeaderLabels(self, labels, n_vars):
self._n_vars = n_vars
super().setHorizontalHeaderLabels(labels)
def data(self, index, role=Qt.DisplayRole):
if role == Qt.BackgroundRole and index.column() < self._n_vars:
return self._BACKGROUND[index.row() % 2]
if role == Qt.DisplayRole or role == Qt.ToolTipRole:
colname = self.headerData(index.column(), Qt.Horizontal)
if colname.lower() in ('count', 'count | class'):
row = self.mapToSourceRows(index.row())
return int(self[row][index.column()])
return super().data(index, role)
owwidget = self
class View(gui.TableView):
_vars = None
def set_vars(self, vars):
self._vars = vars
def selectionChanged(self, *args):
super().selectionChanged(*args)
rows = list({
index.row()
for index in self.selectionModel().selectedRows(0)
})
if not rows:
owwidget.Outputs.data.send(None)
return
model = self.model().tolist()
filters = [
Values([
FilterDiscrete(self._vars[col], {model[row][col]})
for col in range(len(self._vars))
]) for row in self.model().mapToSourceRows(rows)
]
data = Values(filters, conjunction=False)(owwidget.data)
annotated = create_annotated_table(owwidget.data, data.ids)
owwidget.Outputs.selected_data.send(data)
owwidget.Outputs.data.send(annotated)
self.view = view = View(self)
self.model = Model(parent=self)
view.setModel(self.model)
view.horizontalHeader().setStretchLastSection(False)
self.mainArea.layout().addWidget(view)
self.set_test_type()
def __init__(self):
OWWidget.__init__(self)
ConcurrentWidgetMixin.__init__(self)
self.scorers: List[ScoreMeta] = []
self.out_domain_desc = None
self.data = None
self.problem_type_mode = ProblemType.CLASSIFICATION
# results caches
self.scorers_results = {}
self.methods_results = {}
if not self.selected_methods:
self.selected_methods = {
method.name
for method in SCORES if method.is_default
}
# GUI
self.ranksModel = model = TableModel(parent=self) # type: TableModel
self.ranksView = view = TableView(self) # type: TableView
self.mainArea.layout().addWidget(view)
view.setModel(model)
view.setColumnWidth(NVAL_COL, 30)
view.selectionModel().selectionChanged.connect(self.on_select)
def _set_select_manual():
self.setSelectionMethod(OWRank.SelectManual)
view.manualSelection.connect(_set_select_manual)
view.verticalHeader().sectionClicked.connect(_set_select_manual)
view.horizontalHeader().sectionClicked.connect(self.headerClick)
self.measuresStack = stacked = QStackedWidget(self)
self.controlArea.layout().addWidget(stacked)
for scoring_methods in (CLS_SCORES, REG_SCORES, []):
box = gui.vBox(None, "评分方法" if scoring_methods else None)
stacked.addWidget(box)
for method in scoring_methods:
box.layout().addWidget(
QCheckBox(
method.zh_name,
self,
objectName=method.
shortname, # To be easily found in tests
checked=method.name in self.selected_methods,
stateChanged=partial(self.methodSelectionChanged,
method_name=method.name)))
gui.rubber(box)
gui.rubber(self.controlArea)
self.switchProblemType(ProblemType.CLASSIFICATION)
selMethBox = gui.vBox(self.buttonsArea, "选择特征")
grid = QGridLayout()
grid.setContentsMargins(0, 0, 0, 0)
grid.setSpacing(6)
self.selectButtons = QButtonGroup()
self.selectButtons.buttonClicked[int].connect(self.setSelectionMethod)
def button(text, buttonid, toolTip=None):
b = QRadioButton(text)
self.selectButtons.addButton(b, buttonid)
if toolTip is not None:
b.setToolTip(toolTip)
return b
b1 = button(self.tr("无"), OWRank.SelectNone)
b2 = button(self.tr("所有"), OWRank.SelectAll)
b3 = button(self.tr("手动"), OWRank.SelectManual)
b4 = button(self.tr("最佳排名:"), OWRank.SelectNBest)
s = gui.spin(
selMethBox,
self,
"nSelected",
1,
999,
callback=lambda: self.setSelectionMethod(OWRank.SelectNBest),
addToLayout=False)
grid.addWidget(b1, 0, 0)
grid.addWidget(b2, 1, 0)
grid.addWidget(b3, 2, 0)
grid.addWidget(b4, 3, 0)
grid.addWidget(s, 3, 1)
self.selectButtons.button(self.selectionMethod).setChecked(True)
selMethBox.layout().addLayout(grid)
gui.auto_send(self.buttonsArea, self, "auto_apply")
self.resize(690, 500)
def __init__(self):
super().__init__()
# sets self.curvePoints, self.steps equidistant points from
# 1/self.steps to 1
self.updateCurvePoints()
self.scoring = [
("Classification Accuracy", Orange.evaluation.scoring.CA),
("AUC", Orange.evaluation.scoring.AUC),
("Precision", Orange.evaluation.scoring.Precision),
("Recall", Orange.evaluation.scoring.Recall),
]
#: input data on which to construct the learning curve
self.data = None
#: optional test data
self.testdata = None
#: A {input_id: Learner} mapping of current learners from input channel
self.learners = OrderedDict()
#: A {input_id: List[Results]} mapping of input id to evaluation
#: results list, one for each curve point
self.results = OrderedDict()
#: A {input_id: List[float]} mapping of input id to learning curve
#: point scores
self.curves = OrderedDict()
# [start-snippet-3]
#: The current evaluating task (if any)
self._task = None # type: Optional[Task]
#: An executor we use to submit learner evaluations into a thread pool
self._executor = ThreadExecutor()
# [end-snippet-3]
# GUI
box = gui.widgetBox(self.controlArea, "Info")
self.infoa = gui.widgetLabel(box, "No data on input.")
self.infob = gui.widgetLabel(box, "No learners.")
gui.separator(self.controlArea)
box = gui.widgetBox(self.controlArea, "Evaluation Scores")
gui.comboBox(
box,
self,
"scoringF",
items=[x[0] for x in self.scoring],
callback=self._invalidate_curves,
)
gui.separator(self.controlArea)
box = gui.widgetBox(self.controlArea, "Options")
gui.spin(
box,
self,
"folds",
2,
100,
step=1,
label="Cross validation folds: ",
keyboardTracking=False,
callback=lambda: self._invalidate_results()
if self.commitOnChange else None,
)
gui.spin(
box,
self,
"steps",
2,
100,
step=1,
label="Learning curve points: ",
keyboardTracking=False,
callback=[
self.updateCurvePoints,
lambda: self._invalidate_results()
if self.commitOnChange else None,
],
)
gui.checkBox(box, self, "commitOnChange",
"Apply setting on any change")
self.commitBtn = gui.button(box,
self,
"Apply Setting",
callback=self._invalidate_results,
disabled=True)
gui.rubber(self.controlArea)
# table widget
self.table = gui.table(self.mainArea,
selectionMode=QTableWidget.NoSelection)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.api = None
self.corpus = None
self.api_dlg = self.APICredentialsDialog(self)
self.api_dlg.accept(silent=True)
# Set API key button
gui.button(self.controlArea,
self,
'Twitter API Key',
callback=self.open_key_dialog,
tooltip='Set the API key for this widget.',
focusPolicy=Qt.NoFocus)
# Query
query_box = gui.hBox(self.controlArea, 'Query')
layout = QGridLayout()
layout.setVerticalSpacing(5)
layout.setColumnStretch(2, 1) # stretch last columns
layout.setColumnMinimumWidth(1, 15) # add some space for checkbox
ROW = 0
COLUMNS = 3
def add_row(label, items):
nonlocal ROW, COLUMNS
layout.addWidget(QLabel(label), ROW, 0)
if isinstance(items, tuple):
for i, item in enumerate(items):
layout.addWidget(item, ROW, 1 + i)
else:
layout.addWidget(items, ROW, 1, 1, COLUMNS - 1)
ROW += 1
# Query input
add_row(
'Query word list:',
ListEdit(self, 'word_list', 'Multiple lines are joined with OR.',
80, self))
# Search mode
add_row(
'Search by:',
gui.comboBox(self,
self,
'mode',
items=self.MODES,
callback=self.mode_toggle))
# Language
self.language_combo = ComboBox(self,
'language',
items=(('Any', None), ) +
tuple(sorted(lang2code.items())))
add_row('Language:', self.language_combo)
# Max tweets
add_row(
'Max tweets:',
gui.spin(self,
self,
'max_tweets',
minv=1,
maxv=10000,
checked='limited_search'))
# Retweets
self.retweets_checkbox = gui.checkBox(self,
self,
'allow_retweets',
'',
minimumHeight=30)
add_row('Allow retweets:', self.retweets_checkbox)
# Collect Results
add_row('Collect results:', gui.checkBox(self, self, 'collecting', ''))
query_box.layout().addLayout(layout)
self.controlArea.layout().addWidget(
CheckListLayout('Text includes',
self,
'text_includes',
self.attributes,
cols=2,
callback=self.set_text_features))
self.tweets_info_label = gui.label(self.controlArea,
self,
self.tweets_info.format(0),
box='Info')
# Buttons
self.button_box = gui.hBox(self.controlArea)
self.search_button = gui.button(self.button_box,
self,
'Search',
self.start_stop,
focusPolicy=Qt.NoFocus)
self.mode_toggle()
self.setFocus() # to widget itself to show placeholder for query_edit
def __init__(self):
super().__init__()
self.results = None
self.classifier_names = []
self.perf_line = None
self.colors = []
self._curve_data = {}
self._plot_curves = {}
self._rocch = None
self._perf_line = None
self._tooltip_cache = None
box = gui.vBox(self.controlArea, "绘制")
self.target_cb = gui.comboBox(box,
self,
"target_index",
label="目标",
orientation=Qt.Horizontal,
callback=self._on_target_changed,
contentsLength=8,
searchable=True)
gui.widgetLabel(box, "分类器")
line_height = 4 * QFontMetrics(self.font()).lineSpacing()
self.classifiers_list_box = gui.listBox(
box,
self,
"selected_classifiers",
"classifier_names",
selectionMode=QListView.MultiSelection,
callback=self._on_classifiers_changed,
sizeHint=QSize(0, line_height))
abox = gui.vBox(self.controlArea, "曲线")
gui.comboBox(abox,
self,
"roc_averaging",
items=["合并折叠预测", "平均真阳性率", "阈值处的平均真阳性率和假阳性率", "显示单个曲线"],
callback=self._replot)
gui.checkBox(abox,
self,
"display_convex_curve",
"显示凸ROC曲线",
callback=self._replot)
gui.checkBox(abox,
self,
"display_convex_hull",
"显示ROC凸包",
callback=self._replot)
box = gui.vBox(self.controlArea, "分析")
gui.checkBox(box,
self,
"display_def_threshold",
"默认阈值（0.5）点",
callback=self._on_display_def_threshold_changed)
gui.checkBox(box,
self,
"display_perf_line",
"显示性能线",
callback=self._on_display_perf_line_changed)
grid = QGridLayout()
gui.indentedBox(box, orientation=grid)
sp = gui.spin(box,
self,
"fp_cost",
1,
1000,
10,
alignment=Qt.AlignRight,
callback=self._on_display_perf_line_changed)
grid.addWidget(QLabel("假阳性率损失:"), 0, 0)
grid.addWidget(sp, 0, 1)
sp = gui.spin(box,
self,
"fn_cost",
1,
1000,
10,
alignment=Qt.AlignRight,
callback=self._on_display_perf_line_changed)
grid.addWidget(QLabel("假阴性率损失:"))
grid.addWidget(sp, 1, 1)
self.target_prior_sp = gui.spin(box,
self,
"target_prior",
1,
99,
alignment=Qt.AlignRight,
spinType=float,
callback=self._on_target_prior_changed)
self.target_prior_sp.setSuffix(" %")
self.target_prior_sp.addAction(QAction("Auto", sp))
grid.addWidget(QLabel("先验概率:"))
grid.addWidget(self.target_prior_sp, 2, 1)
self.plotview = GraphicsView(background=None)
self.plotview.setFrameStyle(QFrame.StyledPanel)
self.plotview.scene().sigMouseMoved.connect(self._on_mouse_moved)
self.plot = PlotItem(enableMenu=False)
self.plot.setMouseEnabled(False, False)
self.plot.hideButtons()
tickfont = QFont(self.font())
tickfont.setPixelSize(max(int(tickfont.pixelSize() * 2 // 3), 11))
axis = self.plot.getAxis("bottom")
axis.setTickFont(tickfont)
axis.setLabel("假阳性率 (1-特异度)")
axis.setGrid(16)
axis = self.plot.getAxis("left")
axis.setTickFont(tickfont)
axis.setLabel("真阳性率 (灵敏度)")
axis.setGrid(16)
self.plot.showGrid(True, True, alpha=0.2)
self.plot.setRange(xRange=(0.0, 1.0), yRange=(0.0, 1.0), padding=0.05)
self.plotview.setCentralItem(self.plot)
self.mainArea.layout().addWidget(self.plotview)
def __init__(self):
super().__init__()
self.data = None
self.plotdata = None
box = gui.widgetBox(self.controlArea, "Optimization", spacing=10)
form = QtGui.QFormLayout(
labelAlignment=Qt.AlignLeft,
formAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QtGui.QFormLayout.AllNonFixedFieldsGrow,
verticalSpacing=10)
form.addRow(
"Force law",
gui.comboBox(box,
self,
"force_law",
items=[text for text, _ in OWFreeViz.ForceLaw],
callback=self.__reset_update_interval))
form.addRow("Max iterations", gui.spin(box, self, "maxiter", 10,
10**4))
form.addRow(
"Initialization",
gui.comboBox(box,
self,
"initialization",
items=["Circular", "Random"],
callback=self.__reset_initialization))
form.addRow(
"Replot",
gui.comboBox(box,
self,
"replot_interval",
items=[text for text, _ in OWFreeViz.ReplotIntervals],
callback=self.__reset_update_interval))
box.layout().addLayout(form)
self.start_button = gui.button(box, self, "Optimize",
self._toogle_start)
self.color_varmodel = itemmodels.VariableListModel(parent=self)
self.shape_varmodel = itemmodels.VariableListModel(parent=self)
self.size_varmodel = itemmodels.VariableListModel(parent=self)
self.label_varmodel = itemmodels.VariableListModel(parent=self)
box = gui.widgetBox(self.controlArea, "Plot")
form = QtGui.QFormLayout(
formAlignment=Qt.AlignLeft,
labelAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QtGui.QFormLayout.AllNonFixedFieldsGrow,
spacing=8,
)
box.layout().addLayout(form)
color_cb = gui.comboBox(box,
self,
"color_var",
sendSelectedValue=True,
emptyString="(Same color)",
contentsLength=10,
callback=self._update_color)
color_cb.setModel(self.color_varmodel)
form.addRow("Color", color_cb)
opacity_slider = gui.hSlider(box,
self,
"opacity",
minValue=50,
maxValue=255,
ticks=True,
createLabel=False,
callback=self._update_color)
opacity_slider.setTickInterval(0)
opacity_slider.setPageStep(10)
form.addRow("Opacity", opacity_slider)
shape_cb = gui.comboBox(box,
self,
"shape_var",
contentsLength=10,
sendSelectedValue=True,
emptyString="(Same shape)",
callback=self._update_shape)
shape_cb.setModel(self.shape_varmodel)
form.addRow("Shape", shape_cb)
size_cb = gui.comboBox(box,
self,
"size_var",
contentsLength=10,
sendSelectedValue=True,
emptyString="(Same size)",
callback=self._update_size)
size_cb.setModel(self.size_varmodel)
form.addRow("Size", size_cb)
size_slider = gui.hSlider(box,
self,
"point_size",
minValue=3,
maxValue=20,
ticks=True,
createLabel=False,
callback=self._update_size)
form.addRow(None, size_slider)
label_cb = gui.comboBox(box,
self,
"label_var",
contentsLength=10,
sendSelectedValue=True,
emptyString="(No labels)",
callback=self._update_labels)
label_cb.setModel(self.label_varmodel)
form.addRow("Label", label_cb)
form.addRow(
"Jitter",
gui.comboBox(box,
self,
"jitter",
items=[text for text, _ in self.JitterAmount],
callback=self._update_xy))
self.class_density_cb = gui.checkBox(box,
self,
"class_density",
"",
callback=self._update_density)
form.addRow("Class density", self.class_density_cb)
box = gui.widgetBox(self.controlArea, "Hide anchors")
rslider = gui.hSlider(box,
self,
"min_anchor_radius",
minValue=0,
maxValue=100,
step=5,
label="Hide radius",
createLabel=False,
ticks=True,
callback=self._update_anchor_visibility)
rslider.setTickInterval(0)
rslider.setPageStep(10)
box = gui.widgetBox(self.controlArea, "Zoom/Select")
hlayout = QtGui.QHBoxLayout()
box.layout().addLayout(hlayout)
toolbox = PlotToolBox(self)
hlayout.addWidget(toolbox.button(PlotToolBox.SelectTool))
hlayout.addWidget(toolbox.button(PlotToolBox.ZoomTool))
hlayout.addWidget(toolbox.button(PlotToolBox.PanTool))
hlayout.addSpacing(2)
hlayout.addWidget(toolbox.button(PlotToolBox.ZoomReset))
toolbox.standardAction(PlotToolBox.ZoomReset).triggered.connect(
lambda: self.plot.setRange(QtCore.QRectF(-1.05, -1.05, 2.1, 2.1)))
toolbox.standardAction(PlotToolBox.ZoomIn).triggered.connect(
lambda: self.plot.getViewBox().scaleBy((1.25, 1.25)))
toolbox.standardAction(PlotToolBox.ZoomIn).triggered.connect(
lambda: self.plot.getViewBox().scaleBy((1 / 1.25, 1 / 1.25)))
selecttool = toolbox.plotTool(PlotToolBox.SelectTool)
selecttool.selectionFinished.connect(self.__select_area)
self.addActions(toolbox.actions())
self.controlArea.layout().addStretch(1)
box = gui.widgetBox(self.controlArea, "Output")
gui.comboBox(box,
self,
"embedding_domain_role",
items=[
"Original features only", "Coordinates as features",
"Coordinates as meta attributes"
])
gui.auto_commit(box,
self,
"autocommit",
"Commit",
box=False,
callback=self.commit)
self.plot = pg.PlotWidget(enableMouse=False, enableMenu=False)
self.plot.setFrameStyle(QtGui.QFrame.StyledPanel)
self.plot.plotItem.hideAxis("bottom")
self.plot.plotItem.hideAxis("left")
self.plot.plotItem.hideButtons()
self.plot.setAspectLocked(True)
self.plot.scene().installEventFilter(self)
self.legend = linproj.LegendItem()
self.legend.setParentItem(self.plot.getViewBox())
self.legend.anchor((1, 0), (1, 0))
self.plot.setRenderHint(QtGui.QPainter.Antialiasing, True)
self.mainArea.layout().addWidget(self.plot)
viewbox = self.plot.getViewBox()
viewbox.grabGesture(Qt.PinchGesture)
pinchtool = linproj.PlotPinchZoomTool(parent=self)
pinchtool.setViewBox(viewbox)
toolbox.setViewBox(viewbox)
self._loop = AsyncUpdateLoop(parent=self)
self._loop.yielded.connect(self.__set_projection)
self._loop.finished.connect(self.__freeviz_finished)
self._loop.raised.connect(self.__on_error)
def __init__(self):
super().__init__()
self.data = None # type: Optional[Table]
self.graph = None # type: Optional[nx.Graph]
self.partition = None # type: Optional[np.array]
self.__executor = ThreadExecutor(parent=self)
self.__future = None # type: Optional[Future]
self.__state = self.State.Pending
pca_box = gui.vBox(self.controlArea, 'PCA Preprocessing')
self.apply_pca_cbx = gui.checkBox(
pca_box,
self,
'apply_pca',
label='Apply PCA preprocessing',
callback=self._invalidate_graph,
) # type: QCheckBox
self.pca_components_slider = gui.hSlider(
pca_box,
self,
'pca_components',
label='Components: ',
minValue=2,
maxValue=_MAX_PCA_COMPONENTS,
callback=self._invalidate_pca_projection,
) # type: QSlider
graph_box = gui.vBox(self.controlArea, 'Graph parameters')
self.metric_combo = gui.comboBox(
graph_box,
self,
'metric_idx',
label='Distance metric',
items=[m[0] for m in METRICS],
callback=self._invalidate_graph,
orientation=Qt.Horizontal,
) # type: gui.OrangeComboBox
self.k_neighbours_spin = gui.spin(
graph_box,
self,
'k_neighbours',
minv=1,
maxv=_MAX_K_NEIGBOURS,
label='k neighbours',
controlWidth=80,
alignment=Qt.AlignRight,
callback=self._invalidate_graph,
) # type: gui.SpinBoxWFocusOut
self.cls_epsilon_spin = gui.spin(
graph_box,
self,
'resolution',
0,
5.,
1e-2,
spinType=float,
label='Resolution',
controlWidth=80,
alignment=Qt.AlignRight,
callback=self._invalidate_partition,
) # type: gui.SpinBoxWFocusOut
self.apply_button = gui.auto_commit(
self.controlArea,
self,
'auto_commit',
'Apply',
box=False,
commit=lambda: self.commit(force=True),
callback=self.commit,
) # type: QWidget
def __init__(self):
super().__init__()
self._delta = 0
self.play_timer = QTimer(self,
interval=self.playback_interval,
timeout=self.play_single_step)
slider = self.slider = Slider(
Qt.Horizontal,
self,
minimum=0,
maximum=self.MAX_SLIDER_VALUE,
tracking=False,
valuesChanged=self.valuesChanged,
minimumValue=self.slider_values[0],
maximumValue=self.slider_values[1],
)
slider.setShowText(False)
box = gui.vBox(self.controlArea, 'Time Slice')
box.layout().addWidget(slider)
hbox = gui.hBox(box)
def _dateTimeChanged(editted):
def handler():
minTime = self.date_from.dateTime().toMSecsSinceEpoch() / 1000
maxTime = self.date_to.dateTime().toMSecsSinceEpoch() / 1000
if minTime > maxTime:
minTime = maxTime = minTime if editted == self.date_from else maxTime
other = self.date_to if editted == self.date_from else self.date_from
with blockSignals(other):
other.setDateTime(editted.dateTime())
with blockSignals(self.slider):
self.slider.setValues(self.slider.unscale(minTime),
self.slider.unscale(maxTime))
self.send_selection(minTime, maxTime)
return handler
kwargs = dict(calendarPopup=True,
displayFormat=' '.join(self.DATE_FORMATS),
timeSpec=Qt.UTC)
date_from = self.date_from = QDateTimeEdit(self, **kwargs)
date_to = self.date_to = QDateTimeEdit(self, **kwargs)
date_from.dateTimeChanged.connect(_dateTimeChanged(date_from))
date_to.dateTimeChanged.connect(_dateTimeChanged(date_to))
hbox.layout().addStretch(100)
hbox.layout().addWidget(date_from)
hbox.layout().addWidget(QLabel(' – '))
hbox.layout().addWidget(date_to)
hbox.layout().addStretch(100)
vbox = gui.vBox(self.controlArea, 'Step / Play Through')
gui.checkBox(vbox, self, 'loop_playback', label='Loop playback')
hbox = gui.hBox(vbox)
gui.checkBox(hbox,
self,
'steps_overlap',
label='Stepping overlaps by:',
toolTip='If enabled, the active interval moves forward '
'(backward) by half of the interval at each step.')
gui.comboBox(hbox,
self,
'overlap_amount',
items=tuple(self.OVERLAP_AMOUNTS.keys()),
sendSelectedValue=True)
gui.spin(vbox,
self,
'playback_interval',
label='Playback delay (msec):',
minv=100,
maxv=30000,
step=200,
callback=lambda: self.play_timer.setInterval(
self.playback_interval))
hbox = gui.hBox(vbox)
self.step_backward = gui.button(
hbox,
self,
'⏮',
callback=lambda: self.play_single_step(backward=True),
autoDefault=False)
self.play_button = gui.button(hbox,
self,
'▶',
callback=self.playthrough,
toggleButton=True,
default=True)
self.step_forward = gui.button(hbox,
self,
'⏭',
callback=self.play_single_step,
autoDefault=False)
gui.rubber(self.controlArea)
def __init__(self):
super().__init__()
self.data = None # type: Optional[Table]
self.preprocessed_data = None # type: Optional[Table]
self.pca_projection = None # type: Optional[Table]
self.graph = None # type: Optional[nx.Graph]
self.partition = None # type: Optional[np.array]
# Use a executor with a single worker, to limit CPU overcommitment for
# cancelled tasks. The method does not have a fine cancellation
# granularity so we assure that there are not N - 1 jobs executing
# for no reason only to be thrown away. It would be better to use the
# global pool but implement a limit on jobs from this source.
self.__executor = futures.ThreadPoolExecutor(max_workers=1)
self.__task = None # type: Optional[TaskState]
self.__invalidated = False
# coalescing commit timer
self.__commit_timer = QTimer(self, singleShot=True)
self.__commit_timer.timeout.connect(self.commit)
# Set up UI
info_box = gui.vBox(self.controlArea, "Info")
self.info_label = gui.widgetLabel(info_box,
"No data on input.") # type: QLabel
preprocessing_box = gui.vBox(self.controlArea, "Preprocessing")
self.normalize_cbx = gui.checkBox(
preprocessing_box,
self,
"normalize",
label="Normalize data",
callback=self._invalidate_preprocessed_data,
attribute=Qt.WA_LayoutUsesWidgetRect) # type: QCheckBox
self.apply_pca_cbx = gui.checkBox(
preprocessing_box,
self,
"apply_pca",
label="Apply PCA preprocessing",
callback=self._apply_pca_changed,
attribute=Qt.WA_LayoutUsesWidgetRect) # type: QCheckBox
self.pca_components_slider = gui.hSlider(
preprocessing_box,
self,
"pca_components",
label="PCA Components: ",
minValue=2,
maxValue=_MAX_PCA_COMPONENTS,
callback=self._invalidate_pca_projection,
tracking=False) # type: QSlider
graph_box = gui.vBox(self.controlArea, "Graph parameters")
self.metric_combo = gui.comboBox(
graph_box,
self,
"metric_idx",
label="Distance metric",
items=[m[0] for m in METRICS],
callback=self._invalidate_graph,
orientation=Qt.Horizontal,
)
self.k_neighbors_spin = gui.spin(
graph_box,
self,
"k_neighbors",
minv=1,
maxv=_MAX_K_NEIGBOURS,
label="k neighbors",
controlWidth=80,
alignment=Qt.AlignRight,
callback=self._invalidate_graph,
)
self.resolution_spin = gui.hSlider(
graph_box,
self,
"resolution",
minValue=0,
maxValue=5.,
step=1e-1,
label="Resolution",
intOnly=False,
labelFormat="%.1f",
callback=self._invalidate_partition,
tracking=False,
) # type: QSlider
self.resolution_spin.parent().setToolTip(
"The resolution parameter affects the number of clusters to find. "
"Smaller values tend to produce more clusters and larger values "
"retrieve less clusters.")
self.apply_button = gui.auto_apply(
self.buttonsArea,
self,
"auto_commit",
commit=lambda: self.commit(),
callback=lambda: self._on_auto_commit_changed()) # type: QWidget
def add_main_layout(self):
# top-level control procedure
top_box = gui.hBox(widget=self.controlArea, box=None, addSpace=2)
rule_ordering_box = gui.hBox(widget=top_box, box="Rule ordering")
rule_ordering_rbs = gui.radioButtons(
widget=rule_ordering_box, master=self, value="rule_ordering",
callback=self.settings_changed, btnLabels=("Ordered", "Unordered"))
rule_ordering_rbs.layout().setSpacing(7)
covering_algorithm_box = gui.hBox(
widget=top_box, box="Covering algorithm")
covering_algorithm_rbs = gui.radioButtons(
widget=covering_algorithm_box, master=self,
value="covering_algorithm",
callback=self.settings_changed,
btnLabels=("Exclusive", "Weighted"))
covering_algorithm_rbs.layout().setSpacing(7)
insert_gamma_box = gui.vBox(widget=covering_algorithm_box, box=None)
gui.separator(insert_gamma_box, 0, 14)
self.gamma_spin = gui.doubleSpin(
widget=insert_gamma_box, master=self, value="gamma", minv=0.0,
maxv=1.0, step=0.01, label="γ:", orientation=Qt.Horizontal,
callback=self.settings_changed, alignment=Qt.AlignRight,
enabled=self.storage_covers[self.covering_algorithm] == "weighted")
# bottom-level search procedure (search bias)
middle_box = gui.vBox(widget=self.controlArea, box="Rule search")
evaluation_measure_box = gui.comboBox(
widget=middle_box, master=self, value="evaluation_measure",
label="Evaluation measure:", orientation=Qt.Horizontal,
items=("Entropy", "Laplace accuracy", "WRAcc"),
callback=self.settings_changed, contentsLength=3)
beam_width_box = gui.spin(
widget=middle_box, master=self, value="beam_width", minv=1,
maxv=100, step=1, label="Beam width:", orientation=Qt.Horizontal,
callback=self.settings_changed, alignment=Qt.AlignRight,
controlWidth=80)
# bottom-level search procedure (over-fitting avoidance bias)
bottom_box = gui.vBox(widget=self.controlArea, box="Rule filtering")
min_covered_examples_box = gui.spin(
widget=bottom_box, master=self, value="min_covered_examples", minv=1,
maxv=10000, step=1, label="Minimum rule coverage:",
orientation=Qt.Horizontal, callback=self.settings_changed,
alignment=Qt.AlignRight, controlWidth=80)
max_rule_length_box = gui.spin(
widget=bottom_box, master=self, value="max_rule_length",
minv=1, maxv=100, step=1, label="Maximum rule length:",
orientation=Qt.Horizontal, callback=self.settings_changed,
alignment=Qt.AlignRight, controlWidth=80)
default_alpha_spin = gui.doubleSpin(
widget=bottom_box, master=self, value="default_alpha", minv=0.0,
maxv=1.0, step=0.01, label="Statistical significance\n(default α):",
orientation=Qt.Horizontal, callback=self.settings_changed,
alignment=Qt.AlignRight, controlWidth=80,
checked="checked_default_alpha")
parent_alpha_spin = gui.doubleSpin(
widget=bottom_box, master=self, value="parent_alpha", minv=0.0,
maxv=1.0, step=0.01, label="Relative significance\n(parent α):",
orientation=Qt.Horizontal, callback=self.settings_changed,
alignment=Qt.AlignRight, controlWidth=80,
checked="checked_parent_alpha")
def __init__(self):
super().__init__()
# sets self.curvePoints, self.steps equidistant points from
# 1/self.steps to 1
self.updateCurvePoints()
# [start-snippet-2]
self.scoring = [("Classification Accuracy",
Orange.evaluation.scoring.CA),
("AUC", Orange.evaluation.scoring.AUC),
("Precision", Orange.evaluation.scoring.Precision),
("Recall", Orange.evaluation.scoring.Recall)]
# [end-snippet-2]
#: input data on which to construct the learning curve
self.data = None
#: A {input_id: Learner} mapping of current learners from input channel
self.learners = OrderedDict()
#: A {input_id: List[Results]} mapping of input id to evaluation
#: results list, one for each curve point
self.results = OrderedDict()
#: A {input_id: List[float]} mapping of input id to learning curve
#: point scores
self.curves = OrderedDict()
# GUI
box = gui.widgetBox(self.controlArea, "Info")
self.infoa = gui.widgetLabel(box, 'No data on input.')
self.infob = gui.widgetLabel(box, 'No learners.')
gui.separator(self.controlArea)
box = gui.widgetBox(self.controlArea, "Evaluation Scores")
gui.comboBox(box,
self,
"scoringF",
items=[x[0] for x in self.scoring],
callback=self._invalidate_curves)
gui.separator(self.controlArea)
box = gui.widgetBox(self.controlArea, "Options")
gui.spin(box,
self,
'folds',
2,
100,
step=1,
label='Cross validation folds: ',
keyboardTracking=False,
callback=lambda: self._invalidate_results()
if self.commitOnChange else None)
gui.spin(box,
self,
'steps',
2,
100,
step=1,
label='Learning curve points: ',
keyboardTracking=False,
callback=[
self.updateCurvePoints,
lambda: self._invalidate_results()
if self.commitOnChange else None
])
gui.checkBox(box, self, 'commitOnChange',
'Apply setting on any change')
self.commitBtn = gui.button(box,
self,
"Apply Setting",
callback=self._invalidate_results,
disabled=True)
gui.rubber(self.controlArea)
# table widget
self.table = gui.table(self.mainArea,
selectionMode=QTableWidget.NoSelection)
def __init__(self):
super().__init__()
self.data = None
self.indices = None
self.sampled_instances = self.remaining_instances = None
box = gui.vBox(self.controlArea, "Information")
self.dataInfoLabel = gui.widgetLabel(box, 'No data on input.')
self.outputInfoLabel = gui.widgetLabel(box, ' ')
self.sampling_box = gui.vBox(self.controlArea, "Sampling Type")
sampling = gui.radioButtons(self.sampling_box,
self,
"sampling_type",
callback=self.sampling_type_changed)
def set_sampling_type(i):
def f():
self.sampling_type = i
self.sampling_type_changed()
return f
gui.appendRadioButton(sampling, "Fixed proportion of data:")
self.sampleSizePercentageSlider = gui.hSlider(
gui.indentedBox(sampling),
self,
"sampleSizePercentage",
minValue=0,
maxValue=99,
ticks=10,
labelFormat="%d %%",
callback=set_sampling_type(self.FixedProportion),
addSpace=12)
gui.appendRadioButton(sampling, "Fixed sample size")
ibox = gui.indentedBox(sampling)
self.sampleSizeSpin = gui.spin(ibox,
self,
"sampleSizeNumber",
label="Instances: ",
minv=1,
maxv=2**31 - 1,
callback=set_sampling_type(
self.FixedSize))
gui.checkBox(ibox,
self,
"replacement",
"Sample with replacement",
callback=set_sampling_type(self.FixedSize),
addSpace=12)
gui.appendRadioButton(sampling, "Cross validation")
form = QFormLayout(formAlignment=Qt.AlignLeft | Qt.AlignTop,
labelAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QFormLayout.AllNonFixedFieldsGrow)
ibox = gui.indentedBox(sampling, addSpace=True, orientation=form)
form.addRow(
"Number of folds:",
gui.spin(ibox,
self,
"number_of_folds",
2,
100,
addToLayout=False,
callback=self.number_of_folds_changed))
self.selected_fold_spin = gui.spin(ibox,
self,
"selectedFold",
1,
self.number_of_folds,
addToLayout=False,
callback=self.fold_changed)
form.addRow("Selected fold:", self.selected_fold_spin)
gui.appendRadioButton(sampling, "Bootstrap")
self.sql_box = gui.vBox(self.controlArea, "Sampling Type")
sampling = gui.radioButtons(self.sql_box,
self,
"sampling_type",
callback=self.sampling_type_changed)
gui.appendRadioButton(sampling, "Time:")
ibox = gui.indentedBox(sampling)
spin = gui.spin(ibox,
self,
"sampleSizeSqlTime",
minv=1,
maxv=3600,
callback=set_sampling_type(self.SqlTime))
spin.setSuffix(" sec")
gui.appendRadioButton(sampling, "Percentage")
ibox = gui.indentedBox(sampling)
spin = gui.spin(ibox,
self,
"sampleSizeSqlPercentage",
spinType=float,
minv=0.0001,
maxv=100,
step=0.1,
decimals=4,
callback=set_sampling_type(self.SqlProportion))
spin.setSuffix(" %")
self.sql_box.setVisible(False)
self.options_box = gui.vBox(self.controlArea, "Options")
self.cb_seed = gui.checkBox(self.options_box,
self,
"use_seed",
"Replicable (deterministic) sampling",
callback=self.settings_changed)
self.cb_stratify = gui.checkBox(self.options_box,
self,
"stratify",
"Stratify sample (when possible)",
callback=self.settings_changed)
self.cb_sql_dl = gui.checkBox(self.options_box,
self,
"sql_dl",
"Download data to local memory",
callback=self.settings_changed)
self.cb_sql_dl.setVisible(False)
gui.button(self.buttonsArea, self, "Sample Data", callback=self.commit)
def __init__(self, *args, **kwargs):
"""Initialize a Variety widget"""
super().__init__(*args, **kwargs)
self.infoBox = InfoBox(
widget=self.controlArea,
stringClickSend=u", please click 'Send' when ready.",
)
self.sendButton = SendButton(
widget=self.controlArea,
master=self,
callback=self.sendData,
infoBoxAttribute='infoBox',
buttonLabel=u'Send',
checkboxLabel=u'Send automatically',
sendIfPreCallback=self.updateGUI,
)
# GUI...
# Units box
self.unitsBox = gui.widgetBox(
widget=self.controlArea,
box=u'Units',
orientation='vertical',
addSpace=True,
)
self.unitSegmentationCombo = gui.comboBox(
widget=self.unitsBox,
master=self,
value='units',
orientation='horizontal',
label=u'Segmentation:',
labelWidth=180,
callback=self.sendButton.settingsChanged,
tooltip=(
u"The segmentation whose variety will be measured."
),
)
self.unitSegmentationCombo.setMinimumWidth(120)
gui.separator(widget=self.unitsBox, height=3)
self.unitAnnotationCombo = gui.comboBox(
widget=self.unitsBox,
master=self,
value='unitAnnotationKey',
sendSelectedValue=True,
emptyString=u'(none)',
orientation='horizontal',
label=u'Annotation key:',
labelWidth=180,
callback=self.sendButton.settingsChanged,
tooltip=(
u"Indicate whether the variety of the above\n"
u"specified segmentation must be measured on the\n"
u"segments' content (value 'none') or on their\n"
u"annotation values for a specific annotation key."
),
)
gui.separator(widget=self.unitsBox, height=3)
self.sequenceLengthSpin = gui.spin(
widget=self.unitsBox,
master=self,
value='sequenceLength',
minv=1,
maxv=1,
step=1,
orientation='horizontal',
label=u'Sequence length:',
labelWidth=180,
callback=self.sendButton.settingsChanged,
keyboardTracking=False,
tooltip=(
u"Indicate whether to measure the variety of\n"
u"single segments or rather of sequences of 2,\n"
u"3,... segments (n-grams).\n\n"
u"Note that this parameter cannot be set to a\n"
u"value larger than 1 if variety is to be\n"
u"measured per category."
),
)
gui.separator(widget=self.unitsBox, height=3)
gui.checkBox(
widget=self.unitsBox,
master=self,
value='unitWeighting',
label=u'Weigh by frequency',
callback=self.sendButton.settingsChanged,
tooltip=(
u"Check this box in order to apply unit frequency\n"
u"weighting (i.e. use perplexity instead of variety)."
),
)
gui.separator(widget=self.unitsBox, height=3)
# Categories box
self.categoriesBox = gui.widgetBox(
widget=self.controlArea,
box=u'Categories',
orientation='vertical',
addSpace=True,
)
self.measurePerCategoryCheckbox = gui.checkBox(
widget=self.categoriesBox,
master=self,
value='measurePerCategory',
label=u'Measure variety per category',
callback=self.sendButton.settingsChanged,
tooltip=(
u"Check this box in order to measure the average\n"
u"variety per category."
),
)
gui.separator(widget=self.categoriesBox, height=3)
iBox = gui.indentedBox(
widget=self.categoriesBox,
)
self.categoryAnnotationCombo = gui.comboBox(
widget=iBox,
master=self,
value='categoryAnnotationKey',
sendSelectedValue=True,
emptyString=u'(none)',
orientation='horizontal',
label=u'Annotation key:',
labelWidth=160,
callback=self.sendButton.settingsChanged,
tooltip=(
u"Indicate whether categories are defined by the\n"
u"segments' content (value 'none') or by their\n"
u"annotation values for a specific annotation key."
),
)
gui.separator(widget=iBox, height=3)
gui.checkBox(
widget=iBox,
master=self,
value='categoryWeighting',
label=u'Weigh by frequency',
callback=self.sendButton.settingsChanged,
tooltip=(
u"Check this box in order to apply category\n"
u"frequency weighting (i.e. compute a weighted\n"
u"rather than unweighted average)."
),
)
gui.separator(widget=iBox, height=3)
gui.checkBox(
widget=iBox,
master=self,
value='adjustSubsampleSize',
label=u'Dynamically adjust subsample size',
callback=self.sendButton.settingsChanged,
tooltip=(
u"Attempt to make variety estimation more robust\n"
u"by using the RMSP subsample size adjustment method\n"
u"described in Xanthos and Guex 2015."
),
)
self.measurePerCategoryCheckbox.disables.append(iBox)
if self.measurePerCategory:
iBox.setDisabled(False)
else:
iBox.setDisabled(True)
gui.separator(widget=self.categoriesBox, height=3)
# Contexts box...
self.contextsBox = gui.widgetBox(
widget=self.controlArea,
box=u'Contexts',
orientation='vertical',
addSpace=True,
)
self.modeCombo = gui.comboBox(
widget=self.contextsBox,
master=self,
value='mode',
sendSelectedValue=True,
items=[
u'No context',
u'Sliding window',
u'Containing segmentation',
],
orientation='horizontal',
label=u'Mode:',
labelWidth=180,
callback=self.sendButton.settingsChanged,
tooltip=(
u"Context specification mode.\n\n"
u"Contexts define the rows of the resulting\n"
u"table.\n\n"
u"'No context': variety will be measured\n"
u"irrespective of the context (hence the output\n"
u"table contains a single row).\n\n"
u"'Sliding window': contexts are defined as all the\n"
u"successive, overlapping sequences of n segments\n"
u"in the 'Units' segmentation.\n\n"
u"'Containing segmentation': contexts are defined\n"
u"as the distinct segments occurring in a given\n"
u"segmentation."
),
)
self.slidingWindowBox = gui.widgetBox(
widget=self.contextsBox,
orientation='vertical',
)
gui.separator(widget=self.slidingWindowBox, height=3)
self.windowSizeSpin = gui.spin(
widget=self.slidingWindowBox,
master=self,
value='windowSize',
minv=1,
maxv=1,
step=1,
orientation='horizontal',
label=u'Window size:',
labelWidth=180,
callback=self.sendButton.settingsChanged,
keyboardTracking=False,
tooltip=(
u"The length of segment sequences defining contexts."
),
)
self.containingSegmentationBox = gui.widgetBox(
widget=self.contextsBox,
orientation='vertical',
)
gui.separator(widget=self.containingSegmentationBox, height=3)
self.contextSegmentationCombo = gui.comboBox(
widget=self.containingSegmentationBox,
master=self,
value='_contexts',
orientation='horizontal',
label=u'Segmentation:',
labelWidth=180,
callback=self.sendButton.settingsChanged,
tooltip=(
u"The segmentation whose segment types define\n"
u"the contexts in which the variety of segments\n"
u"in the 'Units' segmentation will be measured."
),
)
gui.separator(widget=self.containingSegmentationBox, height=3)
self.contextAnnotationCombo = gui.comboBox(
widget=self.containingSegmentationBox,
master=self,
value='contextAnnotationKey',
sendSelectedValue=True,
emptyString=u'(none)',
orientation='horizontal',
label=u'Annotation key:',
labelWidth=180,
callback=self.sendButton.settingsChanged,
tooltip=(
u"Indicate whether context types are defined by\n"
u"the content of segments in the above specified\n"
u"segmentation (value 'none') or by their annotation\n"
u"values for a specific annotation key."
),
)
gui.separator(widget=self.containingSegmentationBox, height=3)
gui.checkBox(
widget=self.containingSegmentationBox,
master=self,
value='mergeContexts',
label=u'Merge contexts',
callback=self.sendButton.settingsChanged,
tooltip=(
u"Check this box if you want to treat all segments\n"
u"of the above specified segmentation as forming\n"
u"a single context (hence the resulting table\n"
u"contains a single row)."
),
)
gui.separator(widget=self.contextsBox, height=3)
# Resampling box...
self.resamplingBox = gui.widgetBox(
widget=self.controlArea,
box=u'Resampling',
orientation='vertical',
addSpace=True,
)
applyResamplingCheckBox = gui.checkBox(
widget=self.resamplingBox,
master=self,
value='applyResampling',
label=u'Apply Resampling',
callback=self.sendButton.settingsChanged,
tooltip=(
u"Check this box if you want to compute the average\n"
u"(or expected) variety per subsample."
),
)
# TODO: document RMSP!
gui.separator(widget=self.resamplingBox, height=3)
iBox2 = gui.indentedBox(
widget=self.resamplingBox,
)
self.subsampleSizeSpin = gui.spin(
widget=iBox2,
master=self,
value='subsampleSize',
minv=1,
maxv=1,
step=1,
orientation='horizontal',
label=u'Subsample size:',
labelWidth=160,
callback=self.sendButton.settingsChanged,
keyboardTracking=False,
tooltip=(
u"The number of segments per subsample."
),
)
gui.separator(widget=iBox2, height=3)
self.numSubsampleSpin = gui.spin(
widget=iBox2,
master=self,
value='numSubsamples',
minv=1,
maxv=100000,
step=1,
orientation='horizontal',
label=u'Number of subsamples:',
labelWidth=160,
callback=self.sendButton.settingsChanged,
keyboardTracking=False,
tooltip=(
u"The number of subsamples (per context)."
),
)
applyResamplingCheckBox.disables.append(iBox2)
if self.applyResampling:
iBox2.setDisabled(False)
else:
iBox2.setDisabled(True)
gui.separator(widget=self.resamplingBox, height=3)
gui.rubber(self.controlArea)
# Send button...
self.sendButton.draw()
# Info box...
self.infoBox.draw()
self.sendButton.sendIf()
self.adjustSizeWithTimer()
def __init__(self):
super().__init__()
self.data = None
self.source_id = None
self._mas = None
self._Ws = None
self._transformed = None
self._components = None
self._use_genes = None
self._shared_correlations = None
self._transformed_table = None
self._line = False
self._feature_model = DomainModel(valid_types=DiscreteVariable, separators=False)
self._feature_model.set_domain(None)
self._init_mas()
self._legend = None
form = QFormLayout(
labelAlignment=Qt.AlignLeft,
formAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QFormLayout.AllNonFixedFieldsGrow,
verticalSpacing=10
)
# Data source indicator
box = gui.vBox(self.controlArea, "Data source indicator")
gui.comboBox(
box, self, "source_id", sendSelectedValue=True,
callback=self._update_combo_source_id,
model=self._feature_model,
)
# Canonical correlation analysis
box = gui.vBox(self.controlArea, "Canonical correlation analysis")
gui.spin(
box, self, "ncomponents", 1, MAX_COMPONENTS,
callback=self._update_selection_component_spin,
keyboardTracking=False,
label="Num. of components"
)
# Shared genes
box = gui.vBox(self.controlArea, "Shared genes")
gui.spin(
box, self, "ngenes", 1, MAX_GENES,
callback=self._update_ngenes_spin,
keyboardTracking=False,
)
form.addRow(
"Num. of genes",
self.controls.ngenes
)
gui.comboBox(
box, self, "scoring",
callback=self._update_scoring_combo,
items=list(SCORINGS.keys()), sendSelectedValue=True,
editable=False,
)
form.addRow(
"Scoring:",
self.controls.scoring
)
box.layout().addLayout(form)
# Post-processing
box = gui.vBox(self.controlArea, "Post-processing")
gui.doubleSpin(
box, self, "quantile_normalization_perc", minv=0, maxv=49, step=5e-1,
callback=self._update_quantile_normalization,
checkCallback=self._update_quantile_normalization,
controlWidth=80, alignment=Qt.AlignRight,
label="Quantile normalization", checked="quantile_normalization",
)
self.controls.quantile_normalization_perc.setSuffix("%")
gui.checkBox(
box, self, "dynamic_time_warping",
callback=self._update_dynamic_time_warping,
label="Dynamic time warping"
)
self.controlArea.layout().addStretch()
gui.auto_commit(self.controlArea, self, "auto_commit", "Apply",
callback=self._invalidate_selection(),
checkbox_label="Apply automatically")
self.plot = pg.PlotWidget(background="w")
axis = self.plot.getAxis("bottom")
axis.setLabel("Correlation components")
axis = self.plot.getAxis("left")
axis.setLabel("Correlation strength")
self.plot_horlabels = []
self.plot_horlines = []
self.plot.getViewBox().setMenuEnabled(False)
self.plot.getViewBox().setMouseEnabled(False, False)
self.plot.showGrid(True, True, alpha=0.5)
self.plot.setRange(xRange=(0.0, 1.0), yRange=(0.0, 1.0))
self.mainArea.layout().addWidget(self.plot)
def __init__(self):
super().__init__()
self.data = None
self._pca = None
self._transformed = None
self._variance_ratio = None
self._cumulative = None
self._line = False
self._init_projector()
# Components Selection
box = gui.vBox(self.controlArea, "Components Selection")
form = QFormLayout()
box.layout().addLayout(form)
self.components_spin = gui.spin(
box,
self,
"ncomponents",
1,
MAX_COMPONENTS,
callback=self._update_selection_component_spin,
keyboardTracking=False)
self.components_spin.setSpecialValueText("All")
self.variance_spin = gui.spin(
box,
self,
"variance_covered",
1,
100,
callback=self._update_selection_variance_spin,
keyboardTracking=False)
self.variance_spin.setSuffix("%")
form.addRow("Components:", self.components_spin)
form.addRow("Variance covered:", self.variance_spin)
# Incremental learning
self.sampling_box = gui.vBox(self.controlArea, "Incremental learning")
self.addresstext = QLineEdit(box)
self.addresstext.setPlaceholderText('Remote server')
if self.address:
self.addresstext.setText(self.address)
self.sampling_box.layout().addWidget(self.addresstext)
form = QFormLayout()
self.sampling_box.layout().addLayout(form)
self.batch_spin = gui.spin(self.sampling_box,
self,
"batch_size",
50,
100000,
step=50,
keyboardTracking=False)
form.addRow("Batch size ~ ", self.batch_spin)
self.start_button = gui.button(
self.sampling_box,
self,
"Start remote computation",
callback=self.start,
autoDefault=False,
tooltip="Start/abort computation on the server")
self.start_button.setEnabled(False)
gui.checkBox(self.sampling_box,
self,
"auto_update",
"Periodically fetch model",
callback=self.update_model)
self.__timer = QTimer(self, interval=2000)
self.__timer.timeout.connect(self.get_model)
self.sampling_box.setVisible(remotely)
# Decomposition
self.decomposition_box = gui.radioButtons(
self.controlArea,
self,
"decomposition_idx", [d.name for d in DECOMPOSITIONS],
box="Decomposition",
callback=self._update_decomposition)
# Options
self.options_box = gui.vBox(self.controlArea, "Options")
self.normalize_box = gui.checkBox(self.options_box,
self,
"normalize",
"Normalize data",
callback=self._update_normalize)
self.maxp_spin = gui.spin(self.options_box,
self,
"maxp",
1,
MAX_COMPONENTS,
label="Show only first",
callback=self._setup_plot,
keyboardTracking=False)
self.controlArea.layout().addStretch()
gui.auto_commit(self.controlArea,
self,
"auto_commit",
"Apply",
checkbox_label="Apply automatically")
self.plot = pg.PlotWidget(background="w")
axis = self.plot.getAxis("bottom")
axis.setLabel("Principal Components")
axis = self.plot.getAxis("left")
axis.setLabel("Proportion of variance")
self.plot_horlabels = []
self.plot_horlines = []
self.plot.getViewBox().setMenuEnabled(False)
self.plot.getViewBox().setMouseEnabled(False, False)
self.plot.showGrid(True, True, alpha=0.5)
self.plot.setRange(xRange=(0.0, 1.0), yRange=(0.0, 1.0))
self.mainArea.layout().addWidget(self.plot)
self._update_normalize()
def __init__(self):
super().__init__()
self.data = None # type: Optional[Table]
self.clusterings = {}
self.__executor = ThreadExecutor(parent=self)
self.__task = None # type: Optional[Task]
layout = QGridLayout()
bg = gui.radioButtonsInBox(
self.controlArea,
self,
"optimize_k",
orientation=layout,
box="Number of Clusters",
callback=self.update_method,
)
layout.addWidget(
gui.appendRadioButton(bg, "Fixed:", addToLayout=False), 1, 1)
sb = gui.hBox(None, margin=0)
gui.spin(sb,
self,
"k",
minv=2,
maxv=30,
controlWidth=60,
alignment=Qt.AlignRight,
callback=self.update_k)
gui.rubber(sb)
layout.addWidget(sb, 1, 2)
layout.addWidget(gui.appendRadioButton(bg, "From", addToLayout=False),
2, 1)
ftobox = gui.hBox(None)
ftobox.layout().setContentsMargins(0, 0, 0, 0)
layout.addWidget(ftobox, 2, 2)
gui.spin(ftobox,
self,
"k_from",
minv=2,
maxv=29,
controlWidth=60,
alignment=Qt.AlignRight,
callback=self.update_from)
gui.widgetLabel(ftobox, "to")
gui.spin(ftobox,
self,
"k_to",
minv=3,
maxv=30,
controlWidth=60,
alignment=Qt.AlignRight,
callback=self.update_to)
gui.rubber(ftobox)
box = gui.vBox(self.controlArea, "Initialization")
gui.comboBox(box,
self,
"smart_init",
items=[m[0] for m in self.INIT_METHODS],
callback=self.invalidate)
layout = QGridLayout()
gui.widgetBox(box, orientation=layout)
layout.addWidget(gui.widgetLabel(None, "Re-runs: "), 0, 0,
Qt.AlignLeft)
sb = gui.hBox(None, margin=0)
layout.addWidget(sb, 0, 1)
gui.lineEdit(sb,
self,
"n_init",
controlWidth=60,
valueType=int,
validator=QIntValidator(),
callback=self.invalidate)
layout.addWidget(gui.widgetLabel(None, "Maximum iterations: "), 1, 0,
Qt.AlignLeft)
sb = gui.hBox(None, margin=0)
layout.addWidget(sb, 1, 1)
gui.lineEdit(sb,
self,
"max_iterations",
controlWidth=60,
valueType=int,
validator=QIntValidator(),
callback=self.invalidate)
self.apply_button = gui.auto_commit(self.buttonsArea,
self,
"auto_commit",
"Apply",
box=None,
commit=self.commit)
gui.rubber(self.controlArea)
box = gui.vBox(self.mainArea, box="Silhouette Scores")
self.mainArea.setVisible(self.optimize_k)
self.table_model = ClusterTableModel(self)
table = self.table_view = QTableView(self.mainArea)
table.setModel(self.table_model)
table.setSelectionMode(QTableView.SingleSelection)
table.setSelectionBehavior(QTableView.SelectRows)
table.setItemDelegate(gui.ColoredBarItemDelegate(self, color=Qt.cyan))
table.selectionModel().selectionChanged.connect(self.select_row)
table.setMaximumWidth(200)
table.horizontalHeader().setStretchLastSection(True)
table.horizontalHeader().hide()
table.setShowGrid(False)
box.layout().addWidget(table)
def __init__(self):
self.data = None
self.output = None
self.onehot_mapping = {}
self._is_running = False
self._antecedentMatch = self._consequentMatch = lambda x: True
self.proxy_model = self.ProxyModel(self)
owwidget = self
class TableView(QTableView):
def selectionChanged(self, selected, deselected):
nonlocal owwidget
super().selectionChanged(selected, deselected)
mapping = owwidget.onehot_mapping
if not mapping:
return
where = np.where
X, Y = owwidget.X, owwidget.data.Y
instances = set()
selected_rows = self.selectionModel().selectedRows(0)
for model_index in selected_rows:
itemset, class_item = model_index.data(
owwidget.ROW_DATA_ROLE)
cols, vals = zip(*(mapping[i] for i in itemset))
if issparse(X):
matching = (len(cols) == np.bincount(
(X[:, cols] != 0).indices,
minlength=X.shape[0])).nonzero()[0]
else:
matching = set(
where((X[:, cols] == vals).all(axis=1))[0])
if class_item:
matching &= set(where(Y == mapping[class_item][1])[0])
instances.update(matching)
owwidget.nSelectedExamples = len(instances)
owwidget.nSelectedRules = len(selected_rows)
owwidget.output = owwidget.data[sorted(instances)] or None
owwidget.commit()
table = self.table = TableView(
self,
showGrid=False,
sortingEnabled=True,
alternatingRowColors=True,
selectionBehavior=QTableView.SelectRows,
selectionMode=QTableView.ExtendedSelection,
horizontalScrollMode=QTableView.ScrollPerPixel,
verticalScrollMode=QTableView.ScrollPerPixel,
editTriggers=QTableView.NoEditTriggers)
table.verticalHeader().setVisible(False)
table.verticalHeader().setDefaultSectionSize(
table.verticalHeader().minimumSectionSize())
table.horizontalHeader().setStretchLastSection(True)
table.setModel(QStandardItemModel(table))
self.mainArea.layout().addWidget(table)
box = gui.widgetBox(self.controlArea, "Info")
self.nRules = self.nFilteredRules = self.nSelectedExamples = self.nSelectedRules = ''
gui.label(box, self, "Number of rules: %(nRules)s")
gui.label(box, self, "Filtered rules: %(nFilteredRules)s")
gui.label(box, self, "Selected rules: %(nSelectedRules)s")
gui.label(box, self, "Selected examples: %(nSelectedExamples)s")
box = gui.widgetBox(self.controlArea, 'Find association rules')
gui.valueSlider(box,
self,
'minSupport',
values=[.0001, .0005, .001, .005, .01, .05, .1, .5] +
list(range(1, 101)),
label='Minimal support:',
labelFormat="%g%%",
callback=lambda: self.find_rules())
gui.hSlider(box,
self,
'minConfidence',
minValue=1,
maxValue=100,
label='Minimal confidence:',
labelFormat="%g%%",
callback=lambda: self.find_rules())
gui.hSlider(box,
self,
'maxRules',
minValue=10000,
maxValue=100000,
step=10000,
label='Max. number of rules:',
callback=lambda: self.find_rules())
self.cb_classify = gui.checkBox(
box,
self,
'classify',
label='Induce classification (itemset → class) rules')
self.button = gui.auto_commit(
box,
self,
'autoFind',
'Find Rules',
commit=self.find_rules,
callback=lambda: self.autoFind and self.find_rules())
vbox = gui.widgetBox(self.controlArea, 'Filter rules')
## This is disabled because it's hard to make a scatter plot with
## selectable spots. Options:
## * PyQtGraph, which doesn't support selection OOTB (+is poorly
## contrived and under-documented);
## * Orange.widgets.visualize.ScatterPlotGraph, which comes without
## any documentation or comprehensible examples of use whatsoever;
## * QGraphicsView, which would work, but lacks graphing features,
## namely labels, axes, ticks.
##
## I don't feel like pursuing any of those right now, so I am letting
## it to be figured out at a later date.
#~ button = self.scatter_button = gui.button(vbox, self, 'Scatter plot',
#~ callback=self.show_scatter,
#~ autoDefault=False)
#~ button.setDisabled(True)
#~ self.scatter = self.ScatterPlotWindow(self)
box = gui.widgetBox(vbox, 'Antecedent')
gui.lineEdit(box,
self,
'filterKeywordsAntecedent',
'Contains:',
callback=self.filter_change,
orientation='horizontal',
tooltip='A comma or space-separated list of regular '
'expressions.')
hbox = gui.widgetBox(box, orientation='horizontal')
gui.spin(hbox,
self,
'filterAntecedentMin',
1,
998,
label='Min. items:',
callback=self.filter_change)
gui.spin(hbox,
self,
'filterAntecedentMax',
2,
999,
label='Max. items:',
callback=self.filter_change)
gui.rubber(hbox)
box = gui.widgetBox(vbox, 'Consequent')
gui.lineEdit(box,
self,
'filterKeywordsConsequent',
'Contains:',
callback=self.filter_change,
orientation='horizontal',
tooltip='A comma or space-separated list of regular '
'expressions.')
hbox = gui.widgetBox(box, orientation='horizontal')
gui.spin(hbox,
self,
'filterConsequentMin',
1,
998,
label='Min. items:',
callback=self.filter_change)
gui.spin(hbox,
self,
'filterConsequentMax',
2,
999,
label='Max. items:',
callback=self.filter_change)
gui.checkBox(box,
self,
'filterSearch',
label='Apply these filters in search',
tooltip='If checked, the rules are filtered according '
'to these filter conditions already in the search '
'phase. \nIf unchecked, the only filters applied '
'during search are the ones above, '
'and the generated rules \nare filtered afterwards '
'only for display, i.e. only the matching association '
'rules are shown.')
gui.rubber(hbox)
gui.rubber(self.controlArea)
gui.auto_commit(self.controlArea, self, 'autoSend', 'Send selection')
self.filter_change()
def __init__(self):
super().__init__()
self.data = None
self._effective_data = None
self._matrix = None
self._silhouette = None
self._labels = None
self._silplot = None
box = gui.widgetBox(
self.controlArea,
"Settings",
)
gui.comboBox(box,
self,
"distance_idx",
label="Distance",
items=[name for name, _ in OWSilhouettePlot.Distances],
callback=self._invalidate_distances)
self.cluster_var_cb = gui.comboBox(box,
self,
"cluster_var_idx",
label="Cluster",
callback=self._invalidate_scores)
self.cluster_var_model = itemmodels.VariableListModel(parent=self)
self.cluster_var_cb.setModel(self.cluster_var_model)
gui.spin(box,
self,
"bar_size",
minv=1,
maxv=10,
label="Bar Size",
callback=self._update_bar_size)
gui.checkBox(box,
self,
"group_by_cluster",
"Group by cluster",
callback=self._replot)
self.annotation_cb = gui.comboBox(box,
self,
"annotation_var_idx",
label="Annotations",
callback=self._update_annotations)
self.annotation_var_model = itemmodels.VariableListModel(parent=self)
self.annotation_var_model[:] = ["None"]
self.annotation_cb.setModel(self.annotation_var_model)
gui.rubber(self.controlArea)
box = gui.widgetBox(self.controlArea, "Output")
gui.checkBox(
box,
self,
"add_scores",
"Add silhouette scores",
)
gui.auto_commit(box, self, "auto_commit", "Commit", box=False)
self.scene = QtGui.QGraphicsScene()
self.view = QtGui.QGraphicsView(self.scene)
self.view.setRenderHint(QtGui.QPainter.Antialiasing, True)
self.view.setAlignment(Qt.AlignTop | Qt.AlignLeft)
self.mainArea.layout().addWidget(self.view)
def __init__(self):
super().__init__()
self.__pending_selection = self.selected_rows
# A kingdom for a save_state/restore_state
self.col_clustering = enum_get(Clustering, self.col_clustering_method,
Clustering.None_)
self.row_clustering = enum_get(Clustering, self.row_clustering_method,
Clustering.None_)
@self.settingsAboutToBePacked.connect
def _():
self.col_clustering_method = self.col_clustering.name
self.row_clustering_method = self.row_clustering.name
self.keep_aspect = False
#: The original data with all features (retained to
#: preserve the domain on the output)
self.input_data = None
#: The effective data striped of discrete features, and often
#: merged using k-means
self.data = None
self.effective_data = None
#: kmeans model used to merge rows of input_data
self.kmeans_model = None
#: merge indices derived from kmeans
#: a list (len==k) of int ndarray where the i-th item contains
#: the indices which merge the input_data into the heatmap row i
self.merge_indices = None
self.parts: Optional[Parts] = None
self.__rows_cache = {}
self.__columns_cache = {}
# GUI definition
colorbox = gui.vBox(self.controlArea, "Color")
self.color_cb = gui.palette_combo_box(self.palette_name)
self.color_cb.currentIndexChanged.connect(self.update_color_schema)
colorbox.layout().addWidget(self.color_cb)
form = QFormLayout(formAlignment=Qt.AlignLeft,
labelAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QFormLayout.AllNonFixedFieldsGrow)
lowslider = gui.hSlider(colorbox,
self,
"threshold_low",
minValue=0.0,
maxValue=1.0,
step=0.05,
ticks=True,
intOnly=False,
createLabel=False,
callback=self.update_lowslider)
highslider = gui.hSlider(colorbox,
self,
"threshold_high",
minValue=0.0,
maxValue=1.0,
step=0.05,
ticks=True,
intOnly=False,
createLabel=False,
callback=self.update_highslider)
form.addRow("Low:", lowslider)
form.addRow("High:", highslider)
colorbox.layout().addLayout(form)
mergebox = gui.vBox(
self.controlArea,
"Merge",
)
gui.checkBox(mergebox,
self,
"merge_kmeans",
"Merge by k-means",
callback=self.__update_row_clustering)
ibox = gui.indentedBox(mergebox)
gui.spin(ibox,
self,
"merge_kmeans_k",
minv=5,
maxv=500,
label="Clusters:",
keyboardTracking=False,
callbackOnReturn=True,
callback=self.update_merge)
cluster_box = gui.vBox(self.controlArea, "Clustering")
# Row clustering
self.row_cluster_cb = cb = ComboBox()
cb.setModel(create_list_model(ClusteringModelData, self))
cbselect(cb, self.row_clustering, ClusteringRole)
self.connect_control(
"row_clustering",
lambda value, cb=cb: cbselect(cb, value, ClusteringRole))
@cb.activated.connect
def _(idx, cb=cb):
self.set_row_clustering(cb.itemData(idx, ClusteringRole))
# Column clustering
self.col_cluster_cb = cb = ComboBox()
cb.setModel(create_list_model(ClusteringModelData, self))
cbselect(cb, self.col_clustering, ClusteringRole)
self.connect_control(
"col_clustering",
lambda value, cb=cb: cbselect(cb, value, ClusteringRole))
@cb.activated.connect
def _(idx, cb=cb):
self.set_col_clustering(cb.itemData(idx, ClusteringRole))
form = QFormLayout(
labelAlignment=Qt.AlignLeft,
formAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QFormLayout.AllNonFixedFieldsGrow,
)
form.addRow("Rows:", self.row_cluster_cb)
form.addRow("Columns:", self.col_cluster_cb)
cluster_box.layout().addLayout(form)
box = gui.vBox(self.controlArea, "Split By")
self.row_split_model = DomainModel(
placeholder="(None)",
valid_types=(Orange.data.DiscreteVariable, ),
parent=self,
)
self.row_split_cb = cb = ComboBoxSearch(
enabled=not self.merge_kmeans,
sizeAdjustPolicy=ComboBox.AdjustToMinimumContentsLengthWithIcon,
minimumContentsLength=14,
toolTip="Split the heatmap vertically by a categorical column")
self.row_split_cb.setModel(self.row_split_model)
self.connect_control("split_by_var",
lambda value, cb=cb: cbselect(cb, value))
self.connect_control("merge_kmeans", self.row_split_cb.setDisabled)
self.split_by_var = None
self.row_split_cb.activated.connect(self.__on_split_rows_activated)
box.layout().addWidget(self.row_split_cb)
box = gui.vBox(self.controlArea, 'Annotation && Legends')
gui.checkBox(box,
self,
'legend',
'Show legend',
callback=self.update_legend)
gui.checkBox(box,
self,
'averages',
'Stripes with averages',
callback=self.update_averages_stripe)
annotbox = QGroupBox("Row Annotations", flat=True)
form = QFormLayout(annotbox,
formAlignment=Qt.AlignLeft,
labelAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QFormLayout.AllNonFixedFieldsGrow)
self.annotation_model = DomainModel(placeholder="(None)")
self.annotation_text_cb = ComboBoxSearch(
minimumContentsLength=12,
sizeAdjustPolicy=QComboBox.AdjustToMinimumContentsLength)
self.annotation_text_cb.setModel(self.annotation_model)
self.annotation_text_cb.activated.connect(self.set_annotation_var)
self.connect_control("annotation_var", self.annotation_var_changed)
self.row_side_color_model = DomainModel(
order=(DomainModel.CLASSES, DomainModel.Separator,
DomainModel.METAS),
placeholder="(None)",
valid_types=DomainModel.PRIMITIVE,
flags=Qt.ItemIsSelectable | Qt.ItemIsEnabled,
parent=self,
)
self.row_side_color_cb = ComboBoxSearch(
sizeAdjustPolicy=QComboBox.AdjustToMinimumContentsLength,
minimumContentsLength=12)
self.row_side_color_cb.setModel(self.row_side_color_model)
self.row_side_color_cb.activated.connect(self.set_annotation_color_var)
self.connect_control("annotation_color_var",
self.annotation_color_var_changed)
form.addRow("Text", self.annotation_text_cb)
form.addRow("Color", self.row_side_color_cb)
box.layout().addWidget(annotbox)
posbox = gui.vBox(box, "Column Labels Position", addSpace=False)
posbox.setFlat(True)
cb = gui.comboBox(posbox,
self,
"column_label_pos",
callback=self.update_column_annotations)
cb.setModel(create_list_model(ColumnLabelsPosData, parent=self))
cb.setCurrentIndex(self.column_label_pos)
gui.checkBox(self.controlArea,
self,
"keep_aspect",
"Keep aspect ratio",
box="Resize",
callback=self.__aspect_mode_changed)
gui.rubber(self.controlArea)
gui.auto_send(self.controlArea, self, "auto_commit")
# Scene with heatmap
class HeatmapScene(QGraphicsScene):
widget: Optional[HeatmapGridWidget] = None
self.scene = self.scene = HeatmapScene(parent=self)
self.view = GraphicsView(
self.scene,
verticalScrollBarPolicy=Qt.ScrollBarAlwaysOn,
horizontalScrollBarPolicy=Qt.ScrollBarAlwaysOn,
viewportUpdateMode=QGraphicsView.FullViewportUpdate,
widgetResizable=True,
)
self.view.setContextMenuPolicy(Qt.CustomContextMenu)
self.view.customContextMenuRequested.connect(
self._on_view_context_menu)
self.mainArea.layout().addWidget(self.view)
self.selected_rows = []
self.__font_inc = QAction("Increase Font",
self,
shortcut=QKeySequence("ctrl+>"))
self.__font_dec = QAction("Decrease Font",
self,
shortcut=QKeySequence("ctrl+<"))
self.__font_inc.triggered.connect(lambda: self.__adjust_font_size(1))
self.__font_dec.triggered.connect(lambda: self.__adjust_font_size(-1))
if hasattr(QAction, "setShortcutVisibleInContextMenu"):
apply_all([self.__font_inc, self.__font_dec],
lambda a: a.setShortcutVisibleInContextMenu(True))
self.addActions([self.__font_inc, self.__font_dec])
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
# Other attributes...
self.segmentation = None
self.operation = "no"
self.applyInclusion = False
self.applyExclusion = False
self.applySampling = True
self.samplingRate = 100
self.createdInputs = list()
self.folderLabels = list()
self.selectedFolderLabels = list()
self.rootFolderPath = u''
self.inclusionsUser = u''
self.exclusionsUser = u''
self.newAnnotationKey = u''
self.newAnnotationValue = u''
# self.folder is a dictionary whose keys are :'rootPath', 'maxDepth','inclusionsUser','exclusionsUser', ...
# ... 'samplingRate' and 'fileList'
self.folder = dict()
# self.folders is a list of previously defined "self.folder" dictionaries
self.folders = list()
# self.inclusionList is the default inclusion list (used in minimal mode, ...
# ... and in advanced mode when no inclusion has been selected)
self.inclusionList = [".txt", ".html", ".xml", ".csv", ".rtf"]
# self.inclusionList is the default null inclusion list (used in minimal mode, ...
# ... and in advanced mode when no inclusion has been selected)
self.exclusionList = []
self.infoBox = InfoBox(widget=self.controlArea)
self.sendButton = SendButton(
widget=self.controlArea,
master=self,
callback=self.sendData,
infoBoxAttribute='infoBox',
sendIfPreCallback=self.updateGUI,
)
self.advancedSettings = AdvancedSettings(
widget=self.controlArea,
master=self,
callback=self.sendButton.settingsChanged,
)
# GUI...
# Advanced settings checkbox...
self.advancedSettings.draw()
# BASIC GUI...
# Basic folder box
basicFolderBox = gui.widgetBox(
widget=self.controlArea,
box=u'Source',
orientation='vertical',
addSpace=False,
)
basicFolderBoxLine1 = gui.widgetBox(
widget=basicFolderBox,
box=False,
orientation='horizontal',
)
gui.lineEdit(
widget=basicFolderBoxLine1,
master=self,
value='rootFolderPath',
orientation='horizontal',
label=u'Folder path:',
labelWidth=101,
callback=self.add,
tooltip=(u"The path of the folder."),
)
gui.separator(widget=basicFolderBoxLine1, width=5)
gui.button(
widget=basicFolderBoxLine1,
master=self,
label=u'Browse',
callback=self.browse,
tooltip=(u"Open a dialog for selecting a top folder."),
)
gui.separator(widget=basicFolderBox, width=3)
self.advancedSettings.basicWidgets.append(basicFolderBox)
self.advancedSettings.basicWidgetsAppendSeparator()
# ADVANCED GUI...
# folder box
folderBox = gui.widgetBox(
widget=self.controlArea,
box=u'Sources',
orientation='vertical',
addSpace=False,
)
folderBoxLine1 = gui.widgetBox(
widget=folderBox,
box=False,
orientation='horizontal',
addSpace=True,
)
self.folderListbox = gui.listBox(
widget=folderBoxLine1,
master=self,
value='selectedFolderLabels',
labels='folderLabels',
callback=self.updatefolderBoxButtons,
tooltip=(u"The list of folders whose content will be imported.\n"
u"\nIn the output segmentation, the content of each\n"
u"folder appears in the same position as in the list.\n"
u"\nColumn 1 shows the folder's name.\n"
u"Column 2 shows the folder's depth.\n"
u"Column 3 shows the inclusions filter.\n"
u"Column 4 shows the exclusions filter.\n"
u"Column 5 shows the folder's level of sampling."),
)
font = QFont()
font.setFamily('Courier')
font.setStyleHint(QFont.Courier)
font.setPixelSize(12)
self.folderListbox.setFont(font)
folderBoxCol2 = gui.widgetBox(
widget=folderBoxLine1,
orientation='vertical',
)
self.moveUpButton = gui.button(
widget=folderBoxCol2,
master=self,
label=u'Move Up',
callback=self.moveUp,
tooltip=(u"Move the selected folder upward in the list."),
)
self.moveDownButton = gui.button(
widget=folderBoxCol2,
master=self,
label=u'Move Down',
callback=self.moveDown,
tooltip=(u"Move the selected folder downward in the list."),
)
self.removeButton = gui.button(
widget=folderBoxCol2,
master=self,
label=u'Remove',
callback=self.remove,
tooltip=(u"Remove the selected folder from the list."),
)
self.clearAllButton = gui.button(
widget=folderBoxCol2,
master=self,
label=u'Clear All',
callback=self.clearAll,
tooltip=(u"Remove all folders from the list."),
)
self.exportButton = gui.button(
widget=folderBoxCol2,
master=self,
label=u'',
callback=self.exportList,
disabled=True,
tooltip=(u"Open a dialog for selecting a folder where the folder\n"
u"list can be exported in JSON format."),
)
self.importButton = gui.button(
widget=folderBoxCol2,
master=self,
label=u'',
callback=self.importList,
disabled=True,
tooltip=(u"Open a dialog for selecting a folder list to\n"
u"import (in JSON format). folders from this list\n"
u"will be added to those already imported."),
)
folderBoxLine2 = gui.widgetBox(
widget=folderBox,
box=False,
orientation='vertical',
)
# Add folder box
addFolderBox = gui.widgetBox(
widget=folderBoxLine2,
box=True,
orientation='vertical',
)
addFolderBoxLine1 = gui.widgetBox(
widget=addFolderBox,
orientation='horizontal',
)
# Folder path input
gui.lineEdit(
widget=addFolderBoxLine1,
master=self,
value='rootFolderPath',
orientation='horizontal',
label=u'Folder path:',
labelWidth=101,
callback=self.updateGUI,
tooltip=(u"The paths of the folders that will be added to the\n"
u"list when button 'Add' is clicked.\n\n"
u"Successive paths must be separated with ' / ' \n"
u"(whitespace + slash + whitespace). Their order in\n"
u"the list will be the same as in this field."),
)
gui.separator(widget=addFolderBoxLine1, width=5)
# Button Browse
gui.button(
widget=addFolderBoxLine1,
master=self,
label=u'Browse',
callback=self.browse,
tooltip=(u"Open a dialog for selecting a top folder.\n\n"
u"Selected folder paths will appear in the field to\n"
u"the left of this button afterwards, ready to be\n"
u"added to the list when button 'Add' is clicked."),
)
gui.separator(widget=addFolderBox, width=10)
# Filter box to input include
gui.separator(widget=addFolderBox, width=3)
includeBoxLine1 = gui.widgetBox(
widget=addFolderBox,
box=False,
orientation='horizontal',
)
# Include box
gui.checkBox(
widget=includeBoxLine1,
master=self,
value='applyInclusion',
label=u'Include',
labelWidth=100,
callback=lambda: includeLineEdit.setDisabled(not self.
applyInclusion),
tooltip=(u"Choose the inclusion(s)"),
)
includeLineEdit = gui.lineEdit(
widget=includeBoxLine1,
master=self,
value='inclusionsUser',
orientation='horizontal',
label=u'',
disabled=True,
labelWidth=101,
tooltip=(u"This field lets you specify a custom filter\n"
u"to select the folders to be\n"
u"added to the list."),
)
# Filter box to exclude
gui.separator(widget=addFolderBox, width=3)
excludeBoxLine1 = gui.widgetBox(
widget=addFolderBox,
box=False,
orientation='horizontal',
)
# Exclude box
gui.checkBox(
widget=excludeBoxLine1,
master=self,
value='applyExclusion',
label=u'Exclude',
labelWidth=100,
disabled=False,
callback=lambda: includeLineEdit2.setDisabled(not self.
applyExclusion),
tooltip=(u"Exclude the inclusion(s)"),
)
includeLineEdit2 = gui.lineEdit(
widget=excludeBoxLine1,
master=self,
value='exclusionsUser',
orientation='horizontal',
label=u'',
disabled=True,
labelWidth=101,
tooltip=(u"This field lets you specify a custom filter\n"
u"to select the folders to be\n"
u"added to the list."),
)
# Sampling box to input the level of sampling
gui.separator(widget=addFolderBox, width=3)
samplingBoxLine1 = gui.widgetBox(
widget=addFolderBox,
box=False,
orientation='horizontal',
)
# Check box for sampling
gui.checkBox(
widget=samplingBoxLine1,
master=self,
value='applySampling',
label=u'Sampling',
labelWidth=100,
disabled=False,
callback=lambda: samplingSpin.setDisabled(not self.applySampling),
tooltip=(u"Choose the sampling level"),
)
samplingSpin = gui.spin(
widget=samplingBoxLine1,
master=self,
value='samplingRate',
minv=10,
maxv=100,
labelWidth=50,
orientation='horizontal',
tooltip=(u"sampling level"),
)
gui.separator(widget=addFolderBox, width=3)
self.addButton = gui.button(
widget=addFolderBox,
master=self,
label=u'Add',
callback=self.add,
tooltip=(u"Add the folder(s) currently displayed in the\n"
u"'folders' text field to the list.\n\n"
u"Each of these folders will be associated with the\n"
u"specified encoding and annotation (if any).\n\n"
u"Other folders may be selected afterwards and\n"
u"assigned a different encoding and annotation."),
)
self.advancedSettings.advancedWidgets.append(folderBox)
self.advancedSettings.advancedWidgetsAppendSeparator()
# Options box...
optionsBox = gui.widgetBox(
widget=self.controlArea,
box=u'Options',
orientation='vertical',
addSpace=False,
)
optionsBoxLine1 = gui.widgetBox(
widget=optionsBox,
box=False,
orientation='horizontal',
)
gui.separator(widget=optionsBox, width=3)
optionsBoxLine2 = gui.widgetBox(
widget=optionsBox,
box=False,
orientation='horizontal',
)
gui.checkBox(
widget=optionsBoxLine2,
master=self,
value='autoNumber',
label=u'Auto-number with key:',
labelWidth=180,
callback=self.sendButton.settingsChanged,
tooltip=(u"Annotate folders with increasing numeric indices."),
)
self.autoNumberKeyLineEdit = gui.lineEdit(
widget=optionsBoxLine2,
master=self,
value='autoNumberKey',
orientation='horizontal',
callback=self.sendButton.settingsChanged,
tooltip=(u"Annotation key for folder auto-numbering."),
)
gui.separator(widget=optionsBox, width=3)
self.advancedSettings.advancedWidgets.append(optionsBox)
self.advancedSettings.advancedWidgetsAppendSeparator()
gui.rubber(self.controlArea)
# Send button...
self.sendButton.draw()
# Info box...
self.infoBox.draw()
self.adjustSizeWithTimer()
QTimer.singleShot(0, self.sendButton.sendIf)
def __init__(self):
super().__init__()
self.data = None
self.n_inliers = self.n_outliers = None
box = gui.widgetBox(self.controlArea, "Information")
self.data_info_label = gui.widgetLabel(box, self.data_info_default)
self.in_out_info_label = gui.widgetLabel(box, self.in_out_info_default)
box = gui.widgetBox(self.controlArea, "Outlier detection method")
detection = gui.radioButtons(box, self, "outlier_method")
gui.appendRadioButton(detection,
"One class SVM with non-linear kernel (RBF):")
ibox = gui.indentedBox(detection)
tooltip = "An upper bound on the fraction of training errors and a " \
"lower bound of the fraction of support vectors"
gui.widgetLabel(ibox, 'Nu:', tooltip=tooltip)
self.nu_slider = gui.hSlider(ibox,
self,
"nu",
minValue=1,
maxValue=100,
ticks=10,
labelFormat="%d %%",
callback=self.nu_changed,
tooltip=tooltip)
self.gamma_spin = gui.spin(ibox,
self,
"gamma",
label="Kernel coefficient:",
step=1e-2,
spinType=float,
minv=0,
maxv=10,
callback=self.gamma_changed)
gui.separator(detection, 12)
self.rb_cov = gui.appendRadioButton(detection, "Covariance estimator:")
ibox = gui.indentedBox(detection)
self.l_cov = gui.widgetLabel(ibox, 'Contamination:')
self.cont_slider = gui.hSlider(ibox,
self,
"cont",
minValue=0,
maxValue=100,
ticks=10,
labelFormat="%d %%",
callback=self.cont_changed)
ebox = gui.widgetBox(ibox, box=None, orientation='horizontal')
self.cb_emp_cov = gui.checkBox(ebox,
self,
"empirical_covariance",
"Support fraction:",
callback=self.empirical_changed)
self.support_fraction_spin = gui.spin(
ebox,
self,
"support_fraction",
step=1e-1,
spinType=float,
minv=0.1,
maxv=10,
callback=self.support_fraction_changed)
gui.separator(detection, 12)
gui.button(self.controlArea,
self,
"Detect Outliers",
callback=self.commit)
self.layout().setSizeConstraint(QtGui.QLayout.SetFixedSize)
def __init__(self):
super().__init__()
# var models
self.x_var_model = itemmodels.VariableListModel()
self.y_var_model = itemmodels.VariableListModel()
# info box
self.info_box = gui.widgetBox(self.controlArea, "Info")
self.learner_label = gui.label(
widget=self.info_box, master=self, label="")
# options box
policy = QSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Fixed)
self.options_box = gui.widgetBox(self.controlArea, "Data")
opts = dict(
widget=self.options_box, master=self, orientation=Qt.Horizontal,
callback=self.change_attributes, sendSelectedValue=True,
maximumContentsLength=15
)
self.cbx = gui.comboBox(value='attr_x', label='X:', **opts)
self.cby = gui.comboBox(value='attr_y', label='Y:', **opts)
self.target_class_combobox = gui.comboBox(
value='target_class', label='Target class: ', **opts)
self.cbx.setModel(self.x_var_model)
self.cby.setModel(self.y_var_model)
gui.separator(self.controlArea, 20, 20)
# properties box
self.properties_box = gui.widgetBox(self.controlArea, "Properties")
self.alpha_spin = gui.spin(
widget=self.properties_box, master=self, callback=self.change_alpha,
value="alpha", label="Learning rate: ",
minv=0.001, maxv=100, step=0.001, spinType=float, decimals=3,
alignment=Qt.AlignRight, controlWidth=80)
self.stochastic_checkbox = gui.checkBox(
widget=self.properties_box, master=self,
callback=self.change_stochastic, value="stochastic",
label="Stochastic ")
self.step_size_spin = gui.spin(
widget=self.properties_box, master=self, callback=self.change_step,
value="step_size", label="Step size: ",
minv=1, maxv=100, step=1, alignment=Qt.AlignRight, controlWidth=80)
self.restart_button = gui.button(
widget=self.properties_box, master=self,
callback=self.restart, label="Restart")
self.alpha_spin.setSizePolicy(policy)
self.step_size_spin.setSizePolicy(policy)
gui.separator(self.controlArea, 20, 20)
# step box
self.step_box = gui.widgetBox(self.controlArea, "Manually step through")
self.step_button = gui.button(
widget=self.step_box, master=self, callback=self.step, label="Step",
default=True)
self.step_back_button = gui.button(
widget=self.step_box, master=self, callback=self.step_back,
label="Step back")
gui.separator(self.controlArea, 20, 20)
# run box
self.run_box = gui.widgetBox(self.controlArea, "Run")
self.auto_play_button = gui.button(
widget=self.run_box, master=self,
label=self.auto_play_button_text[0], callback=self.auto_play)
self.auto_play_speed_spinner = gui.hSlider(
widget=self.run_box, master=self, value='auto_play_speed',
minValue=0, maxValue=1.91, step=0.1,
intOnly=False, createLabel=False, label='Speed:')
# graph in mainArea
self.scatter = Scatterplot(click_callback=self.change_theta,
xAxis_gridLineWidth=0,
yAxis_gridLineWidth=0,
title_text='',
tooltip_shared=False,
legend=dict(enabled=False),)
gui.rubber(self.controlArea)
# Just render an empty chart so it shows a nice 'No data to display'
self.scatter.chart()
self.mainArea.layout().addWidget(self.scatter)
self.step_size_lock()
self.step_back_button_lock()
def __init__(self):
super().__init__()
self.data = None
self._pca = None
self._transformed = None
self._variance_ratio = None
self._cumulative = None
self._init_projector()
# Components Selection
form = QFormLayout()
box = gui.widgetBox(self.controlArea,
"Components Selection",
orientation=form)
self.components_spin = gui.spin(
box,
self,
"ncomponents",
1,
MAX_COMPONENTS,
callback=self._update_selection_component_spin,
keyboardTracking=False,
addToLayout=False)
self.components_spin.setSpecialValueText("All")
self.variance_spin = gui.spin(
box,
self,
"variance_covered",
1,
100,
callback=self._update_selection_variance_spin,
keyboardTracking=False,
addToLayout=False)
self.variance_spin.setSuffix("%")
form.addRow("Components:", self.components_spin)
form.addRow("Explained variance:", self.variance_spin)
# Options
self.options_box = gui.vBox(self.controlArea, "Options")
self.normalize_box = gui.checkBox(self.options_box,
self,
"normalize",
"Normalize variables",
callback=self._update_normalize,
attribute=Qt.WA_LayoutUsesWidgetRect)
self.maxp_spin = gui.spin(self.options_box,
self,
"maxp",
1,
MAX_COMPONENTS,
label="Show only first",
callback=self._setup_plot,
keyboardTracking=False)
gui.rubber(self.controlArea)
gui.auto_apply(self.buttonsArea, self, "auto_commit")
self.plot = SliderGraph("Principal Components",
"Proportion of variance", self._on_cut_changed)
self.mainArea.layout().addWidget(self.plot)
self._update_normalize()
def __init__(self):
super().__init__()
self.scorers = OrderedDict()
self.out_domain_desc = None
self.data = None
self.problem_type_mode = ProblemType.CLASSIFICATION
if not self.selected_methods:
self.selected_methods = {
method.name
for method in SCORES if method.is_default
}
# GUI
self.ranksModel = model = TableModel(parent=self) # type: TableModel
self.ranksView = view = TableView(self) # type: TableView
self.mainArea.layout().addWidget(view)
view.setModel(model)
view.setColumnWidth(0, 30)
view.selectionModel().selectionChanged.connect(self.on_select)
def _set_select_manual():
self.setSelectionMethod(OWRank.SelectManual)
view.pressed.connect(_set_select_manual)
view.verticalHeader().sectionClicked.connect(_set_select_manual)
view.horizontalHeader().sectionClicked.connect(self.headerClick)
self.measuresStack = stacked = QStackedWidget(self)
self.controlArea.layout().addWidget(stacked)
for scoring_methods in (CLS_SCORES, REG_SCORES, []):
box = gui.vBox(None,
"Scoring Methods" if scoring_methods else None)
stacked.addWidget(box)
for method in scoring_methods:
box.layout().addWidget(
QCheckBox(
method.name,
self,
objectName=method.
shortname, # To be easily found in tests
checked=method.name in self.selected_methods,
stateChanged=partial(self.methodSelectionChanged,
method_name=method.name)))
gui.rubber(box)
gui.rubber(self.controlArea)
self.switchProblemType(ProblemType.CLASSIFICATION)
selMethBox = gui.vBox(self.controlArea,
"Select Attributes",
addSpace=True)
grid = QGridLayout()
grid.setContentsMargins(6, 0, 6, 0)
self.selectButtons = QButtonGroup()
self.selectButtons.buttonClicked[int].connect(self.setSelectionMethod)
def button(text, buttonid, toolTip=None):
b = QRadioButton(text)
self.selectButtons.addButton(b, buttonid)
if toolTip is not None:
b.setToolTip(toolTip)
return b
b1 = button(self.tr("None"), OWRank.SelectNone)
b2 = button(self.tr("All"), OWRank.SelectAll)
b3 = button(self.tr("Manual"), OWRank.SelectManual)
b4 = button(self.tr("Best ranked:"), OWRank.SelectNBest)
s = gui.spin(
selMethBox,
self,
"nSelected",
1,
100,
callback=lambda: self.setSelectionMethod(OWRank.SelectNBest))
grid.addWidget(b1, 0, 0)
grid.addWidget(b2, 1, 0)
grid.addWidget(b3, 2, 0)
grid.addWidget(b4, 3, 0)
grid.addWidget(s, 3, 1)
self.selectButtons.button(self.selectionMethod).setChecked(True)
selMethBox.layout().addLayout(grid)
gui.auto_commit(selMethBox, self, "auto_apply", "Send", box=False)
self.resize(690, 500)
def __init__(self, parent=None):
widget.OWWidget.__init__(self, parent)
self.min_value, self.max_value = self.thresholds.get(
self.Scores[self.score_index][0], (1, 0))
# threshold defining expressed genes (for Hypergeometric Test)
self.expression_threshold_value = 1.0
#: Input data set
self.data = None
#: Current target group selection
self.targets = []
#: The computed scores
self.scores = None
#: The computed scores from label permutations
self.nulldist = None
self.__scores_future = self.__scores_state = None
self.__in_progress = False
self.test_f = {
OWDifferentialExpression.LowTail: test_low,
OWDifferentialExpression.HighTail: test_high,
OWDifferentialExpression.TwoTail: test_two_tail,
}
self.histogram = Histogram(enableMouse=False,
enableMenu=False,
background="w")
self.histogram.enableAutoRange(enable=False)
self.histogram.getPlotItem().hideButtons() # hide auto range button
self.histogram.getViewBox().setMouseEnabled(False, False)
self.histogram.selectionChanged.connect(
self.__on_histogram_plot_selection_changed)
self.histogram.selectionEdited.connect(self._invalidate_selection)
self.mainArea.layout().addWidget(self.histogram)
box = gui.widgetBox(self.controlArea, "Info")
self.dataInfoLabel = gui.widgetLabel(box, "No data on input.\n")
self.dataInfoLabel.setWordWrap(True)
self.selectedInfoLabel = gui.widgetLabel(box, "\n")
box1 = gui.widgetBox(self.controlArea, "Scoring Method")
gui.comboBox(
box1,
self,
"score_index",
items=[sm[0] for sm in self.Scores],
callback=[self.on_scoring_method_changed, self.update_scores],
)
self.expression_threshold_box = gui.widgetBox(self.controlArea,
'Expression threshold')
self.expression_threshold = gui.doubleSpin(
self.expression_threshold_box,
self,
"expression_threshold_value",
minv=0,
maxv=1e2,
step=1e-2,
callback=self.update_scores,
callbackOnReturn=True,
)
box = gui.widgetBox(self.controlArea, "Target Labels")
self.label_selection_widget = guiutils.LabelSelectionWidget()
self.label_selection_widget.setMaximumHeight(150)
box.layout().addWidget(self.label_selection_widget)
self.label_selection_widget.groupChanged.connect(
self.on_label_activated)
self.label_selection_widget.groupSelectionChanged.connect(
self.on_target_changed)
box = gui.widgetBox(self.controlArea, "Selection")
box.layout().setSpacing(0)
self.max_value_spin = gui.doubleSpin(
box,
self,
"max_value",
minv=-1e6,
maxv=1e6,
step=1e-6,
label="Upper threshold:",
callback=self.update_boundary,
callbackOnReturn=True,
)
self.low_value_spin = gui.doubleSpin(
box,
self,
"min_value",
minv=-1e6,
maxv=1e6,
step=1e-6,
label="Lower threshold:",
callback=self.update_boundary,
callbackOnReturn=True,
)
check = gui.checkBox(box,
self,
"compute_null",
"Compute null distribution",
callback=self.update_scores)
perm_spin = gui.spin(
box,
self,
"permutations_count",
minv=1,
maxv=50,
label="Permutations:",
callback=self.update_scores,
callbackOnReturn=True,
)
check.disables.append(perm_spin)
box1 = gui.widgetBox(box, orientation='horizontal')
pval_spin = gui.doubleSpin(box1,
self,
"alpha_value",
minv=2e-7,
maxv=1.0,
step=1e-7,
label="α-value:")
pval_select = gui.button(box1,
self,
"Select",
callback=self.select_p_best,
autoDefault=False)
check.disables.append(pval_spin)
check.disables.append(pval_select)
check.makeConsistent()
box1 = gui.widgetBox(box, orientation='horizontal')
gui.spin(box1, self, "n_best", 0, 10000, step=1, label="Best Ranked:")
gui.button(box1,
self,
"Select",
callback=self.select_n_best,
autoDefault=False)
box = gui.widgetBox(self.controlArea, "Output")
acbox = gui.auto_commit(box, self, "auto_commit", "Commit", box=None)
acbox.button.setDefault(True)
gui.rubber(self.controlArea)
self.on_scoring_method_changed()
self._executor = concurrent.ThreadExecutor()
def __init__(self):
super().__init__()
self.results = None
self.classifier_names = []
self.perf_line = None
self.colors = []
self._curve_data = {}
self._plot_curves = {}
self._rocch = None
self._perf_line = None
self._tooltip_cache = None
box = gui.vBox(self.controlArea, "Plot")
self.target_cb = gui.comboBox(box,
self,
"target_index",
label="Target",
orientation=Qt.Horizontal,
callback=self._on_target_changed,
contentsLength=8,
searchable=True)
gui.widgetLabel(box, "Classifiers")
line_height = 4 * QFontMetrics(self.font()).lineSpacing()
self.classifiers_list_box = gui.listBox(
box,
self,
"selected_classifiers",
"classifier_names",
selectionMode=QListView.MultiSelection,
callback=self._on_classifiers_changed,
sizeHint=QSize(0, line_height))
abox = gui.vBox(self.controlArea, "Curves")
gui.comboBox(abox,
self,
"roc_averaging",
items=[
"Merge Predictions from Folds", "Mean TP Rate",
"Mean TP and FP at Threshold",
"Show Individual Curves"
],
callback=self._replot)
gui.checkBox(abox,
self,
"display_convex_curve",
"Show convex ROC curves",
callback=self._replot)
gui.checkBox(abox,
self,
"display_convex_hull",
"Show ROC convex hull",
callback=self._replot)
box = gui.vBox(self.controlArea, "Analysis")
gui.checkBox(box,
self,
"display_def_threshold",
"Default threshold (0.5) point",
callback=self._on_display_def_threshold_changed)
gui.checkBox(box,
self,
"display_perf_line",
"Show performance line",
callback=self._on_display_perf_line_changed)
grid = QGridLayout()
gui.indentedBox(box, orientation=grid)
sp = gui.spin(box,
self,
"fp_cost",
1,
1000,
10,
alignment=Qt.AlignRight,
callback=self._on_display_perf_line_changed)
grid.addWidget(QLabel("FP Cost:"), 0, 0)
grid.addWidget(sp, 0, 1)
sp = gui.spin(box,
self,
"fn_cost",
1,
1000,
10,
alignment=Qt.AlignRight,
callback=self._on_display_perf_line_changed)
grid.addWidget(QLabel("FN Cost:"))
grid.addWidget(sp, 1, 1)
self.target_prior_sp = gui.spin(box,
self,
"target_prior",
1,
99,
alignment=Qt.AlignRight,
spinType=float,
callback=self._on_target_prior_changed)
self.target_prior_sp.setSuffix(" %")
self.target_prior_sp.addAction(QAction("Auto", sp))
grid.addWidget(QLabel("Prior probability:"))
grid.addWidget(self.target_prior_sp, 2, 1)
self.plotview = GraphicsView(background=None)
self.plotview.setFrameStyle(QFrame.StyledPanel)
self.plotview.scene().sigMouseMoved.connect(self._on_mouse_moved)
self.plot = PlotItem(enableMenu=False)
self.plot.setMouseEnabled(False, False)
self.plot.hideButtons()
tickfont = QFont(self.font())
tickfont.setPixelSize(max(int(tickfont.pixelSize() * 2 // 3), 11))
axis = self.plot.getAxis("bottom")
axis.setTickFont(tickfont)
axis.setLabel("FP Rate (1-Specificity)")
axis.setGrid(16)
axis = self.plot.getAxis("left")
axis.setTickFont(tickfont)
axis.setLabel("TP Rate (Sensitivity)")
axis.setGrid(16)
self.plot.showGrid(True, True, alpha=0.2)
self.plot.setRange(xRange=(0.0, 1.0), yRange=(0.0, 1.0), padding=0.05)
self.plotview.setCentralItem(self.plot)
self.mainArea.layout().addWidget(self.plotview)
def __init__(self, parent=None):
super().__init__(parent)
self.matrix = None
self.items = None
self.linkmatrix = None
self.root = None
self._displayed_root = None
self.cutoff_height = 0.0
self._invalidated = False
gui.comboBox(gui.widgetBox(self.controlArea, "Linkage"),
self,
"linkage",
items=LINKAGE,
callback=self._invalidate_clustering)
box = gui.widgetBox(self.controlArea, "Annotation")
self.label_cb = gui.comboBox(box,
self,
"annotation_idx",
callback=self._update_labels)
self.label_cb.setModel(itemmodels.VariableListModel())
self.label_cb.model()[:] = ["None", "Enumeration"]
box = gui.radioButtons(self.controlArea,
self,
"pruning",
box="Pruning",
callback=self._invalidate_pruning)
grid = QGridLayout()
box.layout().addLayout(grid)
grid.addWidget(gui.appendRadioButton(box, "None", addToLayout=False),
0, 0)
self.max_depth_spin = gui.spin(box,
self,
"max_depth",
minv=1,
maxv=100,
callback=self._invalidate_pruning,
keyboardTracking=False)
grid.addWidget(
gui.appendRadioButton(box, "Max depth", addToLayout=False), 1, 0)
grid.addWidget(self.max_depth_spin, 1, 1)
box = gui.radioButtons(self.controlArea,
self,
"selection_method",
box="Selection",
callback=self._selection_method_changed)
grid = QGridLayout()
box.layout().addLayout(grid)
grid.addWidget(gui.appendRadioButton(box, "Manual", addToLayout=False),
0, 0)
grid.addWidget(
gui.appendRadioButton(box, "Height ratio", addToLayout=False), 1,
0)
self.cut_ratio_spin = gui.spin(box,
self,
"cut_ratio",
0,
100,
step=1e-1,
spinType=float,
callback=self._selection_method_changed)
self.cut_ratio_spin.setSuffix("%")
grid.addWidget(self.cut_ratio_spin, 1, 1)
grid.addWidget(gui.appendRadioButton(box, "Top N", addToLayout=False),
2, 0)
self.top_n_spin = gui.spin(box,
self,
"top_n",
1,
20,
callback=self._selection_method_changed)
grid.addWidget(self.top_n_spin, 2, 1)
box.layout().addLayout(grid)
self.controlArea.layout().addStretch()
box = gui.widgetBox(self.controlArea, "Output")
gui.checkBox(box,
self,
"append_clusters",
"Append cluster IDs",
callback=self._invalidate_output)
ibox = gui.indentedBox(box)
name_edit = gui.lineEdit(ibox, self, "cluster_name")
name_edit.editingFinished.connect(self._invalidate_output)
cb = gui.comboBox(
ibox,
self,
"cluster_role",
callback=self._invalidate_output,
items=["Attribute", "Class variable", "Meta variable"])
form = QFormLayout(fieldGrowthPolicy=QFormLayout.AllNonFixedFieldsGrow,
labelAlignment=Qt.AlignLeft,
spacing=8)
form.addRow("Name", name_edit)
form.addRow("Place", cb)
ibox.layout().addSpacing(5)
ibox.layout().addLayout(form)
ibox.layout().addSpacing(5)
cb = gui.checkBox(box, self, "autocommit", "Commit automatically")
b = gui.button(box, self, "Commit", callback=self.commit, default=True)
gui.setStopper(self, b, cb, "_invalidated", callback=self.commit)
self.scene = QGraphicsScene()
self.view = QGraphicsView(
self.scene,
horizontalScrollBarPolicy=Qt.ScrollBarAlwaysOff,
verticalScrollBarPolicy=Qt.ScrollBarAlwaysOn,
alignment=Qt.AlignLeft | Qt.AlignVCenter)
def axis_view(orientation):
ax = pg.AxisItem(orientation=orientation, maxTickLength=7)
scene = QGraphicsScene()
scene.addItem(ax)
view = QGraphicsView(
scene,
horizontalScrollBarPolicy=Qt.ScrollBarAlwaysOff,
verticalScrollBarPolicy=Qt.ScrollBarAlwaysOn,
alignment=Qt.AlignLeft | Qt.AlignVCenter)
view.setFixedHeight(ax.size().height())
ax.line = SliderLine(orientation=Qt.Horizontal,
length=ax.size().height())
scene.addItem(ax.line)
return view, ax
axview, self.top_axis = axis_view("top")
self.mainArea.layout().setSpacing(1)
self.mainArea.layout().addWidget(axview)
self.mainArea.layout().addWidget(self.view)
axview, self.bottom_axis = axis_view("bottom")
self.mainArea.layout().addWidget(axview)
self._main_graphics = QGraphicsWidget()
self._main_layout = QGraphicsLinearLayout(Qt.Horizontal)
self._main_layout.setSpacing(1)
self._main_graphics.setLayout(self._main_layout)
self.scene.addItem(self._main_graphics)
self.dendrogram = DendrogramWidget()
self.dendrogram.setSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.MinimumExpanding)
self.dendrogram.selectionChanged.connect(self._invalidate_output)
self.dendrogram.selectionEdited.connect(self._selection_edited)
fm = self.fontMetrics()
self.dendrogram.setContentsMargins(5,
fm.lineSpacing() / 2, 5,
fm.lineSpacing() / 2)
self.labels = GraphicsSimpleTextList()
self.labels.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
self.labels.setAlignment(Qt.AlignLeft)
self.labels.setMaximumWidth(200)
self.labels.layout().setSpacing(0)
self._main_layout.addItem(self.dendrogram)
self._main_layout.addItem(self.labels)
self._main_layout.setAlignment(self.dendrogram,
Qt.AlignLeft | Qt.AlignVCenter)
self._main_layout.setAlignment(self.labels,
Qt.AlignLeft | Qt.AlignVCenter)
self.view.viewport().installEventFilter(self)
self._main_graphics.installEventFilter(self)
self.cut_line = SliderLine(self.dendrogram, orientation=Qt.Horizontal)
self.cut_line.valueChanged.connect(self._dendrogram_slider_changed)
self.cut_line.hide()
self.bottom_axis.line.valueChanged.connect(self._axis_slider_changed)
self.top_axis.line.valueChanged.connect(self._axis_slider_changed)
self.dendrogram.geometryChanged.connect(self._dendrogram_geom_changed)
self._set_cut_line_visible(self.selection_method == 1)
def __init__(self):
super().__init__()
self.data = None
self.km = None
self.optimization_runs = []
box = gui.vBox(self.controlArea, "Number of Clusters")
layout = QGridLayout()
bg = gui.radioButtonsInBox(
box, self, "optimize_k", [], orientation=layout,
callback=self.update)
layout.addWidget(
gui.appendRadioButton(bg, "Fixed", addToLayout=False),
1, 1)
sb = gui.hBox(None, margin=0)
self.fixedSpinBox = gui.spin(
sb, self, "k", minv=2, maxv=30,
controlWidth=60, alignment=Qt.AlignRight, callback=self.update_k)
gui.rubber(sb)
layout.addWidget(sb, 1, 2)
layout.addWidget(
gui.appendRadioButton(bg, "Optimized", addToLayout=False), 2, 1)
ftobox = gui.hBox(None)
ftobox.layout().setContentsMargins(0, 0, 0, 0)
layout.addWidget(ftobox)
gui.spin(
ftobox, self, "k_from", minv=2, maxv=29,
controlWidth=60, alignment=Qt.AlignRight,
callback=self.update_from)
gui.widgetLabel(ftobox, " To: ")
self.fixedSpinBox = gui.spin(
ftobox, self, "k_to", minv=3, maxv=30,
controlWidth=60, alignment=Qt.AlignRight,
callback=self.update_to)
gui.rubber(ftobox)
layout.addWidget(gui.widgetLabel(None, "Scoring: "),
5, 1, Qt.AlignRight)
layout.addWidget(
gui.comboBox(
None, self, "scoring", label="Scoring",
items=list(zip(*self.SCORING_METHODS))[0],
callback=self.update), 5, 2)
box = gui.vBox(self.controlArea, "Initialization")
gui.comboBox(
box, self, "smart_init", items=self.INIT_METHODS,
callback=self.update)
layout = QGridLayout()
box2 = gui.widgetBox(box, orientation=layout)
box2.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Maximum)
layout.addWidget(gui.widgetLabel(None, "Re-runs: "),
0, 0, Qt.AlignLeft)
sb = gui.hBox(None, margin=0)
layout.addWidget(sb, 0, 1)
gui.lineEdit(
sb, self, "n_init", controlWidth=60,
valueType=int, validator=QIntValidator(),
callback=self.update)
layout.addWidget(gui.widgetLabel(None, "Maximal iterations: "),
1, 0, Qt.AlignLeft)
sb = gui.hBox(None, margin=0)
layout.addWidget(sb, 1, 1)
gui.lineEdit(sb, self, "max_iterations",
controlWidth=60, valueType=int,
validator=QIntValidator(),
callback=self.update)
box = gui.vBox(self.controlArea, "Output")
gui.comboBox(box, self, "place_cluster_ids",
label="Append cluster id as ", orientation=Qt.Horizontal,
callback=self.send_data, items=self.OUTPUT_METHODS)
gui.lineEdit(box, self, "output_name",
label="Name ", orientation=Qt.Horizontal,
callback=self.send_data)
gui.separator(self.buttonsArea, 30)
gui.auto_commit(self.buttonsArea, self, "auto_run", "Run",
"Run on change", box=None)
gui.rubber(self.controlArea)
self.table_model = QStandardItemModel(self)
self.table_model.setHorizontalHeaderLabels(["k", "Score"])
self.table_model.setColumnCount(2)
self.table_box = gui.vBox(
self.mainArea, "Optimization Report", addSpace=0)
table = self.table_view = QTableView(self.table_box)
table.setHorizontalScrollMode(QTableView.ScrollPerPixel)
table.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
table.setSelectionMode(QTableView.SingleSelection)
table.setSelectionBehavior(QTableView.SelectRows)
table.verticalHeader().hide()
table.setItemDelegateForColumn(1, gui.TableBarItem(self))
table.setModel(self.table_model)
table.selectionModel().selectionChanged.connect(
self.table_item_selected)
table.setColumnWidth(0, 40)
table.setColumnWidth(1, 120)
table.horizontalHeader().setStretchLastSection(True)
self.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
self.mainArea.setSizePolicy(QSizePolicy.Maximum,
QSizePolicy.Preferred)
self.table_box.setSizePolicy(QSizePolicy.Fixed,
QSizePolicy.MinimumExpanding)
self.table_view.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.MinimumExpanding)
self.table_box.layout().addWidget(self.table_view)
self.hide_show_opt_results()
