def __init__(self):
super().__init__()
self.data = None
self.preprocessors = None
box = gui.widgetBox(self.controlArea, "Learner/Predictor Name")
gui.lineEdit(box, self, "learner_name")
box = gui.widgetBox(self.controlArea, "Regularization")
box = gui.radioButtons(
box, self, "reg_type",
btnLabels=["No regularization", "Ridge regression",
"Lasso regression"],
callback=self._reg_type_changed)
gui.separator(box)
self.alpha_box = box2 = gui.widgetBox(box, margin=0)
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.widgetBox(box, orientation="horizontal")
box3.layout().setAlignment(Qt.AlignCenter)
self.alpha_label = gui.widgetLabel(box3, "")
self._set_alpha_label()
gui.auto_commit(self.controlArea, self, "autosend", "Apply",
checkbox_label="Apply on every change")
self.layout().setSizeConstraint(QLayout.SetFixedSize)
self.alpha_slider.setEnabled(self.reg_type != self.OLS)
self.commit()
def __init__(self, parent=None, signalManager=None, settings=None,
data=None, file_formats=None):
super().__init__(self, parent, signalManager, settings, "Save")
self.data = None
self.filename = ""
self.format_index = 0
self.file_formats = FileFormats.writers
if file_formats:
self.file_formats = file_formats
self.formats = tuple((FileFormats.names[ext], ext)
for ext in self.file_formats)
self.comboBoxFormat = gui.comboBox(
self.controlArea, self, value='format_index',
items=['{} (*{})'.format(*x) for x in self.formats],
box='File Format', callback=self.reset_filename)
box = gui.widgetBox(self.controlArea)
self.save = gui.button(box, self, "Save", callback=self.save_file,
default=True, disabled=True)
gui.separator(box)
self.saveAs = gui.button(box, self, "Save as ...",
callback=self.save_file_as, disabled=True)
self.setMinimumWidth(320)
self.adjustSize()
if data:
self.dataset(data)
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 __init__(self):
super().__init__()
# sets self.curvePoints, self.steps equidistant points from
# 1/self.steps to 1
self.updateCurvePoints()
# [start-snippet-2]
self.scoring = [
("Classification Accuracy", Orange.evaluation.scoring.CA),
("AUC", Orange.evaluation.scoring.AUC),
("Precision", Orange.evaluation.scoring.Precision),
("Recall", Orange.evaluation.scoring.Recall)
]
# [end-snippet-2]
#: input data on which to construct the learning curve
self.data = None
#: A {input_id: Learner} mapping of current learners from input channel
self.learners = OrderedDict()
#: A {input_id: List[Results]} mapping of input id to evaluation
#: results list, one for each curve point
self.results = OrderedDict()
#: A {input_id: List[float]} mapping of input id to learning curve
#: point scores
self.curves = OrderedDict()
# GUI
box = gui.widgetBox(self.controlArea, "Info")
self.infoa = gui.widgetLabel(box, 'No data on input.')
self.infob = gui.widgetLabel(box, 'No learners.')
gui.separator(self.controlArea)
box = gui.widgetBox(self.controlArea, "Evaluation Scores")
gui.comboBox(box, self, "scoringF",
items=[x[0] for x in self.scoring],
callback=self._invalidate_curves)
gui.separator(self.controlArea)
box = gui.widgetBox(self.controlArea, "Options")
gui.spin(box, self, 'folds', 2, 100, step=1,
label='Cross validation folds: ', keyboardTracking=False,
callback=lambda:
self._invalidate_results() if self.commitOnChange else None
)
gui.spin(box, self, 'steps', 2, 100, step=1,
label='Learning curve points: ', keyboardTracking=False,
callback=[self.updateCurvePoints,
lambda: self._invalidate_results() if self.commitOnChange else None])
gui.checkBox(box, self, 'commitOnChange', 'Apply setting on any change')
self.commitBtn = gui.button(box, self, "Apply Setting",
callback=self._invalidate_results,
disabled=True)
gui.rubber(self.controlArea)
# table widget
self.table = gui.table(self.mainArea,
selectionMode=QTableWidget.NoSelection)
def add_main_layout(self):
box = gui.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
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 __init__(self):
super().__init__()
self.data = None
self.learner = None
self.preprocessors = None
self.model = None
gui.lineEdit(self.controlArea, self, 'model_name', box='Name',
tooltip='The name will identify this model in other '
'widgets')
gui.comboBox(self.controlArea, self, "attribute_score",
box='Feature selection',
items=[name for name, _ in self.scores])
box = gui.widgetBox(self.controlArea, 'Pruning')
gui.spin(box, self, "min_leaf", 1, 1000,
label="Min. instances in leaves ", checked="limit_min_leaf")
gui.spin(box, self, "min_internal", 1, 1000,
label="Stop splitting nodes with less instances than ",
checked="limit_min_internal")
gui.spin(box, self, "max_depth", 1, 1000,
label="Limit the depth to ", checked="limit_depth")
box = gui.widgetBox(self.controlArea, True, orientation="horizontal")
box.layout().addWidget(self.report_button)
gui.separator(box, 20)
self.btn_apply = gui.button(box, self, "&Apply",
callback=self.apply, disabled=0,
default=True)
self.apply()
def _add_controls_start_box(self):
box = gui.vBox(self.controlArea, True)
form = QFormLayout(
labelAlignment=Qt.AlignLeft,
formAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QFormLayout.AllNonFixedFieldsGrow,
verticalSpacing=10
)
form.addRow(
"Max iterations:",
gui.spin(box, self, "max_iter", 1, 2000, step=50))
form.addRow(
"Perplexity:",
gui.spin(box, self, "perplexity", 1, 100, step=1))
box.layout().addLayout(form)
gui.separator(box, 10)
self.runbutton = gui.button(box, self, "Run", callback=self._toggle_run)
gui.separator(box, 10)
gui.hSlider(box, self, "pca_components", label="PCA components:",
minValue=2, maxValue=50, step=1)
def __init__(self):
super().__init__()
# options box
self.options_box = gui.widgetBox(self.controlArea, "Data")
opts = dict(
widget=self.options_box, master=self, orientation=Qt.Horizontal,
callback=self.restart, sendSelectedValue=True,
maximumContentsLength=15)
self.cbx = gui.comboBox(value='attr_x', label='X: ', **opts)
self.cby = gui.comboBox(value='attr_y', label='Y: ', **opts)
self.centroids_box = gui.widgetBox(self.controlArea, "Centroids")
self.centroid_numbers_spinner = gui.spin(
self.centroids_box, self, 'number_of_clusters',
minv=1, maxv=10, step=1, label='Number of centroids:',
alignment=Qt.AlignRight, callback=self.number_of_clusters_change)
self.restart_button = gui.button(
self.centroids_box, self, "Randomize Positions",
callback=self.restart)
gui.separator(self.centroids_box)
self.lines_checkbox = gui.checkBox(
self.centroids_box, self, 'lines_to_centroids',
'Show membership lines', callback=self.complete_replot)
# control box
gui.separator(self.controlArea, 20, 20)
self.step_box = gui.widgetBox(self.controlArea, "Manually step through")
self.step_button = gui.button(
self.step_box, self, self.STEP_BUTTONS[1], callback=self.step)
self.step_back_button = gui.button(
self.step_box, self, "Step Back", callback=self.step_back)
self.run_box = gui.widgetBox(self.controlArea, "Run")
self.auto_play_speed_spinner = gui.hSlider(
self.run_box, self, 'auto_play_speed', label='Speed:',
minValue=0, maxValue=1.91, step=0.1, intOnly=False,
createLabel=False)
self.auto_play_button = gui.button(
self.run_box, self, self.AUTOPLAY_BUTTONS[0],
callback=self.auto_play)
gui.rubber(self.controlArea)
# disable until data loaded
self.set_disabled_all(True)
# graph in mainArea
self.scatter = Scatterplot(
click_callback=self.graph_clicked,
drop_callback=self.centroid_dropped,
xAxis_gridLineWidth=0, yAxis_gridLineWidth=0,
tooltip_enabled=False,
debug=False)
# Just render an empty chart so it shows a nice 'No data to display'
self.scatter.chart()
self.mainArea.layout().addWidget(self.scatter)
def __init__(self, data=None, file_formats=None):
super().__init__()
self.data = None
self.filename = ""
self.format_index = 0
self.file_formats = file_formats or FileFormat.writers
self.formats = [
(f.DESCRIPTION, f.EXTENSIONS)
for f in sorted(set(self.file_formats.values()), key=lambda f: f.OWSAVE_PRIORITY)
]
self.comboBoxFormat = gui.comboBox(
self.controlArea,
self,
value="format_index",
items=["{} (*{})".format(x[0], " *".join(x[1])) for x in self.formats],
box="File Format",
)
box = gui.widgetBox(self.controlArea)
self.save = gui.button(box, self, "Save", callback=self.save_file, default=True, disabled=True)
gui.separator(box)
self.saveAs = gui.button(box, self, "Save as ...", callback=self.save_file_as, disabled=True)
self.setMinimumWidth(320)
self.adjustSize()
if data:
self.dataset(data)
def __init__(self):
super().__init__()
self.data = None
self.cont_data = None
# GUI
box = gui.vBox(self.mainArea)
self.correlation_combo = gui.comboBox(
box, self, "correlation_type", items=CorrelationType.items(),
orientation=Qt.Horizontal, callback=self._correlation_combo_changed
)
self.feature_model = DomainModel(
order=DomainModel.ATTRIBUTES, separators=False,
placeholder="(All combinations)", valid_types=ContinuousVariable)
gui.comboBox(
box, self, "feature", callback=self._feature_combo_changed,
model=self.feature_model
)
self.vizrank, _ = CorrelationRank.add_vizrank(
None, self, None, self._vizrank_selection_changed)
self.vizrank.progressBar = self.progressBar
self.vizrank.button.setEnabled(False)
self.vizrank.threadStopped.connect(self._vizrank_stopped)
gui.separator(box)
box.layout().addWidget(self.vizrank.filter)
box.layout().addWidget(self.vizrank.rank_table)
button_box = gui.hBox(self.mainArea)
button_box.layout().addWidget(self.vizrank.button)
def __init__(self, parent=None):
super().__init__(parent)
# GUI
box = gui.widgetBox(self.controlArea, "Info", addSpace=True)
self.infoBox = gui.widgetLabel(box, "No data on input.")
box = gui.widgetBox(self.controlArea, "Split by", addSpace=True)
self.groupCombo = gui.comboBox(
box, self, "selectedGroup", callback=self.onGroupSelection)
gui.comboBox(self.controlArea, self, "selectedCenterMethod",
box="Center Fold-change Using",
items=[name for name, _ in self.CENTER_METHODS],
callback=self.onCenterMethodChange,
addSpace=True)
gui.comboBox(self.controlArea, self, "selectedMergeMethod",
box="Merge Replicates",
items=[name for name, _ in self.MERGE_METHODS],
tooltip="Select the method for replicate merging",
callback=self.onMergeMethodChange,
addSpace=True)
box = gui.doubleSpin(self.controlArea, self, "zCutoff", 0.0, 3.0, 0.01,
box="Z-Score Cutoff",
callback=[self.replotMA, self.commitIf])
gui.separator(self.controlArea)
box = gui.widgetBox(self.controlArea, "Ouput")
gui.checkBox(box, self, "appendZScore", "Append Z-Scores",
tooltip="Append calculated Z-Scores to output",
callback=self.commitIf)
gui.checkBox(box, self, "appendRIValues",
"Append Log Ratio and Intensity values",
tooltip="Append calculated Log Ratio and Intensity "
"values to output data",
callback=self.commitIf)
gui.rubber(self.controlArea)
gui.auto_commit(self.controlArea, self, "autoCommit", "Commit")
self.graph = pg.PlotWidget(background="w")
self.graph.getAxis("bottom").setLabel("Intensity: log<sub>10</sub>(R*G)")
self.graph.getAxis("left").setLabel("Log ratio: log<sub>2</sub>(R/G)")
self.mainArea.layout().addWidget(self.graph)
self.groups = []
self.split_data = None, None
self.merged_splits = None, None
self.centered = None, None
self.changedFlag = False
self.data = None
self._executor = concurrent.ThreadExecutor(
threadPool=QThreadPool(maxThreadCount=1))
def __init__(self, parent=None):
super().__init__(parent)
self.inputs = OrderedDict()
self.dist_color = QtGui.QColor(*self.dist_color_RGB)
info_box = gui.widgetBox(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)
gui.separator(info_box)
gui.button(info_box, self, "Restore Original Order",
callback=self.restore_order,
tooltip="Show rows in the original order",
autoDefault=False)
info_box.setMinimumWidth(200)
gui.separator(self.controlArea)
box = gui.widgetBox(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 continuous values',
callback=self._on_distribution_color_changed)
gui.checkBox(box, self, "color_by_class", 'Color by instance classes',
callback=self._on_distribution_color_changed)
gui.button(box, self, "Set colors", self.set_colors, autoDefault=False,
tooltip="Set the background color and color palette")
box = gui.widgetBox(self.controlArea, "Selection")
gui.checkBox(box, self, "select_rows", "Select full rows",
callback=self._on_select_rows_changed)
gui.rubber(self.controlArea)
gui.auto_commit(self.controlArea, self, "auto_commit",
"Send Selected Rows", "Auto send is on")
dlg = self.create_color_dialog()
self.discPalette = dlg.getDiscretePalette("discPalette")
# GUI with tabs
self.tabs = gui.tabWidget(self.mainArea)
self.tabs.currentChanged.connect(self._on_current_tab_changed)
copy = QtGui.QAction("Copy", self, shortcut=QtGui.QKeySequence.Copy,
triggered=self.copy)
self.addAction(copy)
def __init__(self, parent=None):
super().__init__(parent)
self.data = None
self.preRemoveValues = 1
self.preRemoveClasses = 1
self.removedAttrs = "-"
self.reducedAttrs = "-"
self.resortedAttrs = "-"
self.classAttr = "-"
boxAt = gui.widgetBox(self.controlArea, "Attributes")
gui.checkBox(boxAt, self, 'sortValues', 'Sort attribute values',
callback=self.optionsChanged)
gui.separator(boxAt, 2)
rua = gui.checkBox(
boxAt, self, "removeAttributes",
"Remove attributes with less than two values",
callback=self.removeAttributesChanged)
ruv = gui.checkBox(
gui.indentedBox(boxAt, sep=gui.checkButtonOffsetHint(rua)),
self,
"removeValues",
"Remove unused attribute values",
callback=self.optionsChanged
)
rua.disables = [ruv]
rua.makeConsistent()
boxAt = gui.widgetBox(self.controlArea, "Classes", addSpace=True)
gui.checkBox(boxAt, self, 'sortClasses', 'Sort classes',
callback=self.optionsChanged)
gui.separator(boxAt, 2)
rua = gui.checkBox(
boxAt, self, "removeClassAttribute",
"Remove class attribute if there are less than two classes",
callback=self.removeClassesChanged
)
ruv = gui.checkBox(
gui.indentedBox(boxAt, sep=gui.checkButtonOffsetHint(rua)),
self,
"removeClasses",
"Remove unused class values",
callback=self.optionsChanged
)
rua.disables = [ruv]
rua.makeConsistent()
box3 = gui.widgetBox(self.controlArea, 'Statistics', addSpace=True)
gui.label(box3, self, "Removed attributes: %(removedAttrs)s")
gui.label(box3, self, "Reduced attributes: %(reducedAttrs)s")
gui.label(box3, self, "Resorted attributes: %(resortedAttrs)s")
gui.label(box3, self, "Class attribute: %(classAttr)s")
gui.auto_commit(self.controlArea, self, "autoSend", "Send Data",
checkbox_label="Send automatically",
orientation="horizontal")
gui.rubber(self.controlArea)
def add_form(box):
gui.separator(box)
box2 = gui.hBox(box)
gui.rubber(box2)
form = QtGui.QFormLayout()
form.setContentsMargins(0, 0, 0, 0)
box2.layout().addLayout(form)
return form
def __init__(self, parent=None):
super().__init__(parent)
self.data = None
self.distributions = None
self.contingencies = None
self.var = self.cvar = None
varbox = gui.widgetBox(self.controlArea, "Variable")
self.varmodel = itemmodels.VariableListModel()
self.groupvarmodel = itemmodels.VariableListModel()
self.varview = QtGui.QListView(
selectionMode=QtGui.QListView.SingleSelection)
self.varview.setSizePolicy(
QtGui.QSizePolicy.Minimum, QtGui.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)
gui.separator(varbox, 8, 8)
gui.comboBox(
varbox, self, "cont_est_type", label="Show continuous variables by",
valueType=int,
items=["Histograms", "Average shifted histograms",
"Kernel density estimators"],
callback=self._on_cont_est_type_changed)
box = gui.widgetBox(self.controlArea, "Group by")
self.groupvarview = QtGui.QListView(
selectionMode=QtGui.QListView.SingleSelection)
self.groupvarview.setFixedHeight(100)
self.groupvarview.setSizePolicy(
QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Preferred)
self.groupvarview.setModel(self.groupvarmodel)
self.groupvarview.selectionModel().selectionChanged.connect(
self._on_groupvar_idx_changed)
box.layout().addWidget(self.groupvarview)
self.cb_rel_freq = gui.checkBox(
box, self, "relative_freq", "Show relative frequencies",
callback=self._on_relative_freq_changed)
plotview = pg.PlotWidget(background=None)
self.mainArea.layout().addWidget(plotview)
w = QtGui.QLabel()
w.setSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Fixed)
self.mainArea.layout().addWidget(w, Qt.AlignCenter)
self.plot = pg.PlotItem()
# self.plot.getViewBox().setMouseEnabled(False, False)
self.plot.getViewBox().setMenuEnabled(False)
plotview.setCentralItem(self.plot)
pen = QtGui.QPen(self.palette().color(QtGui.QPalette.Text))
for axis in ("left", "bottom"):
self.plot.getAxis(axis).setPen(pen)
def __init__(self):
super().__init__()
box = gui.vBox(self.controlArea, "Nodes", addSpace=True)
self.color_combo = gui.comboBox(
box, self, "color_index", orientation=Qt.Horizontal, items=[],
label="Colors", callback=self.toggle_color,
contentsLength=8)
gui.separator(box)
gui.rubber(self.controlArea)
def box_spacing(self, widget):
if isinstance(widget.layout(), QGridLayout):
widget = widget.layout()
if isinstance(widget, QGridLayout):
space = QWidget()
space.setFixedSize(12, 12)
widget.addWidget(space, widget.rowCount(), 0)
else:
gui.separator(widget)
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.widgetBox(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.widgetBox(box, orientation="horizontal")
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.widgetBox(self.controlArea, '', orientation="horizontal")
box_data_in = gui.widgetBox(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.widgetBox(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.widgetBox(self.controlArea, orientation="horizontal")
box_setting = gui.widgetBox(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="Commit",
checkbox_label="Commit on change")
self.set_data(None)
self.resize(600, 400)
def __init__(self, parent=None, signalManager=None, settings=None):
super().__init__(self, parent, signalManager, settings, "Save")
self.data = None
self.filename = ""
box = gui.widgetBox(self.controlArea)
self.save = gui.button(box, self, "Save", callback=self.saveFile, default=True, disabled=True)
gui.separator(box)
self.saveAs = gui.button(box, self, "Save as ...", callback=self.saveFileAs, disabled=True)
self.setMinimumWidth(320)
self.adjustSize()
def __init__(self):
super().__init__()
box = gui.widgetBox(self.controlArea, "Nodes", addSpace=True)
self.color_combo = gui.comboBox(
box, self, "color_index", orientation=0, items=[],
label="Target class", callback=self.toggle_color,
contentsLength=8)
gui.separator(box)
gui.button(box, self, "Set Colors", callback=self.set_colors)
gui.rubber(self.controlArea)
def _setup_layout(self):
gui.lineEdit(self.controlArea, self, "learner_name", box="Name")
self._add_type_box()
self._add_kernel_box()
self._add_optimization_box()
box = gui.widgetBox(self.controlArea, True, orientation="horizontal")
box.layout().addWidget(self.report_button)
gui.separator(box, 20)
gui.button(box, self, "&Apply", callback=self.apply, default=True)
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 add_main_layout(self):
def add_form(box):
gui.separator(box)
box2 = gui.hBox(box)
gui.rubber(box2)
form = QtGui.QFormLayout()
form.setContentsMargins(0, 0, 0, 0)
box2.layout().addLayout(form)
return form
box = gui.radioButtons(
self.controlArea, self, "loss_function", box="Loss Function",
btnLabels=self.LOSS_FUNCTIONS, callback=self._on_func_changed,
orientation=Qt.Vertical)
form = add_form(box)
epsilon = gui.doubleSpin(
box, self, "epsilon", 0.0, 10.0, 0.01, controlWidth=70)
form.addRow("ε:", epsilon)
self._func_params = [epsilon]
self._on_func_changed()
box = gui.radioButtons(
self.controlArea, self, "penalty_type", box="Penalty",
btnLabels=self.PENALTIES, callback=self._on_penalty_changed,
orientation=Qt.Vertical)
form = add_form(box)
alpha = gui.doubleSpin(
box, self, "alpha", 0.0, 10.0, 0.0001, controlWidth=80)
form.addRow("α:", alpha)
l1_ratio = gui.doubleSpin(
box, self, "l1_ratio", 0.0, 10.0, 0.01, controlWidth=80)
form.addRow("L1 ratio:", l1_ratio)
self._penalty_params = [l1_ratio]
self._on_penalty_changed()
box = gui.radioButtons(
self.controlArea, self, "learning_rate", box="Learning Rate",
btnLabels=self.LEARNING_RATES, callback=self._on_lrate_changed,
orientation=Qt.Vertical)
form = add_form(box)
spin = gui.doubleSpin(
box, self, "eta0", 0.0, 10, 0.01, controlWidth=70)
form.addRow("η<sub>0</sub>:", spin)
power_t = gui.doubleSpin(
box, self, "power_t", 0.0, 10.0, 0.01, controlWidth=70)
form.addRow("Power t:", power_t)
gui.separator(box, height=8)
niterations = gui.doubleSpin(
box, self, "n_iter", 1, 1e+6, 1, controlWidth=70)
form.addRow("Number of iterations:", niterations)
self._lrate_params = [power_t]
self._on_lrate_changed()
def _create_radio_parameter(self, name, label):
self.__radio_parameter_update(name)
values = (x[1] for x in getattr(self, name + "_values"))
gui.separator(self.main_area)
box = gui.hBox(self.main_area)
lbl = gui.label(box, self, label + ":")
rbt = gui.radioButtons(
box, self, name + "_index", btnLabels=values,
callback=lambda f=self.__radio_parameter_update,
p=name: self.__parameter_changed(f, p))
rbt.layout().setAlignment(Qt.AlignTop)
lbl.setAlignment(Qt.AlignTop)
return rbt
def add_main_layout(self):
form = QFormLayout()
form.setFieldGrowthPolicy(form.AllNonFixedFieldsGrow)
form.setVerticalSpacing(25)
form.setLabelAlignment(Qt.AlignLeft)
gui.widgetBox(self.controlArea, True, orientation=form)
form.addRow(
"Neurons in hidden layers:",
gui.lineEdit(
None, self, "hidden_layers_input",
orientation=Qt.Horizontal, callback=self.settings_changed,
tooltip="A list of integers defining neurons. Length of list "
"defines the number of layers. E.g. 4, 2, 2, 3.",
placeholderText="e.g. 10,"))
form.addRow(
"Activation:",
gui.comboBox(
None, self, "activation_index", orientation=Qt.Horizontal,
label="Activation:", items=[i for i in self.act_lbl],
callback=self.settings_changed))
form.addRow(" ", gui.separator(None, 16))
form.addRow(
"Solver:",
gui.comboBox(
None, self, "solver_index", orientation=Qt.Horizontal,
label="Solver:", items=[i for i in self.solv_lbl],
callback=self.settings_changed))
self.reg_label = QLabel()
slider = gui.hSlider(
None, self, "alpha_index",
minValue=0, maxValue=len(self.alphas) - 1,
callback=lambda: (self.set_alpha(), self.settings_changed()),
createLabel=False)
form.addRow(self.reg_label, slider)
self.set_alpha()
form.addRow(
"Maximal number of iterations:",
gui.spin(
None, self, "max_iterations", 10, 10000, step=10,
label="Max iterations:", orientation=Qt.Horizontal,
alignment=Qt.AlignRight, callback=self.settings_changed))
form.addRow(gui.separator(None))
form.addRow(
gui.checkBox(
None, self, "replicable", label="Replicable training", callback=self.settings_changed),
)
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
self.n_inliers = self.n_outliers = None
box = gui.vBox(self.controlArea, "Information")
self.data_info_label = gui.widgetLabel(box, self.data_info_default)
self.in_out_info_label = gui.widgetLabel(box,
self.in_out_info_default)
box = gui.vBox(self.controlArea, "Outlier Detection Method")
detection = gui.radioButtons(box, self, "outlier_method")
gui.appendRadioButton(detection,
"One class SVM with non-linear kernel (RBF)")
ibox = gui.indentedBox(detection)
tooltip = "An upper bound on the fraction of training errors and a " \
"lower bound of the fraction of support vectors"
gui.widgetLabel(ibox, 'Nu:', tooltip=tooltip)
self.nu_slider = gui.hSlider(
ibox, self, "nu", minValue=1, maxValue=100, ticks=10,
labelFormat="%d %%", callback=self.nu_changed, tooltip=tooltip)
self.gamma_spin = gui.spin(
ibox, self, "gamma", label="Kernel coefficient:", step=1e-2,
spinType=float, minv=0.01, maxv=10, callback=self.gamma_changed)
gui.separator(detection, 12)
self.rb_cov = gui.appendRadioButton(detection, "Covariance estimator")
ibox = gui.indentedBox(detection)
self.l_cov = gui.widgetLabel(ibox, 'Contamination:')
self.cont_slider = gui.hSlider(
ibox, self, "cont", minValue=0, maxValue=100, ticks=10,
labelFormat="%d %%", callback=self.cont_changed)
ebox = gui.hBox(ibox)
self.cb_emp_cov = gui.checkBox(
ebox, self, "empirical_covariance",
"Support fraction:", callback=self.empirical_changed)
self.support_fraction_spin = gui.spin(
ebox, self, "support_fraction", step=1e-1, spinType=float,
minv=0.1, maxv=10, callback=self.support_fraction_changed)
gui.separator(detection, 12)
gui.button(self.buttonsArea, self, "Detect Outliers",
callback=self.commit)
self.layout().setSizeConstraint(QtGui.QLayout.SetFixedSize)
def __init__(self):
super().__init__()
self._nhops = 2
self._edge_threshold = 0.5
self._n_max_neighbors = 20
self.selected_titles = []
self.titles = []
self.filter = ""
self.ids = []
self._selected_nodes = []
self._algorithm = 0
self._k_algorithm = 0.3
box = gui.widgetBox(self.controlArea, "Paper Selection", orientation="vertical")
gui.lineEdit(box, self, "filter", callback=self.filter_list, callbackOnType=True)
self.list_titles = gui.listBox(
box, self, "selected_titles", "titles", selectionMode=QListWidget.MultiSelection, callback=self.update_view
)
gui.separator(self.controlArea)
box_pref = gui.widgetBox(self.controlArea, "Preferences", orientation="vertical")
gui.spin(box_pref, self, "_nhops", 1, 6, 1, label="Number of hops: ", callback=self.update_view)
gui.spin(
box_pref, self, "_n_max_neighbors", 1, 100, 1, label="Max number of neighbors: ", callback=self.update_view
)
gui.doubleSpin(
box_pref, self, "_edge_threshold", 0, 1, step=0.01, label="Edge threshold: ", callback=self.update_view
)
gui.separator(self.controlArea)
box_alg = gui.widgetBox(self.controlArea, "Interest Propagation Algorithm", orientation="vertical")
radio_box = gui.radioButtonsInBox(box_alg, self, "_algorithm", [], callback=self.update_view)
gui.appendRadioButton(radio_box, self, "_algorithm", "Without Clustering", callback=self.update_view)
gui.doubleSpin(
gui.indentedBox(radio_box),
self,
"_k_algorithm",
0,
1,
step=0.01,
label="Parameter k: ",
callback=self.update_view,
)
gui.appendRadioButton(radio_box, self, "_algorithm", "With Clustering", callback=self.update_view)
self.inside_view = PubmedNetworkView(self)
self.send("Nx View", self.inside_view)
def __init__(self, parent=None, signalManager=None, settings=None):
super().__init__(self, parent, signalManager, settings, "Save")
self.data = None
self.filename = ""
self.comboBoxFormat = gui.comboBox(
self.controlArea,
self,
value="format_index",
items=["{} (*{})".format(*x) for x in self.formats],
box="File Format",
callback=self.reset_filename,
)
box = gui.widgetBox(self.controlArea)
self.save = gui.button(box, self, "Save", callback=self.save_file, default=True, disabled=True)
gui.separator(box)
self.saveAs = gui.button(box, self, "Save as ...", callback=self.save_file_as, disabled=True)
self.setMinimumWidth(320)
self.adjustSize()
def __init__(self):
super().__init__()
self.data = None
self.removedAttrs = "-"
self.reducedAttrs = "-"
self.resortedAttrs = "-"
self.removedClasses = "-"
self.reducedClasses = "-"
self.resortedClasses = "-"
self.removedMetas = "-"
self.reducedMetas = "-"
def add_line(parent):
frame = QFrame()
frame.setFrameShape(QFrame.HLine)
frame.setFrameShadow(QFrame.Sunken)
parent.layout().addSpacing(6)
parent.layout().addWidget(frame)
parent.layout().addSpacing(6)
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)
add_line(boxAt)
gui.label(
boxAt, self, "Sorted: %(resortedAttrs)s, "
"reduced: %(reducedAttrs)s, removed: %(removedAttrs)s")
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)
add_line(boxAt)
gui.label(
boxAt, self, "Sorted: %(resortedClasses)s,"
"reduced: %(reducedClasses)s, removed: %(removedClasses)s")
boxAt = gui.vBox(self.controlArea, "Meta attributes", addSpace=True)
for not_first, (value, label) in enumerate(self.meta_options):
if not_first:
gui.separator(boxAt, 2)
gui.checkBox(boxAt,
self,
value,
label,
callback=self.optionsChanged)
add_line(boxAt)
gui.label(boxAt, self,
"Reduced: %(reducedMetas)s, removed: %(removedMetas)s")
gui.auto_send(self.buttonsArea, self, "autoSend")
gui.rubber(self.controlArea)
self.info.set_input_summary(self.info.NoInput)
self.info.set_output_summary(self.info.NoOutput)
def __init__(self):
super().__init__()
self.primary_data = None
self.more_data = OrderedDict()
self.mergebox = gui.vBox(self.controlArea, "Variable Merging")
box = gui.radioButtons(self.mergebox,
self,
"merge_type",
callback=self._merge_type_changed)
gui.widgetLabel(
box,
self.tr("When there is no primary table, " +
"the output should contain:"))
for opts in self.domain_opts:
gui.appendRadioButton(box, self.tr(opts))
gui.separator(box)
label = gui.widgetLabel(
box,
self.tr("The resulting table will have a class only if there " +
"is no conflict between input classes."))
label.setWordWrap(True)
gui.separator(box)
gui.checkBox(
box,
self,
"ignore_compute_value",
"Treat variables with the same name as the same variable,\n"
"even if they are computed using different formulae.",
callback=self.apply,
stateWhenDisabled=False)
###
box = gui.vBox(
self.controlArea,
self.tr("Source Identification"),
)
cb = gui.checkBox(box,
self,
"append_source_column",
self.tr("Append data source IDs"),
callback=self._source_changed)
ibox = gui.indentedBox(box, sep=gui.checkButtonOffsetHint(cb))
form = QFormLayout(spacing=8,
labelAlignment=Qt.AlignLeft,
formAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QFormLayout.AllNonFixedFieldsGrow)
form.addRow(
self.tr("Feature name:"),
gui.lineEdit(ibox,
self,
"source_attr_name",
valueType=str,
callback=self._source_changed))
form.addRow(
self.tr("Place:"),
gui.comboBox(ibox,
self,
"source_column_role",
items=self.id_roles,
callback=self._source_changed))
self.info.set_input_summary(self.info.NoInput)
self.info.set_output_summary(self.info.NoOutput)
ibox.layout().addLayout(form)
mleft, mtop, mright, _ = ibox.layout().getContentsMargins()
ibox.layout().setContentsMargins(mleft, mtop, mright, 4)
cb.disables.append(ibox)
cb.makeConsistent()
gui.auto_apply(self.buttonsArea,
self,
"auto_commit",
commit=self.apply)
def __init__(self, parent=None):
super().__init__(parent)
self.organismCodes = []
self._changedFlag = False
self.__invalidated = False
self.__runstate = OWKEGGPathwayBrowser.Initializing
self.__in_setProgress = False
self.controlArea.setMaximumWidth(250)
box = gui.widgetBox(self.controlArea, "Info")
self.infoLabel = gui.widgetLabel(box, "No data on input\n")
# Organism selection.
box = gui.widgetBox(self.controlArea, "Organism")
self.organismComboBox = gui.comboBox(
box,
self,
"organismIndex",
items=[],
callback=self.Update,
addSpace=True,
tooltip="Select the organism of the input genes")
# Selection of genes attribute
box = gui.widgetBox(self.controlArea, "Gene attribute")
self.geneAttrCandidates = itemmodels.VariableListModel(parent=self)
self.geneAttrCombo = gui.comboBox(box,
self,
"geneAttrIndex",
callback=self.Update)
self.geneAttrCombo.setModel(self.geneAttrCandidates)
gui.checkBox(box,
self,
"useAttrNames",
"Use variable names",
disables=[(-1, self.geneAttrCombo)],
callback=self.Update)
self.geneAttrCombo.setDisabled(bool(self.useAttrNames))
gui.separator(self.controlArea)
gui.checkBox(self.controlArea,
self,
"useReference",
"From signal",
box="Reference",
callback=self.Update)
gui.separator(self.controlArea)
gui.checkBox(self.controlArea,
self,
"showOrthology",
"Show pathways in full orthology",
box="Orthology",
callback=self.UpdateListView)
gui.checkBox(self.controlArea,
self,
"autoResize",
"Resize to fit",
box="Image",
callback=self.UpdatePathwayViewTransform)
box = gui.widgetBox(self.controlArea, "Cache Control")
gui.button(box,
self,
"Clear cache",
callback=self.ClearCache,
tooltip="Clear all locally cached KEGG data.",
default=False,
autoDefault=False)
gui.separator(self.controlArea)
gui.auto_commit(self.controlArea, self, "autoCommit", "Commit")
gui.rubber(self.controlArea)
spliter = QSplitter(Qt.Vertical, self.mainArea)
self.pathwayView = PathwayView(self, spliter)
self.pathwayView.scene().selectionChanged.connect(
self._onSelectionChanged)
self.mainArea.layout().addWidget(spliter)
self.listView = QTreeWidget(allColumnsShowFocus=True,
selectionMode=QTreeWidget.SingleSelection,
sortingEnabled=True,
maximumHeight=200)
spliter.addWidget(self.listView)
self.listView.setColumnCount(4)
self.listView.setHeaderLabels(
["Pathway", "P value", "Genes", "Reference"])
self.listView.itemSelectionChanged.connect(self.UpdatePathwayView)
select = QAction("Select All", self, shortcut=QKeySequence.SelectAll)
select.triggered.connect(self.selectAll)
self.addAction(select)
self.data = None
self.refData = None
self._executor = concurrent.ThreadExecutor()
self.setEnabled(False)
self.setBlocking(True)
progress = concurrent.methodinvoke(self, "setProgress", (float, ))
def get_genome():
"""Return a KEGGGenome with the common org entries precached."""
genome = kegg.KEGGGenome()
essential = genome.essential_organisms()
common = genome.common_organisms()
# Remove duplicates of essential from common.
# (essential + common list as defined here will be used in the
# GUI.)
common = [c for c in common if c not in essential]
# TODO: Add option to specify additional organisms not
# in the common list.
keys = list(map(genome.org_code_to_entry_key, essential + common))
genome.pre_cache(keys, progress_callback=progress)
return (keys, genome)
self._genomeTask = task = concurrent.Task(function=get_genome)
task.finished.connect(self.__initialize_finish)
self.progressBarInit()
self.infoLabel.setText("Fetching organism definitions\n")
self._executor.submit(task)
def __init__(self):
super().__init__()
self.data = None
self.km = None
self.optimization_runs = []
box = gui.vBox(self.controlArea, "Number of Clusters")
layout = QGridLayout()
bg = gui.radioButtonsInBox(
box, self, "optimize_k", [], orientation=layout,
callback=self.update)
layout.addWidget(
gui.appendRadioButton(bg, "Fixed", addToLayout=False),
1, 1)
sb = gui.hBox(None, margin=0)
self.fixedSpinBox = gui.spin(
sb, self, "k", minv=2, maxv=30,
controlWidth=60, alignment=Qt.AlignRight, callback=self.update_k)
gui.rubber(sb)
layout.addWidget(sb, 1, 2)
layout.addWidget(
gui.appendRadioButton(bg, "Optimized", addToLayout=False), 2, 1)
ftobox = gui.hBox(None)
ftobox.layout().setContentsMargins(0, 0, 0, 0)
layout.addWidget(ftobox)
gui.spin(
ftobox, self, "k_from", minv=2, maxv=29,
controlWidth=60, alignment=Qt.AlignRight,
callback=self.update_from)
gui.widgetLabel(ftobox, " To: ")
self.fixedSpinBox = gui.spin(
ftobox, self, "k_to", minv=3, maxv=30,
controlWidth=60, alignment=Qt.AlignRight,
callback=self.update_to)
gui.rubber(ftobox)
layout.addWidget(gui.widgetLabel(None, "Scoring: "),
5, 1, Qt.AlignRight)
layout.addWidget(
gui.comboBox(
None, self, "scoring", label="Scoring",
items=list(zip(*self.SCORING_METHODS))[0],
callback=self.update), 5, 2)
box = gui.vBox(self.controlArea, "Initialization")
gui.comboBox(
box, self, "smart_init", items=self.INIT_METHODS,
callback=self.update)
layout = QGridLayout()
box2 = gui.widgetBox(box, orientation=layout)
box2.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Maximum)
layout.addWidget(gui.widgetLabel(None, "Re-runs: "),
0, 0, Qt.AlignLeft)
sb = gui.hBox(None, margin=0)
layout.addWidget(sb, 0, 1)
gui.lineEdit(
sb, self, "n_init", controlWidth=60,
valueType=int, validator=QIntValidator(),
callback=self.update)
layout.addWidget(gui.widgetLabel(None, "Maximal iterations: "),
1, 0, Qt.AlignLeft)
sb = gui.hBox(None, margin=0)
layout.addWidget(sb, 1, 1)
gui.lineEdit(sb, self, "max_iterations",
controlWidth=60, valueType=int,
validator=QIntValidator(),
callback=self.update)
box = gui.vBox(self.controlArea, "Output")
gui.comboBox(box, self, "place_cluster_ids",
label="Append cluster id as ", orientation=Qt.Horizontal,
callback=self.send_data, items=self.OUTPUT_METHODS)
gui.lineEdit(box, self, "output_name",
label="Name ", orientation=Qt.Horizontal,
callback=self.send_data)
gui.separator(self.buttonsArea, 30)
gui.auto_commit(self.buttonsArea, self, "auto_run", "Run",
"Run on change", box=None)
gui.rubber(self.controlArea)
self.table_model = QStandardItemModel(self)
self.table_model.setHorizontalHeaderLabels(["k", "Score"])
self.table_model.setColumnCount(2)
self.table_box = gui.vBox(
self.mainArea, "Optimization Report", addSpace=0)
table = self.table_view = QTableView(self.table_box)
table.setHorizontalScrollMode(QTableView.ScrollPerPixel)
table.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
table.setSelectionMode(QTableView.SingleSelection)
table.setSelectionBehavior(QTableView.SelectRows)
table.verticalHeader().hide()
table.setItemDelegateForColumn(1, gui.TableBarItem(self))
table.setModel(self.table_model)
table.selectionModel().selectionChanged.connect(
self.table_item_selected)
table.setColumnWidth(0, 40)
table.setColumnWidth(1, 120)
table.horizontalHeader().setStretchLastSection(True)
self.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
self.mainArea.setSizePolicy(QSizePolicy.Maximum,
QSizePolicy.Preferred)
self.table_box.setSizePolicy(QSizePolicy.Fixed,
QSizePolicy.MinimumExpanding)
self.table_view.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.MinimumExpanding)
self.table_box.layout().addWidget(self.table_view)
self.hide_show_opt_results()
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,
callback=self._attr_name_changed)
gui.separator(hbox, 21)
hbox = gui.hBox(namesBox, margin=0, spacing=0)
attr2 = gui.lineEdit(hbox,
self,
"attr2",
"Variable Y: ",
controlWidth=80,
orientation=Qt.Horizontal,
callback=self._attr_name_changed)
gui.separator(hbox)
gui.checkBox(hbox,
self,
"hasAttr2",
'',
disables=attr2,
labelWidth=0,
callback=self.set_dimensions)
gui.separator(namesBox)
gui.widgetLabel(namesBox, "Labels")
self.classValuesView = listView = gui.ListViewWithSizeHint(
preferred_size=(-1, 30))
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=QGridLayout())
self.toolActions = 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 = 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(QKeySequence.Undo)
redo.setShortcut(QKeySequence.Redo)
self.addActions([undo, redo])
self.undo_stack.indexChanged.connect(lambda _: self.invalidate())
gui.separator(tBox)
indBox = gui.indentedBox(tBox, sep=8)
form = QFormLayout(formAlignment=Qt.AlignLeft,
labelAlignment=Qt.AlignLeft,
fieldGrowthPolicy=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.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(QPalette.Text)
axis_pen = QPen(axis_color)
tickfont = 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__()
#: The input data
self.data = None # type: Optional[Orange.data.Table]
#: Distance matrix computed from data
self._matrix = None # type: Optional[Orange.misc.DistMatrix]
#: An bool mask (size == len(data)) indicating missing group/cluster
#: assignments
self._mask = None # type: Optional[np.ndarray]
#: An array of cluster/group labels for instances with valid group
#: assignment
self._labels = None # type: Optional[np.ndarray]
#: An array of silhouette scores for instances with valid group
#: assignment
self._silhouette = None # type: Optional[np.ndarray]
self._silplot = None # type: Optional[SilhouettePlot]
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", contentsLength=14, 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", contentsLength=14,
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_send(box, self, "auto_commit", box=False)
# Ensure that the controlArea is not narrower than buttonsArea
self.controlArea.layout().addWidget(self.buttonsArea)
self.scene = QGraphicsScene()
self.view = StickyGraphicsView(self.scene)
self.view.setRenderHint(QPainter.Antialiasing, True)
self.view.setAlignment(Qt.AlignTop | Qt.AlignLeft)
self.mainArea.layout().addWidget(self.view)
self.settingsAboutToBePacked.connect(self.pack_settings)
def add_main_layout(self):
# top-level control procedure
top_box = gui.hBox(widget=self.controlArea, box=None, addSpace=2)
rule_ordering_box = gui.hBox(widget=top_box, box="Rule ordering")
rule_ordering_rbs = gui.radioButtons(widget=rule_ordering_box,
master=self,
value="rule_ordering",
callback=self.settings_changed,
btnLabels=("Ordered",
"Unordered"))
rule_ordering_rbs.layout().setSpacing(7)
covering_algorithm_box = gui.hBox(widget=top_box,
box="Covering algorithm")
covering_algorithm_rbs = gui.radioButtons(
widget=covering_algorithm_box,
master=self,
value="covering_algorithm",
callback=self.settings_changed,
btnLabels=("Exclusive", "Weighted"))
covering_algorithm_rbs.layout().setSpacing(7)
insert_gamma_box = gui.vBox(widget=covering_algorithm_box, box=None)
gui.separator(insert_gamma_box, 0, 14)
self.gamma_spin = gui.doubleSpin(
widget=insert_gamma_box,
master=self,
value="gamma",
minv=0.0,
maxv=1.0,
step=0.01,
label="γ:",
orientation=Qt.Horizontal,
callback=self.settings_changed,
alignment=Qt.AlignRight,
enabled=self.storage_covers[self.covering_algorithm] == "weighted")
# bottom-level search procedure (search bias)
middle_box = gui.vBox(widget=self.controlArea, box="Rule search")
evaluation_measure_box = gui.comboBox(widget=middle_box,
master=self,
value="evaluation_measure",
label="Evaluation measure:",
orientation=Qt.Horizontal,
items=("Entropy",
"Laplace accuracy",
"WRAcc"),
callback=self.settings_changed,
contentsLength=3)
beam_width_box = gui.spin(widget=middle_box,
master=self,
value="beam_width",
minv=1,
maxv=100,
step=1,
label="Beam width:",
orientation=Qt.Horizontal,
callback=self.settings_changed,
alignment=Qt.AlignRight,
controlWidth=80)
# bottom-level search procedure (over-fitting avoidance bias)
bottom_box = gui.vBox(widget=self.controlArea, box="Rule filtering")
min_covered_examples_box = gui.spin(widget=bottom_box,
master=self,
value="min_covered_examples",
minv=1,
maxv=10000,
step=1,
label="Minimum rule coverage:",
orientation=Qt.Horizontal,
callback=self.settings_changed,
alignment=Qt.AlignRight,
controlWidth=80)
max_rule_length_box = gui.spin(widget=bottom_box,
master=self,
value="max_rule_length",
minv=1,
maxv=100,
step=1,
label="Maximum rule length:",
orientation=Qt.Horizontal,
callback=self.settings_changed,
alignment=Qt.AlignRight,
controlWidth=80)
default_alpha_spin = gui.doubleSpin(
widget=bottom_box,
master=self,
value="default_alpha",
minv=0.0,
maxv=1.0,
step=0.01,
label="Statistical significance\n(default α):",
orientation=Qt.Horizontal,
callback=self.settings_changed,
alignment=Qt.AlignRight,
controlWidth=80,
checked="checked_default_alpha")
parent_alpha_spin = gui.doubleSpin(
widget=bottom_box,
master=self,
value="parent_alpha",
minv=0.0,
maxv=1.0,
step=0.01,
label="Relative significance\n(parent α):",
orientation=Qt.Horizontal,
callback=self.settings_changed,
alignment=Qt.AlignRight,
controlWidth=80,
checked="checked_parent_alpha")
def __init__(self):
super().__init__()
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="Commit",
checkbox_label="Commit on change")
self.set_data(None)
self.resize(600, 400)
def _init_ui(self):
# implement your user interface here (for setting hyperparameters)
gui.separator(self.controlArea)
box = gui.widgetBox(self.controlArea, "Hyperparameter")
gui.separator(self.controlArea)
gui.lineEdit(box,
self,
"lamb",
label='lamb',
valueType=int,
callback=None)
gui.checkBox(box,
self,
"use_semantic_types",
label='Mannally select columns if active.',
callback=None)
gui.lineEdit(
box,
self,
"use_columns_buf",
label=
'Column index to use when use_semantic_types is activated. Tuple, e.g. (0,1,2)',
validator=None,
callback=self._use_columns_callback)
gui.lineEdit(
box,
self,
"exclude_columns_buf",
label=
'Column index to exclude when use_semantic_types is activated. Tuple, e.g. (0,1,2)',
validator=None,
callback=self._exclude_columns_callback)
gui.comboBox(
box,
self,
"return_result",
sendSelectedValue=True,
label='Output results.',
items=['new', 'append', 'replace'],
)
gui.checkBox(box,
self,
"add_index_columns",
label='Keep index in the outputs.',
callback=None)
gui.checkBox(box,
self,
"error_on_no_input",
label='Error on no input.',
callback=None)
gui.comboBox(
box,
self,
"return_semantic_type",
sendSelectedValue=True,
label='Semantic type attach with results.',
items=[
'https://metadata.datadrivendiscovery.org/types/Attribute',
'https://metadata.datadrivendiscovery.org/types/ConstructedAttribute'
],
)
gui.auto_apply(box, self, "autosend", box=False)
self.data = None
self.info.set_input_summary(self.info.NoInput)
self.info.set_output_summary(self.info.NoOutput)
def _add_learning_params_to_layout(self):
# this is part of init, pylint: disable=attribute-defined-outside-init
box = gui.widgetBox(self.controlArea, 'Learning parameters')
self.learning_rate_combo = gui.comboBox(
box,
self,
'learning_rate_index',
label='Learning rate: ',
items=list(zip(*self.learning_rates))[0],
orientation=Qt.Horizontal,
callback=self._on_learning_rate_change)
self.eta0_spin = gui.spin(
box,
self,
'eta0',
1e-4,
1.,
1e-4,
spinType=float,
label='Initial learning rate (η<sub>0</sub>): ',
alignment=Qt.AlignRight,
controlWidth=80,
callback=self.settings_changed)
self.power_t_spin = gui.spin(box,
self,
'power_t',
0,
1.,
1e-4,
spinType=float,
label='Inverse scaling exponent (t): ',
alignment=Qt.AlignRight,
controlWidth=80,
callback=self.settings_changed)
gui.separator(box, height=12)
self.max_iter_spin = gui.spin(box,
self,
'max_iter',
1,
MAXINT - 1,
label='Number of iterations: ',
controlWidth=80,
alignment=Qt.AlignRight,
callback=self.settings_changed)
self.tol_spin = gui.spin(box,
self,
'tol',
0,
10.,
.1e-3,
spinType=float,
controlWidth=80,
label='Tolerance (stopping criterion): ',
checked='tol_enabled',
alignment=Qt.AlignRight,
callback=self.settings_changed)
gui.separator(box, height=12)
# Wrap shuffle_cbx inside another hbox to align it with the random_seed
# spin box on OSX
self.shuffle_cbx = gui.checkBox(gui.hBox(box),
self,
'shuffle',
'Shuffle data after each iteration',
callback=self._on_shuffle_change)
self.random_seed_spin = gui.spin(
box,
self,
'random_state',
0,
MAXINT,
label='Fixed seed for random shuffling: ',
controlWidth=80,
alignment=Qt.AlignRight,
callback=self.settings_changed,
checked='use_random_state',
checkCallback=self.settings_changed)
# Enable/disable appropriate controls
self._on_learning_rate_change()
self._on_shuffle_change()
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,
uniformItemSizes=True,
)
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 numeric variables",
callback=self._on_groupvar_idx_changed,
tooltip="Show numeric variables as categorical.")
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.inputs = OrderedDict()
self.dist_color = QtGui.QColor(*self.dist_color_RGB)
info_box = gui.widgetBox(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)
gui.separator(info_box)
gui.button(info_box,
self,
"Restore Original Order",
callback=self.restore_order,
tooltip="Show rows in the original order",
autoDefault=False)
info_box.setMinimumWidth(200)
gui.separator(self.controlArea)
box = gui.widgetBox(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 continuous 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.widgetBox(self.controlArea, "Selection")
gui.checkBox(box,
self,
"select_rows",
"Select full rows",
callback=self._on_select_rows_changed)
gui.rubber(self.controlArea)
gui.auto_commit(self.controlArea, self, "auto_commit",
"Send Selected Rows", "Auto send is on")
# GUI with tabs
self.tabs = gui.tabWidget(self.mainArea)
self.tabs.currentChanged.connect(self._on_current_tab_changed)
copy = QtGui.QAction("Copy",
self,
shortcut=QtGui.QKeySequence.Copy,
triggered=self.copy)
self.addAction(copy)
def add_main_layout(self):
self.data = None
self.learner = None
self.scatterplot_item = None
self.plot_item = None
self.x_label = 'x'
self.y_label = 'y'
self.rmse = ""
self.mae = ""
self.regressor_name = self.default_learner_name
# info box
info_box = gui.vBox(self.controlArea, "Info")
self.regressor_label = gui.label(
widget=info_box,
master=self,
label="Regressor: %(regressor_name).30s")
gui.label(widget=info_box,
master=self,
label="Mean absolute error: %(mae).6s")
gui.label(widget=info_box,
master=self,
label="Root mean square error: %(rmse).6s")
box = gui.vBox(self.controlArea, "Variables")
self.x_var_model = itemmodels.VariableListModel()
self.comboBoxAttributesX = gui.comboBox(box,
self,
value='x_var_index',
label="Input: ",
orientation=Qt.Horizontal,
callback=self.apply,
maximumContentsLength=15)
self.comboBoxAttributesX.setModel(self.x_var_model)
self.expansion_spin = gui.doubleSpin(gui.indentedBox(box),
self,
"polynomialexpansion",
0,
10,
label="Polynomial expansion:",
callback=self.apply)
gui.separator(box, height=8)
self.y_var_model = itemmodels.VariableListModel()
self.comboBoxAttributesY = gui.comboBox(box,
self,
value="y_var_index",
label="Target: ",
orientation=Qt.Horizontal,
callback=self.apply,
maximumContentsLength=15)
self.comboBoxAttributesY.setModel(self.y_var_model)
properties_box = gui.vBox(self.controlArea, "Properties")
self.error_bars_checkbox = gui.checkBox(widget=properties_box,
master=self,
value='error_bars_enabled',
label="Show error bars",
callback=self.apply)
gui.rubber(self.controlArea)
# main area GUI
self.plotview = pg.PlotWidget(background="w")
self.plot = self.plotview.getPlotItem()
axis_color = self.palette().color(QPalette.Text)
axis_pen = QPen(axis_color)
tickfont = QFont(self.font())
tickfont.setPixelSize(max(int(tickfont.pixelSize() * 2 // 3), 11))
axis = self.plot.getAxis("bottom")
axis.setLabel(self.x_label)
axis.setPen(axis_pen)
axis.setTickFont(tickfont)
axis = self.plot.getAxis("left")
axis.setLabel(self.y_label)
axis.setPen(axis_pen)
axis.setTickFont(tickfont)
self.plot.setRange(xRange=(0.0, 1.0),
yRange=(0.0, 1.0),
disableAutoRange=True)
self.mainArea.layout().addWidget(self.plotview)
def __init__(self):
super().__init__()
box = gui.vBox(self.mainArea, True, margin=0)
self.graph = OWScatterPlotGraph(self, box, "ScatterPlot")
box.layout().addWidget(self.graph.plot_widget)
plot = self.graph.plot_widget
axispen = QPen(self.palette().color(QPalette.Text))
axis = plot.getAxis("bottom")
axis.setPen(axispen)
axis = plot.getAxis("left")
axis.setPen(axispen)
self.data = None # Orange.data.Table
self.subset_data = None # Orange.data.Table
self.data_metas_X = None # self.data, where primitive metas are moved to X
self.sql_data = None # Orange.data.sql.table.SqlTable
self.attribute_selection_list = None # list of Orange.data.Variable
self.__timer = QTimer(self, interval=1200)
self.__timer.timeout.connect(self.add_data)
common_options = dict(labelWidth=50,
orientation=Qt.Horizontal,
sendSelectedValue=True,
valueType=str)
box = gui.vBox(self.controlArea, "Axis Data")
dmod = DomainModel
self.xy_model = DomainModel(dmod.MIXED, valid_types=dmod.PRIMITIVE)
self.cb_attr_x = gui.comboBox(box,
self,
"attr_x",
label="Axis x:",
callback=self.update_attr,
model=self.xy_model,
**common_options)
self.cb_attr_y = gui.comboBox(box,
self,
"attr_y",
label="Axis y:",
callback=self.update_attr,
model=self.xy_model,
**common_options)
vizrank_box = gui.hBox(box)
gui.separator(vizrank_box, width=common_options["labelWidth"])
self.vizrank, self.vizrank_button = ScatterPlotVizRank.add_vizrank(
vizrank_box, self, "Find Informative Projections", self.set_attr)
gui.separator(box)
gui.valueSlider(box,
self,
value='graph.jitter_size',
label='Jittering: ',
values=self.jitter_sizes,
callback=self.reset_graph_data,
labelFormat=lambda x: "None"
if x == 0 else ("%.1f %%" if x < 1 else "%d %%") % x)
gui.checkBox(gui.indentedBox(box),
self,
'graph.jitter_continuous',
'Jitter continuous values',
callback=self.reset_graph_data)
self.sampling = gui.auto_commit(self.controlArea,
self,
"auto_sample",
"Sample",
box="Sampling",
callback=self.switch_sampling,
commit=lambda: self.add_data(1))
self.sampling.setVisible(False)
g = self.graph.gui
g.point_properties_box(self.controlArea)
self.models = [self.xy_model] + g.points_models
box = gui.vBox(self.controlArea, "Plot Properties")
g.add_widgets([g.ShowLegend, g.ShowGridLines], box)
gui.checkBox(box,
self,
value='graph.tooltip_shows_all',
label='Show all data on mouse hover')
self.cb_class_density = gui.checkBox(box,
self,
value='graph.class_density',
label='Show class density',
callback=self.update_density)
self.cb_reg_line = gui.checkBox(box,
self,
value='graph.show_reg_line',
label='Show regression line',
callback=self.update_regression_line)
gui.checkBox(box,
self,
'graph.label_only_selected',
'Label only selected points',
callback=self.graph.update_labels)
self.zoom_select_toolbar = g.zoom_select_toolbar(
gui.vBox(self.controlArea, "Zoom/Select"),
nomargin=True,
buttons=[
g.StateButtonsBegin, g.SimpleSelect, g.Pan, g.Zoom,
g.StateButtonsEnd, g.ZoomReset
])
buttons = self.zoom_select_toolbar.buttons
buttons[g.Zoom].clicked.connect(self.graph.zoom_button_clicked)
buttons[g.Pan].clicked.connect(self.graph.pan_button_clicked)
buttons[g.SimpleSelect].clicked.connect(
self.graph.select_button_clicked)
buttons[g.ZoomReset].clicked.connect(self.graph.reset_button_clicked)
self.controlArea.layout().addStretch(100)
self.icons = gui.attributeIconDict
p = self.graph.plot_widget.palette()
self.graph.set_palette(p)
gui.auto_commit(self.controlArea, self, "auto_send_selection",
"Send Selection", "Send Automatically")
def zoom(s):
"""Zoom in/out by factor `s`."""
viewbox = plot.getViewBox()
# scaleBy scales the view's bounds (the axis range)
viewbox.scaleBy((1 / s, 1 / s))
def fit_to_view():
viewbox = plot.getViewBox()
viewbox.autoRange()
zoom_in = QAction("Zoom in", self, triggered=lambda: zoom(1.25))
zoom_in.setShortcuts([
QKeySequence(QKeySequence.ZoomIn),
QKeySequence(self.tr("Ctrl+="))
])
zoom_out = QAction("Zoom out",
self,
shortcut=QKeySequence.ZoomOut,
triggered=lambda: zoom(1 / 1.25))
zoom_fit = QAction("Fit in view",
self,
shortcut=QKeySequence(Qt.ControlModifier
| Qt.Key_0),
triggered=fit_to_view)
self.addActions([zoom_in, zoom_out, zoom_fit])
def __init__(self):
super().__init__()
#: Input dissimilarity matrix
self.matrix = None # type: Optional[Orange.misc.DistMatrix]
#: Effective data used for plot styling/annotations. Can be from the
#: input signal (`self.signal_data`) or the input matrix
#: (`self.matrix.data`)
self.data = None # type: Optional[Orange.data.Table]
#: Input subset data table
self.subset_data = None # type: Optional[Orange.data.Table]
#: Data table from the `self.matrix.row_items` (if present)
self.matrix_data = None # type: Optional[Orange.data.Table]
#: Input data table
self.signal_data = None
self._similar_pairs = None
self._subset_mask = None # type: Optional[np.ndarray]
self._invalidated = False
self.effective_matrix = None
self._curve = None
self.variable_x = ContinuousVariable("mds-x")
self.variable_y = ContinuousVariable("mds-y")
self.__update_loop = None
# timer for scheduling updates
self.__timer = QTimer(self, singleShot=True, interval=0)
self.__timer.timeout.connect(self.__next_step)
self.__state = OWMDS.Waiting
self.__in_next_step = False
self.__draw_similar_pairs = False
box = gui.vBox(self.controlArea, "MDS Optimization")
form = QFormLayout(
labelAlignment=Qt.AlignLeft,
formAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QFormLayout.AllNonFixedFieldsGrow,
verticalSpacing=10
)
form.addRow(
"Max iterations:",
gui.spin(box, self, "max_iter", 10, 10 ** 4, step=1))
form.addRow(
"Initialization:",
gui.radioButtons(box, self, "initialization", btnLabels=("PCA (Torgerson)", "Random"),
callback=self.__invalidate_embedding))
box.layout().addLayout(form)
form.addRow(
"Refresh:",
gui.comboBox(box, self, "refresh_rate", items=[t for t, _ in OWMDS.RefreshRate],
callback=self.__invalidate_refresh))
gui.separator(box, 10)
self.runbutton = gui.button(box, self, "Run", callback=self._toggle_run)
box = gui.vBox(self.mainArea, True, margin=0)
self.graph = OWMDSGraph(self, box, "MDSGraph", view_box=MDSInteractiveViewBox)
box.layout().addWidget(self.graph.plot_widget)
self.plot = self.graph.plot_widget
g = self.graph.gui
box = g.point_properties_box(self.controlArea)
self.models = g.points_models
self.size_model = self.models[2]
self.label_model = self.models[3]
self.size_model.order = \
self.size_model.order[:1] + ("Stress", ) + self.models[2].order[1:]
gui.hSlider(box, self, "connected_pairs", label="Show similar pairs:", minValue=0,
maxValue=20, createLabel=False, callback=self._on_connected_changed)
g.add_widgets(ids=[g.JitterSizeSlider], widget=box)
box = gui.vBox(self.controlArea, "Plot Properties")
g.add_widgets([g.ShowLegend,
g.ToolTipShowsAll,
g.ClassDensity,
g.LabelOnlySelected], box)
self.controlArea.layout().addStretch(100)
self.icons = gui.attributeIconDict
palette = self.graph.plot_widget.palette()
self.graph.set_palette(palette)
gui.rubber(self.controlArea)
self.graph.box_zoom_select(self.controlArea)
gui.auto_commit(box, self, "auto_commit", "Send Selected",
checkbox_label="Send selected automatically",
box=None)
self.plot.getPlotItem().hideButtons()
self.plot.setRenderHint(QPainter.Antialiasing)
self.graph.jitter_continuous = True
self._initialize()
def _add_learning_params_to_layout(self, layout):
# this is part of init, pylint: disable=attribute-defined-outside-init
box = gui.widgetBox(None, '优化')
layout.addWidget(box)
self.learning_rate_combo = gui.comboBox(
box,
self,
'learning_rate_index',
label='学习率: ',
items=list(zip(*self.Chinese_learning_rates))[0],
orientation=Qt.Horizontal,
callback=self._on_learning_rate_change)
self.eta0_spin = gui.spin(box,
self,
'eta0',
1e-4,
1.,
1e-4,
spinType=float,
label='初始学习率 (η<sub>0</sub>): ',
alignment=Qt.AlignRight,
controlWidth=80,
callback=self.settings_changed)
self.power_t_spin = gui.spin(box,
self,
'power_t',
0,
1.,
1e-4,
spinType=float,
label='逆比例指数 (t): ',
alignment=Qt.AlignRight,
controlWidth=80,
callback=self.settings_changed)
gui.separator(box, height=12)
self.max_iter_spin = gui.spin(box,
self,
'max_iter',
1,
MAXINT - 1,
label='迭代次数: ',
controlWidth=80,
alignment=Qt.AlignRight,
callback=self.settings_changed)
self.tol_spin = gui.spin(box,
self,
'tol',
0,
10.,
.1e-3,
spinType=float,
controlWidth=80,
label='公差（停止标准）: ',
checked='tol_enabled',
alignment=Qt.AlignRight,
callback=self.settings_changed)
gui.separator(box, height=12)
# Wrap shuffle_cbx inside another hbox to align it with the random_seed
# spin box on OSX
self.shuffle_cbx = gui.checkBox(gui.hBox(box),
self,
'shuffle',
'每次迭代后随机化数据',
callback=self._on_shuffle_change)
self.random_seed_spin = gui.spin(box,
self,
'random_state',
0,
MAXINT,
label='固定随机化种子:',
controlWidth=80,
alignment=Qt.AlignRight,
callback=self.settings_changed,
checked='use_random_state',
checkCallback=self.settings_changed)
# Enable/disable appropriate controls
self._on_learning_rate_change()
self._on_shuffle_change()
def __init__(self):
super().__init__()
self.primary_data = None
self.more_data = OrderedDict()
self.mergebox = gui.vBox(self.controlArea, "Domain Merging")
box = gui.radioButtons(self.mergebox,
self,
"merge_type",
callback=self._merge_type_changed)
gui.widgetLabel(
box,
self.tr("When there is no primary table, " +
"the domain should be:"))
for opts in self.domain_opts:
gui.appendRadioButton(box, self.tr(opts))
gui.separator(box)
label = gui.widgetLabel(
box,
self.tr("The resulting table will have a class only if there " +
"is no conflict between input classes."))
label.setWordWrap(True)
###
box = gui.vBox(self.controlArea,
self.tr("Source Identification"),
addSpace=False)
cb = gui.checkBox(box,
self,
"append_source_column",
self.tr("Append data source IDs"),
callback=self._source_changed)
ibox = gui.indentedBox(box, sep=gui.checkButtonOffsetHint(cb))
form = QFormLayout(spacing=8,
labelAlignment=Qt.AlignLeft,
formAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QFormLayout.AllNonFixedFieldsGrow)
form.addRow(
self.tr("Feature name:"),
gui.lineEdit(ibox,
self,
"source_attr_name",
valueType=str,
callback=self._source_changed))
form.addRow(
self.tr("Place:"),
gui.comboBox(ibox,
self,
"source_column_role",
items=self.id_roles,
callback=self._source_changed))
ibox.layout().addLayout(form)
mleft, mtop, mright, _ = ibox.layout().getContentsMargins()
ibox.layout().setContentsMargins(mleft, mtop, mright, 4)
cb.disables.append(ibox)
cb.makeConsistent()
box = gui.auto_apply(self.controlArea,
self,
"auto_commit",
commit=self.apply)
box.button.setFixedWidth(180)
box.layout().insertStretch(0)
def __init__(self):
"""Widget creator."""
super().__init__()
# ATTRIBUTS
# searchFunction
self.searchResults = None
self.inputSeg = None
# newQuery = attribut box lineEdit (search something)
self.newQuery = ''
self.nbr_results = 10
# Results box attributs
self.titleLabels = list()
self.selectedTitles = list()
# selections box attributs
self.myTitles = list()
self.mytitleLabels = list()
# stock all the inputs (songs) in a list
self.createdInputs = list()
# Next two instructions are helpers from TextableUtils. Corresponding
# interface elements are declared here and actually drawn below (at
# their position in the UI)...
self.infoBox = InfoBox(widget=self.controlArea)
self.sendButton = SendButton(
widget=self.controlArea,
master=self,
callback=self.sendData,
infoBoxAttribute="infoBox",
)
#----------------------------------------------------------------------
# User interface...
# Create the working area
queryBox = gui.widgetBox(
widget=self.controlArea,
box="Search songs",
orientation="vertical",
)
# Allows to enter specific text to the research
# Uses "newQuery" attribut
gui.lineEdit(
widget=queryBox,
master=self,
value='newQuery',
orientation='horizontal',
label=u"Query: ",
labelWidth=120,
tooltip=("Enter a string"),
)
# Allows to choose the wanted results numberp (10 by 10)
queryNbr = gui.comboBox(
widget=queryBox,
master=self,
value="nbr_results",
items=[
"10",
"20",
"30",
"40",
"50",
"60",
"70",
"80",
"90",
"100",
],
sendSelectedValue=True,
orientation="horizontal",
label="Number of results: ",
labelWidth=120,
tooltip=("Please select the desired search.\n"),
)
# Reasearch button
# Uses "searchFunction" attribut
self.searchButton = gui.button(
widget=queryBox,
master=self,
label="Search",
callback=self.searchFunction,
tooltip="Connect Genius and make a research",
)
self.titleListbox = gui.listBox(
widget=queryBox,
master=self,
value="selectedTitles", # setting (list)
labels="titleLabels", # setting (list)
callback=lambda: self.addButton.setDisabled(self.selectedTitles ==
list()),
tooltip="The list of titles whose content will be imported",
)
self.titleListbox.setMinimumHeight(150)
self.titleListbox.setSelectionMode(3)
boxbutton = gui.widgetBox(
widget=queryBox,
box=False,
orientation='horizontal',
)
# Add songs button
self.addButton = gui.button(
widget=boxbutton,
master=self,
label=u'Add to corpus',
callback=self.add,
tooltip=(u"Move the selected song downward in your corpus."),
)
self.addButton.setDisabled(True)
# Clear button
# Uses "clearResults" function
self.clearButton = gui.button(
widget=boxbutton,
master=self,
label="Clear results",
callback=self.clearResults,
tooltip="Clear results",
)
self.clearButton.setDisabled(True)
gui.separator(widget=queryBox, height=3)
# area where confirmed songs are moved and stocked
mytitleBox = gui.widgetBox(
widget=self.controlArea,
box="Corpus",
orientation="vertical",
)
self.mytitleListbox = gui.listBox(
widget=mytitleBox,
master=self,
value="myTitles",
labels="mytitleLabels",
callback=lambda: self.removeButton.setDisabled(self.myTitles ==
list()),
tooltip="The list of titles whose content will be imported",
)
self.mytitleListbox.setMinimumHeight(150)
self.mytitleListbox.setSelectionMode(3)
boxbutton2 = gui.widgetBox(
widget=mytitleBox,
box=False,
orientation='horizontal',
)
# Remove songs button
self.removeButton = gui.button(
widget=boxbutton2,
master=self,
label=u'Remove from corpus',
callback=self.remove,
tooltip=(u"Remove the selected song from your corpus."),
)
self.removeButton.setDisabled(True)
# Delete all confirmed songs button
self.clearmyBasket = gui.button(
widget=boxbutton2,
master=self,
label=u'Clear corpus',
callback=self.clearmyBasket,
tooltip=(u"Remove all songs from your corpus."),
)
self.clearmyBasket.setDisabled(True)
gui.separator(widget=mytitleBox, height=3)
gui.rubber(self.controlArea)
#----------------------------------------------------------------------
# Draw Info box and Send button
self.sendButton.draw()
self.searchButton.setDefault(True)
self.infoBox.draw()
# Update the selections list
self.updateMytitleLabels()
# Send data if autoSend.
self.sendButton.sendIf()
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
# Other attributes...
self.segmentation = None
self.operation = "no"
self.applyInclusion = False
self.applyExclusion = False
self.applySampling = True
self.samplingRate = 100
self.createdInputs = list()
self.folderLabels = list()
self.selectedFolderLabels = list()
self.rootFolderPath = u''
self.inclusionsUser = u''
self.exclusionsUser = u''
self.newAnnotationKey = u''
self.newAnnotationValue = u''
# self.folder is a dictionary whose keys are :'rootPath', 'maxDepth','inclusionsUser','exclusionsUser', ...
# ... 'samplingRate' and 'fileList'
self.folder = dict()
# self.folders is a list of previously defined "self.folder" dictionaries
self.folders = list()
# self.inclusionList is the default inclusion list (used in minimal mode, ...
# ... and in advanced mode when no inclusion has been selected)
self.inclusionList = [".txt", ".html", ".xml", ".csv", ".rtf"]
# self.inclusionList is the default null inclusion list (used in minimal mode, ...
# ... and in advanced mode when no inclusion has been selected)
self.exclusionList = []
self.infoBox = InfoBox(widget=self.controlArea)
self.sendButton = SendButton(
widget=self.controlArea,
master=self,
callback=self.sendData,
infoBoxAttribute='infoBox',
sendIfPreCallback=self.updateGUI,
)
self.advancedSettings = AdvancedSettings(
widget=self.controlArea,
master=self,
callback=self.sendButton.settingsChanged,
)
# GUI...
# Advanced settings checkbox...
self.advancedSettings.draw()
# BASIC GUI...
# Basic folder box
basicFolderBox = gui.widgetBox(
widget=self.controlArea,
box=u'Source',
orientation='vertical',
addSpace=False,
)
basicFolderBoxLine1 = gui.widgetBox(
widget=basicFolderBox,
box=False,
orientation='horizontal',
)
gui.lineEdit(
widget=basicFolderBoxLine1,
master=self,
value='rootFolderPath',
orientation='horizontal',
label=u'Folder path:',
labelWidth=101,
callback=self.add,
tooltip=(u"The path of the folder."),
)
gui.separator(widget=basicFolderBoxLine1, width=5)
gui.button(
widget=basicFolderBoxLine1,
master=self,
label=u'Browse',
callback=self.browse,
tooltip=(u"Open a dialog for selecting a top folder."),
)
gui.separator(widget=basicFolderBox, width=3)
self.advancedSettings.basicWidgets.append(basicFolderBox)
self.advancedSettings.basicWidgetsAppendSeparator()
# ADVANCED GUI...
# folder box
folderBox = gui.widgetBox(
widget=self.controlArea,
box=u'Sources',
orientation='vertical',
addSpace=False,
)
folderBoxLine1 = gui.widgetBox(
widget=folderBox,
box=False,
orientation='horizontal',
addSpace=True,
)
self.folderListbox = gui.listBox(
widget=folderBoxLine1,
master=self,
value='selectedFolderLabels',
labels='folderLabels',
callback=self.updatefolderBoxButtons,
tooltip=(u"The list of folders whose content will be imported.\n"
u"\nIn the output segmentation, the content of each\n"
u"folder appears in the same position as in the list.\n"
u"\nColumn 1 shows the folder's name.\n"
u"Column 2 shows the folder's depth.\n"
u"Column 3 shows the inclusions filter.\n"
u"Column 4 shows the exclusions filter.\n"
u"Column 5 shows the folder's level of sampling."),
)
font = QFont()
font.setFamily('Courier')
font.setStyleHint(QFont.Courier)
font.setPixelSize(12)
self.folderListbox.setFont(font)
folderBoxCol2 = gui.widgetBox(
widget=folderBoxLine1,
orientation='vertical',
)
self.moveUpButton = gui.button(
widget=folderBoxCol2,
master=self,
label=u'Move Up',
callback=self.moveUp,
tooltip=(u"Move the selected folder upward in the list."),
)
self.moveDownButton = gui.button(
widget=folderBoxCol2,
master=self,
label=u'Move Down',
callback=self.moveDown,
tooltip=(u"Move the selected folder downward in the list."),
)
self.removeButton = gui.button(
widget=folderBoxCol2,
master=self,
label=u'Remove',
callback=self.remove,
tooltip=(u"Remove the selected folder from the list."),
)
self.clearAllButton = gui.button(
widget=folderBoxCol2,
master=self,
label=u'Clear All',
callback=self.clearAll,
tooltip=(u"Remove all folders from the list."),
)
self.exportButton = gui.button(
widget=folderBoxCol2,
master=self,
label=u'',
callback=self.exportList,
disabled=True,
tooltip=(u"Open a dialog for selecting a folder where the folder\n"
u"list can be exported in JSON format."),
)
self.importButton = gui.button(
widget=folderBoxCol2,
master=self,
label=u'',
callback=self.importList,
disabled=True,
tooltip=(u"Open a dialog for selecting a folder list to\n"
u"import (in JSON format). folders from this list\n"
u"will be added to those already imported."),
)
folderBoxLine2 = gui.widgetBox(
widget=folderBox,
box=False,
orientation='vertical',
)
# Add folder box
addFolderBox = gui.widgetBox(
widget=folderBoxLine2,
box=True,
orientation='vertical',
)
addFolderBoxLine1 = gui.widgetBox(
widget=addFolderBox,
orientation='horizontal',
)
# Folder path input
gui.lineEdit(
widget=addFolderBoxLine1,
master=self,
value='rootFolderPath',
orientation='horizontal',
label=u'Folder path:',
labelWidth=101,
callback=self.updateGUI,
tooltip=(u"The paths of the folders that will be added to the\n"
u"list when button 'Add' is clicked.\n\n"
u"Successive paths must be separated with ' / ' \n"
u"(whitespace + slash + whitespace). Their order in\n"
u"the list will be the same as in this field."),
)
gui.separator(widget=addFolderBoxLine1, width=5)
# Button Browse
gui.button(
widget=addFolderBoxLine1,
master=self,
label=u'Browse',
callback=self.browse,
tooltip=(u"Open a dialog for selecting a top folder.\n\n"
u"Selected folder paths will appear in the field to\n"
u"the left of this button afterwards, ready to be\n"
u"added to the list when button 'Add' is clicked."),
)
gui.separator(widget=addFolderBox, width=10)
# Filter box to input include
gui.separator(widget=addFolderBox, width=3)
includeBoxLine1 = gui.widgetBox(
widget=addFolderBox,
box=False,
orientation='horizontal',
)
# Include box
gui.checkBox(
widget=includeBoxLine1,
master=self,
value='applyInclusion',
label=u'Include',
labelWidth=100,
callback=lambda: includeLineEdit.setDisabled(not self.
applyInclusion),
tooltip=(u"Choose the inclusion(s)"),
)
includeLineEdit = gui.lineEdit(
widget=includeBoxLine1,
master=self,
value='inclusionsUser',
orientation='horizontal',
label=u'',
disabled=True,
labelWidth=101,
tooltip=(u"This field lets you specify a custom filter\n"
u"to select the folders to be\n"
u"added to the list."),
)
# Filter box to exclude
gui.separator(widget=addFolderBox, width=3)
excludeBoxLine1 = gui.widgetBox(
widget=addFolderBox,
box=False,
orientation='horizontal',
)
# Exclude box
gui.checkBox(
widget=excludeBoxLine1,
master=self,
value='applyExclusion',
label=u'Exclude',
labelWidth=100,
disabled=False,
callback=lambda: includeLineEdit2.setDisabled(not self.
applyExclusion),
tooltip=(u"Exclude the inclusion(s)"),
)
includeLineEdit2 = gui.lineEdit(
widget=excludeBoxLine1,
master=self,
value='exclusionsUser',
orientation='horizontal',
label=u'',
disabled=True,
labelWidth=101,
tooltip=(u"This field lets you specify a custom filter\n"
u"to select the folders to be\n"
u"added to the list."),
)
# Sampling box to input the level of sampling
gui.separator(widget=addFolderBox, width=3)
samplingBoxLine1 = gui.widgetBox(
widget=addFolderBox,
box=False,
orientation='horizontal',
)
# Check box for sampling
gui.checkBox(
widget=samplingBoxLine1,
master=self,
value='applySampling',
label=u'Sampling',
labelWidth=100,
disabled=False,
callback=lambda: samplingSpin.setDisabled(not self.applySampling),
tooltip=(u"Choose the sampling level"),
)
samplingSpin = gui.spin(
widget=samplingBoxLine1,
master=self,
value='samplingRate',
minv=10,
maxv=100,
labelWidth=50,
orientation='horizontal',
tooltip=(u"sampling level"),
)
gui.separator(widget=addFolderBox, width=3)
self.addButton = gui.button(
widget=addFolderBox,
master=self,
label=u'Add',
callback=self.add,
tooltip=(u"Add the folder(s) currently displayed in the\n"
u"'folders' text field to the list.\n\n"
u"Each of these folders will be associated with the\n"
u"specified encoding and annotation (if any).\n\n"
u"Other folders may be selected afterwards and\n"
u"assigned a different encoding and annotation."),
)
self.advancedSettings.advancedWidgets.append(folderBox)
self.advancedSettings.advancedWidgetsAppendSeparator()
# Options box...
optionsBox = gui.widgetBox(
widget=self.controlArea,
box=u'Options',
orientation='vertical',
addSpace=False,
)
optionsBoxLine1 = gui.widgetBox(
widget=optionsBox,
box=False,
orientation='horizontal',
)
gui.separator(widget=optionsBox, width=3)
optionsBoxLine2 = gui.widgetBox(
widget=optionsBox,
box=False,
orientation='horizontal',
)
gui.checkBox(
widget=optionsBoxLine2,
master=self,
value='autoNumber',
label=u'Auto-number with key:',
labelWidth=180,
callback=self.sendButton.settingsChanged,
tooltip=(u"Annotate folders with increasing numeric indices."),
)
self.autoNumberKeyLineEdit = gui.lineEdit(
widget=optionsBoxLine2,
master=self,
value='autoNumberKey',
orientation='horizontal',
callback=self.sendButton.settingsChanged,
tooltip=(u"Annotation key for folder auto-numbering."),
)
gui.separator(widget=optionsBox, width=3)
self.advancedSettings.advancedWidgets.append(optionsBox)
self.advancedSettings.advancedWidgetsAppendSeparator()
gui.rubber(self.controlArea)
# Send button...
self.sendButton.draw()
# Info box...
self.infoBox.draw()
self.adjustSizeWithTimer()
QTimer.singleShot(0, self.sendButton.sendIf)
def __init__(self):
super().__init__()
# sets self.curvePoints, self.steps equidistant points from
# 1/self.steps to 1
self.updateCurvePoints()
# [start-snippet-2]
self.scoring = [("Classification Accuracy",
Orange.evaluation.scoring.CA),
("AUC", Orange.evaluation.scoring.AUC),
("Precision", Orange.evaluation.scoring.Precision),
("Recall", Orange.evaluation.scoring.Recall)]
# [end-snippet-2]
#: input data on which to construct the learning curve
self.data = None
#: A {input_id: Learner} mapping of current learners from input channel
self.learners = OrderedDict()
#: A {input_id: List[Results]} mapping of input id to evaluation
#: results list, one for each curve point
self.results = OrderedDict()
#: A {input_id: List[float]} mapping of input id to learning curve
#: point scores
self.curves = OrderedDict()
# GUI
box = gui.widgetBox(self.controlArea, "Info")
self.infoa = gui.widgetLabel(box, 'No data on input.')
self.infob = gui.widgetLabel(box, 'No learners.')
gui.separator(self.controlArea)
box = gui.widgetBox(self.controlArea, "Evaluation Scores")
gui.comboBox(box,
self,
"scoringF",
items=[x[0] for x in self.scoring],
callback=self._invalidate_curves)
gui.separator(self.controlArea)
box = gui.widgetBox(self.controlArea, "Options")
gui.spin(box,
self,
'folds',
2,
100,
step=1,
label='Cross validation folds: ',
keyboardTracking=False,
callback=lambda: self._invalidate_results()
if self.commitOnChange else None)
gui.spin(box,
self,
'steps',
2,
100,
step=1,
label='Learning curve points: ',
keyboardTracking=False,
callback=[
self.updateCurvePoints,
lambda: self._invalidate_results()
if self.commitOnChange else None
])
gui.checkBox(box, self, 'commitOnChange',
'Apply setting on any change')
self.commitBtn = gui.button(box,
self,
"Apply Setting",
callback=self._invalidate_results,
disabled=True)
gui.rubber(self.controlArea)
# table widget
self.table = gui.table(self.mainArea,
selectionMode=QTableWidget.NoSelection)
def __init__(self):
super().__init__()
self.primary_data = None
self.more_data = OrderedDict()
self.mergebox = gui.vBox(self.controlArea, "合并方法")
box = gui.radioButtons(
self.mergebox, self, "merge_type",
callback=self._merge_type_changed)
gui.widgetLabel(
box, self.tr("当没有主表时，" +
"方法应该是："))
for opts in self.domain_opts:
gui.appendRadioButton(box, self.tr(opts))
gui.separator(box)
label = gui.widgetLabel(
box,
self.tr("只有在输入类别(class)之间没有冲突时，结果表才会有一个类别(class)。"
))
label.setWordWrap(True)
###
box = gui.vBox(
self.controlArea, self.tr("数据源识别"),
addSpace=False)
cb = gui.checkBox(
box, self, "append_source_column",
self.tr("附加数据源ID"),
callback=self._source_changed)
ibox = gui.indentedBox(box, sep=gui.checkButtonOffsetHint(cb))
form = QFormLayout(
spacing=8,
labelAlignment=Qt.AlignLeft,
formAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QFormLayout.AllNonFixedFieldsGrow
)
form.addRow(
self.tr("特征名称:"),
gui.lineEdit(ibox, self, "source_attr_name", valueType=str,
callback=self._source_changed))
form.addRow(
self.tr("位于:"),
gui.comboBox(ibox, self, "source_column_role", items=self.id_roles,
callback=self._source_changed))
ibox.layout().addLayout(form)
mleft, mtop, mright, _ = ibox.layout().getContentsMargins()
ibox.layout().setContentsMargins(mleft, mtop, mright, 4)
cb.disables.append(ibox)
cb.makeConsistent()
box = gui.auto_apply(self.controlArea, self, "auto_commit", commit=self.apply)
box.button.setFixedWidth(180)
box.layout().insertStretch(0)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
# Other attributes...
self.segmentation = None
self.createdInputs = list()
self.fileLabels = list()
self.selectedFileLabels = list()
self.newFiles = u''
self.newAnnotationKey = u''
self.newAnnotationValue = u''
self.pdfPassword = u'' # SuperTextFiles
self.ocrForce = False # SuperTextFiles
self.ocrLanguages = u'eng' # SuperTextFiles
self.infoBox = InfoBox(widget=self.controlArea)
self.sendButton = SendButton(
widget=self.controlArea,
master=self,
callback=self.sendData,
infoBoxAttribute='infoBox',
sendIfPreCallback=self.updateGUI,
)
self.advancedSettings = AdvancedSettings(
widget=self.controlArea,
master=self,
callback=self.sendButton.settingsChanged,
)
# GUI...
# Advanced settings checkbox...
self.advancedSettings.draw()
# BASIC GUI...
# Basic file box
basicFileBox = gui.widgetBox(
widget=self.controlArea,
box=u'Source',
orientation='vertical',
addSpace=False,
)
basicFileBoxLine1 = gui.widgetBox(
widget=basicFileBox,
box=False,
orientation='horizontal',
)
gui.lineEdit(
widget=basicFileBoxLine1,
master=self,
value='file',
orientation='horizontal',
label=u'File path:',
labelWidth=101,
callback=self.sendButton.settingsChanged,
tooltip=(
u"The path of the file."
),
)
gui.separator(widget=basicFileBoxLine1, width=5)
gui.button(
widget=basicFileBoxLine1,
master=self,
label=u'Browse',
callback=self.browse,
tooltip=(
u"Open a dialog for selecting file."
),
)
gui.separator(widget=basicFileBox, width=3)
advancedEncodingsCombobox = gui.comboBox(
widget=basicFileBox,
master=self,
value='encoding',
items=getPredefinedEncodings(),
sendSelectedValue=True,
orientation='horizontal',
label=u'Encoding:',
labelWidth=101,
callback=self.sendButton.settingsChanged,
tooltip=(
u"Select input file(s) encoding."
),
)
addSeparatorAfterDefaultEncodings(advancedEncodingsCombobox)
addAutoDetectEncoding(advancedEncodingsCombobox)
gui.separator(widget=basicFileBox, width=3)
self.advancedSettings.basicWidgets.append(basicFileBox)
self.advancedSettings.basicWidgetsAppendSeparator()
# ADVANCED GUI...
defaultLabelWidth = 120 # SuperTextFiles
# File box
fileBox = gui.widgetBox(
widget=self.controlArea,
box=u'Sources',
orientation='vertical',
addSpace=False,
)
fileBoxLine1 = gui.widgetBox(
widget=fileBox,
box=False,
orientation='horizontal',
addSpace=True,
)
self.fileListbox = gui.listBox(
widget=fileBoxLine1,
master=self,
value='selectedFileLabels',
labels='fileLabels',
callback=self.updateFileBoxButtons,
tooltip=(
u"The list of files whose content will be imported.\n"
u"\nIn the output segmentation, the content of each\n"
u"file appears in the same position as in the list.\n"
u"\nColumn 1 shows the file's name.\n"
u"Column 2 shows the file's annotation (if any).\n"
# Start SuperTextFiles
# u"Column 3 shows the file's encoding." # removed
u"Column 3 shows the file's password (if any).\n"
u"Column 4 shows the file's languages (if any).\n"
u"Column 5 shows if OCR is forced.\n"
u"Column 6 shows the file's encoding."
# End SuperTextFiles
),
)
font = QFont()
font.setFamily('Courier')
font.setStyleHint(QFont.Courier)
font.setPixelSize(12)
self.fileListbox.setFont(font)
fileBoxCol2 = gui.widgetBox(
widget=fileBoxLine1,
orientation='vertical',
)
self.moveUpButton = gui.button(
widget=fileBoxCol2,
master=self,
label=u'Move Up',
callback=self.moveUp,
tooltip=(
u"Move the selected file upward in the list."
),
)
self.moveDownButton = gui.button(
widget=fileBoxCol2,
master=self,
label=u'Move Down',
callback=self.moveDown,
tooltip=(
u"Move the selected file downward in the list."
),
)
self.removeButton = gui.button(
widget=fileBoxCol2,
master=self,
label=u'Remove',
callback=self.remove,
tooltip=(
u"Remove the selected file from the list."
),
)
self.clearAllButton = gui.button(
widget=fileBoxCol2,
master=self,
label=u'Clear All',
callback=self.clearAll,
tooltip=(
u"Remove all files from the list."
),
)
self.exportButton = gui.button(
widget=fileBoxCol2,
master=self,
label=u'Export List',
callback=self.exportList,
tooltip=(
u"Open a dialog for selecting a file where the file\n"
u"list can be exported in JSON format."
),
)
self.importButton = gui.button(
widget=fileBoxCol2,
master=self,
label=u'Import List',
callback=self.importList,
tooltip=(
u"Open a dialog for selecting a file list to\n"
u"import (in JSON format). Files from this list\n"
u"will be added to those already imported."
),
)
fileBoxLine2 = gui.widgetBox(
widget=fileBox,
box=False,
orientation='vertical',
)
# Add file box
addFileBox = gui.widgetBox(
widget=fileBoxLine2,
box=True,
orientation='vertical',
)
addFileBoxLine1 = gui.widgetBox(
widget=addFileBox,
orientation='horizontal',
)
gui.lineEdit(
widget=addFileBoxLine1,
master=self,
value='newFiles',
orientation='horizontal',
label=u'File path(s):',
labelWidth=defaultLabelWidth,
callback=self.updateGUI,
tooltip=(
u"The paths of the files that will be added to the\n"
u"list when button 'Add' is clicked.\n\n"
u"Successive paths must be separated with ' / ' \n"
u"(whitespace + slash + whitespace). Their order in\n"
u"the list will be the same as in this field."
),
)
gui.separator(widget=addFileBoxLine1, width=5)
gui.button(
widget=addFileBoxLine1,
master=self,
label=u'Browse',
callback=self.browse,
tooltip=(
u"Open a dialog for selecting files.\n\n"
u"To select multiple files at once, either draw a\n"
u"selection box around them, or use shift and/or\n"
u"ctrl + click.\n\n"
u"Selected file paths will appear in the field to\n"
u"the left of this button afterwards, ready to be\n"
u"added to the list when button 'Add' is clicked."
),
)
gui.separator(widget=addFileBox, width=3)
basicEncodingsCombobox = gui.comboBox(
widget=addFileBox,
master=self,
value='encoding',
items=getPredefinedEncodings(),
sendSelectedValue=True,
orientation='horizontal',
label=u'Encoding:',
labelWidth=defaultLabelWidth,
callback=self.updateGUI,
tooltip=(
u"Select input file(s) encoding."
),
)
addSeparatorAfterDefaultEncodings(basicEncodingsCombobox)
addAutoDetectEncoding(basicEncodingsCombobox)
self.encoding = self.encoding
gui.separator(widget=addFileBox, width=3)
gui.lineEdit(
widget=addFileBox,
master=self,
value='newAnnotationKey',
orientation='horizontal',
label=u'Annotation key:',
labelWidth=defaultLabelWidth,
callback=self.updateGUI,
tooltip=(
u"This field lets you specify a custom annotation\n"
u"key associated with each file that is about to be\n"
u"added to the list."
),
)
gui.separator(widget=addFileBox, width=3)
gui.lineEdit(
widget=addFileBox,
master=self,
value='newAnnotationValue',
orientation='horizontal',
label=u'Annotation value:',
labelWidth=defaultLabelWidth,
callback=self.updateGUI,
tooltip=(
u"This field lets you specify the annotation value\n"
u"associated with the above annotation key."
),
)
### Start SuperTextFiles addition
gui.separator(widget=addFileBox, width=3)
# Field for PDF password
gui.lineEdit(
widget=addFileBox,
master=self,
value='pdfPassword',
orientation='horizontal',
label=u'PDF password:'******'ocrLanguages',
orientation='horizontal',
label=u'OCR Language(s):',
labelWidth=defaultLabelWidth,
callback=self.updateGUI,
tooltip=(
u"This field lets you specify languages\n"
u"for the OCR process. Ex.: fra+ita"
),
)
gui.checkBox(
widget=addFileBox,
master=self,
value='ocrForce',
label=u'Force OCR',
labelWidth=defaultLabelWidth,
callback=self.updateGUI,
tooltip=(u"Force to use an OCR detection on this file"),
)
### End SuperTextFiles addition
gui.separator(widget=addFileBox, width=3)
self.addButton = gui.button(
widget=addFileBox,
master=self,
label=u'Add',
callback=self.add,
tooltip=(
u"Add the file(s) currently displayed in the\n"
u"'Files' text field to the list.\n\n"
u"Each of these files will be associated with the\n"
u"specified encoding and annotation (if any).\n\n"
u"Other files may be selected afterwards and\n"
u"assigned a different encoding and annotation."
),
)
self.advancedSettings.advancedWidgets.append(fileBox)
self.advancedSettings.advancedWidgetsAppendSeparator()
# Options box...
optionsBox = gui.widgetBox(
widget=self.controlArea,
box=u'Options',
orientation='vertical',
addSpace=False,
)
optionsBoxLine1 = gui.widgetBox(
widget=optionsBox,
box=False,
orientation='horizontal',
)
gui.checkBox(
widget=optionsBoxLine1,
master=self,
value='importFilenames',
label=u'Import file names with key:',
labelWidth=180,
callback=self.sendButton.settingsChanged,
tooltip=(
u"Import file names as annotations."
),
)
self.importFilenamesKeyLineEdit = gui.lineEdit(
widget=optionsBoxLine1,
master=self,
value='importFilenamesKey',
orientation='horizontal',
callback=self.sendButton.settingsChanged,
tooltip=(
u"Annotation key for importing file names."
),
)
gui.separator(widget=optionsBox, width=3)
optionsBoxLine2 = gui.widgetBox(
widget=optionsBox,
box=False,
orientation='horizontal',
)
gui.checkBox(
widget=optionsBoxLine2,
master=self,
value='autoNumber',
label=u'Auto-number with key:',
labelWidth=180,
callback=self.sendButton.settingsChanged,
tooltip=(
u"Annotate files with increasing numeric indices."
),
)
self.autoNumberKeyLineEdit = gui.lineEdit(
widget=optionsBoxLine2,
master=self,
value='autoNumberKey',
orientation='horizontal',
callback=self.sendButton.settingsChanged,
tooltip=(
u"Annotation key for file auto-numbering."
),
)
gui.separator(widget=optionsBox, width=3)
self.advancedSettings.advancedWidgets.append(optionsBox)
self.advancedSettings.advancedWidgetsAppendSeparator()
gui.rubber(self.controlArea)
# Send button...
self.sendButton.draw()
# Info box...
self.infoBox.draw()
self.adjustSizeWithTimer()
QTimer.singleShot(0, self.sendButton.sendIf)
def __init__(self):
"""Widget creator."""
super().__init__()
if INSTALLED_MODELS:
self.model = INSTALLED_MODELS[0]
else:
self.model = ""
# Other attributes...
self.inputSeg = None
self.nlp = None
self.selectedModels = list()
self.downloadableModelLabels = list()
self.loadedComponents = list()
self.mustLoad = True
# Next two instructions are helpers from TextableUtils. Corresponding
# interface elements are declared here and actually drawn below (at
# their position in the UI)...
self.infoBox = InfoBox(widget=self.controlArea)
self.sendButton = SendButton(
widget=self.controlArea,
master=self,
callback=self.sendData,
infoBoxAttribute="infoBox",
sendIfPreCallback=None,
)
# User interface...
# Tabs...
self.tabs = QTabWidget()
self.optionsTab = QWidget()
self.modelManagerTab = QWidget()
self.tabs.addTab(self.optionsTab, "Options")
self.tabs.addTab(self.modelManagerTab, "Model manager")
# Options tab...
OptionsTabBox = QHBoxLayout()
optionsBox = gui.widgetBox(widget=self.optionsTab)
self.modelComboBox = gui.comboBox(
widget=optionsBox,
master=self,
value='model',
label='Model: ',
tooltip='Select the spaCy language model you want to use.',
items=INSTALLED_MODELS[:],
sendSelectedValue=True,
callback=self.modelComboboxChanged,
)
gui.separator(widget=optionsBox, height=3)
annotationsBox = gui.widgetBox(
widget=optionsBox,
box="Additional token annotations:",
)
annotationsBoxLine1 = gui.widgetBox(
widget=annotationsBox,
orientation="horizontal",
box=None,
)
gui.checkBox(
widget=annotationsBoxLine1,
master=self,
value='annotatePOSTags',
label='part-of-speech tags',
callback=self.updateDisabledComponents,
tooltip=("Annotate output tokens with part-of-speech tags."),
)
self.annotatePOSTagsReloadLabel = gui.label(
annotationsBoxLine1,
master=self,
label="(reload needed)",
)
self.annotatePOSTagsReloadLabel.setStyleSheet(
"font-style: oblique; color: gray"
)
annotationsBoxLine2 = gui.widgetBox(
widget=annotationsBox,
orientation="horizontal",
box=None,
)
gui.checkBox(
widget=annotationsBoxLine2,
master=self,
value='annotateDependencies',
label='syntactic dependencies',
callback=self.updateDisabledComponents,
tooltip=("Annotate output tokens with syntactic dependencies."),
)
self.annotateDependenciesReloadLabel = gui.label(
annotationsBoxLine2,
master=self,
label="(reload needed)",
)
self.annotateDependenciesReloadLabel.setStyleSheet(
"font-style: oblique; color: gray"
)
annotationsBoxLine3 = gui.widgetBox(
widget=annotationsBox,
orientation="horizontal",
box=None,
)
gui.checkBox(
widget=annotationsBoxLine3,
master=self,
value='annotateEntities',
label='named entities',
callback=self.updateDisabledComponents,
tooltip=("Annotate output tokens with named entities."),
)
self.annotateEntitiesReloadLabel = gui.label(
annotationsBoxLine3,
master=self,
label="(reload needed)",
)
self.annotateEntitiesReloadLabel.setStyleSheet(
"font-style: oblique; color: gray"
)
segmentationsBox = gui.widgetBox(
widget=optionsBox,
box="Additional segmentations:",
)
segmentationsBoxLine1 = gui.widgetBox(
widget=segmentationsBox,
orientation="horizontal",
box=None,
)
gui.checkBox(
widget=segmentationsBoxLine1,
master=self,
value='segmentEntities',
label='named entities',
callback=self.updateDisabledComponents,
tooltip="Output named entity segmentation on separate channel.",
)
self.segmentEntitiesReloadLabel = gui.label(
segmentationsBoxLine1,
master=self,
label="(reload needed)",
)
self.segmentEntitiesReloadLabel.setStyleSheet(
"font-style: oblique; color: gray"
)
segmentationsBoxLine2 = gui.widgetBox(
widget=segmentationsBox,
orientation="horizontal",
box=None,
)
gui.checkBox(
widget=segmentationsBoxLine2,
master=self,
value='segmentChunks',
label='noun chunks',
callback=self.updateDisabledComponents,
tooltip="Output noun chunk segmentation on separate channel.",
)
self.segmentChunksReloadLabel = gui.label(
segmentationsBoxLine2,
master=self,
label="(reload needed)",
)
self.segmentChunksReloadLabel.setStyleSheet(
"font-style: oblique; color: gray"
)
segmentationsBoxLine3 = gui.widgetBox(
widget=segmentationsBox,
orientation="horizontal",
box=None,
)
gui.checkBox(
widget=segmentationsBoxLine3,
master=self,
value='segmentSentences',
label='sentences',
callback=self.updateDisabledComponents,
tooltip="Output sentence segmentation on separate channel.",
)
self.segmentSentencesReloadLabel = gui.label(
segmentationsBoxLine3,
master=self,
label="(reload needed)",
)
self.segmentSentencesReloadLabel.setStyleSheet(
"font-style: oblique; color: gray"
)
self.updateReloadNeededLabels()
gui.comboBox(
widget=optionsBox,
master=self,
value='maxLen',
items=["1 million"] + ["%i millions" % l for l in range(2, 10)] \
+ ["no limit"],
sendSelectedValue=True,
label=u'Max number of input characters:',
tooltip=(
"The spaCy parser and NER models require roughly 1GB of\n"
"temporary memory per 100'000 characters in the input.\n"
"This means long texts may cause memory allocation errors.\n"
"If you're not using the parser or NER, or have lots of \n"
"RAM, it's probably safe to increase the default limit of\n"
"1 million characters."
),
)
gui.rubber(optionsBox)
OptionsTabBox.addWidget(optionsBox)
self.optionsTab.setLayout(OptionsTabBox)
# Model manager tab...
modelManagerTabBox = QHBoxLayout()
modelManagerBox = gui.widgetBox(widget=self.modelManagerTab)
gui.label(modelManagerBox, self, label="Available models:")
self.downloadableModelsListbox = gui.listBox(
widget=modelManagerBox,
master=self,
value="selectedModels",
labels="downloadableModelLabels",
callback=self.downloadableModelsListboxChanged,
tooltip="Select language models then click Download.",
)
self.downloadableModelsListbox.setSelectionMode(3)
self.downloadableModelLabels = DOWNLOADABLE_MODELS[:]
self.downloadableModelLabels = self.downloadableModelLabels
self.downloadButton = gui.button(
widget=modelManagerBox,
master=self,
label="Download",
callback=self.downloadModels,
tooltip="Download the selected language models.",
)
self.downloadButton.setDisabled(True)
modelManagerTabBox.addWidget(modelManagerBox)
self.modelManagerTab.setLayout(modelManagerTabBox)
self.controlArea.layout().addWidget(self.tabs)
gui.rubber(self.controlArea)
# Now Info box and Send button must be drawn...
self.sendButton.draw()
self.infoBox.draw()
self.infoBox.setText("Widget needs input.", "warning")
# Check that there's a model...
if not self.model:
self.infoBox.setText(
"Please download a language model first.",
"warning",
)
self.tabs.setCurrentIndex(1)
optionsBox.setDisabled(True)
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, showGrid=False, selectionMode=QtGui.QTableWidget.NoSelection)
box.layout().addWidget(self.cond_list)
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)
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)
boxes = gui.widgetBox(self.controlArea,
orientation=QtGui.QGridLayout())
layout = boxes.layout()
layout.setColumnStretch(0, 1)
layout.setColumnStretch(1, 1)
box_data = gui.vBox(boxes, 'Data', addToLayout=False)
self.data_in_variables = gui.widgetLabel(box_data, " ")
self.data_out_rows = gui.widgetLabel(box_data, " ")
layout.addWidget(box_data, 0, 0)
box_setting = gui.vBox(boxes, 'Purging', addToLayout=False)
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)
layout.addWidget(box_setting, 0, 1)
self.report_button.setFixedWidth(120)
gui.rubber(self.buttonsArea.layout())
layout.addWidget(self.buttonsArea, 1, 0)
acbox = gui.auto_commit(None,
self,
"auto_commit",
label="Send",
orientation=Qt.Horizontal,
checkbox_label="Send automatically")
layout.addWidget(acbox, 1, 1)
self.set_data(None)
self.resize(600, 400)
def __init__(self):
super().__init__()
# var models
self.x_var_model = itemmodels.VariableListModel()
self.y_var_model = itemmodels.VariableListModel()
# info box
self.info_box = gui.widgetBox(self.controlArea, "Info")
self.learner_label = gui.label(
widget=self.info_box, master=self, label="")
# options box
policy = QSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Fixed)
self.options_box = gui.widgetBox(self.controlArea, "Data")
opts = dict(
widget=self.options_box, master=self, orientation=Qt.Horizontal,
callback=self.change_attributes, sendSelectedValue=True,
maximumContentsLength=15
)
self.cbx = gui.comboBox(value='attr_x', label='X:', **opts)
self.cby = gui.comboBox(value='attr_y', label='Y:', **opts)
self.target_class_combobox = gui.comboBox(
value='target_class', label='Target class: ', **opts)
self.cbx.setModel(self.x_var_model)
self.cby.setModel(self.y_var_model)
gui.separator(self.controlArea, 20, 20)
# properties box
self.properties_box = gui.widgetBox(self.controlArea, "Properties")
self.alpha_spin = gui.spin(
widget=self.properties_box, master=self, callback=self.change_alpha,
value="alpha", label="Learning rate: ",
minv=0.001, maxv=100, step=0.001, spinType=float, decimals=3,
alignment=Qt.AlignRight, controlWidth=80)
self.stochastic_checkbox = gui.checkBox(
widget=self.properties_box, master=self,
callback=self.change_stochastic, value="stochastic",
label="Stochastic ")
self.step_size_spin = gui.spin(
widget=self.properties_box, master=self, callback=self.change_step,
value="step_size", label="Step size: ",
minv=1, maxv=100, step=1, alignment=Qt.AlignRight, controlWidth=80)
self.restart_button = gui.button(
widget=self.properties_box, master=self,
callback=self.restart, label="Restart")
self.alpha_spin.setSizePolicy(policy)
self.step_size_spin.setSizePolicy(policy)
gui.separator(self.controlArea, 20, 20)
# step box
self.step_box = gui.widgetBox(self.controlArea, "Manually step through")
self.step_button = gui.button(
widget=self.step_box, master=self, callback=self.step, label="Step",
default=True)
self.step_back_button = gui.button(
widget=self.step_box, master=self, callback=self.step_back,
label="Step back")
gui.separator(self.controlArea, 20, 20)
# run box
self.run_box = gui.widgetBox(self.controlArea, "Run")
self.auto_play_button = gui.button(
widget=self.run_box, master=self,
label=self.auto_play_button_text[0], callback=self.auto_play)
self.auto_play_speed_spinner = gui.hSlider(
widget=self.run_box, master=self, value='auto_play_speed',
minValue=0, maxValue=1.91, step=0.1,
intOnly=False, createLabel=False, label='Speed:')
# graph in mainArea
self.scatter = Scatterplot(click_callback=self.change_theta,
xAxis_gridLineWidth=0,
yAxis_gridLineWidth=0,
title_text='',
tooltip_shared=False,
legend=dict(enabled=False),)
gui.rubber(self.controlArea)
# Just render an empty chart so it shows a nice 'No data to display'
self.scatter.chart()
self.mainArea.layout().addWidget(self.scatter)
self.step_size_lock()
self.step_back_button_lock()
def add_main_layout(self):
# this is part of init, pylint: disable=attribute-defined-outside-init
form = QFormLayout()
form.setFieldGrowthPolicy(form.AllNonFixedFieldsGrow)
form.setVerticalSpacing(25)
form.setLabelAlignment(Qt.AlignLeft)
gui.widgetBox(self.controlArea, True, orientation=form)
form.addRow(
"Neurons in hidden layers:",
gui.lineEdit(
None,
self,
"hidden_layers_input",
orientation=Qt.Horizontal,
callback=self.settings_changed,
tooltip="A list of integers defining neurons. Length of list "
"defines the number of layers. E.g. 4, 2, 2, 3.",
placeholderText="e.g. 10,"))
form.addRow(
"Activation:",
gui.comboBox(None,
self,
"activation_index",
orientation=Qt.Horizontal,
label="Activation:",
items=[i for i in self.act_lbl],
callback=self.settings_changed))
form.addRow(" ", gui.separator(None, 16))
form.addRow(
"Solver:",
gui.comboBox(None,
self,
"solver_index",
orientation=Qt.Horizontal,
label="Solver:",
items=[i for i in self.solv_lbl],
callback=self.settings_changed))
self.reg_label = QLabel()
slider = gui.hSlider(None,
self,
"alpha_index",
minValue=0,
maxValue=len(self.alphas) - 1,
callback=lambda:
(self.set_alpha(), self.settings_changed()),
createLabel=False)
form.addRow(self.reg_label, slider)
self.set_alpha()
form.addRow(
"Maximal number of iterations:",
gui.spin(None,
self,
"max_iterations",
10,
1000000,
step=10,
label="Max iterations:",
orientation=Qt.Horizontal,
alignment=Qt.AlignRight,
callback=self.settings_changed))
form.addRow(gui.separator(None))
form.addRow(
gui.checkBox(None,
self,
"replicable",
label="Replicable training",
callback=self.settings_changed), )
def __init__(self):
super().__init__()
# sets self.curvePoints, self.steps equidistant points from
# 1/self.steps to 1
self.updateCurvePoints()
self.scoring = [
("Classification Accuracy", Orange.evaluation.scoring.CA),
("AUC", Orange.evaluation.scoring.AUC),
("Precision", Orange.evaluation.scoring.Precision),
("Recall", Orange.evaluation.scoring.Recall),
]
#: input data on which to construct the learning curve
self.data = None
#: optional test data
self.testdata = None
#: A {input_id: Learner} mapping of current learners from input channel
self.learners = OrderedDict()
#: A {input_id: List[Results]} mapping of input id to evaluation
#: results list, one for each curve point
self.results = OrderedDict()
#: A {input_id: List[float]} mapping of input id to learning curve
#: point scores
self.curves = OrderedDict()
# [start-snippet-3]
#: The current evaluating task (if any)
self._task = None # type: Optional[Task]
#: An executor we use to submit learner evaluations into a thread pool
self._executor = ThreadExecutor()
# [end-snippet-3]
# GUI
box = gui.widgetBox(self.controlArea, "Info")
self.infoa = gui.widgetLabel(box, "No data on input.")
self.infob = gui.widgetLabel(box, "No learners.")
gui.separator(self.controlArea)
box = gui.widgetBox(self.controlArea, "Evaluation Scores")
gui.comboBox(
box,
self,
"scoringF",
items=[x[0] for x in self.scoring],
callback=self._invalidate_curves,
)
gui.separator(self.controlArea)
box = gui.widgetBox(self.controlArea, "Options")
gui.spin(
box,
self,
"folds",
2,
100,
step=1,
label="Cross validation folds: ",
keyboardTracking=False,
callback=lambda: self._invalidate_results()
if self.commitOnChange else None,
)
gui.spin(
box,
self,
"steps",
2,
100,
step=1,
label="Learning curve points: ",
keyboardTracking=False,
callback=[
self.updateCurvePoints,
lambda: self._invalidate_results()
if self.commitOnChange else None,
],
)
gui.checkBox(box, self, "commitOnChange",
"Apply setting on any change")
self.commitBtn = gui.button(box,
self,
"Apply Setting",
callback=self._invalidate_results,
disabled=True)
gui.rubber(self.controlArea)
# table widget
self.table = gui.table(self.mainArea,
selectionMode=QTableWidget.NoSelection)
def __init__(self):
super().__init__()
#self.controlArea.setMinimumWidth(250)
#set default settings
self.data = None
self.attrX = ""
self.attrY = ""
self.attrCondition = ""
self.attrConditionValue = ""
self.showLines = 1
self.showCases = 0
self.showInColor = 1
self.attributeSelectionList = None
self.stopCalculating = 0
self.canvas = QGraphicsScene()
self.canvasView = QGraphicsView(self.canvas, self.mainArea)
self.mainArea.layout().addWidget(self.canvasView)
self.canvasView.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.canvasView.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
#GUI
self.attrSelGroup = gui.widgetBox(self.controlArea,
box="Shown attributes")
self.attrXCombo = gui.comboBox(
self.attrSelGroup,
self,
value="attrX",
label="X attribute:",
orientation="horizontal",
tooltip="Select an attribute to be shown on the X axis",
callback=self.updateGraph,
sendSelectedValue=1,
valueType=str,
labelWidth=70,
contentsLength=12)
self.attrYCombo = gui.comboBox(
self.attrSelGroup,
self,
value="attrY",
label="Y attribute:",
orientation="horizontal",
tooltip="Select an attribute to be shown on the Y axis",
callback=self.updateGraph,
sendSelectedValue=1,
valueType=str,
labelWidth=70,
contentsLength=12)
gui.separator(self.controlArea)
self.conditionGroup = gui.widgetBox(self.controlArea, box="Condition")
self.attrConditionCombo = gui.comboBox(
self.conditionGroup,
self,
value="attrCondition",
label="Attribute:",
orientation="horizontal",
callback=self.updateConditionAttr,
sendSelectedValue=True,
valueType=str,
labelWidth=70,
contentsLength=12)
self.attrConditionValueCombo = gui.comboBox(self.conditionGroup,
self,
value="attrConditionValue",
label="Value:",
orientation="horizontal",
callback=self.updateGraph,
sendSelectedValue=True,
valueType=str,
labelWidth=70,
contentsLength=10)
gui.separator(self.controlArea)
box2 = gui.widgetBox(self.controlArea, box="Visual settings")
gui.checkBox(box2,
self,
"showLines",
"Show squares (observed frequency)",
callback=self.updateGraph)
hbox = gui.widgetBox(box2, orientation="horizontal")
gui.checkBox(hbox,
self,
"showCases",
"Show data instances...",
callback=self.updateGraph)
gui.checkBox(hbox,
self,
"showInColor",
"...in color",
callback=self.updateGraph)
gui.separator(self.controlArea)
# self.optimizationDlg = OWSieveOptimization(self, self.signalManager)
# optimizationButtons = gui.widgetBox(self.controlArea, "Dialogs", orientation = "horizontal")
# gui.button(optimizationButtons, self, "VizRank", callback = self.optimizationDlg.reshow, debuggingEnabled = 0, tooltip = "Find attribute groups with highest value dependency")
gui.rubber(self.controlArea)
# self.wdChildDialogs = [self.optimizationDlg] # used when running widget debugging
# self.graphButton.clicked.connect(self.saveToFileCanvas)
self.icons = gui.attributeIconDict
self.resize(800, 550)
random.seed()
self.graphButton.clicked.connect(self.save_graph)
def __init__(self, parent=None):
super().__init__(parent)
self.primary_data = None
self.more_data = OrderedDict()
mergebox = gui.widgetBox(self.controlArea, "Domains merging")
box = gui.radioButtons(mergebox,
self,
"merge_type",
callback=self._merge_type_changed)
gui.widgetLabel(
box,
self.tr("When there is no primary table, " +
"the domain should be:"))
gui.appendRadioButton(
box, self.tr("Union of attributes appearing in all tables"))
gui.appendRadioButton(
box, self.tr("Intersection of attributes in all tables"))
gui.separator(box)
label = gui.widgetLabel(
box,
self.tr("The resulting table will have class only if there " +
"is no conflict between input classes."))
label.setWordWrap(True)
###
box = gui.widgetBox(self.controlArea,
self.tr("Source identification"),
addSpace=False)
cb = gui.checkBox(box, self, "append_source_column",
self.tr("Append data source IDs"))
ibox = gui.indentedBox(box, sep=gui.checkButtonOffsetHint(cb))
form = QtGui.QFormLayout(
spacing=8,
labelAlignment=Qt.AlignLeft,
formAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QtGui.QFormLayout.AllNonFixedFieldsGrow)
form.addRow(
self.tr("Feature name"),
gui.lineEdit(ibox, self, "source_attr_name", valueType=str))
form.addRow(
self.tr("Place"),
gui.comboBox(ibox,
self,
"source_column_role",
items=[
self.tr("Class attribute"),
self.tr("Attribute"),
self.tr("Meta attribute")
]))
ibox.layout().addLayout(form)
mleft, mtop, mright, _ = ibox.layout().getContentsMargins()
ibox.layout().setContentsMargins(mleft, mtop, mright, 4)
cb.disables.append(ibox)
cb.makeConsistent()
gui.button(self.controlArea,
self,
self.tr("Apply Changes"),
callback=self.apply,
default=True)
gui.rubber(self.controlArea)
self.setSizePolicy(QtGui.QSizePolicy.Fixed, QtGui.QSizePolicy.Fixed)
def __init__(self):
super().__init__()
self.data = None
self.removedAttrs = "-"
self.reducedAttrs = "-"
self.resortedAttrs = "-"
self.removedClasses = "-"
self.reducedClasses = "-"
self.resortedClasses = "-"
boxAt = gui.widgetBox(self.controlArea, "Features")
gui.checkBox(boxAt,
self,
'sortValues',
'Sort discrete feature values',
callback=self.optionsChanged)
gui.separator(boxAt, 2)
gui.checkBox(boxAt,
self,
"removeValues",
"Remove unused feature values",
callback=self.optionsChanged)
gui.separator(boxAt, 2)
gui.checkBox(boxAt,
self,
"removeAttributes",
"Remove constant features",
callback=self.optionsChanged)
boxAt = gui.widgetBox(self.controlArea, "Classes", addSpace=True)
gui.checkBox(boxAt,
self,
'sortClasses',
'Sort discrete class variable values',
callback=self.optionsChanged)
gui.separator(boxAt, 2)
gui.checkBox(boxAt,
self,
"removeClasses",
"Remove unused class variable values",
callback=self.optionsChanged)
gui.separator(boxAt, 2)
gui.checkBox(boxAt,
self,
"removeClassAttribute",
"Remove constant class variables",
callback=self.optionsChanged)
box3 = gui.widgetBox(self.controlArea, 'Statistics', addSpace=True)
gui.label(box3, self, "Removed features: %(removedAttrs)s")
gui.label(box3, self, "Reduced features: %(reducedAttrs)s")
gui.label(box3, self, "Resorted features: %(resortedAttrs)s")
gui.label(box3, self, "Removed classes: %(removedClasses)s")
gui.label(box3, self, "Reduced classes: %(reducedClasses)s")
gui.label(box3, self, "Resorted classes: %(resortedClasses)s")
gui.auto_commit(self.controlArea,
self,
"autoSend",
"Send Data",
checkbox_label="Send automatically ",
orientation="horizontal")
gui.rubber(self.controlArea)