def __init__(self):
super().__init__()
self.data = None
self.reference = None
box = gui.vBox(self.controlArea, "Info")
self.data_info_label = gui.widgetLabel(box, self._data_info_default)
self.ref_info_label = gui.widgetLabel(box, self._ref_info_default)
box = gui.vBox(self.controlArea, "Settings")
self.distance_combo = gui.comboBox(
box, self, "distance_index", orientation=Qt.Horizontal,
label="Distance: ", items=[d[0] for d in METRICS],
callback=self.settings_changed)
check_box = gui.hBox(box)
self.exclude_ref_label = gui.label(
check_box, self, "Exclude references:")
self.exclude_ref_check = gui.checkBox(
check_box, self, "exclude_reference", label="",
callback=self.settings_changed)
box = gui.vBox(self.controlArea, "Output")
self.nn_spin = gui.spin(
box, self, "n_neighbors", label="Neighbors:", step=1, spinType=int,
minv=0, maxv=100, callback=self.settings_changed)
box = gui.hBox(self.controlArea, True)
self.apply_button = gui.auto_commit(box, self, "auto_apply", "&Apply",
box=False, commit=self.apply)
def __init__(self):
super().__init__()
self.data = None
self.removedAttrs = "-"
self.reducedAttrs = "-"
self.resortedAttrs = "-"
self.removedClasses = "-"
self.reducedClasses = "-"
self.resortedClasses = "-"
boxAt = gui.vBox(self.controlArea, "Features")
for not_first, (value, label) in enumerate(self.feature_options):
if not_first:
gui.separator(boxAt, 2)
gui.checkBox(boxAt, self, value, label,
callback=self.optionsChanged)
boxAt = gui.vBox(self.controlArea, "Classes", addSpace=True)
for not_first, (value, label) in enumerate(self.class_options):
if not_first:
gui.separator(boxAt, 2)
gui.checkBox(boxAt, self, value, label,
callback=self.optionsChanged)
box3 = gui.vBox(self.controlArea, 'Statistics', addSpace=True)
for label, value in self.stat_labels:
gui.label(box3, self, "{}: %({})s".format(label, value))
gui.auto_commit(self.buttonsArea, self, "autoSend", "Send Data",
checkbox_label="Send automatically",
orientation=Qt.Horizontal)
gui.rubber(self.controlArea)
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__()
box = gui.vBox(self.controlArea, "Multinomial Attributes")
gui.radioButtonsInBox(
box, self, "multinomial_treatment",
btnLabels=[x[0] for x in self.multinomial_treats],
callback=self.settings_changed)
box = gui.vBox(self.controlArea, "Continuous Attributes")
gui.radioButtonsInBox(
box, self, "continuous_treatment",
btnLabels=[x[0] for x in self.continuous_treats],
callback=self.settings_changed)
box = gui.vBox(self.controlArea, "Discrete Class Attribute")
gui.radioButtonsInBox(
box, self, "class_treatment",
btnLabels=[t[0] for t in self.class_treats],
callback=self.settings_changed)
zbbox = gui.vBox(self.controlArea, "Value Range")
gui.radioButtonsInBox(
zbbox, self, "zero_based",
btnLabels=self.value_ranges,
callback=self.settings_changed)
gui.auto_commit(self.buttonsArea, self, "autosend", "Apply", box=False)
self.data = None
def __init__(self):
super().__init__()
self.data = None
self.input_vars = ()
self._invalidated = False
box = gui.vBox(self.controlArea, "Domain Features")
self.domain_model = itemmodels.VariableListModel()
self.domain_view = QListView(
selectionMode=QListView.SingleSelection
)
self.domain_view.setModel(self.domain_model)
self.domain_view.selectionModel().selectionChanged.connect(
self._on_selection_changed)
box.layout().addWidget(self.domain_view)
box = gui.hBox(self.controlArea)
gui.button(box, self, "Reset Selected", callback=self.reset_selected)
gui.button(box, self, "Reset All", callback=self.reset_all)
gui.auto_commit(self.controlArea, self, "autocommit", "Apply")
box = gui.vBox(self.mainArea, "Edit")
self.editor_stack = QStackedWidget()
self.editor_stack.addWidget(DiscreteVariableEditor())
self.editor_stack.addWidget(ContinuousVariableEditor())
self.editor_stack.addWidget(VariableEditor())
box.layout().addWidget(self.editor_stack)
def _add_kernel_box(self):
# Initialize with the widest label to measure max width
self.kernel_eq = self.kernels[-1][1]
box = gui.hBox(self.controlArea, "Kernel")
self.kernel_box = buttonbox = gui.radioButtonsInBox(
box, self, "kernel_type", btnLabels=[k[0] for k in self.kernels],
callback=self._on_kernel_changed, addSpace=20)
buttonbox.layout().setSpacing(10)
gui.rubber(buttonbox)
parambox = gui.vBox(box)
gui.label(parambox, self, "Kernel: %(kernel_eq)s")
common = dict(orientation=Qt.Horizontal, callback=self.settings_changed,
alignment=Qt.AlignRight, controlWidth=80)
spbox = gui.hBox(parambox)
gui.rubber(spbox)
inbox = gui.vBox(spbox)
gamma = gui.doubleSpin(
inbox, self, "gamma", 0.0, 10.0, 0.01, label=" g: ", **common)
gamma.setSpecialValueText(self._default_gamma)
coef0 = gui.doubleSpin(
inbox, self, "coef0", 0.0, 10.0, 0.01, label=" c: ", **common)
degree = gui.doubleSpin(
inbox, self, "degree", 0.0, 10.0, 0.5, label=" d: ", **common)
self._kernel_params = [gamma, coef0, degree]
gui.rubber(parambox)
# This is the maximal height (all double spins are visible)
# and the maximal width (the label is initialized to the widest one)
box.layout().activate()
box.setFixedHeight(box.sizeHint().height())
box.setMinimumWidth(box.sizeHint().width())
def __init__(self):
self.data = None
# GUI
method_box = gui.vBox(self.controlArea, "Method")
self.manifold_methods_combo = gui.comboBox(
method_box, self, "manifold_method_index",
items=[m.name for m in self.MANIFOLD_METHODS],
callback=self.manifold_method_changed)
self.params_box = gui.vBox(self.controlArea, "Parameters")
self.tsne_editor = TSNEParametersEditor(self)
self.mds_editor = MDSParametersEditor(self)
self.isomap_editor = IsomapParametersEditor(self)
self.lle_editor = LocallyLinearEmbeddingParametersEditor(self)
self.spectral_editor = SpectralEmbeddingParametersEditor(self)
self.parameter_editors = [
self.tsne_editor, self.mds_editor, self.isomap_editor,
self.lle_editor, self.spectral_editor]
for editor in self.parameter_editors:
self.params_box.layout().addWidget(editor)
editor.hide()
self.params_widget = self.parameter_editors[self.manifold_method_index]
self.params_widget.show()
output_box = gui.vBox(self.controlArea, "Output")
self.n_components_spin = gui.spin(
output_box, self, "n_components", 1, 10, label="Components:",
alignment=Qt.AlignRight, callbackOnReturn=True,
callback=self.settings_changed)
self.apply_button = gui.auto_commit(
output_box, self, "auto_apply", "&Apply",
box=False, commit=self.apply)
def __init__(self):
super().__init__()
self.data = None
self.component_x = 0
self.component_y = 1
box = gui.vBox(self.controlArea, "Variables")
self.varlist = itemmodels.VariableListModel()
self.varview = view = QListView(selectionMode=QListView.MultiSelection)
view.setModel(self.varlist)
view.selectionModel().selectionChanged.connect(self._var_changed)
box.layout().addWidget(view)
axes_box = gui.vBox(self.controlArea, "Axes")
box = gui.vBox(axes_box, "Axis X", margin=0)
box.setFlat(True)
self.axis_x_cb = gui.comboBox(
box, self, "component_x", callback=self._component_changed)
box = gui.vBox(axes_box, "Axis Y", margin=0)
box.setFlat(True)
self.axis_y_cb = gui.comboBox(
box, self, "component_y", callback=self._component_changed)
self.infotext = gui.widgetLabel(
gui.vBox(self.controlArea, "Contribution to Inertia"), "\n"
)
gui.rubber(self.controlArea)
self.plot = pg.PlotWidget(background="w")
self.plot.setMenuEnabled(False)
self.mainArea.layout().addWidget(self.plot)
def __init__(self):
super().__init__()
self.data = None
self.feature_model = DomainModel(valid_types=DiscreteVariable)
self.table = None
box = gui.vBox(self.controlArea, "Rows")
gui.comboBox(box, self, 'rows', sendSelectedValue=True,
model=self.feature_model, callback=self._attribute_changed)
box = gui.vBox(self.controlArea, "Columns")
gui.comboBox(box, self, 'columns', sendSelectedValue=True,
model=self.feature_model, callback=self._attribute_changed)
gui.rubber(self.controlArea)
box = gui.vBox(self.controlArea, "Scores")
self.scores = gui.widgetLabel(box, "\n\n")
self.apply_button = gui.auto_commit(
self.controlArea, self, "auto_apply", "&Apply", box=False)
self.tableview = ContingencyTable(self)
self.mainArea.layout().addWidget(self.tableview)
def __init__(self):
self.data = None
self.indices = []
box = gui.vBox(self.controlArea, 'Axes')
self.combo_ax2 = gui.comboBox(
box, self, 'ax2', label='Y axis:', callback=self.replot,
sendSelectedValue=True, orientation='horizontal')
self.combo_ax1 = gui.comboBox(
box, self, 'ax1', label='Radial:', callback=self.replot,
sendSelectedValue=True, orientation='horizontal')
box = gui.vBox(self.controlArea, 'Aggregation')
self.combo_func = gui.comboBox(
box, self, 'agg_func', label='Function:', orientation='horizontal',
callback=self.replot)
func_model = ListModel(AGG_FUNCTIONS, parent=self)
self.combo_func.setModel(func_model)
self.attrlist_model = VariableListModel(parent=self)
self.attrlist = QListView(selectionMode=QListView.ExtendedSelection)
self.attrlist.setModel(self.attrlist_model)
self.attrlist.selectionModel().selectionChanged.connect(
self.attrlist_selectionChanged)
box.layout().addWidget(self.attrlist)
gui.rubber(self.controlArea)
self.chart = chart = Spiralogram(self,
selection_callback=self.on_selection)
self.mainArea.layout().addWidget(chart)
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 __init__(self):
super().__init__()
RecentPathsWComboMixin.__init__(self)
self.loaded_file = ""
vbox = gui.vBox(self.controlArea, "Distance File", addSpace=True)
box = gui.hBox(vbox)
self.file_combo.setMinimumWidth(300)
box.layout().addWidget(self.file_combo)
self.file_combo.activated[int].connect(self.select_file)
button = gui.button(box, self, '...', callback=self.browse_file)
button.setIcon(self.style().standardIcon(QtGui.QStyle.SP_DirOpenIcon))
button.setSizePolicy(
QtGui.QSizePolicy.Maximum, QtGui.QSizePolicy.Fixed)
button = gui.button(
box, self, "Reload", callback=self.reload, default=True)
button.setIcon(self.style().standardIcon(QtGui.QStyle.SP_BrowserReload))
button.setSizePolicy(QtGui.QSizePolicy.Fixed, QtGui.QSizePolicy.Fixed)
box = gui.vBox(self.controlArea, "Info", addSpace=True)
self.infoa = gui.widgetLabel(box, 'No data loaded.')
self.warnings = gui.widgetLabel(box, ' ')
#Set word wrap, so long warnings won't expand the widget
self.warnings.setWordWrap(True)
self.warnings.setSizePolicy(
QtGui.QSizePolicy.Ignored, QtGui.QSizePolicy.MinimumExpanding)
self.set_file_list()
QtCore.QTimer.singleShot(0, self.open_file)
def __init__(self):
hbox = gui.hBox(self.controlArea)
_properties = dict(alternatingRowColors=True,
defaultDropAction=Qt.MoveAction,
dragDropMode=QListView.DragDrop,
dragEnabled=True,
selectionMode=QListView.ExtendedSelection,
selectionBehavior=QListView.SelectRows,
showDropIndicator=True,
acceptDrops=True)
listview_avail = DnDListView(lambda: self.commit(), self, **_properties)
self.model_avail = model = VariableListModel(parent=self, enable_dnd=True)
listview_avail.setModel(model)
listview_key = DnDListView(lambda: self.commit(), self, **_properties)
self.model_key = model = VariableListModel(parent=self, enable_dnd=True)
listview_key.setModel(model)
box = gui.vBox(hbox, 'Available Variables')
box.layout().addWidget(listview_avail)
box = gui.vBox(hbox, 'Group-By Key')
box.layout().addWidget(listview_key)
gui.comboBox(self.controlArea, self, 'tiebreaker',
label='Which instance to select in each group:',
items=tuple(self.TIEBREAKERS.keys()),
callback=lambda: self.commit(),
sendSelectedValue=True)
gui.auto_commit(self.controlArea, self, 'autocommit', 'Commit',
orientation=Qt.Horizontal)
def __init__(self):
super().__init__()
self.data = None
self._effective_data = None
self._matrix = None
self._silhouette = None
self._labels = None
self._silplot = None
gui.comboBox(
self.controlArea, self, "distance_idx", box="Distance",
items=[name for name, _ in OWSilhouettePlot.Distances],
orientation=Qt.Horizontal, callback=self._invalidate_distances)
box = gui.vBox(self.controlArea, "Cluster Label")
self.cluster_var_cb = gui.comboBox(
box, self, "cluster_var_idx", addSpace=4,
callback=self._invalidate_scores)
gui.checkBox(
box, self, "group_by_cluster", "Group by cluster",
callback=self._replot)
self.cluster_var_model = itemmodels.VariableListModel(parent=self)
self.cluster_var_cb.setModel(self.cluster_var_model)
box = gui.vBox(self.controlArea, "Bars")
gui.widgetLabel(box, "Bar width:")
gui.hSlider(
box, self, "bar_size", minValue=1, maxValue=10, step=1,
callback=self._update_bar_size, addSpace=6)
gui.widgetLabel(box, "Annotations:")
self.annotation_cb = gui.comboBox(
box, self, "annotation_var_idx", 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)
ibox = gui.indentedBox(box, 5)
self.ann_hidden_warning = warning = gui.widgetLabel(
ibox, "(increase the width to show)")
ibox.setFixedWidth(ibox.sizeHint().width())
warning.setVisible(False)
gui.rubber(self.controlArea)
gui.separator(self.buttonsArea)
box = gui.vBox(self.buttonsArea, "Output")
# Thunk the call to commit to call conditional commit
gui.checkBox(box, self, "add_scores", "Add silhouette scores",
callback=lambda: self.commit())
gui.auto_commit(
box, self, "auto_commit", "Commit",
auto_label="Auto commit", box=False)
# Ensure that the controlArea is not narrower than buttonsArea
self.controlArea.layout().addWidget(self.buttonsArea)
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 add_main_layout(self):
box = gui.hBox(self.controlArea, "Regularization")
gui.radioButtons(box, self, "reg_type",
btnLabels=self.REGULARIZATION_TYPES,
callback=self._reg_type_changed)
gui.separator(box, 20, 20)
self.alpha_box = box2 = gui.vBox(box, margin=10)
gui.widgetLabel(box2, "Regularization strength:")
self.alpha_slider = gui.hSlider(
box2, self, "alpha_index",
minValue=0, maxValue=len(self.alphas) - 1,
callback=self._alpha_changed, createLabel=False)
box3 = gui.hBox(box2)
box3.layout().setAlignment(Qt.AlignCenter)
self.alpha_label = gui.widgetLabel(box3, "")
self._set_alpha_label()
gui.separator(box2, 10, 10)
box4 = gui.vBox(box2, margin=0)
gui.widgetLabel(box4, "Elastic net mixing:")
box5 = gui.hBox(box4)
gui.widgetLabel(box5, "L1")
self.l1_ratio_slider = gui.hSlider(
box5, self, "l1_ratio", minValue=0.01, maxValue=0.99,
intOnly=False, ticks=0.1, createLabel=False, width=120,
step=0.01, callback=self._l1_ratio_changed)
gui.widgetLabel(box5, "L2")
self.l1_ratio_label = gui.widgetLabel(
box4, "",
sizePolicy=(QSizePolicy.MinimumExpanding, QSizePolicy.Fixed))
self.l1_ratio_label.setAlignment(Qt.AlignCenter)
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)
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, 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,
) # type: gui.OrangeComboBox
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,
) # type: gui.SpinBoxWFocusOut
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_commit(
self.controlArea, self, 'auto_commit', 'Apply', box=None,
commit=lambda: self.commit(),
callback=lambda: self._on_auto_commit_changed(),
) # type: QWidget
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 __init__(self):
super().__init__()
self.old_purge_classes = True
self.conditions = []
self.last_output_conditions = None
self.data = None
self.data_desc = self.match_desc = self.nonmatch_desc = None
box = gui.vBox(self.controlArea, 'Conditions', stretch=100)
self.cond_list = QtGui.QTableWidget(box)
box.layout().addWidget(self.cond_list)
self.cond_list.setShowGrid(False)
self.cond_list.setSelectionMode(QtGui.QTableWidget.NoSelection)
self.cond_list.setColumnCount(3)
self.cond_list.setRowCount(0)
self.cond_list.verticalHeader().hide()
self.cond_list.horizontalHeader().hide()
self.cond_list.resizeColumnToContents(0)
self.cond_list.horizontalHeader().setResizeMode(
QtGui.QHeaderView.Stretch)
self.cond_list.viewport().setBackgroundRole(QtGui.QPalette.Window)
box2 = gui.hBox(box)
self.add_button = gui.button(box2, self, "Add Condition",
callback=self.add_row)
self.add_all_button = gui.button(box2, self, "Add All Variables",
callback=self.add_all)
self.remove_all_button = gui.button(box2, self, "Remove All",
callback=self.remove_all)
gui.rubber(box2)
info = gui.hBox(self.controlArea)
box_data_in = gui.vBox(info, 'Data In')
# self.data_in_rows = gui.widgetLabel(box_data_in, " ")
self.data_in_variables = gui.widgetLabel(box_data_in, " ")
gui.rubber(box_data_in)
box_data_out = gui.vBox(info, 'Data Out')
self.data_out_rows = gui.widgetLabel(box_data_out, " ")
# self.dataOutAttributesLabel = gui.widgetLabel(box_data_out, " ")
gui.rubber(box_data_out)
box = gui.hBox(self.controlArea)
box_setting = gui.vBox(box, 'Purging')
self.cb_pa = gui.checkBox(
box_setting, self, "purge_attributes", "Remove unused features",
callback=self.conditions_changed)
gui.separator(box_setting, height=1)
self.cb_pc = gui.checkBox(
box_setting, self, "purge_classes", "Remove unused classes",
callback=self.conditions_changed)
gui.auto_commit(box, self, "auto_commit", label="Send",
checkbox_label="Send automatically")
self.set_data(None)
self.resize(600, 400)
def __init__(self):
super().__init__()
self.data = None
self.results = None
self.learners = []
self.headers = []
self.learners_box = gui.listBox(
self.controlArea, self, "selected_learner", "learners", box=True,
callback=self._learner_changed
)
self.outputbox = gui.vBox(self.controlArea, "Output")
box = gui.hBox(self.outputbox)
gui.checkBox(box, self, "append_predictions",
"Predictions", callback=self._invalidate)
gui.checkBox(box, self, "append_probabilities",
"Probabilities",
callback=self._invalidate)
gui.auto_commit(self.outputbox, self, "autocommit",
"Send Selected", "Send Automatically", box=False)
self.mainArea.layout().setContentsMargins(0, 0, 0, 0)
box = gui.vBox(self.mainArea, box=True)
sbox = gui.hBox(box)
gui.rubber(sbox)
gui.comboBox(sbox, self, "selected_quantity",
items=self.quantities, label="Show: ",
orientation=Qt.Horizontal, callback=self._update)
self.tablemodel = QStandardItemModel(self)
view = self.tableview = QTableView(
editTriggers=QTableView.NoEditTriggers)
view.setModel(self.tablemodel)
view.horizontalHeader().hide()
view.verticalHeader().hide()
view.horizontalHeader().setMinimumSectionSize(60)
view.selectionModel().selectionChanged.connect(self._invalidate)
view.setShowGrid(False)
view.setItemDelegate(BorderedItemDelegate(Qt.white))
view.setSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.MinimumExpanding)
view.clicked.connect(self.cell_clicked)
box.layout().addWidget(view)
selbox = gui.hBox(box)
gui.button(selbox, self, "Select Correct",
callback=self.select_correct, autoDefault=False)
gui.button(selbox, self, "Select Misclassified",
callback=self.select_wrong, autoDefault=False)
gui.button(selbox, self, "Clear Selection",
callback=self.select_none, autoDefault=False)
def __init__(self):
super().__init__()
# data
self.dataA = None
self.dataB = None
# GUI
w = QtGui.QWidget(self)
self.controlArea.layout().addWidget(w)
grid = QtGui.QGridLayout()
grid.setContentsMargins(0, 0, 0, 0)
w.setLayout(grid)
# attribute A selection
boxAttrA = gui.vBox(self, self.tr("Attribute A"), addToLayout=False)
grid.addWidget(boxAttrA, 0, 0)
self.attrViewA = QtGui.QListView(
selectionMode=QtGui.QListView.SingleSelection
)
self.attrModelA = itemmodels.VariableListModel()
self.attrViewA.setModel(self.attrModelA)
self.attrViewA.selectionModel().selectionChanged.connect(
self._selectedAttrAChanged)
boxAttrA.layout().addWidget(self.attrViewA)
# attribute B selection
boxAttrB = gui.vBox(self, self.tr("Attribute B"), addToLayout=False)
grid.addWidget(boxAttrB, 0, 1)
self.attrViewB = QtGui.QListView(
selectionMode=QtGui.QListView.SingleSelection
)
self.attrModelB = itemmodels.VariableListModel()
self.attrViewB.setModel(self.attrModelB)
self.attrViewB.selectionModel().selectionChanged.connect(
self._selectedAttrBChanged)
boxAttrB.layout().addWidget(self.attrViewB)
# info A
boxDataA = gui.vBox(self, self.tr("Data A Input"), addToLayout=False)
grid.addWidget(boxDataA, 1, 0)
self.infoBoxDataA = gui.widgetLabel(boxDataA, self.dataInfoText(None))
# info B
boxDataB = gui.vBox(self, self.tr("Data B Input"), addToLayout=False)
grid.addWidget(boxDataB, 1, 1)
self.infoBoxDataB = gui.widgetLabel(boxDataB, self.dataInfoText(None))
gui.rubber(self.buttonsArea)
# resize
self.resize(400, 500)
def __init__(self):
super().__init__()
if isinstance(self.selected_learner, list):
self.selected_learner = (self.selected_learner + [0])[0]
self.data = None
self.results = None
self.learners = []
self.headers = []
box = gui.vBox(self.controlArea, "Learners")
self.learners_box = gui.listBox(
box, self, "selected_learner", "learners",
callback=self._learner_changed
)
box = gui.vBox(self.controlArea, "Show")
gui.comboBox(box, self, "selected_quantity", items=self.quantities,
callback=self._update)
box = gui.vBox(self.controlArea, "Select")
gui.button(box, self, "Select Correct",
callback=self.select_correct, autoDefault=False)
gui.button(box, self, "Select Misclassified",
callback=self.select_wrong, autoDefault=False)
gui.button(box, self, "Clear Selection",
callback=self.select_none, autoDefault=False)
self.outputbox = box = gui.vBox(self.controlArea, "Output")
gui.checkBox(box, self, "append_predictions",
"Predictions", callback=self._invalidate)
gui.checkBox(box, self, "append_probabilities",
"Probabilities",
callback=self._invalidate)
gui.auto_commit(self.controlArea, self, "autocommit",
"Send Selected", "Send Automatically")
grid = QGridLayout()
self.tablemodel = QStandardItemModel(self)
view = self.tableview = QTableView(
editTriggers=QTableView.NoEditTriggers)
view.setModel(self.tablemodel)
view.horizontalHeader().hide()
view.verticalHeader().hide()
view.horizontalHeader().setMinimumSectionSize(60)
view.selectionModel().selectionChanged.connect(self._invalidate)
view.setShowGrid(False)
view.setItemDelegate(BorderedItemDelegate(Qt.white))
view.clicked.connect(self.cell_clicked)
grid.addWidget(view, 0, 0)
self.mainArea.layout().addLayout(grid)
def __init__(self, parent=None, windowTitle="Color Palette List",
**kwargs):
super().__init__(parent, windowTitle=windowTitle, **kwargs)
self.setLayout(QVBoxLayout())
self.layout().setContentsMargins(0, 0, 0, 0)
sa = QScrollArea(
horizontalScrollBarPolicy=Qt.ScrollBarAlwaysOff,
verticalScrollBarPolicy=Qt.ScrollBarAlwaysOn
)
sa.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
sa.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
self.layout().addWidget(sa)
space = QWidget(self)
space.setLayout(QVBoxLayout())
sa.setWidget(space)
sa.setWidgetResizable(True)
self.buttons = []
self.setMinimumWidth(400)
box = gui.vBox(space, "Information", addSpace=True)
gui.widgetLabel(
box,
'<p align="center">This dialog shows a list of predefined '
'color palettes <br>from colorbrewer.org that can be used '
'in Orange.<br/>You can select a palette by clicking on it.</p>'
)
box = gui.vBox(space, "Default Palette", addSpace=True)
butt = _ColorButton(
DefaultRGBColors, flat=True, toolTip="Default color palette",
clicked=self._buttonClicked
)
box.layout().addWidget(butt)
self.buttons.append(butt)
for type in ["Qualitative", "Spectral", "Diverging", "Sequential", "Pastels"]:
colorGroup = colorbrewer.colorSchemes.get(type.lower(), {})
if colorGroup:
box = gui.vBox(space, type + " Palettes", addSpace=True)
items = sorted(colorGroup.items())
for key, colors in items:
butt = _ColorButton(colors, self, toolTip=key, flat=True,
clicked=self._buttonClicked)
box.layout().addWidget(butt)
self.buttons.append(butt)
buttons = QDialogButtonBox(
QDialogButtonBox.Cancel, rejected=self.reject
)
self.layout().addWidget(buttons)
self.selectedColors = None
def __init__(self):
super().__init__()
self.stats = []
self.dataset = None
self.posthoc_lines = []
self.label_txts = self.mean_labels = self.boxes = self.labels = \
self.label_txts_all = self.attr_labels = self.order = []
self.p = -1.0
self.scale_x = self.scene_min_x = self.scene_width = 0
self.label_width = 0
common_options = dict(
callback=self.attr_changed, sizeHint=(200, 100))
self.attrs = VariableListModel()
gui.listView(
self.controlArea, self, "attribute", box="Variable",
model=self.attrs, **common_options)
self.group_vars = VariableListModel()
gui.listView(
self.controlArea, self, "group_var", box="Grouping",
model=self.group_vars, **common_options)
# TODO: move Compare median/mean to grouping box
self.display_box = gui.vBox(self.controlArea, "Display")
gui.checkBox(self.display_box, self, "show_annotations", "Annotate",
callback=self.display_changed)
self.compare_rb = gui.radioButtonsInBox(
self.display_box, self, 'compare',
btnLabels=["No comparison", "Compare medians", "Compare means"],
callback=self.display_changed)
self.stretching_box = gui.checkBox(
self.controlArea, self, 'stretched', "Stretch bars", box='Display',
callback=self.display_changed).box
gui.vBox(self.mainArea, addSpace=True)
self.box_scene = QGraphicsScene()
self.box_view = QGraphicsView(self.box_scene)
self.box_view.setRenderHints(QPainter.Antialiasing |
QPainter.TextAntialiasing |
QPainter.SmoothPixmapTransform)
self.box_view.viewport().installEventFilter(self)
self.mainArea.layout().addWidget(self.box_view)
e = gui.hBox(self.mainArea, addSpace=False)
self.infot1 = gui.widgetLabel(e, "<center>No test results.</center>")
self.mainArea.setMinimumWidth(650)
self.stats = self.dist = self.conts = []
self.is_continuous = False
self.update_display_box()
def __init__(self):
super().__init__()
self.results = None
self.classifier_names = []
self.colors = []
self._curve_data = {}
box = gui.vBox(self.controlArea, "Plot")
tbox = gui.vBox(box, "Target Class")
tbox.setFlat(True)
self.target_cb = gui.comboBox(
tbox, self, "target_index", callback=self._on_target_changed,
contentsLength=8)
cbox = gui.vBox(box, "Classifiers")
cbox.setFlat(True)
self.classifiers_list_box = gui.listBox(
cbox, self, "selected_classifiers", "classifier_names",
selectionMode=QtWidgets.QListView.MultiSelection,
callback=self._on_classifiers_changed)
gui.checkBox(box, self, "display_convex_hull",
"Show lift convex hull", callback=self._replot)
self.plotview = pg.GraphicsView(background="w")
self.plotview.setFrameStyle(QtWidgets.QFrame.StyledPanel)
self.plot = pg.PlotItem(enableMenu=False)
self.plot.setMouseEnabled(False, False)
self.plot.hideButtons()
pen = QPen(self.palette().color(QPalette.Text))
tickfont = QFont(self.font())
tickfont.setPixelSize(max(int(tickfont.pixelSize() * 2 // 3), 11))
axis = self.plot.getAxis("bottom")
axis.setTickFont(tickfont)
axis.setPen(pen)
axis.setLabel("P Rate")
axis = self.plot.getAxis("left")
axis.setTickFont(tickfont)
axis.setPen(pen)
axis.setLabel("TP Rate")
self.plot.showGrid(True, True, alpha=0.1)
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._inputs = OrderedDict()
self.__pending_selected_rows = self.selected_rows
self.selected_rows = None
self.__pending_selected_cols = self.selected_cols
self.selected_cols = None
self.dist_color = QColor(*self.dist_color_RGB)
info_box = gui.vBox(self.controlArea, "Info")
self.info_ex = gui.widgetLabel(info_box, 'No data on input.', )
self.info_ex.setWordWrap(True)
self.info_attr = gui.widgetLabel(info_box, ' ')
self.info_attr.setWordWrap(True)
self.info_class = gui.widgetLabel(info_box, ' ')
self.info_class.setWordWrap(True)
self.info_meta = gui.widgetLabel(info_box, ' ')
self.info_meta.setWordWrap(True)
info_box.setMinimumWidth(200)
gui.separator(self.controlArea)
box = gui.vBox(self.controlArea, "Variables")
self.c_show_attribute_labels = gui.checkBox(
box, self, "show_attribute_labels",
"Show variable labels (if present)",
callback=self._on_show_variable_labels_changed)
gui.checkBox(box, self, "show_distributions",
'Visualize numeric values',
callback=self._on_distribution_color_changed)
gui.checkBox(box, self, "color_by_class", 'Color by instance classes',
callback=self._on_distribution_color_changed)
box = gui.vBox(self.controlArea, "Selection")
gui.checkBox(box, self, "select_rows", "Select full rows",
callback=self._on_select_rows_changed)
gui.rubber(self.controlArea)
reset = gui.button(
None, self, "Restore Original Order", callback=self.restore_order,
tooltip="Show rows in the original order", autoDefault=False)
self.buttonsArea.layout().insertWidget(0, reset)
gui.auto_commit(self.buttonsArea, self, "auto_commit",
"Send Selected Rows", "Send Automatically")
# GUI with tabs
self.tabs = gui.tabWidget(self.mainArea)
self.tabs.currentChanged.connect(self._on_current_tab_changed)
def __init__(self):
hbox = gui.hBox(self.controlArea)
vbox = gui.vBox(hbox)
self.calendar = Calendar(self)
vbox.layout().addWidget(self.calendar)
vbox = gui.vBox(hbox)
EXPANDING = QSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.MinimumExpanding)
self.digital_clock = DigitalClock(self, sizePolicy=EXPANDING)
self.analog_clock = AnalogClock(self, sizePolicy=EXPANDING)
vbox.layout().addWidget(self.digital_clock, 1)
vbox.layout().addWidget(self.analog_clock, 4)
self.clear()
def _insert_control_area(self):
self.left_side = gui.vBox(self.splitter, spacing=0)
self.splitter.setSizes([1]) # Smallest size allowed by policy
if self.buttons_area_orientation is not None:
self.controlArea = gui.vBox(self.left_side, addSpace=0)
self._insert_buttons_area()
else:
self.controlArea = self.left_side
if self.want_main_area:
self.controlArea.setSizePolicy(
QSizePolicy.Fixed, QSizePolicy.MinimumExpanding)
m = 0
else:
m = 4
self.controlArea.layout().setContentsMargins(m, m, m, m)
def _init_layout(self):
"""Initialize widget layout."""
# Control area
info_box = gui.widgetBox(self.controlArea, "Info", addSpace=True)
self._info_label = gui.widgetLabel(info_box, "Initializing\n\n")
box = gui.vBox(self.controlArea, "Average intervals:")
self.ch_month = gui.checkBox(box, self, "include_month", "Month",
callback=self.commit_if)
self.ch_year = gui.checkBox(box, self, "include_year", 'Year',
callback=self.commit_if)
self.ch_decade = gui.checkBox(box, self, "include_decade", 'Decade',
callback=self.commit_if)
box = gui.vBox(self.controlArea, "Data Types")
gui.checkBox(box, self, "include_temperature", "Temperature",
callback=self.commit_if)
gui.checkBox(box, self, "include_precipitation", 'Precipitation',
callback=self.commit_if)
output_box = gui.widgetBox(self.controlArea, "Output", addSpace=True)
gui.radioButtonsInBox(output_box, self, "output_type",
["Countries", "Time Series"], "Rows",
callback=self.output_type_selected)
gui.checkBox(output_box, self, "use_country_names",
"Use Country names", callback=self.commit_if)
self.output_type = 0
# pylint: disable=duplicate-code
gui.separator(output_box)
gui.auto_commit(self.controlArea, self, "auto_commit", "Commit",
box="Commit")
gui.rubber(self.controlArea)
# Main area
box = gui.widgetBox(self.mainArea, "Countries")
self.country_tree = CountryTreeWidget(
self.mainArea,
self.country_selection,
commit_callback=self.commit_if,
default_colapse=True,
default_select=False,
)
self.country_tree.set_data(countries.get_countries_dict())
box.layout().addWidget(self.country_tree)
self.resize(500, 400) # why does this not work
def __init__(self):
super().__init__()
self.data = None # type: Optional[Table]
# Information panel
info_box = gui.vBox(self.controlArea, 'Info')
info_box.setMinimumWidth(200)
self.info_summary = gui.widgetLabel(info_box, wordWrap=True)
self.info_attr = gui.widgetLabel(info_box, wordWrap=True)
self.info_class = gui.widgetLabel(info_box, wordWrap=True)
self.info_meta = gui.widgetLabel(info_box, wordWrap=True)
self.set_info()
# TODO: Implement filtering on the model
# filter_box = gui.vBox(self.controlArea, 'Filter')
# self.filter_text = gui.lineEdit(
# filter_box, self, value='filter_string',
# placeholderText='Filter variables by name',
# callback=self._filter_table_variables, callbackOnType=True,
# )
# shortcut = QShortcut(QKeySequence('Ctrl+f'), self, self.filter_text.setFocus)
# shortcut.setWhatsThis('Filter variables by name')
self.color_var_model = DomainModel(
valid_types=(ContinuousVariable, DiscreteVariable),
placeholder='None',
)
box = gui.vBox(self.controlArea, 'Histogram')
self.cb_color_var = gui.comboBox(
box, master=self, value='color_var', model=self.color_var_model,
label='Color:', orientation=Qt.Horizontal,
)
self.cb_color_var.activated.connect(self.__color_var_changed)
gui.rubber(self.controlArea)
gui.auto_commit(
self.buttonsArea, self, 'auto_commit', 'Send Selected Rows',
'Send Automatically',
)
# Main area
self.model = FeatureStatisticsTableModel(parent=self)
self.table_view = FeatureStatisticsTableView(self.model, parent=self)
self.table_view.selectionModel().selectionChanged.connect(self.on_select)
self.table_view.horizontalHeader().sectionClicked.connect(self.on_header_click)
self.mainArea.layout().addWidget(self.table_view)
def __init__(self):
super().__init__()
self.data = None
self.discrete_data = None
self.subset_data = None
self.subset_indices = None
self.color_data = None
self.areas = []
self.canvas = QGraphicsScene()
self.canvas_view = ViewWithPress(
self.canvas, handler=self.clear_selection)
self.mainArea.layout().addWidget(self.canvas_view)
self.canvas_view.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.canvas_view.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.canvas_view.setRenderHint(QPainter.Antialiasing)
box = gui.vBox(self.controlArea, box=True)
self.model_1 = DomainModel(
order=DomainModel.MIXED, valid_types=DomainModel.PRIMITIVE)
self.model_234 = DomainModel(
order=DomainModel.MIXED, valid_types=DomainModel.PRIMITIVE,
placeholder="(None)")
self.attr_combos = [
gui.comboBox(
box, self, value="variable{}".format(i),
orientation=Qt.Horizontal, contentsLength=12,
callback=self.attr_changed,
model=self.model_1 if i == 1 else self.model_234)
for i in range(1, 5)]
self.vizrank, self.vizrank_button = MosaicVizRank.add_vizrank(
box, self, "Find Informative Mosaics", self.set_attr)
box2 = gui.vBox(self.controlArea, box="Interior Coloring")
self.color_model = DomainModel(
order=DomainModel.MIXED, valid_types=DomainModel.PRIMITIVE,
placeholder="(Pearson residuals)")
self.cb_attr_color = gui.comboBox(
box2, self, value="variable_color",
orientation=Qt.Horizontal, contentsLength=12, labelWidth=50,
callback=self.set_color_data, model=self.color_model)
self.bar_button = gui.checkBox(
box2, self, 'use_boxes', label='Compare with total',
callback=self.update_graph)
gui.rubber(self.controlArea)
def __init__(self):
super().__init__()
self.data = None
self.test_data = None
self.preprocessor = None
self.train_data_missing_vals = False
self.test_data_missing_vals = False
self.scorers = []
self.__pending_comparison_criterion = self.comparison_criterion
#: An Ordered dictionary with current inputs and their testing results.
self.learners = OrderedDict() # type: Dict[Any, Input]
self.__state = State.Waiting
# Do we need to [re]test any learners, set by _invalidate and
# cleared by __update
self.__needupdate = False
self.__task = None # type: Optional[TaskState]
self.__executor = ThreadExecutor()
sbox = gui.vBox(self.controlArea, "Sampling")
rbox = gui.radioButtons(sbox,
self,
"resampling",
callback=self._param_changed)
gui.appendRadioButton(rbox, "Cross validation")
ibox = gui.indentedBox(rbox)
gui.comboBox(ibox,
self,
"n_folds",
label="Number of folds: ",
items=[str(x) for x in self.NFolds],
maximumContentsLength=3,
orientation=Qt.Horizontal,
callback=self.kfold_changed)
gui.checkBox(ibox,
self,
"cv_stratified",
"Stratified",
callback=self.kfold_changed)
gui.appendRadioButton(rbox, "Cross validation by feature")
ibox = gui.indentedBox(rbox)
self.feature_model = DomainModel(order=DomainModel.METAS,
valid_types=DiscreteVariable)
self.features_combo = gui.comboBox(ibox,
self,
"fold_feature",
model=self.feature_model,
orientation=Qt.Horizontal,
callback=self.fold_feature_changed)
gui.appendRadioButton(rbox, "Random sampling")
ibox = gui.indentedBox(rbox)
gui.comboBox(ibox,
self,
"n_repeats",
label="Repeat train/test: ",
items=[str(x) for x in self.NRepeats],
maximumContentsLength=3,
orientation=Qt.Horizontal,
callback=self.shuffle_split_changed)
gui.comboBox(ibox,
self,
"sample_size",
label="Training set size: ",
items=["{} %".format(x) for x in self.SampleSizes],
maximumContentsLength=5,
orientation=Qt.Horizontal,
callback=self.shuffle_split_changed)
gui.checkBox(ibox,
self,
"shuffle_stratified",
"Stratified",
callback=self.shuffle_split_changed)
gui.appendRadioButton(rbox, "Leave one out")
gui.appendRadioButton(rbox, "Test on train data")
gui.appendRadioButton(rbox, "Test on test data")
self.cbox = gui.vBox(self.controlArea, "Target Class")
self.class_selection_combo = gui.comboBox(
self.cbox,
self,
"class_selection",
items=[],
sendSelectedValue=True,
callback=self._on_target_class_changed,
contentsLength=8)
self.modcompbox = box = gui.vBox(self.controlArea, "Model Comparison")
gui.comboBox(box,
self,
"comparison_criterion",
callback=self.update_comparison_table)
hbox = gui.hBox(box)
gui.checkBox(hbox,
self,
"use_rope",
"Negligible difference: ",
callback=self._on_use_rope_changed)
gui.lineEdit(hbox,
self,
"rope",
validator=QDoubleValidator(),
controlWidth=70,
callback=self.update_comparison_table,
alignment=Qt.AlignRight)
self.controls.rope.setEnabled(self.use_rope)
gui.rubber(self.controlArea)
self.score_table = ScoreTable(self)
self.score_table.shownScoresChanged.connect(self.update_stats_model)
view = self.score_table.view
view.setSizeAdjustPolicy(view.AdjustToContents)
box = gui.vBox(self.mainArea, "Evaluation Results")
box.layout().addWidget(self.score_table.view)
self.compbox = box = gui.vBox(self.mainArea, box="Model comparison")
table = self.comparison_table = QTableWidget(
wordWrap=False,
editTriggers=QTableWidget.NoEditTriggers,
selectionMode=QTableWidget.NoSelection)
table.setSizeAdjustPolicy(table.AdjustToContents)
header = table.verticalHeader()
header.setSectionResizeMode(QHeaderView.Fixed)
header.setSectionsClickable(False)
header = table.horizontalHeader()
header.setTextElideMode(Qt.ElideRight)
header.setDefaultAlignment(Qt.AlignCenter)
header.setSectionsClickable(False)
header.setStretchLastSection(False)
header.setSectionResizeMode(QHeaderView.ResizeToContents)
avg_width = self.fontMetrics().averageCharWidth()
header.setMinimumSectionSize(8 * avg_width)
header.setMaximumSectionSize(15 * avg_width)
header.setDefaultSectionSize(15 * avg_width)
box.layout().addWidget(table)
box.layout().addWidget(
QLabel(
"<small>Table shows probabilities that the score for the model in "
"the row is higher than that of the model in the column. "
"Small numbers show the probability that the difference is "
"negligible.</small>",
wordWrap=True))
def __init__(self):
super().__init__()
self.data = None # type: Optional[Orange.data.Table]
self.predictors = {} # type: Dict[object, PredictorSlot]
self.class_values = [] # type: List[str]
self._delegates = []
self.left_width = 10
self.selection_store = None
self.__pending_selection = self.selection
self._set_input_summary()
self._set_output_summary(None)
gui.listBox(self.controlArea,
self,
"selected_classes",
"class_values",
box="Show probabibilities for",
callback=self._update_prediction_delegate,
selectionMode=QListWidget.ExtendedSelection,
addSpace=False,
sizePolicy=(QSizePolicy.Preferred, QSizePolicy.Preferred))
gui.rubber(self.controlArea)
self.reset_button = gui.button(
self.controlArea,
self,
"Restore Original Order",
callback=self._reset_order,
tooltip="Show rows in the original order")
table_opts = dict(horizontalScrollBarPolicy=Qt.ScrollBarAlwaysOn,
horizontalScrollMode=QTableView.ScrollPerPixel,
selectionMode=QTableView.ExtendedSelection,
focusPolicy=Qt.StrongFocus)
self.dataview = TableView(sortingEnabled=True,
verticalScrollBarPolicy=Qt.ScrollBarAlwaysOn,
**table_opts)
self.predictionsview = TableView(
sortingEnabled=True,
verticalScrollBarPolicy=Qt.ScrollBarAlwaysOff,
**table_opts)
self.dataview.verticalHeader().hide()
dsbar = self.dataview.verticalScrollBar()
psbar = self.predictionsview.verticalScrollBar()
psbar.valueChanged.connect(dsbar.setValue)
dsbar.valueChanged.connect(psbar.setValue)
self.dataview.verticalHeader().setDefaultSectionSize(22)
self.predictionsview.verticalHeader().setDefaultSectionSize(22)
self.dataview.verticalHeader().sectionResized.connect(
lambda index, _, size: self.predictionsview.verticalHeader(
).resizeSection(index, size))
self.dataview.setItemDelegate(DataItemDelegate(self.dataview))
self.splitter = QSplitter(orientation=Qt.Horizontal,
childrenCollapsible=False,
handleWidth=2)
self.splitter.splitterMoved.connect(self.splitter_resized)
self.splitter.addWidget(self.predictionsview)
self.splitter.addWidget(self.dataview)
self.score_table = ScoreTable(self)
self.vsplitter = gui.vBox(self.mainArea)
self.vsplitter.layout().addWidget(self.splitter)
self.vsplitter.layout().addWidget(self.score_table.view)
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 set_sampling_type_i():
self.sampling_type = i
self.sampling_type_changed()
return set_sampling_type_i
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=self._MAX_SAMPLE_SIZE,
callback=set_sampling_type(
self.FixedSize),
controlWidth=90)
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):
super().__init__()
self.old_purge_classes = True
self.conditions = []
self.last_output_conditions = None
self.data = None
self.data_desc = self.match_desc = self.nonmatch_desc = None
self.variable_model = DomainModel([
list(self.AllTypes), DomainModel.Separator, DomainModel.CLASSES,
DomainModel.ATTRIBUTES, DomainModel.METAS
])
box = gui.vBox(self.controlArea, 'Conditions', stretch=100)
self.cond_list = QTableWidget(box,
showGrid=False,
selectionMode=QTableWidget.NoSelection)
box.layout().addWidget(self.cond_list)
self.cond_list.setColumnCount(4)
self.cond_list.setRowCount(0)
self.cond_list.verticalHeader().hide()
self.cond_list.horizontalHeader().hide()
for i in range(3):
self.cond_list.horizontalHeader().setSectionResizeMode(
i, QHeaderView.Stretch)
self.cond_list.horizontalHeader().resizeSection(3, 30)
self.cond_list.viewport().setBackgroundRole(QPalette.Window)
box2 = gui.hBox(box)
gui.rubber(box2)
self.add_button = gui.button(box2,
self,
"Add Condition",
callback=self.add_row)
self.add_all_button = gui.button(box2,
self,
"Add All Variables",
callback=self.add_all)
self.remove_all_button = gui.button(box2,
self,
"Remove All",
callback=self.remove_all)
gui.rubber(box2)
box_setting = gui.vBox(self.buttonsArea)
self.cb_pa = gui.checkBox(box_setting,
self,
"purge_attributes",
"Remove unused features",
callback=self.conditions_changed)
self.cb_pc = gui.checkBox(box_setting,
self,
"purge_classes",
"Remove unused classes",
callback=self.conditions_changed)
self.report_button.setFixedWidth(120)
gui.rubber(self.buttonsArea.layout())
gui.auto_send(self.buttonsArea, self, "auto_commit")
self.set_data(None)
self.resize(600, 400)
def __init__(self):
super().__init__()
self.matrix = None
self._tree = None
self._ordered_tree = None
self._sorted_matrix = None
self._sort_indices = None
self._selection = None
self.sorting_cb = gui.comboBox(self.controlArea,
self,
"sorting",
box="排序",
items=["无", "聚类", "使用有序叶子进行聚类"],
callback=self._invalidate_ordering)
box = gui.vBox(self.controlArea, "颜色")
self.colormap_cb = gui.comboBox(box,
self,
"colormap",
callback=self._update_color)
self.colormap_cb.setIconSize(QSize(64, 16))
self.palettes = list(_color_palettes)
init_color_combo(self.colormap_cb, self.palettes, QSize(64, 16))
self.colormap_cb.setCurrentIndex(self.colormap)
form = QFormLayout(formAlignment=Qt.AlignLeft,
labelAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QFormLayout.AllNonFixedFieldsGrow)
# form.addRow(
# "Gamma",
# gui.hSlider(box, self, "color_gamma", minValue=0.0, maxValue=1.0,
# step=0.05, ticks=True, intOnly=False,
# createLabel=False, callback=self._update_color)
# )
form.addRow(
"低:",
gui.hSlider(box,
self,
"color_low",
minValue=0.0,
maxValue=1.0,
step=0.05,
ticks=True,
intOnly=False,
createLabel=False,
callback=self._update_color))
form.addRow(
"高:",
gui.hSlider(box,
self,
"color_high",
minValue=0.0,
maxValue=1.0,
step=0.05,
ticks=True,
intOnly=False,
createLabel=False,
callback=self._update_color))
box.layout().addLayout(form)
self.annot_combo = gui.comboBox(self.controlArea,
self,
"annotation_idx",
box="注解",
callback=self._invalidate_annotations,
contentsLength=12)
self.annot_combo.setModel(itemmodels.VariableListModel())
self.annot_combo.model()[:] = ["无", "列举"]
self.controlArea.layout().addStretch()
gui.auto_commit(self.controlArea, self, "autocommit", "选中发送")
self.view = pg.GraphicsView(background="w")
self.mainArea.layout().addWidget(self.view)
self.grid_widget = pg.GraphicsWidget()
self.grid = QGraphicsGridLayout()
self.grid_widget.setLayout(self.grid)
self.viewbox = pg.ViewBox(enableMouse=False, enableMenu=False)
self.viewbox.setAcceptedMouseButtons(Qt.NoButton)
self.viewbox.setAcceptHoverEvents(False)
self.grid.addItem(self.viewbox, 1, 1)
self.left_dendrogram = DendrogramWidget(
self.grid_widget,
orientation=DendrogramWidget.Left,
selectionMode=DendrogramWidget.NoSelection,
hoverHighlightEnabled=False)
self.left_dendrogram.setAcceptedMouseButtons(Qt.NoButton)
self.left_dendrogram.setAcceptHoverEvents(False)
self.top_dendrogram = DendrogramWidget(
self.grid_widget,
orientation=DendrogramWidget.Top,
selectionMode=DendrogramWidget.NoSelection,
hoverHighlightEnabled=False)
self.top_dendrogram.setAcceptedMouseButtons(Qt.NoButton)
self.top_dendrogram.setAcceptHoverEvents(False)
self.grid.addItem(self.left_dendrogram, 1, 0)
self.grid.addItem(self.top_dendrogram, 0, 1)
self.right_labels = TextList(alignment=Qt.AlignLeft)
self.bottom_labels = TextList(orientation=Qt.Horizontal,
alignment=Qt.AlignRight)
self.grid.addItem(self.right_labels, 1, 2)
self.grid.addItem(self.bottom_labels, 2, 1)
self.view.setCentralItem(self.grid_widget)
self.left_dendrogram.hide()
self.top_dendrogram.hide()
self.right_labels.hide()
self.bottom_labels.hide()
self.matrix_item = None
self.dendrogram = None
self.grid_widget.scene().installEventFilter(self)
def __init__(self):
super().__init__()
self.data = None
self.test_data = None
self.preprocessor = None
self.train_data_missing_vals = False
self.test_data_missing_vals = False
self.scorers = []
#: An Ordered dictionary with current inputs and their testing results.
self.learners = OrderedDict() # type: Dict[Any, Input]
self.__state = State.Waiting
# Do we need to [re]test any learners, set by _invalidate and
# cleared by __update
self.__needupdate = False
self.__task = None # type: Optional[Task]
self.__executor = ThreadExecutor()
sbox = gui.vBox(self.controlArea, "Sampling")
rbox = gui.radioButtons(sbox,
self,
"resampling",
callback=self._param_changed)
gui.appendRadioButton(rbox, "Cross validation")
ibox = gui.indentedBox(rbox)
gui.comboBox(ibox,
self,
"n_folds",
label="Number of folds: ",
items=[str(x) for x in self.NFolds],
maximumContentsLength=3,
orientation=Qt.Horizontal,
callback=self.kfold_changed)
gui.checkBox(ibox,
self,
"cv_stratified",
"Stratified",
callback=self.kfold_changed)
gui.appendRadioButton(rbox, "Cross validation by feature")
ibox = gui.indentedBox(rbox)
self.feature_model = DomainModel(order=DomainModel.METAS,
valid_types=DiscreteVariable)
self.features_combo = gui.comboBox(ibox,
self,
"fold_feature",
model=self.feature_model,
orientation=Qt.Horizontal,
callback=self.fold_feature_changed)
gui.appendRadioButton(rbox, "Random sampling")
ibox = gui.indentedBox(rbox)
gui.comboBox(ibox,
self,
"n_repeats",
label="Repeat train/test: ",
items=[str(x) for x in self.NRepeats],
maximumContentsLength=3,
orientation=Qt.Horizontal,
callback=self.shuffle_split_changed)
gui.comboBox(ibox,
self,
"sample_size",
label="Training set size: ",
items=["{} %".format(x) for x in self.SampleSizes],
maximumContentsLength=5,
orientation=Qt.Horizontal,
callback=self.shuffle_split_changed)
gui.checkBox(ibox,
self,
"shuffle_stratified",
"Stratified",
callback=self.shuffle_split_changed)
gui.appendRadioButton(rbox, "Leave one out")
gui.appendRadioButton(rbox, "Test on train data")
gui.appendRadioButton(rbox, "Test on test data")
self.cbox = gui.vBox(self.controlArea, "Target Class")
self.class_selection_combo = gui.comboBox(
self.cbox,
self,
"class_selection",
items=[],
sendSelectedValue=True,
valueType=str,
callback=self._on_target_class_changed,
contentsLength=8)
gui.rubber(self.controlArea)
self.score_table = ScoreTable(self)
self.score_table.shownScoresChanged.connect(self.update_stats_model)
box = gui.vBox(self.mainArea, "Evaluation Results")
box.layout().addWidget(self.score_table.view)
def __init__(self):
super().__init__()
self.data = None
self.valid_data = self.valid_group_data = None
self.bar_items = []
self.curve_items = []
self.curve_descriptions = None
self.binnings = []
self.last_click_idx = None
self.drag_operation = self.DragNone
self.key_operation = None
self._user_var_bins = {}
gui.listView(self.controlArea,
self,
"var",
box="Variable",
model=DomainModel(valid_types=DomainModel.PRIMITIVE,
separators=False),
callback=self._on_var_changed)
box = self.continuous_box = gui.vBox(self.controlArea, "Distribution")
slider = gui.hSlider(box,
self,
"number_of_bins",
label="Bin width",
orientation=Qt.Horizontal,
minValue=0,
maxValue=max(1,
len(self.binnings) - 1),
createLabel=False,
callback=self._on_bins_changed)
self.bin_width_label = gui.widgetLabel(slider.box)
self.bin_width_label.setFixedWidth(35)
self.bin_width_label.setAlignment(Qt.AlignRight)
slider.sliderReleased.connect(self._on_bin_slider_released)
gui.comboBox(box,
self,
"fitted_distribution",
label="Fitted distribution",
orientation=Qt.Horizontal,
items=(name[0] for name in self.Fitters),
callback=self._on_fitted_dist_changed)
self.smoothing_box = gui.indentedBox(box, 40)
gui.hSlider(self.smoothing_box,
self,
"kde_smoothing",
label="Smoothing",
orientation=Qt.Horizontal,
minValue=2,
maxValue=20,
callback=self.replot)
gui.checkBox(box,
self,
"hide_bars",
"Hide bars",
stateWhenDisabled=False,
callback=self._on_hide_bars_changed,
disabled=not self.fitted_distribution)
box = gui.vBox(self.controlArea, "Columns")
gui.comboBox(box,
self,
"cvar",
label="Split by",
orientation=Qt.Horizontal,
model=DomainModel(
placeholder="(None)",
valid_types=(DiscreteVariable),
),
callback=self._on_cvar_changed,
contentsLength=18)
gui.checkBox(box,
self,
"stacked_columns",
"Stack columns",
callback=self.replot)
gui.checkBox(box,
self,
"show_probs",
"Show probabilities",
callback=self._on_show_probabilities_changed)
gui.checkBox(box,
self,
"cumulative_distr",
"Show cumulative distribution",
callback=self.replot)
gui.auto_apply(self.controlArea, self, commit=self.apply)
self._set_smoothing_visibility()
self._setup_plots()
self._setup_legend()
def _add_graph(self):
box = gui.vBox(self.mainArea, True, margin=0)
self.graph = self.GRAPH_CLASS(self, box)
box.layout().addWidget(self.graph.plot_widget)
self.graph.too_many_labels.connect(
lambda too_many: self.Warning.too_many_labels(shown=too_many))
def __init__(self):
super().__init__()
self.data = None
self.km = None
self.optimization_runs = []
box = gui.vBox(self.controlArea, "Number of Clusters")
layout = QGridLayout()
self.n_clusters = 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 from", 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)
self.apply_button = gui.auto_commit(
self.buttonsArea, self, "auto_run", "Apply", box=None,
commit=self.commit
)
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()
def __init__(self):
super().__init__()
for name in self.signal_names:
setattr(self, name, {})
for s in self.libraryListSource:
s.flags = 0
self._cachedDocuments = {}
self.infoBox = gui.vBox(self.controlArea, 'Info')
gui.label(
self.infoBox, self,
"<p>Execute python script.</p><p>Input variables:<ul><li> " +
"<li>".join(map("in_{0}, in_{0}s".format, self.signal_names)) +
"</ul></p><p>Output variables:<ul><li>" +
"<li>".join(map("out_{0}".format, self.signal_names)) +
"</ul></p>"
)
self.libraryList = itemmodels.PyListModel(
[], self,
flags=Qt.ItemIsSelectable | Qt.ItemIsEnabled | Qt.ItemIsEditable)
self.libraryList.wrap(self.libraryListSource)
self.controlBox = gui.vBox(self.controlArea, 'Library')
self.controlBox.layout().setSpacing(1)
self.libraryView = QListView(
editTriggers=QListView.DoubleClicked |
QListView.EditKeyPressed,
sizePolicy=QSizePolicy(QSizePolicy.Ignored,
QSizePolicy.Preferred)
)
self.libraryView.setItemDelegate(ScriptItemDelegate(self))
self.libraryView.setModel(self.libraryList)
self.libraryView.selectionModel().selectionChanged.connect(
self.onSelectedScriptChanged
)
self.controlBox.layout().addWidget(self.libraryView)
w = itemmodels.ModelActionsWidget()
self.addNewScriptAction = action = QAction("+", self)
action.setToolTip("Add a new script to the library")
action.triggered.connect(self.onAddScript)
w.addAction(action)
action = QAction(unicodedata.lookup("MINUS SIGN"), self)
action.setToolTip("Remove script from library")
action.triggered.connect(self.onRemoveScript)
w.addAction(action)
action = QAction("Update", self)
action.setToolTip("Save changes in the editor to library")
action.setShortcut(QKeySequence(QKeySequence.Save))
action.triggered.connect(self.commitChangesToLibrary)
w.addAction(action)
action = QAction("More", self, toolTip="More actions")
new_from_file = QAction("Import Script from File", self)
save_to_file = QAction("Save Selected Script to File", self)
save_to_file.setShortcut(QKeySequence(QKeySequence.SaveAs))
new_from_file.triggered.connect(self.onAddScriptFromFile)
save_to_file.triggered.connect(self.saveScript)
menu = QMenu(w)
menu.addAction(new_from_file)
menu.addAction(save_to_file)
action.setMenu(menu)
button = w.addAction(action)
button.setPopupMode(QToolButton.InstantPopup)
w.layout().setSpacing(1)
self.controlBox.layout().addWidget(w)
auto = gui.auto_commit(self.controlArea, self, "auto_execute", "Run",
checkbox_label="Autorun on new data")
self.execute_button, self.autobox = auto.button, auto.checkbox
self.splitCanvas = QSplitter(Qt.Vertical, self.mainArea)
self.mainArea.layout().addWidget(self.splitCanvas)
self.defaultFont = defaultFont = \
"Monaco" if sys.platform == "darwin" else "Courier"
self.textBox = gui.vBox(self, 'Python Script')
self.splitCanvas.addWidget(self.textBox)
self.text = PythonScriptEditor(self)
self.textBox.layout().addWidget(self.text)
self.textBox.setAlignment(Qt.AlignVCenter)
self.text.setTabStopWidth(4)
self.text.modificationChanged[bool].connect(self.onModificationChanged)
self.saveAction = action = QAction("&Save", self.text)
action.setToolTip("Save script to file")
action.setShortcut(QKeySequence(QKeySequence.Save))
action.setShortcutContext(Qt.WidgetWithChildrenShortcut)
action.triggered.connect(self.saveScript)
self.consoleBox = gui.vBox(self, 'Console')
self.splitCanvas.addWidget(self.consoleBox)
self.console = PythonConsole({}, self)
self.consoleBox.layout().addWidget(self.console)
self.console.document().setDefaultFont(QFont(defaultFont))
self.consoleBox.setAlignment(Qt.AlignBottom)
self.console.setTabStopWidth(4)
select_row(self.libraryView, self.currentScriptIndex)
self.splitCanvas.setSizes([2, 1])
if self.splitterState is not None:
self.splitCanvas.restoreState(QByteArray(self.splitterState))
self.splitCanvas.splitterMoved[int, int].connect(self.onSpliterMoved)
self.controlArea.layout().addStretch(1)
self.resize(800, 600)
def _init_ui(self):
namesBox = gui.vBox(self.controlArea, "Names")
hbox = gui.hBox(namesBox, margin=0, spacing=0)
gui.lineEdit(hbox,
self,
"attr1",
"Variable X: ",
controlWidth=80,
orientation=Qt.Horizontal,
enterPlaceholder=True,
callback=self._attr_name_changed)
gui.separator(hbox, 18)
hbox = gui.hBox(namesBox, margin=0, spacing=0)
attr2 = gui.lineEdit(hbox,
self,
"attr2",
"Variable Y: ",
controlWidth=80,
orientation=Qt.Horizontal,
enterPlaceholder=True,
callback=self._attr_name_changed)
gui.checkBox(hbox,
self,
"hasAttr2",
'',
disables=attr2,
labelWidth=0,
callback=self.set_dimensions)
gui.separator(namesBox)
gui.widgetLabel(namesBox, "Labels")
self.classValuesView = listView = QListView(
selectionMode=QListView.SingleSelection,
sizePolicy=QSizePolicy(QSizePolicy.Ignored, QSizePolicy.Maximum))
listView.setModel(self.class_model)
itemmodels.select_row(listView, 0)
namesBox.layout().addWidget(listView)
self.addClassLabel = QAction("+",
self,
toolTip="Add new class label",
triggered=self.add_new_class_label)
self.removeClassLabel = QAction(
unicodedata.lookup("MINUS SIGN"),
self,
toolTip="Remove selected class label",
triggered=self.remove_selected_class_label)
actionsWidget = itemmodels.ModelActionsWidget(
[self.addClassLabel, self.removeClassLabel], self)
actionsWidget.layout().addStretch(10)
actionsWidget.layout().setSpacing(1)
namesBox.layout().addWidget(actionsWidget)
tBox = gui.vBox(self.controlArea, "Tools", addSpace=True)
buttonBox = gui.hBox(tBox)
toolsBox = gui.widgetBox(buttonBox, orientation=QtGui.QGridLayout())
self.toolActions = QtGui.QActionGroup(self)
self.toolActions.setExclusive(True)
self.toolButtons = []
for i, (name, tooltip, tool, icon) in enumerate(self.TOOLS):
action = QAction(
name,
self,
toolTip=tooltip,
checkable=tool.checkable,
icon=QIcon(icon),
)
action.triggered.connect(partial(self.set_current_tool, tool))
button = QtGui.QToolButton(
iconSize=QSize(24, 24),
toolButtonStyle=Qt.ToolButtonTextUnderIcon,
sizePolicy=QSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.Fixed))
button.setDefaultAction(action)
self.toolButtons.append((button, tool))
toolsBox.layout().addWidget(button, i / 3, i % 3)
self.toolActions.addAction(action)
for column in range(3):
toolsBox.layout().setColumnMinimumWidth(column, 10)
toolsBox.layout().setColumnStretch(column, 1)
undo = self.undo_stack.createUndoAction(self)
redo = self.undo_stack.createRedoAction(self)
undo.setShortcut(QtGui.QKeySequence.Undo)
redo.setShortcut(QtGui.QKeySequence.Redo)
self.addActions([undo, redo])
self.undo_stack.indexChanged.connect(lambda _: self.invalidate())
gui.separator(tBox)
indBox = gui.indentedBox(tBox, sep=8)
form = QtGui.QFormLayout(
formAlignment=Qt.AlignLeft,
labelAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QtGui.QFormLayout.AllNonFixedFieldsGrow)
indBox.layout().addLayout(form)
slider = gui.hSlider(indBox,
self,
"brushRadius",
minValue=1,
maxValue=100,
createLabel=False)
form.addRow("Radius:", slider)
slider = gui.hSlider(indBox,
self,
"density",
None,
minValue=1,
maxValue=100,
createLabel=False)
form.addRow("Intensity:", slider)
self.btResetToInput = gui.button(tBox, self, "Reset to Input Data",
self.reset_to_input)
self.btResetToInput.setDisabled(True)
gui.rubber(self.controlArea)
gui.auto_commit(self.left_side, self, "autocommit", "Send")
# main area GUI
viewbox = PaintViewBox(enableMouse=False)
self.plotview = pg.PlotWidget(background="w", viewBox=viewbox)
self.plotview.sizeHint = lambda: QSize(
200, 100) # Minimum size for 1-d painting
self.plot = self.plotview.getPlotItem()
axis_color = self.palette().color(QtGui.QPalette.Text)
axis_pen = QtGui.QPen(axis_color)
tickfont = QtGui.QFont(self.font())
tickfont.setPixelSize(max(int(tickfont.pixelSize() * 2 // 3), 11))
axis = self.plot.getAxis("bottom")
axis.setLabel(self.attr1)
axis.setPen(axis_pen)
axis.setTickFont(tickfont)
axis = self.plot.getAxis("left")
axis.setLabel(self.attr2)
axis.setPen(axis_pen)
axis.setTickFont(tickfont)
if not self.hasAttr2:
self.plot.hideAxis('left')
self.plot.hideButtons()
self.plot.setXRange(0, 1, padding=0.01)
self.mainArea.layout().addWidget(self.plotview)
# enable brush tool
self.toolActions.actions()[0].setChecked(True)
self.set_current_tool(self.TOOLS[0][2])
self.set_dimensions()
def __init__(self):
super().__init__()
self.controlArea = QtGui.QWidget(self.controlArea)
self.layout().addWidget(self.controlArea)
layout = QtGui.QGridLayout()
self.controlArea.setLayout(layout)
layout.setContentsMargins(4, 4, 4, 4)
box = gui.vBox(self.controlArea,
"Available Variables",
addToLayout=False)
self.filter_edit = QtGui.QLineEdit()
self.filter_edit.setToolTip("Filter the list of available variables.")
box.layout().addWidget(self.filter_edit)
if hasattr(self.filter_edit, "setPlaceholderText"):
self.filter_edit.setPlaceholderText("Filter")
self.completer = QtGui.QCompleter()
self.completer.setCompletionMode(QtGui.QCompleter.InlineCompletion)
self.completer_model = QtGui.QStringListModel()
self.completer.setModel(self.completer_model)
self.completer.setModelSorting(
QtGui.QCompleter.CaseSensitivelySortedModel)
self.filter_edit.setCompleter(self.completer)
self.completer_navigator = CompleterNavigator(self)
self.filter_edit.installEventFilter(self.completer_navigator)
self.available_attrs = VariablesListItemModel()
self.available_attrs_proxy = VariableFilterProxyModel()
self.available_attrs_proxy.setSourceModel(self.available_attrs)
self.available_attrs_view = VariablesListItemView(
acceptedType=Orange.data.Variable)
self.available_attrs_view.setModel(self.available_attrs_proxy)
aa = self.available_attrs
aa.dataChanged.connect(self.update_completer_model)
aa.rowsInserted.connect(self.update_completer_model)
aa.rowsRemoved.connect(self.update_completer_model)
self.available_attrs_view.selectionModel().selectionChanged.connect(
partial(self.update_interface_state, self.available_attrs_view))
self.filter_edit.textChanged.connect(self.update_completer_prefix)
self.filter_edit.textChanged.connect(
self.available_attrs_proxy.set_filter_string)
box.layout().addWidget(self.available_attrs_view)
layout.addWidget(box, 0, 0, 3, 1)
box = gui.vBox(self.controlArea, "Features", addToLayout=False)
self.used_attrs = VariablesListItemModel()
self.used_attrs_view = VariablesListItemView(
acceptedType=(Orange.data.DiscreteVariable,
Orange.data.ContinuousVariable))
self.used_attrs_view.setModel(self.used_attrs)
self.used_attrs_view.selectionModel().selectionChanged.connect(
partial(self.update_interface_state, self.used_attrs_view))
box.layout().addWidget(self.used_attrs_view)
layout.addWidget(box, 0, 2, 1, 1)
box = gui.vBox(self.controlArea, "Target Variable", addToLayout=False)
self.class_attrs = ClassVarListItemModel()
self.class_attrs_view = ClassVariableItemView(
acceptedType=(Orange.data.DiscreteVariable,
Orange.data.ContinuousVariable))
self.class_attrs_view.setModel(self.class_attrs)
self.class_attrs_view.selectionModel().selectionChanged.connect(
partial(self.update_interface_state, self.class_attrs_view))
self.class_attrs_view.setMaximumHeight(24)
box.layout().addWidget(self.class_attrs_view)
layout.addWidget(box, 1, 2, 1, 1)
box = gui.vBox(self.controlArea, "Meta Attributes", addToLayout=False)
self.meta_attrs = VariablesListItemModel()
self.meta_attrs_view = VariablesListItemView(
acceptedType=Orange.data.Variable)
self.meta_attrs_view.setModel(self.meta_attrs)
self.meta_attrs_view.selectionModel().selectionChanged.connect(
partial(self.update_interface_state, self.meta_attrs_view))
box.layout().addWidget(self.meta_attrs_view)
layout.addWidget(box, 2, 2, 1, 1)
bbox = gui.vBox(self.controlArea, addToLayout=False, margin=0)
layout.addWidget(bbox, 0, 1, 1, 1)
self.up_attr_button = gui.button(bbox,
self,
"Up",
callback=partial(
self.move_up,
self.used_attrs_view))
self.move_attr_button = gui.button(bbox,
self,
">",
callback=partial(
self.move_selected,
self.used_attrs_view))
self.down_attr_button = gui.button(bbox,
self,
"Down",
callback=partial(
self.move_down,
self.used_attrs_view))
bbox = gui.vBox(self.controlArea, addToLayout=False, margin=0)
layout.addWidget(bbox, 1, 1, 1, 1)
self.move_class_button = gui.button(bbox,
self,
">",
callback=partial(
self.move_selected,
self.class_attrs_view,
exclusive=True))
bbox = gui.vBox(self.controlArea, addToLayout=False, margin=0)
layout.addWidget(bbox, 2, 1, 1, 1)
self.up_meta_button = gui.button(bbox,
self,
"Up",
callback=partial(
self.move_up,
self.meta_attrs_view))
self.move_meta_button = gui.button(bbox,
self,
">",
callback=partial(
self.move_selected,
self.meta_attrs_view))
self.down_meta_button = gui.button(bbox,
self,
"Down",
callback=partial(
self.move_down,
self.meta_attrs_view))
autobox = gui.auto_commit(None, self, "auto_commit", "Apply",
"Auto apply")
layout.addWidget(autobox, 3, 0, 1, 3)
reset = gui.button(None, self, "Reset", callback=self.reset)
autobox.layout().insertWidget(0, self.report_button)
autobox.layout().insertWidget(1, reset)
autobox.layout().insertSpacing(2, 40)
reset.setSizePolicy(QtGui.QSizePolicy.Expanding,
QtGui.QSizePolicy.Preferred)
self.report_button.setSizePolicy(QtGui.QSizePolicy.Expanding,
QtGui.QSizePolicy.Preferred)
layout.setRowStretch(0, 4)
layout.setRowStretch(1, 0)
layout.setRowStretch(2, 2)
layout.setHorizontalSpacing(0)
self.controlArea.setLayout(layout)
self.data = None
self.output_data = None
self.original_completer_items = []
self.resize(500, 600)
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.data = None
self._invalidated = False
# List of available preprocessors (DescriptionRole : Description)
self.preprocessors = QStandardItemModel()
def mimeData(indexlist):
assert len(indexlist) == 1
index = indexlist[0]
qname = index.data(DescriptionRole).qualname
m = QMimeData()
m.setData("application/x-qwidget-ref", qname.encode("utf-8"))
return m
# TODO: Fix this (subclass even if just to pass a function
# for mimeData delegate)
self.preprocessors.mimeData = mimeData
box = gui.vBox(self.controlArea, "Preprocessors")
self.preprocessorsView = view = QListView(
selectionMode=QListView.SingleSelection,
dragEnabled=True,
dragDropMode=QListView.DragOnly)
view.setModel(self.preprocessors)
view.activated.connect(self.__activated)
box.layout().addWidget(view)
####
self._qname2ppdef = {
ppdef.qualname: ppdef
for ppdef in self.PREPROCESSORS
}
# List of 'selected' preprocessors and their parameters.
self.preprocessormodel = None
self.flow_view = SequenceFlow()
self.controler = self.CONTROLLER(self.flow_view, parent=self)
self.overlay = OverlayWidget(self)
self.overlay.setAttribute(Qt.WA_TransparentForMouseEvents)
self.overlay.setWidget(self.flow_view)
self.overlay.setLayout(QVBoxLayout())
self.overlay.layout().addWidget(
QLabel("Drag items from the list on the left", wordWrap=True))
self.scroll_area = QScrollArea(
verticalScrollBarPolicy=Qt.ScrollBarAlwaysOn)
self.scroll_area.viewport().setAcceptDrops(True)
self.scroll_area.setWidget(self.flow_view)
self.scroll_area.setWidgetResizable(True)
self.mainArea.layout().addWidget(self.scroll_area)
self.flow_view.installEventFilter(self)
box = gui.vBox(self.controlArea, "Output")
gui.auto_send(box, self, "autocommit", box=False)
self.info.set_input_summary(self.info.NoInput)
self.info.set_output_summary(self.info.NoOutput)
self._initialize()
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.backend = None
self.data_desc_table = None
self.database_desc = None
vbox = gui.vBox(self.controlArea, "Server", addSpace=True)
box = gui.vBox(vbox)
self.backendmodel = BackendModel(Backend.available_backends())
self.backendcombo = QComboBox(box)
if len(self.backendmodel):
self.backendcombo.setModel(self.backendmodel)
else:
self.Error.no_backends()
box.setEnabled(False)
box.layout().addWidget(self.backendcombo)
self.servertext = QLineEdit(box)
self.servertext.setPlaceholderText('Server')
self.servertext.setToolTip('Server')
self.servertext.editingFinished.connect(self._load_credentials)
if self.host:
self.servertext.setText(self.host if not self.port else '{}:{}'.
format(self.host, self.port))
box.layout().addWidget(self.servertext)
self.databasetext = QLineEdit(box)
self.databasetext.setPlaceholderText('Database[/Schema]')
self.databasetext.setToolTip('Database or optionally Database/Schema')
if self.database:
self.databasetext.setText(
self.database if not self.schema else '{}/{}'.
format(self.database, self.schema))
box.layout().addWidget(self.databasetext)
self.usernametext = QLineEdit(box)
self.usernametext.setPlaceholderText('Username')
self.usernametext.setToolTip('Username')
box.layout().addWidget(self.usernametext)
self.passwordtext = QLineEdit(box)
self.passwordtext.setPlaceholderText('Password')
self.passwordtext.setToolTip('Password')
self.passwordtext.setEchoMode(QLineEdit.Password)
box.layout().addWidget(self.passwordtext)
self._load_credentials()
tables = gui.hBox(box)
self.tablemodel = TableModel()
self.tablecombo = QComboBox(
minimumContentsLength=35,
sizeAdjustPolicy=QComboBox.AdjustToMinimumContentsLength)
self.tablecombo.setModel(self.tablemodel)
self.tablecombo.setToolTip('table')
tables.layout().addWidget(self.tablecombo)
self.tablecombo.activated[int].connect(self.select_table)
self.connectbutton = gui.button(tables,
self,
'↻',
callback=self.connect)
self.connectbutton.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
tables.layout().addWidget(self.connectbutton)
self.custom_sql = gui.vBox(box)
self.custom_sql.setVisible(False)
self.sqltext = QTextEdit(self.custom_sql)
self.sqltext.setPlainText(self.sql)
self.custom_sql.layout().addWidget(self.sqltext)
mt = gui.hBox(self.custom_sql)
cb = gui.checkBox(mt, self, 'materialize', 'Materialize to table ')
cb.setToolTip('Save results of the query in a table')
le = gui.lineEdit(mt, self, 'materialize_table_name')
le.setToolTip('Save results of the query in a table')
self.executebtn = gui.button(self.custom_sql,
self,
'Execute',
callback=self.open_table)
box.layout().addWidget(self.custom_sql)
gui.checkBox(box,
self,
"guess_values",
"Auto-discover categorical variables",
callback=self.open_table)
gui.checkBox(box,
self,
"download",
"Download data to local memory",
callback=self.open_table)
gui.rubber(self.buttonsArea)
QTimer.singleShot(0, self.connect)
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=80,
alignment=Qt.AlignRight,
label="Number of trees: ",
callback=self.settings_changed)
self.max_features_spin = gui.spin(
box,
self,
"max_features",
2,
50,
controlWidth=80,
label="Number of attributes considered at each split: ",
callback=self.settings_changed,
checked="use_max_features",
checkCallback=self.settings_changed,
alignment=Qt.AlignRight,
)
self.random_state_spin = gui.spin(
box,
self,
"random_state",
0,
2**31 - 1,
controlWidth=80,
label="Fixed seed for random generator: ",
alignment=Qt.AlignRight,
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=80,
label="Limit depth of individual trees: ",
alignment=Qt.AlignRight,
callback=self.settings_changed,
checked="use_max_depth",
checkCallback=self.settings_changed)
self.min_samples_split_spin = gui.spin(
box,
self,
"min_samples_split",
2,
1000,
controlWidth=80,
label="Do not split subsets smaller than: ",
callback=self.settings_changed,
checked="use_min_samples_split",
checkCallback=self.settings_changed,
alignment=Qt.AlignRight)
def __init__(self):
super().__init__()
RecentPathsWComboMixin.__init__(self)
self.domain = None
self.data = None
self.loaded_file = ""
self.reader = None
layout = QGridLayout()
gui.widgetBox(self.controlArea, margin=0, orientation=layout)
vbox = gui.radioButtons(None, self, "source", box=True, addSpace=True,
callback=self.load_data, addToLayout=False)
rb_button = gui.appendRadioButton(vbox, "File:", addToLayout=False)
layout.addWidget(rb_button, 0, 0, Qt.AlignVCenter)
box = gui.hBox(None, addToLayout=False, margin=0)
box.setSizePolicy(Policy.MinimumExpanding, Policy.Fixed)
self.file_combo.setSizePolicy(Policy.MinimumExpanding, Policy.Fixed)
self.file_combo.activated[int].connect(self.select_file)
box.layout().addWidget(self.file_combo)
layout.addWidget(box, 0, 1)
file_button = gui.button(
None, self, '...', callback=self.browse_file, autoDefault=False)
file_button.setIcon(self.style().standardIcon(QStyle.SP_DirOpenIcon))
file_button.setSizePolicy(Policy.Maximum, Policy.Fixed)
layout.addWidget(file_button, 0, 2)
reload_button = gui.button(
None, self, "Reload", callback=self.load_data, autoDefault=False)
reload_button.setIcon(self.style().standardIcon(
QStyle.SP_BrowserReload))
reload_button.setSizePolicy(Policy.Fixed, Policy.Fixed)
layout.addWidget(reload_button, 0, 3)
self.sheet_box = gui.hBox(None, addToLayout=False, margin=0)
self.sheet_combo = gui.comboBox(None, self, "xls_sheet",
callback=self.select_sheet,
sendSelectedValue=True,)
self.sheet_combo.setSizePolicy(
Policy.MinimumExpanding, Policy.Fixed)
self.sheet_label = QLabel()
self.sheet_label.setText('Sheet')
self.sheet_label.setSizePolicy(
Policy.MinimumExpanding, Policy.Fixed)
self.sheet_box.layout().addWidget(
self.sheet_label, Qt.AlignLeft)
self.sheet_box.layout().addWidget(
self.sheet_combo, Qt.AlignVCenter)
layout.addWidget(self.sheet_box, 2, 1)
self.sheet_box.hide()
rb_button = gui.appendRadioButton(vbox, "URL:", addToLayout=False)
layout.addWidget(rb_button, 3, 0, Qt.AlignVCenter)
self.url_combo = url_combo = QComboBox()
url_model = NamedURLModel(self.sheet_names)
url_model.wrap(self.recent_urls)
url_combo.setLineEdit(LineEditSelectOnFocus())
url_combo.setModel(url_model)
url_combo.setSizePolicy(Policy.MinimumExpanding, Policy.Fixed)
url_combo.setEditable(True)
url_combo.setInsertPolicy(url_combo.InsertAtTop)
url_edit = url_combo.lineEdit()
l, t, r, b = url_edit.getTextMargins()
url_edit.setTextMargins(l + 5, t, r, b)
layout.addWidget(url_combo, 3, 1, 3, 3)
url_combo.activated.connect(self._url_set)
box = gui.vBox(self.controlArea, "Info")
self.info = gui.widgetLabel(box, 'No data loaded.')
self.warnings = gui.widgetLabel(box, '')
box = gui.widgetBox(self.controlArea, "Columns (Double click to edit)")
self.domain_editor = DomainEditor(self)
self.editor_model = self.domain_editor.model()
box.layout().addWidget(self.domain_editor)
box = gui.hBox(self.controlArea)
gui.button(
box, self, "Browse documentation datasets",
callback=lambda: self.browse_file(True), autoDefault=False)
gui.rubber(box)
self.apply_button = gui.button(
box, self, "Apply", callback=self.apply_domain_edit)
self.apply_button.setEnabled(False)
self.apply_button.setFixedWidth(170)
self.editor_model.dataChanged.connect(
lambda: self.apply_button.setEnabled(True))
self.set_file_list()
# Must not call open_file from within __init__. open_file
# explicitly re-enters the event loop (by a progress bar)
self.setAcceptDrops(True)
if self.source == self.LOCAL_FILE:
last_path = self.last_path()
if last_path and os.path.exists(last_path) and \
os.path.getsize(last_path) > self.SIZE_LIMIT:
self.Warning.file_too_big()
return
QTimer.singleShot(0, self.load_data)
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):
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.data = None
self.discrete_data = None
self.subset_data = None
self.subset_indices = None
self.__pending_selection = self.selection
self.selection = set()
self.color_data = None
self.areas = []
self.canvas = QGraphicsScene(self)
self.canvas_view = ViewWithPress(self.canvas,
handler=self.clear_selection)
self.mainArea.layout().addWidget(self.canvas_view)
self.canvas_view.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.canvas_view.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.canvas_view.setRenderHint(QPainter.Antialiasing)
box = gui.vBox(self.controlArea, box=True)
self.model_1 = DomainModel(order=DomainModel.MIXED,
valid_types=DomainModel.PRIMITIVE)
self.model_234 = DomainModel(order=DomainModel.MIXED,
valid_types=DomainModel.PRIMITIVE,
placeholder="(None)")
self.attr_combos = [
gui.comboBox(box,
self,
value="variable{}".format(i),
orientation=Qt.Horizontal,
contentsLength=12,
searchable=True,
callback=self.attr_changed,
model=self.model_1 if i == 1 else self.model_234)
for i in range(1, 5)
]
self.vizrank, self.vizrank_button = MosaicVizRank.add_vizrank(
box, self, "Find Informative Mosaics", self.set_attr)
box2 = gui.vBox(self.controlArea, box="Interior Coloring")
self.color_model = DomainModel(order=DomainModel.MIXED,
valid_types=DomainModel.PRIMITIVE,
placeholder="(Pearson residuals)")
self.cb_attr_color = gui.comboBox(box2,
self,
value="variable_color",
orientation=Qt.Horizontal,
contentsLength=12,
labelWidth=50,
searchable=True,
callback=self.set_color_data,
model=self.color_model)
self.bar_button = gui.checkBox(box2,
self,
'use_boxes',
label='Compare with total',
callback=self.update_graph)
gui.rubber(self.controlArea)
def __init__(self):
super().__init__()
self.data = None
# The following lists are of the same length as self.active_rules
#: list of pairs with counts of matches for each patter when the
# patterns are applied in order and when applied on the entire set,
# disregarding the preceding patterns
self.match_counts = []
#: list of list of QLineEdit: line edit pairs for each pattern
self.line_edits = []
#: list of QPushButton: list of remove buttons
self.remove_buttons = []
#: list of list of QLabel: pairs of labels with counts
self.counts = []
combo = gui.comboBox(
self.controlArea, self, "attribute", label="From column: ",
box=True, orientation=Qt.Horizontal, searchable=True,
callback=self.update_rules,
model=DomainModel(valid_types=(StringVariable, DiscreteVariable)))
# Don't use setSizePolicy keyword argument here: it applies to box,
# not the combo
combo.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Fixed)
patternbox = gui.vBox(self.controlArea, box=True)
#: QWidget: the box that contains the remove buttons, line edits and
# count labels. The lines are added and removed dynamically.
self.rules_box = rules_box = QGridLayout()
patternbox.layout().addLayout(self.rules_box)
box = gui.hBox(patternbox)
gui.button(
box, self, "+", callback=self.add_row, autoDefault=False, flat=True,
minimumSize=(QSize(20, 20)))
gui.rubber(box)
self.rules_box.setColumnMinimumWidth(1, 70)
self.rules_box.setColumnMinimumWidth(0, 10)
self.rules_box.setColumnStretch(0, 1)
self.rules_box.setColumnStretch(1, 1)
self.rules_box.setColumnStretch(2, 100)
rules_box.addWidget(QLabel("Name"), 0, 1)
rules_box.addWidget(QLabel("Substring"), 0, 2)
rules_box.addWidget(QLabel("#Instances"), 0, 3, 1, 2)
self.update_rules()
gui.lineEdit(
self.controlArea, self, "class_name",
label="Name for the new class:",
box=True, orientation=Qt.Horizontal)
optionsbox = gui.vBox(self.controlArea, box=True)
gui.checkBox(
optionsbox, self, "match_beginning", "Match only at the beginning",
callback=self.options_changed)
gui.checkBox(
optionsbox, self, "case_sensitive", "Case sensitive",
callback=self.options_changed)
box = gui.hBox(self.controlArea)
gui.rubber(box)
gui.button(box, self, "Apply", autoDefault=False, width=180,
callback=self.apply)
self.info.set_input_summary(self.info.NoInput)
self.info.set_output_summary(self.info.NoOutput)
# TODO: Resizing upon changing the number of rules does not work
self.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Maximum)
def __init__(self):
super().__init__()
self.__pending_selection = self.selection
self._optimizer = None
self._optimizer_thread = None
self.stop_optimization = False
self.data = self.cont_x = None
self.cells = self.member_data = None
self.selection = None
self.colors = self.thresholds = self.bin_labels = None
box = gui.vBox(self.controlArea, box="SOM")
shape = gui.comboBox(box,
self,
"",
items=("Hexagonal grid", "Square grid"))
shape.setCurrentIndex(1 - self.hexagonal)
box2 = gui.indentedBox(box, 10)
auto_dim = gui.checkBox(box2,
self,
"auto_dimension",
"Set dimensions automatically",
callback=self.on_auto_dimension_changed)
self.manual_box = box3 = gui.hBox(box2)
spinargs = dict(value="",
widget=box3,
master=self,
minv=5,
maxv=100,
step=5,
alignment=Qt.AlignRight)
spin_x = gui.spin(**spinargs)
spin_x.setValue(self.size_x)
gui.widgetLabel(box3, "×")
spin_y = gui.spin(**spinargs)
spin_y.setValue(self.size_y)
gui.rubber(box3)
self.manual_box.setEnabled(not self.auto_dimension)
initialization = gui.comboBox(box,
self,
"initialization",
items=("Initialize with PCA",
"Random initialization",
"Replicable random"))
start = gui.button(box,
self,
"Restart",
callback=self.restart_som_pressed,
sizePolicy=(QSizePolicy.MinimumExpanding,
QSizePolicy.Fixed))
self.opt_controls = self.OptControls(shape, auto_dim, spin_x, spin_y,
initialization, start)
box = gui.vBox(self.controlArea, "Color")
gui.comboBox(box,
self,
"attr_color",
maximumContentsLength=15,
callback=self.on_attr_color_change,
model=DomainModel(placeholder="(Same color)",
valid_types=DomainModel.PRIMITIVE))
gui.checkBox(box,
self,
"pie_charts",
label="Show pie charts",
callback=self.on_pie_chart_change)
gui.checkBox(box,
self,
"size_by_instances",
label="Size by number of instances",
callback=self.on_attr_size_change)
gui.rubber(self.controlArea)
self.scene = QGraphicsScene(self)
self.view = SomView(self.scene)
self.view.setMinimumWidth(400)
self.view.setMinimumHeight(400)
self.view.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.view.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.view.setRenderHint(QPainter.Antialiasing)
self.view.selection_changed.connect(self.on_selection_change)
self.view.selection_moved.connect(self.on_selection_move)
self.view.selection_mark_changed.connect(self.on_selection_mark_change)
self.mainArea.layout().addWidget(self.view)
self.elements = None
self.grid = None
self.grid_cells = None
self.legend = None
def __init__(self):
super().__init__()
self.results = None
self.classifier_names = []
self.colors = []
self._curve_data = {}
box = gui.vBox(self.controlArea, "Plot")
tbox = gui.vBox(box, "Target Class")
tbox.setFlat(True)
self.target_cb = gui.comboBox(tbox,
self,
"target_index",
callback=self._on_target_changed,
contentsLength=8,
searchable=True)
cbox = gui.vBox(box, "Classifiers")
cbox.setFlat(True)
self.classifiers_list_box = gui.listBox(
cbox,
self,
"selected_classifiers",
"classifier_names",
selectionMode=QListView.MultiSelection,
callback=self._on_classifiers_changed)
gui.checkBox(box,
self,
"display_convex_hull",
"Show lift convex hull",
callback=self._replot)
self.plotview = pg.GraphicsView(background="w")
self.plotview.setFrameStyle(QFrame.StyledPanel)
self.plot = pg.PlotItem(enableMenu=False)
self.plot.setMouseEnabled(False, False)
self.plot.hideButtons()
pen = QPen(self.palette().color(QPalette.Text))
tickfont = QFont(self.font())
tickfont.setPixelSize(max(int(tickfont.pixelSize() * 2 // 3), 11))
axis = self.plot.getAxis("bottom")
axis.setTickFont(tickfont)
axis.setPen(pen)
axis.setLabel("P Rate")
axis = self.plot.getAxis("left")
axis.setTickFont(tickfont)
axis.setPen(pen)
axis.setLabel("TP Rate")
self.plot.showGrid(True, True, alpha=0.1)
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.distributions = None
self.contingencies = None
self.var = self.cvar = None
varbox = gui.vBox(self.controlArea, "Variable")
self.varmodel = itemmodels.VariableListModel()
self.groupvarmodel = []
self.varview = QListView(
selectionMode=QListView.SingleSelection)
self.varview.setSizePolicy(
QSizePolicy.Minimum, QSizePolicy.Expanding)
self.varview.setModel(self.varmodel)
self.varview.setSelectionModel(
itemmodels.ListSingleSelectionModel(self.varmodel))
self.varview.selectionModel().selectionChanged.connect(
self._on_variable_idx_changed)
varbox.layout().addWidget(self.varview)
box = gui.vBox(self.controlArea, "Precision")
gui.separator(self.controlArea, 4, 4)
box2 = gui.hBox(box)
self.l_smoothing_l = gui.widgetLabel(box2, "Smooth")
gui.hSlider(box2, self, "smoothing_index",
minValue=0, maxValue=len(self.smoothing_facs) - 1,
callback=self._on_set_smoothing, createLabel=False)
self.l_smoothing_r = gui.widgetLabel(box2, "Precise")
self.cb_disc_cont = gui.checkBox(
gui.indentedBox(box, sep=4),
self, "disc_cont", "Bin continuous variables",
callback=self._on_groupvar_idx_changed,
tooltip="Show continuous variables as discrete.")
box = gui.vBox(self.controlArea, "Group by")
self.icons = gui.attributeIconDict
self.groupvarview = gui.comboBox(box, self, "groupvar_idx",
callback=self._on_groupvar_idx_changed, valueType=str,
contentsLength=12)
box2 = gui.indentedBox(box, sep=4)
self.cb_rel_freq = gui.checkBox(
box2, self, "relative_freq", "Show relative frequencies",
callback=self._on_relative_freq_changed,
tooltip="Normalize probabilities so that probabilities for each group-by value sum to 1.")
gui.separator(box2)
self.cb_prob = gui.comboBox(
box2, self, "show_prob", label="Show probabilities:",
orientation=Qt.Horizontal,
callback=self._on_relative_freq_changed,
tooltip="Show probabilities for a chosen group-by value (at each point probabilities for all group-by values sum to 1).")
self.plotview = pg.PlotWidget(background=None)
self.plotview.setRenderHint(QPainter.Antialiasing)
self.mainArea.layout().addWidget(self.plotview)
w = QLabel()
w.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
self.mainArea.layout().addWidget(w, Qt.AlignCenter)
self.ploti = pg.PlotItem()
self.plot = self.ploti.vb
self.ploti.hideButtons()
self.plotview.setCentralItem(self.ploti)
self.plot_prob = pg.ViewBox()
self.ploti.hideAxis('right')
self.ploti.scene().addItem(self.plot_prob)
self.ploti.getAxis("right").linkToView(self.plot_prob)
self.ploti.getAxis("right").setLabel("Probability")
self.plot_prob.setZValue(10)
self.plot_prob.setXLink(self.ploti)
self.update_views()
self.ploti.vb.sigResized.connect(self.update_views)
self.plot_prob.setRange(yRange=[0,1])
def disable_mouse(plot):
plot.setMouseEnabled(False, False)
plot.setMenuEnabled(False)
disable_mouse(self.plot)
disable_mouse(self.plot_prob)
self.tooltip_items = []
self.plot.scene().installEventFilter(
HelpEventDelegate(self.help_event, self))
pen = QPen(self.palette().color(QPalette.Text))
for axis in ("left", "bottom"):
self.ploti.getAxis(axis).setPen(pen)
self._legend = LegendItem()
self._legend.setParentItem(self.plot)
self._legend.hide()
self._legend.anchor((1, 0), (1, 0))
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("%")
b = gui.vBox(box)
gui.checkBox(b,
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.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")
tbox = gui.vBox(box, "Target Class")
tbox.setFlat(True)
self.target_cb = gui.comboBox(tbox,
self,
"target_index",
callback=self._on_target_changed,
contentsLength=8)
cbox = gui.vBox(box, "Classifiers")
cbox.setFlat(True)
self.classifiers_list_box = gui.listBox(
cbox,
self,
"selected_classifiers",
"classifier_names",
selectionMode=QListView.MultiSelection,
callback=self._on_classifiers_changed)
abox = gui.vBox(box, "Combine ROC Curves From Folds")
abox.setFlat(True)
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)
hbox = gui.vBox(box, "ROC Convex Hull")
hbox.setFlat(True)
gui.checkBox(hbox,
self,
"display_convex_curve",
"Show convex ROC curves",
callback=self._replot)
gui.checkBox(hbox,
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,
callback=self._on_target_prior_changed)
self.target_prior_sp.setSuffix(" %")
self.target_prior_sp.addAction(QAction("Auto", sp))
grid.addWidget(QLabel("Prior target class probability:"))
grid.addWidget(self.target_prior_sp, 2, 1)
self.plotview = pg.GraphicsView(background="w")
self.plotview.setFrameStyle(QFrame.StyledPanel)
self.plotview.scene().sigMouseMoved.connect(self._on_mouse_moved)
self.plot = pg.PlotItem(enableMenu=False)
self.plot.setMouseEnabled(False, False)
self.plot.hideButtons()
pen = QPen(self.palette().color(QPalette.Text))
tickfont = QFont(self.font())
tickfont.setPixelSize(max(int(tickfont.pixelSize() * 2 // 3), 11))
axis = self.plot.getAxis("bottom")
axis.setTickFont(tickfont)
axis.setPen(pen)
axis.setLabel("FP Rate (1-Specificity)")
axis = self.plot.getAxis("left")
axis.setTickFont(tickfont)
axis.setPen(pen)
axis.setLabel("TP Rate (Sensitivity)")
self.plot.showGrid(True, True, alpha=0.1)
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__()
#: input data
self.data = None
#: Current variable discretization state
self.var_state = {}
#: Saved variable discretization settings (context setting)
self.saved_var_states = {}
self.method = 0
self.k = 5
box = gui.vBox(self.controlArea, self.tr("Default Discretization"))
self.default_bbox = rbox = gui.radioButtons(
box, self, "default_method", callback=self._default_disc_changed)
options = self.options = [
self.tr("Default"),
self.tr("Leave numeric"),
self.tr("Entropy-MDL discretization"),
self.tr("Equal-frequency discretization"),
self.tr("Equal-width discretization"),
self.tr("Remove numeric variables")
]
for opt in options[1:5]:
gui.appendRadioButton(rbox, opt)
s = gui.hSlider(gui.indentedBox(rbox),
self,
"default_k",
minValue=2,
maxValue=10,
label="Num. of intervals:",
callback=self._default_disc_changed)
s.setTracking(False)
gui.appendRadioButton(rbox, options[-1])
vlayout = QHBoxLayout()
box = gui.widgetBox(self.controlArea,
"Individual Attribute Settings",
orientation=vlayout,
spacing=8)
# List view with all attributes
self.varview = QListView(selectionMode=QListView.ExtendedSelection)
self.varview.setItemDelegate(DiscDelegate())
self.varmodel = itemmodels.VariableListModel()
self.varview.setModel(self.varmodel)
self.varview.selectionModel().selectionChanged.connect(
self._var_selection_changed)
vlayout.addWidget(self.varview)
# Controls for individual attr settings
self.bbox = controlbox = gui.radioButtons(
box, self, "method", callback=self._disc_method_changed)
vlayout.addWidget(controlbox)
for opt in options[:5]:
gui.appendRadioButton(controlbox, opt)
s = gui.hSlider(gui.indentedBox(controlbox),
self,
"k",
minValue=2,
maxValue=10,
label="Num. of intervals:",
callback=self._disc_method_changed)
s.setTracking(False)
gui.appendRadioButton(controlbox, "Remove attribute")
gui.rubber(controlbox)
controlbox.setEnabled(False)
self.controlbox = controlbox
box = gui.auto_commit(self.controlArea,
self,
"autosend",
"Apply",
orientation=Qt.Horizontal,
checkbox_label="Send data after every change")
box.layout().insertSpacing(0, 20)
box.layout().insertWidget(0, self.report_button)
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 _add_graph(self):
box = gui.vBox(self.mainArea, True, margin=0)
self.graph = LinePlotGraph(self)
box.layout().addWidget(self.graph)