def add_main_layout(self):
box = gui.vBox(self.controlArea, "Network")
self.hidden_layers_edit = gui.lineEdit(
box, self, "hidden_layers_input", label="Neurons per hidden layer:",
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. 100,")
self.activation_combo = gui.comboBox(
box, self, "activation_index", orientation=Qt.Horizontal,
label="Activation:", items=[i for i in self.act_lbl],
callback=self.settings_changed)
self.solver_combo = gui.comboBox(
box, self, "solver_index", orientation=Qt.Horizontal,
label="Solver:", items=[i for i in self.solv_lbl],
callback=self.settings_changed)
self.alpha_spin = gui.doubleSpin(
box, self, "alpha", 1e-5, 1.0, 1e-2,
label="Alpha:", decimals=5, alignment=Qt.AlignRight,
callback=self.settings_changed, controlWidth=80)
self.max_iter_spin = gui.spin(
box, self, "max_iterations", 10, 10000, step=10,
label="Max iterations:", orientation=Qt.Horizontal,
alignment=Qt.AlignRight, callback=self.settings_changed,
controlWidth=80)
def __init__(self):
super().__init__()
self.data = None
self.learner = None
self.preprocessor = None
self.classifier = 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")
self.btn_apply = gui.button(self.controlArea, self, "&Apply",
callback=self.set_learner, disabled=0,
default=True)
gui.rubber(self.controlArea)
self.resize(100, 100)
self.set_learner()
def __init__(self):
super().__init__()
self.data = None
self.feature_model = DomainModel(valid_types=DiscreteVariable)
self.table = None
box = gui.vBox(self.controlArea, "Rows")
gui.comboBox(box, self, 'rows', sendSelectedValue=True,
model=self.feature_model, callback=self._attribute_changed)
box = gui.vBox(self.controlArea, "Columns")
gui.comboBox(box, self, 'columns', sendSelectedValue=True,
model=self.feature_model, callback=self._attribute_changed)
gui.rubber(self.controlArea)
box = gui.vBox(self.controlArea, "Scores")
self.scores = gui.widgetLabel(box, "\n\n")
self.apply_button = gui.auto_commit(
self.controlArea, self, "auto_apply", "&Apply", box=False)
self.tableview = ContingencyTable(self)
self.mainArea.layout().addWidget(self.tableview)
def __init__(self):
super().__init__()
self.data = None
self.preprocessors = None
box = gui.widgetBox(self.controlArea, "Learner/Classifier Name")
gui.lineEdit(box, self, "learner_name")
box = gui.widgetBox(self.controlArea, "Neighbors")
gui.spin(box, self, "n_neighbors", 1, 100, label="Number of neighbors",
alignment=Qt.AlignRight)
gui.comboBox(box, self, "metric_index", label="Metric",
orientation="horizontal",
items=[i.capitalize() for i in self.metrics])
gui.comboBox(box, self, "weight_type", label='Weight',
orientation="horizontal",
items=[i.capitalize() for i in self.weights])
g = QHBoxLayout()
self.controlArea.layout().addLayout(g)
apply = gui.button(None, self, "Apply",
callback=self.apply, default=True)
g.layout().addWidget(self.report_button)
g.layout().addWidget(apply)
self.apply()
def __init__(self):
super().__init__()
self.data = None
self.input_features = None
self.attrs = []
self.attr_box = gui.hBox(self.mainArea)
model = VariableListModel()
model.wrap(self.attrs)
self.attrXCombo = gui.comboBox(
self.attr_box, self, value="attrX", contentsLength=12,
callback=self.change_attr, sendSelectedValue=True, valueType=str)
self.attrXCombo.setModel(model)
gui.widgetLabel(self.attr_box, "\u2715").\
setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.attrYCombo = gui.comboBox(
self.attr_box, self, value="attrY", contentsLength=12,
callback=self.change_attr, sendSelectedValue=True, valueType=str)
self.attrYCombo.setModel(model)
self.canvas = QGraphicsScene()
self.canvasView = ViewWithPress(self.canvas, self.mainArea,
handler=self.reset_selection)
self.mainArea.layout().addWidget(self.canvasView)
self.canvasView.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.canvasView.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
box = gui.hBox(self.mainArea)
box.layout().addWidget(self.graphButton)
box.layout().addWidget(self.report_button)
def __init__(self):
super().__init__()
self.data = None
self.db = None
box = gui.widgetBox(self.controlArea, "Parameters")
gui.spin(box, self, "min_samples", 1, 100, 1, callback=self._invalidate,
label="Core point neighbors")
gui.doubleSpin(box, self, "eps", 0.1, 0.9, 0.1,
callback=self._invalidate,
label="Neighborhood distance")
box = gui.widgetBox(self.controlArea, self.tr("Distance Metric"))
gui.comboBox(box, self, "metric_idx",
items=list(zip(*self.METRICS))[0],
callback=self._invalidate)
box = gui.widgetBox(self.controlArea, "Output")
gui.comboBox(box, self, "place_cluster_ids",
label="Append cluster id as ", orientation="horizontal",
callback=self.send_data, items=self.OUTPUT_METHODS)
gui.lineEdit(box, self, "output_name",
label="Name: ", orientation="horizontal",
callback=self.send_data)
gui.auto_commit(self.controlArea, self, "auto_run", "Run",
checkbox_label="Run after any change ",
orientation="horizontal")
gui.rubber(self.controlArea)
self.controlArea.setMinimumWidth(self.controlArea.sizeHint().width())
self.layout().setSizeConstraint(QtGui.QLayout.SetFixedSize)
def add_main_layout(self):
box = gui.widgetBox(self.controlArea, "Parameters")
self.base_estimator = self.DEFAULT_BASE_ESTIMATOR
self.base_label = gui.label(
box, self, "Base estimator: " + self.base_estimator.name.title())
self.n_estimators_spin = gui.spin(
box, self, "n_estimators", 1, 100, label="Number of estimators:",
alignment=Qt.AlignRight, controlWidth=80,
callback=self.settings_changed)
self.learning_rate_spin = gui.doubleSpin(
box, self, "learning_rate", 1e-5, 1.0, 1e-5,
label="Learning rate:", decimals=5, alignment=Qt.AlignRight,
controlWidth=80, callback=self.settings_changed)
self.random_seed_spin = gui.spin(
box, self, "random_seed", 0, 2 ** 31 - 1, controlWidth=80,
label="Fixed seed for random generator:", alignment=Qt.AlignRight,
callback=self.settings_changed, checked="use_random_seed",
checkCallback=self.settings_changed)
# Algorithms
box = gui.widgetBox(self.controlArea, "Boosting method")
self.cls_algorithm_combo = gui.comboBox(
box, self, "algorithm_index", label="Classification algorithm:",
items=self.algorithms,
orientation=Qt.Horizontal, callback=self.settings_changed)
self.reg_algorithm_combo = gui.comboBox(
box, self, "loss_index", label="Regression loss function:",
items=self.losses,
orientation=Qt.Horizontal, callback=self.settings_changed)
def generate_grid_layout(self):
box = QtGui.QGroupBox(title='Options')
layout = QGridLayout()
layout.setSpacing(10)
row = 0
self.tweet_attr_combo = gui.comboBox(None, self, 'tweet_attr',
callback=self.apply)
layout.addWidget(QLabel('Attribute:'))
layout.addWidget(self.tweet_attr_combo, row, 1)
row += 1
self.model_name_combo = gui.comboBox(None, self, 'model_name',
items=self.profiler.model_names,
sendSelectedValue=True,
callback=self.apply)
if self.profiler.model_names:
self.model_name = self.profiler.model_names[0] # select 0th
layout.addWidget(QLabel('Emotions:'))
layout.addWidget(self.model_name_combo, row, 1)
row += 1
self.output_mode_combo = gui.comboBox(None, self, 'output_mode',
items=self.profiler.output_modes,
sendSelectedValue=True,
callback=self.apply)
if self.profiler.output_modes:
self.output_mode = self.profiler.output_modes[0] # select 0th
layout.addWidget(QLabel('Output:'))
layout.addWidget(self.output_mode_combo, row, 1)
box.setLayout(layout)
return box
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 _create_layout(self):
box = gui.widgetBox(self.controlArea,
orientation='horizontal')
self.varmodel = VariableListModel(parent=self)
self.attr_combo = gui.comboBox(box, self, 'selected_attr',
orientation=Qt.Horizontal,
label='Region attribute:',
callback=self.on_attr_change,
sendSelectedValue=True)
self.attr_combo.setModel(self.varmodel)
self.map_combo = gui.comboBox(box, self, 'selected_map',
orientation=Qt.Horizontal,
label='Map type:',
callback=self.on_map_change,
items=Map.all)
hexpand = QSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Fixed)
self.attr_combo.setSizePolicy(hexpand)
self.map_combo.setSizePolicy(hexpand)
url = urljoin('file:',
pathname2url(os.path.join(
os.path.dirname(__file__),
'resources',
'owgeomap.html')))
self.webview = gui.WebviewWidget(self.controlArea, self, url=QUrl(url))
self.controlArea.layout().addWidget(self.webview)
QTimer.singleShot(
0, lambda: self.webview.evalJS('REGIONS = {};'.format({Map.WORLD: CC_WORLD,
Map.EUROPE: CC_EUROPE,
Map.USA: CC_USA})))
def add_annotation_settings(self, parent):
box = gui.widgetBox(parent, "Statistical Information")
gui.comboBox(box, self, "graph.show_statistics", label="Statistics: ", orientation="horizontal", labelWidth=90,
items=["No statistics", "Means, deviations", "Median, quartiles"], callback=self.update_graph,
sendSelectedValue=False, valueType=int)
gui.checkBox(box, self, 'graph.show_distributions', 'Show distributions', callback=self.update_graph,
tooltip="Show bars with distribution of class values (only for discrete attributes)")
def __init__(self):
# pylint: disable=missing-docstring
super().__init__()
self.data = self.discrete_data = None
self.attrs = []
self.input_features = None
self.areas = []
self.selection = set()
self.attr_box = gui.hBox(self.mainArea)
self.domain_model = DomainModel(valid_types=DomainModel.PRIMITIVE)
combo_args = dict(
widget=self.attr_box, master=self, contentsLength=12,
callback=self.update_attr, sendSelectedValue=True, valueType=str,
model=self.domain_model)
fixed_size = (QSizePolicy.Fixed, QSizePolicy.Fixed)
gui.comboBox(value="attr_x", **combo_args)
gui.widgetLabel(self.attr_box, "\u2715", sizePolicy=fixed_size)
gui.comboBox(value="attr_y", **combo_args)
self.vizrank, self.vizrank_button = SieveRank.add_vizrank(
self.attr_box, self, "Score Combinations", self.set_attr)
self.vizrank_button.setSizePolicy(*fixed_size)
self.canvas = QGraphicsScene()
self.canvasView = ViewWithPress(
self.canvas, self.mainArea, handler=self.reset_selection)
self.mainArea.layout().addWidget(self.canvasView)
self.canvasView.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.canvasView.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
def __init__(self):
super().__init__()
self.preprocessors = None
self.data = None
box = gui.widgetBox(self.controlArea, "Learner/Model Name")
gui.lineEdit(box, self, "learner_name")
box = gui.widgetBox(self.controlArea, "Neighbors")
gui.spin(box, self, "n_neighbors", 1, 100, label="Number of neighbors")
box = gui.widgetBox(box, "Metric")
box.setFlat(True)
box.layout().setContentsMargins(0, 0, 0, 0)
gui.comboBox(box, self, "metric_index",
items=["Euclidean", "Manhattan", "Maximal", "Mahalanobis"])
self.metrics = ["euclidean", "manhattan", "chebyshev", "mahalanobis"]
gui.button(self.controlArea, self, "Apply",
callback=self.apply, default=True)
self.controlArea.layout().addWidget(self.report_button)
layout = self.layout()
self.layout().setSizeConstraint(layout.SetFixedSize)
self.apply()
def _add_algorithm_to_layout(self):
box = gui.widgetBox(self.controlArea, 'Algorithm')
# Classfication loss function
self.cls_loss_function_combo = gui.comboBox(
box, self, 'cls_loss_function_index', orientation=Qt.Horizontal,
label='Classificaton loss function: ',
items=list(zip(*self.cls_losses))[0],
callback=self._on_cls_loss_change)
param_box = gui.hBox(box)
gui.rubber(param_box)
self.cls_epsilon_spin = gui.spin(
param_box, self, 'cls_epsilon', 0, 1., 1e-2, spinType=float,
label='ε: ', controlWidth=80, alignment=Qt.AlignRight,
callback=self.settings_changed)
# Regression loss function
self.reg_loss_function_combo = gui.comboBox(
box, self, 'reg_loss_function_index', orientation=Qt.Horizontal,
label='Regression loss function: ',
items=list(zip(*self.reg_losses))[0],
callback=self._on_reg_loss_change)
param_box = gui.hBox(box)
gui.rubber(param_box)
self.reg_epsilon_spin = gui.spin(
param_box, self, 'reg_epsilon', 0, 1., 1e-2, spinType=float,
label='ε: ', controlWidth=80, alignment=Qt.AlignRight,
callback=self.settings_changed)
# Enable/disable appropriate controls
self._on_cls_loss_change()
self._on_reg_loss_change()
def __init__(self):
super().__init__()
# 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):
hbox = gui.hBox(self.controlArea)
_properties = dict(alternatingRowColors=True,
defaultDropAction=Qt.MoveAction,
dragDropMode=QListView.DragDrop,
dragEnabled=True,
selectionMode=QListView.ExtendedSelection,
selectionBehavior=QListView.SelectRows,
showDropIndicator=True,
acceptDrops=True)
listview_avail = DnDListView(lambda: self.commit(), self, **_properties)
self.model_avail = model = VariableListModel(parent=self, enable_dnd=True)
listview_avail.setModel(model)
listview_key = DnDListView(lambda: self.commit(), self, **_properties)
self.model_key = model = VariableListModel(parent=self, enable_dnd=True)
listview_key.setModel(model)
box = gui.vBox(hbox, 'Available Variables')
box.layout().addWidget(listview_avail)
box = gui.vBox(hbox, 'Group-By Key')
box.layout().addWidget(listview_key)
gui.comboBox(self.controlArea, self, 'tiebreaker',
label='Which instance to select in each group:',
items=tuple(self.TIEBREAKERS.keys()),
callback=lambda: self.commit(),
sendSelectedValue=True)
gui.auto_commit(self.controlArea, self, 'autocommit', 'Commit',
orientation=Qt.Horizontal)
def __init__(self):
super().__init__()
# 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__()
dbox = gui.widgetBox(self.controlArea, "Image values")
rbox = gui.radioButtons(
dbox, self, "value_type", callback=self._change_integration)
gui.appendRadioButton(rbox, "From spectra")
self.box_values_spectra = gui.indentedBox(rbox)
gui.comboBox(
self.box_values_spectra, self, "integration_method", valueType=int,
items=(a.name for a in self.integration_methods),
callback=self._change_integral_type)
gui.rubber(self.controlArea)
gui.appendRadioButton(rbox, "Use feature")
self.box_values_feature = gui.indentedBox(rbox)
self.feature_value_model = DomainModel(DomainModel.METAS | DomainModel.CLASSES,
valid_types=DomainModel.PRIMITIVE)
self.feature_value = gui.comboBox(
self.box_values_feature, self, "attr_value",
callback=self.update_feature_value, model=self.feature_value_model,
sendSelectedValue=True, valueType=str)
splitter = QSplitter(self)
splitter.setOrientation(Qt.Vertical)
self.imageplot = ImagePlot(self)
self.imageplot.selection_changed.connect(self.output_image_selection)
self.curveplot = CurvePlotHyper(self, select=SELECTONE)
self.curveplot.selection_changed.connect(self.redraw_data)
self.curveplot.plot.vb.x_padding = 0.005 # pad view so that lines are not hidden
splitter.addWidget(self.imageplot)
splitter.addWidget(self.curveplot)
self.mainArea.layout().addWidget(splitter)
self.line1 = MovableVline(position=self.lowlim, label="", report=self.curveplot)
self.line1.sigMoved.connect(lambda v: setattr(self, "lowlim", v))
self.line2 = MovableVline(position=self.highlim, label="", report=self.curveplot)
self.line2.sigMoved.connect(lambda v: setattr(self, "highlim", v))
self.line3 = MovableVline(position=self.choose, label="", report=self.curveplot)
self.line3.sigMoved.connect(lambda v: setattr(self, "choose", v))
for line in [self.line1, self.line2, self.line3]:
line.sigMoveFinished.connect(self.changed_integral_range)
self.curveplot.add_marking(line)
line.hide()
self.data = None
self.disable_integral_range = False
self.resize(900, 700)
self._update_integration_type()
# prepare interface according to the new context
self.contextAboutToBeOpened.connect(lambda x: self.init_interface_data(x[0]))
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):
super().__init__()
self.data = None
self.reference = None
self.distances = None
box = gui.vBox(self.controlArea, "Info")
self.data_info_label = gui.widgetLabel(box, "")
self.reference_info_label = gui.widgetLabel(box, "")
self._set_label_text("data")
self._set_label_text("reference")
box = gui.vBox(self.controlArea, box=True)
gui.comboBox(
box, self, "distance_index", orientation=Qt.Horizontal,
label="Distance: ", items=[d[0] for d in METRICS],
callback=self.recompute)
gui.spin(
box, self, "n_neighbors", label="Number of neighbors:",
step=1, spinType=int, minv=0, maxv=100, callback=self.apply)
gui.checkBox(
box, self, "exclude_reference",
label="Exclude rows (equal to) references",
callback=self.apply)
self.apply_button = gui.auto_commit(
self.controlArea, self, "auto_apply", "&Apply", commit=self.apply)
def __init__(self):
self.data = None
self.indices = []
box = gui.vBox(self.controlArea, 'Axes')
self.combo_ax2 = gui.comboBox(
box, self, 'ax2', label='Y axis:', callback=self.replot,
sendSelectedValue=True, orientation='horizontal')
self.combo_ax1 = gui.comboBox(
box, self, 'ax1', label='Radial:', callback=self.replot,
sendSelectedValue=True, orientation='horizontal')
box = gui.vBox(self.controlArea, 'Aggregation')
self.combo_func = gui.comboBox(
box, self, 'agg_func', label='Function:', orientation='horizontal',
callback=self.replot)
func_model = ListModel(AGG_FUNCTIONS, parent=self)
self.combo_func.setModel(func_model)
self.attrlist_model = VariableListModel(parent=self)
self.attrlist = QListView(selectionMode=QListView.ExtendedSelection)
self.attrlist.setModel(self.attrlist_model)
self.attrlist.selectionModel().selectionChanged.connect(
self.attrlist_selectionChanged)
box.layout().addWidget(self.attrlist)
gui.rubber(self.controlArea)
self.chart = chart = Spiralogram(self,
selection_callback=self.on_selection)
self.mainArea.layout().addWidget(chart)
def __add_controls_start_box(self):
box = gui.vBox(self.controlArea, box=True)
gui.comboBox(
box, self, "initialization", label="Initialization:",
items=InitType.items(), orientation=Qt.Horizontal,
labelWidth=90, callback=self.__init_combo_changed)
self.run_button = gui.button(box, self, "Start", self._toggle_run)
def __init__(self, parent=None):
super().__init__(parent)
self.data = None
self.preprocessors = None
box = gui.widgetBox(self.controlArea, "Learner/Classifier Name")
gui.lineEdit(box, self, "learner_name")
box = gui.widgetBox(self.controlArea, "Neighbors")
gui.spin(box, self, "n_neighbors", 1, 100, label="Number of neighbors")
box = gui.widgetBox(box, "Metric")
box.setFlat(True)
gui.comboBox(box, self, "metric_index",
items=["Euclidean", "Manhattan", "Maximal", "Mahalanobis"])
self.metrics = ["euclidean", "manhattan", "chebyshev", "mahalanobis"]
gui.button(self.controlArea, self, "Apply",
callback=self.apply, default=True)
self.setMinimumWidth(250)
layout = self.layout()
self.layout().setSizeConstraint(layout.SetFixedSize)
self.apply()
def __init__(self):
super().__init__()
self.data = None
self.component_x = 0
self.component_y = 1
box = gui.vBox(self.controlArea, "Variables")
self.varlist = itemmodels.VariableListModel()
self.varview = view = QListView(selectionMode=QListView.MultiSelection)
view.setModel(self.varlist)
view.selectionModel().selectionChanged.connect(self._var_changed)
box.layout().addWidget(view)
axes_box = gui.vBox(self.controlArea, "Axes")
box = gui.vBox(axes_box, "Axis X", margin=0)
box.setFlat(True)
self.axis_x_cb = gui.comboBox(
box, self, "component_x", callback=self._component_changed)
box = gui.vBox(axes_box, "Axis Y", margin=0)
box.setFlat(True)
self.axis_y_cb = gui.comboBox(
box, self, "component_y", callback=self._component_changed)
self.infotext = gui.widgetLabel(
gui.vBox(self.controlArea, "Contribution to Inertia"), "\n"
)
gui.rubber(self.controlArea)
self.plot = pg.PlotWidget(background="w")
self.plot.setMenuEnabled(False)
self.mainArea.layout().addWidget(self.plot)
def __init__(self):
super().__init__()
self.data = None
self.preprocessors = None
box = gui.widgetBox(self.controlArea, self.tr("Name"))
gui.lineEdit(box, self, "learner_name")
box = gui.widgetBox(self.controlArea, box=True)
gui.comboBox(box, self, "penalty_type", label="Regularization type: ",
items=self.penalty_types,
orientation="horizontal", addSpace=4)
gui.widgetLabel(box, "Strength:")
box2 = gui.widgetBox(gui.indentedBox(box), orientation="horizontal")
gui.widgetLabel(box2, "Weak").setStyleSheet("margin-top:6px")
gui.hSlider(box2, self, "C_index",
minValue=0, maxValue=len(self.C_s) - 1,
callback=self.set_c, createLabel=False)
gui.widgetLabel(box2, "Strong").setStyleSheet("margin-top:6px")
box2 = gui.widgetBox(box, orientation="horizontal")
box2.layout().setAlignment(Qt.AlignCenter)
self.c_label = gui.widgetLabel(box2)
box = gui.widgetBox(self.controlArea, orientation="horizontal",
margin=0)
box.layout().addWidget(self.report_button)
gui.button(box, self, "&Apply", callback=self.apply, default=True)
self.set_c()
self.apply()
def __init__(self,
dcm=None,
parent=None,
has_finite_dimensions=0,
dimensions=[0.0, 0.0]):
super().__init__(parent)
self.setLayout(QtGui.QVBoxLayout())
self.layout().setAlignment(Qt.AlignTop)
self.setFixedWidth(470)
self.setFixedHeight(400)
self.dcm = dcm
self.has_finite_dimensions = has_finite_dimensions
self.mirror_width = dimensions[0]
self.mirror_length = dimensions[1]
mirror_box = ShadowGui.widgetBox(self, "Crystal Input Parameters", addSpace=False, orientation="vertical", height=330, width=460)
gui.comboBox(mirror_box, self, "has_finite_dimensions", label="Dimensions", labelWidth=350,
items=["Finite", "Infinite"], sendSelectedValue=False, orientation="horizontal", callback=self.set_dimensions)
self.dimension_box = ShadowGui.widgetBox(mirror_box, "", addSpace=False, orientation="vertical", height=50)
self.dimension_box_empty = ShadowGui.widgetBox(mirror_box, "", addSpace=False, orientation="vertical", height=50)
ShadowGui.lineEdit(self.dimension_box, self, "mirror_width", "Crystal Width [cm]", labelWidth=350, valueType=float, orientation="horizontal",
callback=self.dcm.dump_dimensions_0)
ShadowGui.lineEdit(self.dimension_box, self, "mirror_length", "Crystal Length [cm]", labelWidth=350, valueType=float, orientation="horizontal",
callback=self.dcm.dump_dimensions_1)
self.set_dimensions()
self.is_on_init = False
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 __add_controls_start_box(self):
box = gui.vBox(self.controlArea, box=True)
gui.comboBox(
box, self, "initialization", label="Initialization:",
items=InitType.items(), orientation=Qt.Horizontal,
labelWidth=90, callback=self.__init_combo_changed)
self.btn_start = gui.button(
box, self, "Optimize", self.__toggle_start, enabled=False)
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, parent=None):
super().__init__(parent)
self.taxids = taxonomy.common_taxids()
self.current_taxid_index = self.taxids.index(self.taxid)
self.data = None
self.geneinfo = None
self.nettask = None
self._invalidated = False
box = gui.widgetBox(self.controlArea, "Info")
self.info = gui.widgetLabel(box, "No data on input\n")
box = gui.widgetBox(self.controlArea, "Organism")
self.organism_cb = gui.comboBox(
box, self, "current_taxid_index",
items=map(taxonomy.name, self.taxids),
callback=self._update_organism
)
box = gui.widgetBox(self.controlArea, "Genes")
self.genes_cb = gui.comboBox(
box, self, "gene_var_index", callback=self._update_query_genes
)
self.varmodel = itemmodels.VariableListModel()
self.genes_cb.setModel(self.varmodel)
gui.checkBox(
box, self, "use_attr_names",
"Use attribute names",
callback=self._update_query_genes
)
box = gui.widgetBox(self.controlArea, "Network")
gui.comboBox(
box, self, "network_source",
items=[s.name for s in SOURCES],
callback=self._on_source_db_changed
)
gui.checkBox(
box, self, "include_neighborhood",
"Include immediate gene neighbors",
callback=self.invalidate
)
self.score_spin = gui.doubleSpin(
box, self, "min_score", 0.0, 1.0, step=0.001,
label="Minimal edge score",
callback=self.invalidate
)
self.score_spin.setEnabled(SOURCES[self.network_source].score_filter)
box = gui.widgetBox(self.controlArea, "Commit")
gui.button(box, self, "Retrieve", callback=self.commit, default=True)
self.setSizePolicy(QtGui.QSizePolicy.Fixed, QtGui.QSizePolicy.Fixed)
self.layout().setSizeConstraint(QtGui.QLayout.SetFixedSize)
self.executor = ThreadExecutor()
def __init__(self):
super().__init__()
self.results = None
self.classifier_names = []
self.colors = []
self._curve_data = {}
box = gui.vBox(self.controlArea, "Plot")
tbox = gui.vBox(box, "Target Class")
tbox.setFlat(True)
self.target_cb = gui.comboBox(tbox,
self,
"target_index",
callback=self._on_target_changed,
contentsLength=8,
searchable=True)
cbox = gui.vBox(box, "Classifiers")
cbox.setFlat(True)
self.classifiers_list_box = gui.listBox(
cbox,
self,
"selected_classifiers",
"classifier_names",
selectionMode=QListView.MultiSelection,
callback=self._on_classifiers_changed)
gui.checkBox(box,
self,
"display_convex_hull",
"Show lift convex hull",
callback=self._replot)
self.plotview = pg.GraphicsView(background="w")
self.plotview.setFrameStyle(QFrame.StyledPanel)
self.plot = pg.PlotItem(enableMenu=False)
self.plot.setMouseEnabled(False, False)
self.plot.hideButtons()
pen = QPen(self.palette().color(QPalette.Text))
tickfont = QFont(self.font())
tickfont.setPixelSize(max(int(tickfont.pixelSize() * 2 // 3), 11))
axis = self.plot.getAxis("bottom")
axis.setTickFont(tickfont)
axis.setPen(pen)
axis.setLabel("P Rate")
axis = self.plot.getAxis("left")
axis.setTickFont(tickfont)
axis.setPen(pen)
axis.setLabel("TP Rate")
self.plot.showGrid(True, True, alpha=0.1)
self.plot.setRange(xRange=(0.0, 1.0), yRange=(0.0, 1.0), padding=0.05)
self.plotview.setCentralItem(self.plot)
self.mainArea.layout().addWidget(self.plotview)
def __init__(self):
"""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):
super().__init__()
self.data = None
self.stored_phase = None
self.spectra_table = None
if self.dx_HeNe is True:
self.dx = 1.0 / self.laser_wavenumber / 2.0
# GUI
# An info box
infoBox = gui.widgetBox(self.controlArea, "Info")
self.infoa = gui.widgetLabel(infoBox, "No data on input.")
self.infob = gui.widgetLabel(infoBox, "")
self.infoc = gui.widgetLabel(infoBox, "")
# Input Data control area
self.dataBox = gui.widgetBox(self.controlArea, "Input Data")
gui.widgetLabel(self.dataBox, "Datapoint spacing (Δx):")
grid = QGridLayout()
grid.setContentsMargins(0, 0, 0, 0)
self.dx_edit = gui.lineEdit(
self.dataBox,
self,
"dx",
callback=self.setting_changed,
valueType=float,
disabled=self.dx_HeNe,
)
self.dx_HeNe_cb = gui.checkBox(
self.dataBox,
self,
"dx_HeNe",
label="HeNe laser",
callback=self.dx_changed,
)
lb = gui.widgetLabel(self.dataBox, "cm")
grid.addWidget(self.dx_HeNe_cb, 0, 0)
grid.addWidget(self.dx_edit, 0, 1, 1, 2)
grid.addWidget(lb, 0, 3)
wl = gui.widgetLabel(self.dataBox, "Sweep Direction:")
box = gui.comboBox(self.dataBox,
self,
"sweeps",
label=None,
items=self.sweep_opts,
callback=self.sweeps_changed,
disabled=self.auto_sweeps)
cb2 = gui.checkBox(
self.dataBox,
self,
"auto_sweeps",
label="Auto",
callback=self.sweeps_changed,
)
grid.addWidget(wl, 1, 0, 1, 3)
grid.addWidget(cb2, 2, 0)
grid.addWidget(box, 2, 1, 1, 2)
wl = gui.widgetLabel(self.dataBox, "ZPD Peak Search:")
box = gui.comboBox(
self.dataBox,
self,
"peak_search",
label=None,
items=[
name.title()
for name, _ in irfft.PeakSearch.__members__.items()
],
callback=self.peak_search_changed,
enabled=self.peak_search_enable,
)
le1 = gui.lineEdit(
self.dataBox,
self,
"zpd1",
callback=self.peak_search_changed,
valueType=int,
controlWidth=50,
disabled=self.peak_search_enable,
)
le2 = gui.lineEdit(
self.dataBox,
self,
"zpd2",
callback=self.peak_search_changed,
valueType=int,
controlWidth=50,
disabled=self.peak_search_enable,
)
cb = gui.checkBox(
self.dataBox,
self,
"peak_search_enable",
label=None,
callback=self.peak_search_changed,
)
grid.addWidget(wl, 3, 0, 1, 3)
grid.addWidget(cb, 4, 0)
grid.addWidget(box, 4, 1, 1, 2)
grid.addWidget(gui.widgetLabel(self.dataBox, " Manual ZPD:"), 5, 0)
grid.addWidget(le1, 5, 1)
grid.addWidget(le2, 5, 2)
self.dataBox.layout().addLayout(grid)
# FFT Options control area
self.optionsBox = gui.widgetBox(self.controlArea, "FFT Options")
box = gui.comboBox(self.optionsBox,
self,
"apod_func",
label="Apodization function:",
items=self.apod_opts,
callback=self.setting_changed)
box = gui.comboBox(self.optionsBox,
self,
"zff",
label="Zero Filling Factor:",
items=(2**n for n in range(10)),
callback=self.setting_changed)
box = gui.comboBox(self.optionsBox,
self,
"phase_corr",
label="Phase Correction:",
items=self.phase_opts,
callback=self.setting_changed)
grid = QGridLayout()
grid.setContentsMargins(0, 0, 0, 0)
le1 = gui.lineEdit(self.optionsBox,
self,
"phase_resolution",
callback=self.setting_changed,
valueType=int,
controlWidth=30)
cb1 = gui.checkBox(self.optionsBox,
self,
"phase_res_limit",
label="Limit phase resolution to ",
callback=self.setting_changed,
disables=le1)
lb1 = gui.widgetLabel(self.optionsBox, "cm<sup>-1<sup>")
grid.addWidget(cb1, 0, 0)
grid.addWidget(le1, 0, 1)
grid.addWidget(lb1, 0, 2)
self.optionsBox.layout().addLayout(grid)
# Output Data control area
self.outputBox = gui.widgetBox(self.controlArea, "Output")
grid = QGridLayout()
grid.setContentsMargins(0, 0, 0, 0)
le2 = gui.lineEdit(self.outputBox,
self,
"out_limit1",
callback=self.out_limit_changed,
valueType=float,
controlWidth=50)
le3 = gui.lineEdit(self.outputBox,
self,
"out_limit2",
callback=self.out_limit_changed,
valueType=float,
controlWidth=50)
cb2 = gui.checkBox(self.outputBox,
self,
"limit_output",
label="Limit spectral region:",
callback=self.setting_changed,
disables=[le2, le3])
lb2 = gui.widgetLabel(self.outputBox, "-")
lb3 = gui.widgetLabel(self.outputBox, "cm<sup>-1</sup>")
grid.addWidget(cb2, 0, 0, 1, 6)
grid.addWidget(le2, 1, 1)
grid.addWidget(lb2, 1, 2)
grid.addWidget(le3, 1, 3)
grid.addWidget(lb3, 1, 4)
self.outputBox.layout().addLayout(grid)
gui.auto_commit(self.outputBox,
self,
"autocommit",
"Calculate",
box=False)
# Disable the controls initially (no data)
self.dataBox.setDisabled(True)
self.optionsBox.setDisabled(True)
def __init__(self):
super().__init__()
RecentPathsWComboMixin.__init__(self)
self.domain = None
self.data = None
self.loaded_file = ""
self.reader = None
layout = QGridLayout()
gui.widgetBox(self.controlArea, margin=0, orientation=layout)
vbox = gui.radioButtons(None,
self,
"source",
box=True,
addSpace=True,
callback=self.load_data,
addToLayout=False)
rb_button = gui.appendRadioButton(vbox, "文件:", addToLayout=False)
layout.addWidget(rb_button, 0, 0, Qt.AlignVCenter)
box = gui.hBox(None, addToLayout=False, margin=0)
box.setSizePolicy(Policy.MinimumExpanding, Policy.Fixed)
self.file_combo.setSizePolicy(Policy.MinimumExpanding, Policy.Fixed)
self.file_combo.activated[int].connect(self.select_file)
box.layout().addWidget(self.file_combo)
layout.addWidget(box, 0, 1)
file_button = gui.button(None,
self,
'...',
callback=self.browse_file,
autoDefault=False)
file_button.setIcon(self.style().standardIcon(QStyle.SP_DirOpenIcon))
file_button.setSizePolicy(Policy.Maximum, Policy.Fixed)
layout.addWidget(file_button, 0, 2)
reload_button = gui.button(None,
self,
"重新加载",
callback=self.load_data,
autoDefault=False)
reload_button.setIcon(self.style().standardIcon(
QStyle.SP_BrowserReload))
reload_button.setSizePolicy(Policy.Fixed, Policy.Fixed)
layout.addWidget(reload_button, 0, 3)
self.sheet_box = gui.hBox(None, addToLayout=False, margin=0)
self.sheet_combo = gui.comboBox(
None,
self,
"xls_sheet",
callback=self.select_sheet,
sendSelectedValue=True,
)
self.sheet_combo.setSizePolicy(Policy.MinimumExpanding, Policy.Fixed)
self.sheet_label = QLabel()
self.sheet_label.setText('Sheet')
self.sheet_label.setSizePolicy(Policy.MinimumExpanding, Policy.Fixed)
self.sheet_box.layout().addWidget(self.sheet_label, Qt.AlignLeft)
self.sheet_box.layout().addWidget(self.sheet_combo, Qt.AlignVCenter)
layout.addWidget(self.sheet_box, 2, 1)
self.sheet_box.hide()
rb_button = gui.appendRadioButton(vbox, "URL:", addToLayout=False)
layout.addWidget(rb_button, 3, 0, Qt.AlignVCenter)
self.url_combo = url_combo = QComboBox()
url_model = NamedURLModel(self.sheet_names)
url_model.wrap(self.recent_urls)
url_combo.setLineEdit(LineEditSelectOnFocus())
url_combo.setModel(url_model)
url_combo.setSizePolicy(Policy.MinimumExpanding, Policy.Fixed)
url_combo.setEditable(True)
url_combo.setInsertPolicy(url_combo.InsertAtTop)
url_edit = url_combo.lineEdit()
l, t, r, b = url_edit.getTextMargins()
url_edit.setTextMargins(l + 5, t, r, b)
layout.addWidget(url_combo, 3, 1, 3, 3)
url_combo.activated.connect(self._url_set)
box = gui.vBox(self.controlArea, "信息")
self.info = gui.widgetLabel(box, '没有加载数据。')
self.warnings = gui.widgetLabel(box, '')
box = gui.widgetBox(self.controlArea, "列集合 (双击编辑)")
self.domain_editor = DomainEditor(self)
self.editor_model = self.domain_editor.model()
box.layout().addWidget(self.domain_editor)
box = gui.hBox(self.controlArea)
gui.button(box,
self,
"打开数据集",
callback=lambda: self.browse_file(True),
autoDefault=False)
gui.rubber(box)
self.apply_button = gui.button(box,
self,
"应用",
callback=self.apply_domain_edit)
self.apply_button.setEnabled(False)
self.apply_button.setFixedWidth(170)
self.editor_model.dataChanged.connect(
lambda: self.apply_button.setEnabled(True))
self.set_file_list()
# Must not call open_file from within __init__. open_file
# explicitly re-enters the event loop (by a progress bar)
self.setAcceptDrops(True)
if self.source == self.LOCAL_FILE:
last_path = self.last_path()
if last_path and os.path.exists(last_path) and \
os.path.getsize(last_path) > self.SIZE_LIMIT:
self.Warning.file_too_big()
return
QTimer.singleShot(0, self.load_data)
def __init__(self):
super().__init__()
self.matrix = None
self._tree = None
self._ordered_tree = None
self._sorted_matrix = None
self._sort_indices = None
self._selection = None
self.sorting_cb = gui.comboBox(self.controlArea,
self,
"sorting",
box="排序",
items=["无", "聚类", "使用有序叶子进行聚类"],
callback=self._invalidate_ordering)
box = gui.vBox(self.controlArea, "颜色")
self.colormap_cb = gui.comboBox(box,
self,
"colormap",
callback=self._update_color)
self.colormap_cb.setIconSize(QSize(64, 16))
self.palettes = list(_color_palettes)
init_color_combo(self.colormap_cb, self.palettes, QSize(64, 16))
self.colormap_cb.setCurrentIndex(self.colormap)
form = QFormLayout(formAlignment=Qt.AlignLeft,
labelAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QFormLayout.AllNonFixedFieldsGrow)
# form.addRow(
# "Gamma",
# gui.hSlider(box, self, "color_gamma", minValue=0.0, maxValue=1.0,
# step=0.05, ticks=True, intOnly=False,
# createLabel=False, callback=self._update_color)
# )
form.addRow(
"低:",
gui.hSlider(box,
self,
"color_low",
minValue=0.0,
maxValue=1.0,
step=0.05,
ticks=True,
intOnly=False,
createLabel=False,
callback=self._update_color))
form.addRow(
"高:",
gui.hSlider(box,
self,
"color_high",
minValue=0.0,
maxValue=1.0,
step=0.05,
ticks=True,
intOnly=False,
createLabel=False,
callback=self._update_color))
box.layout().addLayout(form)
self.annot_combo = gui.comboBox(self.controlArea,
self,
"annotation_idx",
box="注解",
callback=self._invalidate_annotations,
contentsLength=12)
self.annot_combo.setModel(itemmodels.VariableListModel())
self.annot_combo.model()[:] = ["无", "列举"]
self.controlArea.layout().addStretch()
gui.auto_commit(self.controlArea, self, "autocommit", "选中发送")
self.view = pg.GraphicsView(background="w")
self.mainArea.layout().addWidget(self.view)
self.grid_widget = pg.GraphicsWidget()
self.grid = QGraphicsGridLayout()
self.grid_widget.setLayout(self.grid)
self.viewbox = pg.ViewBox(enableMouse=False, enableMenu=False)
self.viewbox.setAcceptedMouseButtons(Qt.NoButton)
self.viewbox.setAcceptHoverEvents(False)
self.grid.addItem(self.viewbox, 1, 1)
self.left_dendrogram = DendrogramWidget(
self.grid_widget,
orientation=DendrogramWidget.Left,
selectionMode=DendrogramWidget.NoSelection,
hoverHighlightEnabled=False)
self.left_dendrogram.setAcceptedMouseButtons(Qt.NoButton)
self.left_dendrogram.setAcceptHoverEvents(False)
self.top_dendrogram = DendrogramWidget(
self.grid_widget,
orientation=DendrogramWidget.Top,
selectionMode=DendrogramWidget.NoSelection,
hoverHighlightEnabled=False)
self.top_dendrogram.setAcceptedMouseButtons(Qt.NoButton)
self.top_dendrogram.setAcceptHoverEvents(False)
self.grid.addItem(self.left_dendrogram, 1, 0)
self.grid.addItem(self.top_dendrogram, 0, 1)
self.right_labels = TextList(alignment=Qt.AlignLeft)
self.bottom_labels = TextList(orientation=Qt.Horizontal,
alignment=Qt.AlignRight)
self.grid.addItem(self.right_labels, 1, 2)
self.grid.addItem(self.bottom_labels, 2, 1)
self.view.setCentralItem(self.grid_widget)
self.left_dendrogram.hide()
self.top_dendrogram.hide()
self.right_labels.hide()
self.bottom_labels.hide()
self.matrix_item = None
self.dendrogram = None
self.grid_widget.scene().installEventFilter(self)
def __init__(self):
super().__init__()
self.data = None
self.test_data = None
self.preprocessor = None
self.train_data_missing_vals = False
self.test_data_missing_vals = False
self.scorers = []
#: An Ordered dictionary with current inputs and their testing results.
self.learners = OrderedDict() # type: Dict[Any, Input]
self.__state = State.Waiting
# Do we need to [re]test any learners, set by _invalidate and
# cleared by __update
self.__needupdate = False
self.__task = None # type: Optional[Task]
self.__executor = ThreadExecutor()
sbox = gui.vBox(self.controlArea, "Sampling")
rbox = gui.radioButtons(sbox,
self,
"resampling",
callback=self._param_changed)
gui.appendRadioButton(rbox, "Cross validation")
ibox = gui.indentedBox(rbox)
gui.comboBox(ibox,
self,
"n_folds",
label="Number of folds: ",
items=[str(x) for x in self.NFolds],
maximumContentsLength=3,
orientation=Qt.Horizontal,
callback=self.kfold_changed)
gui.checkBox(ibox,
self,
"cv_stratified",
"Stratified",
callback=self.kfold_changed)
gui.appendRadioButton(rbox, "Cross validation by feature")
ibox = gui.indentedBox(rbox)
self.feature_model = DomainModel(order=DomainModel.METAS,
valid_types=DiscreteVariable)
self.features_combo = gui.comboBox(ibox,
self,
"fold_feature",
model=self.feature_model,
orientation=Qt.Horizontal,
callback=self.fold_feature_changed)
gui.appendRadioButton(rbox, "Random sampling")
ibox = gui.indentedBox(rbox)
gui.comboBox(ibox,
self,
"n_repeats",
label="Repeat train/test: ",
items=[str(x) for x in self.NRepeats],
maximumContentsLength=3,
orientation=Qt.Horizontal,
callback=self.shuffle_split_changed)
gui.comboBox(ibox,
self,
"sample_size",
label="Training set size: ",
items=["{} %".format(x) for x in self.SampleSizes],
maximumContentsLength=5,
orientation=Qt.Horizontal,
callback=self.shuffle_split_changed)
gui.checkBox(ibox,
self,
"shuffle_stratified",
"Stratified",
callback=self.shuffle_split_changed)
gui.appendRadioButton(rbox, "Leave one out")
gui.appendRadioButton(rbox, "Test on train data")
gui.appendRadioButton(rbox, "Test on test data")
self.cbox = gui.vBox(self.controlArea, "Target Class")
self.class_selection_combo = gui.comboBox(
self.cbox,
self,
"class_selection",
items=[],
sendSelectedValue=True,
valueType=str,
callback=self._on_target_class_changed,
contentsLength=8)
gui.rubber(self.controlArea)
self.score_table = ScoreTable(self)
self.score_table.shownScoresChanged.connect(self.update_stats_model)
box = gui.vBox(self.mainArea, "Evaluation Results")
box.layout().addWidget(self.score_table.view)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.api = None
self.corpus = None
self.api_dlg = self.APICredentialsDialog(self)
self.api_dlg.accept(silent=True)
# Set API key button
gui.button(self.controlArea,
self,
'Twitter API Key',
callback=self.open_key_dialog,
tooltip='Set the API key for this widget.',
focusPolicy=Qt.NoFocus)
# Query
query_box = gui.hBox(self.controlArea, 'Query')
layout = QGridLayout()
layout.setVerticalSpacing(5)
layout.setColumnStretch(2, 1) # stretch last columns
layout.setColumnMinimumWidth(1, 15) # add some space for checkbox
ROW = 0
COLUMNS = 3
def add_row(label, items):
nonlocal ROW, COLUMNS
layout.addWidget(QLabel(label), ROW, 0)
if isinstance(items, tuple):
for i, item in enumerate(items):
layout.addWidget(item, ROW, 1 + i)
else:
layout.addWidget(items, ROW, 1, 1, COLUMNS - 1)
ROW += 1
# Query input
add_row(
'Query word list:',
ListEdit(self, 'word_list', 'Multiple lines are joined with OR.',
80, self))
# Search mode
add_row(
'Search by:',
gui.comboBox(self,
self,
'mode',
items=self.MODES,
callback=self.mode_toggle))
# Language
self.language_combo = ComboBox(self,
'language',
items=(('Any', None), ) +
tuple(sorted(lang2code.items())))
add_row('Language:', self.language_combo)
# Max tweets
add_row(
'Max tweets:',
gui.spin(self,
self,
'max_tweets',
minv=1,
maxv=10000,
checked='limited_search'))
# Retweets
self.retweets_checkbox = gui.checkBox(self,
self,
'allow_retweets',
'',
minimumHeight=30)
add_row('Allow retweets:', self.retweets_checkbox)
# Collect Results
add_row('Collect results:', gui.checkBox(self, self, 'collecting', ''))
query_box.layout().addLayout(layout)
self.controlArea.layout().addWidget(
CheckListLayout('Text includes',
self,
'text_includes',
self.attributes,
cols=2,
callback=self.set_text_features))
self.tweets_info_label = gui.label(self.controlArea,
self,
self.tweets_info.format(0),
box='Info')
# Buttons
self.button_box = gui.hBox(self.controlArea)
self.search_button = gui.button(self.button_box,
self,
'Search',
self.start_stop,
focusPolicy=Qt.NoFocus)
self.mode_toggle()
self.setFocus() # to widget itself to show placeholder for query_edit
def __init__(self):
super().__init__()
self.data = None # type: Optional[Table]
self.graph = None # type: Optional[nx.Graph]
self.partition = None # type: Optional[np.array]
self.__executor = ThreadExecutor(parent=self)
self.__future = None # type: Optional[Future]
self.__state = self.State.Pending
pca_box = gui.vBox(self.controlArea, 'PCA Preprocessing')
self.apply_pca_cbx = gui.checkBox(
pca_box,
self,
'apply_pca',
label='Apply PCA preprocessing',
callback=self._invalidate_graph,
) # type: QCheckBox
self.pca_components_slider = gui.hSlider(
pca_box,
self,
'pca_components',
label='Components: ',
minValue=2,
maxValue=_MAX_PCA_COMPONENTS,
callback=self._invalidate_pca_projection,
) # type: QSlider
graph_box = gui.vBox(self.controlArea, 'Graph parameters')
self.metric_combo = gui.comboBox(
graph_box,
self,
'metric_idx',
label='Distance metric',
items=[m[0] for m in METRICS],
callback=self._invalidate_graph,
orientation=Qt.Horizontal,
) # type: gui.OrangeComboBox
self.k_neighbours_spin = gui.spin(
graph_box,
self,
'k_neighbours',
minv=1,
maxv=_MAX_K_NEIGBOURS,
label='k neighbours',
controlWidth=80,
alignment=Qt.AlignRight,
callback=self._invalidate_graph,
) # type: gui.SpinBoxWFocusOut
self.cls_epsilon_spin = gui.spin(
graph_box,
self,
'resolution',
0,
5.,
1e-2,
spinType=float,
label='Resolution',
controlWidth=80,
alignment=Qt.AlignRight,
callback=self._invalidate_partition,
) # type: gui.SpinBoxWFocusOut
self.apply_button = gui.auto_commit(
self.controlArea,
self,
'auto_commit',
'Apply',
box=False,
commit=lambda: self.commit(force=True),
callback=self.commit,
) # type: QWidget
def __init__(self, parent=None):
super().__init__(parent)
self.data = None
self.results = None
self.learners = []
box = gui.widgetBox(self.controlArea, "Learners")
self.learners_box = gui.listBox(box,
self,
"selected_learner",
"learners",
callback=self._learner_changed)
box = gui.widgetBox(self.controlArea, "Show")
gui.comboBox(box,
self,
"selected_quantity",
items=self.quantities,
callback=self._update)
box = gui.widgetBox(self.controlArea, "Select")
gui.button(box,
self,
"Correct",
callback=self.select_correct,
autoDefault=False)
gui.button(box,
self,
"Misclassified",
callback=self.select_wrong,
autoDefault=False)
gui.button(box,
self,
"None",
callback=self.select_none,
autoDefault=False)
self.outputbox = box = gui.widgetBox(self.controlArea, "Output")
gui.checkBox(box,
self,
"append_predictions",
"Predictions",
callback=self._invalidate)
gui.checkBox(box,
self,
"append_probabilities",
"Probabilities",
callback=self._invalidate)
gui.auto_commit(self.controlArea, self, "autocommit", "Send Data",
"Auto send is on")
grid = QGridLayout()
grid.setContentsMargins(0, 0, 0, 0)
grid.addWidget(QLabel("Predicted"), 0, 1, Qt.AlignCenter)
grid.addWidget(VerticalLabel("Actual Class"), 1, 0, Qt.AlignCenter)
self.tablemodel = QStandardItemModel()
self.tableview = QTableView(editTriggers=QTableView.NoEditTriggers)
self.tableview.setModel(self.tablemodel)
self.tableview.selectionModel().selectionChanged.connect(
self._invalidate)
grid.addWidget(self.tableview, 1, 1)
self.mainArea.layout().addLayout(grid)
def __init__(self):
super().__init__()
# sets self.curvePoints, self.steps equidistant points from
# 1/self.steps to 1
self.updateCurvePoints()
# [start-snippet-2]
self.scoring = [
("Classification Accuracy", Orange.evaluation.scoring.CA),
("AUC", Orange.evaluation.scoring.AUC),
("Precision", Orange.evaluation.scoring.Precision),
("Recall", Orange.evaluation.scoring.Recall),
]
# [end-snippet-2]
#: input data on which to construct the learning curve
self.data = None
#: A {input_id: Learner} mapping of current learners from input channel
self.learners = OrderedDict()
#: A {input_id: List[Results]} mapping of input id to evaluation
#: results list, one for each curve point
self.results = OrderedDict()
#: A {input_id: List[float]} mapping of input id to learning curve
#: point scores
self.curves = OrderedDict()
# GUI
box = gui.widgetBox(self.controlArea, "Info")
self.infoa = gui.widgetLabel(box, "No data on input.")
self.infob = gui.widgetLabel(box, "No learners.")
gui.separator(self.controlArea)
box = gui.widgetBox(self.controlArea, "Evaluation Scores")
gui.comboBox(
box,
self,
"scoringF",
items=[x[0] for x in self.scoring],
callback=self._invalidate_curves,
)
gui.separator(self.controlArea)
box = gui.widgetBox(self.controlArea, "Options")
gui.spin(
box,
self,
"folds",
2,
100,
step=1,
label="Cross validation folds: ",
keyboardTracking=False,
callback=lambda: self._invalidate_results()
if self.commitOnChange else None,
)
gui.spin(
box,
self,
"steps",
2,
100,
step=1,
label="Learning curve points: ",
keyboardTracking=False,
callback=[
self.updateCurvePoints,
lambda: self._invalidate_results()
if self.commitOnChange else None,
],
)
gui.checkBox(box, self, "commitOnChange",
"Apply setting on any change")
self.commitBtn = gui.button(box,
self,
"Apply Setting",
callback=self._invalidate_results,
disabled=True)
gui.rubber(self.controlArea)
# table widget
self.table = gui.table(self.mainArea,
selectionMode=QTableWidget.NoSelection)
def __init__(self):
super().__init__()
self.data = None
self.plotdata = None
box = gui.widgetBox(self.controlArea, "Optimization", spacing=10)
form = QtGui.QFormLayout(
labelAlignment=Qt.AlignLeft,
formAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QtGui.QFormLayout.AllNonFixedFieldsGrow,
verticalSpacing=10)
form.addRow(
"Force law",
gui.comboBox(box,
self,
"force_law",
items=[text for text, _ in OWFreeViz.ForceLaw],
callback=self.__reset_update_interval))
form.addRow("Max iterations", gui.spin(box, self, "maxiter", 10,
10**4))
form.addRow(
"Initialization",
gui.comboBox(box,
self,
"initialization",
items=["Circular", "Random"],
callback=self.__reset_initialization))
form.addRow(
"Replot",
gui.comboBox(box,
self,
"replot_interval",
items=[text for text, _ in OWFreeViz.ReplotIntervals],
callback=self.__reset_update_interval))
box.layout().addLayout(form)
self.start_button = gui.button(box, self, "Optimize",
self._toogle_start)
self.color_varmodel = itemmodels.VariableListModel(parent=self)
self.shape_varmodel = itemmodels.VariableListModel(parent=self)
self.size_varmodel = itemmodels.VariableListModel(parent=self)
self.label_varmodel = itemmodels.VariableListModel(parent=self)
box = gui.widgetBox(self.controlArea, "Plot")
form = QtGui.QFormLayout(
formAlignment=Qt.AlignLeft,
labelAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QtGui.QFormLayout.AllNonFixedFieldsGrow,
spacing=8,
)
box.layout().addLayout(form)
color_cb = gui.comboBox(box,
self,
"color_var",
sendSelectedValue=True,
emptyString="(Same color)",
contentsLength=10,
callback=self._update_color)
color_cb.setModel(self.color_varmodel)
form.addRow("Color", color_cb)
opacity_slider = gui.hSlider(box,
self,
"opacity",
minValue=50,
maxValue=255,
ticks=True,
createLabel=False,
callback=self._update_color)
opacity_slider.setTickInterval(0)
opacity_slider.setPageStep(10)
form.addRow("Opacity", opacity_slider)
shape_cb = gui.comboBox(box,
self,
"shape_var",
contentsLength=10,
sendSelectedValue=True,
emptyString="(Same shape)",
callback=self._update_shape)
shape_cb.setModel(self.shape_varmodel)
form.addRow("Shape", shape_cb)
size_cb = gui.comboBox(box,
self,
"size_var",
contentsLength=10,
sendSelectedValue=True,
emptyString="(Same size)",
callback=self._update_size)
size_cb.setModel(self.size_varmodel)
form.addRow("Size", size_cb)
size_slider = gui.hSlider(box,
self,
"point_size",
minValue=3,
maxValue=20,
ticks=True,
createLabel=False,
callback=self._update_size)
form.addRow(None, size_slider)
label_cb = gui.comboBox(box,
self,
"label_var",
contentsLength=10,
sendSelectedValue=True,
emptyString="(No labels)",
callback=self._update_labels)
label_cb.setModel(self.label_varmodel)
form.addRow("Label", label_cb)
form.addRow(
"Jitter",
gui.comboBox(box,
self,
"jitter",
items=[text for text, _ in self.JitterAmount],
callback=self._update_xy))
self.class_density_cb = gui.checkBox(box,
self,
"class_density",
"",
callback=self._update_density)
form.addRow("Class density", self.class_density_cb)
box = gui.widgetBox(self.controlArea, "Hide anchors")
rslider = gui.hSlider(box,
self,
"min_anchor_radius",
minValue=0,
maxValue=100,
step=5,
label="Hide radius",
createLabel=False,
ticks=True,
callback=self._update_anchor_visibility)
rslider.setTickInterval(0)
rslider.setPageStep(10)
box = gui.widgetBox(self.controlArea, "Zoom/Select")
hlayout = QtGui.QHBoxLayout()
box.layout().addLayout(hlayout)
toolbox = PlotToolBox(self)
hlayout.addWidget(toolbox.button(PlotToolBox.SelectTool))
hlayout.addWidget(toolbox.button(PlotToolBox.ZoomTool))
hlayout.addWidget(toolbox.button(PlotToolBox.PanTool))
hlayout.addSpacing(2)
hlayout.addWidget(toolbox.button(PlotToolBox.ZoomReset))
toolbox.standardAction(PlotToolBox.ZoomReset).triggered.connect(
lambda: self.plot.setRange(QtCore.QRectF(-1.05, -1.05, 2.1, 2.1)))
toolbox.standardAction(PlotToolBox.ZoomIn).triggered.connect(
lambda: self.plot.getViewBox().scaleBy((1.25, 1.25)))
toolbox.standardAction(PlotToolBox.ZoomIn).triggered.connect(
lambda: self.plot.getViewBox().scaleBy((1 / 1.25, 1 / 1.25)))
selecttool = toolbox.plotTool(PlotToolBox.SelectTool)
selecttool.selectionFinished.connect(self.__select_area)
self.addActions(toolbox.actions())
self.controlArea.layout().addStretch(1)
box = gui.widgetBox(self.controlArea, "Output")
gui.comboBox(box,
self,
"embedding_domain_role",
items=[
"Original features only", "Coordinates as features",
"Coordinates as meta attributes"
])
gui.auto_commit(box,
self,
"autocommit",
"Commit",
box=False,
callback=self.commit)
self.plot = pg.PlotWidget(enableMouse=False, enableMenu=False)
self.plot.setFrameStyle(QtGui.QFrame.StyledPanel)
self.plot.plotItem.hideAxis("bottom")
self.plot.plotItem.hideAxis("left")
self.plot.plotItem.hideButtons()
self.plot.setAspectLocked(True)
self.plot.scene().installEventFilter(self)
self.legend = linproj.LegendItem()
self.legend.setParentItem(self.plot.getViewBox())
self.legend.anchor((1, 0), (1, 0))
self.plot.setRenderHint(QtGui.QPainter.Antialiasing, True)
self.mainArea.layout().addWidget(self.plot)
viewbox = self.plot.getViewBox()
viewbox.grabGesture(Qt.PinchGesture)
pinchtool = linproj.PlotPinchZoomTool(parent=self)
pinchtool.setViewBox(viewbox)
toolbox.setViewBox(viewbox)
self._loop = AsyncUpdateLoop(parent=self)
self._loop.yielded.connect(self.__set_projection)
self._loop.finished.connect(self.__freeviz_finished)
self._loop.raised.connect(self.__on_error)
def __init__(self):
super().__init__()
self.data = None
# The following lists are of the same length as self.active_rules
#: list of pairs with counts of matches for each patter when the
# patterns are applied in order and when applied on the entire set,
# disregarding the preceding patterns
self.match_counts = []
#: list of list of QLineEdit: line edit pairs for each pattern
self.line_edits = []
#: list of QPushButton: list of remove buttons
self.remove_buttons = []
#: list of list of QLabel: pairs of labels with counts
self.counts = []
combo = gui.comboBox(self.controlArea,
self,
"attribute",
label="From column: ",
box=True,
orientation=Qt.Horizontal,
callback=self.update_rules,
model=DomainModel(valid_types=(StringVariable,
DiscreteVariable)))
# Don't use setSizePolicy keyword argument here: it applies to box,
# not the combo
combo.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Fixed)
patternbox = gui.vBox(self.controlArea, box=True)
#: QWidget: the box that contains the remove buttons, line edits and
# count labels. The lines are added and removed dynamically.
self.rules_box = rules_box = QGridLayout()
patternbox.layout().addLayout(self.rules_box)
box = gui.hBox(patternbox)
gui.button(box,
self,
"+",
callback=self.add_row,
autoDefault=False,
flat=True,
minimumSize=(QSize(20, 20)))
gui.rubber(box)
self.rules_box.setColumnMinimumWidth(1, 70)
self.rules_box.setColumnMinimumWidth(0, 10)
self.rules_box.setColumnStretch(0, 1)
self.rules_box.setColumnStretch(1, 1)
self.rules_box.setColumnStretch(2, 100)
rules_box.addWidget(QLabel("Name"), 0, 1)
rules_box.addWidget(QLabel("Substring"), 0, 2)
rules_box.addWidget(QLabel("#Instances"), 0, 3, 1, 2)
self.update_rules()
gui.lineEdit(self.controlArea,
self,
"class_name",
label="Name for the new class:",
box=True,
orientation=Qt.Horizontal)
optionsbox = gui.vBox(self.controlArea, box=True)
gui.checkBox(optionsbox,
self,
"match_beginning",
"Match only at the beginning",
callback=self.options_changed)
gui.checkBox(optionsbox,
self,
"case_sensitive",
"Case sensitive",
callback=self.options_changed)
layout = QGridLayout()
gui.widgetBox(self.controlArea, orientation=layout)
for i in range(3):
layout.setColumnStretch(i, 1)
layout.addWidget(self.report_button, 0, 0)
apply = gui.button(None,
self,
"Apply",
autoDefault=False,
callback=self.apply)
layout.addWidget(apply, 0, 2)
# TODO: Resizing upon changing the number of rules does not work
self.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Maximum)
def theme_combo_box(self, widget):
c = gui.comboBox(widget, self._plot, "theme_name", "Theme", callback = self._plot.update_theme, sendSelectedValue = 1, valueType = str)
c.addItem('Default')
c.addItem('Light')
c.addItem('Dark')
return c
def __init__(self):
super().__init__()
self.data = None
self.source_id = None
self._mas = None
self._Ws = None
self._transformed = None
self._components = None
self._use_genes = None
self._shared_correlations = None
self._transformed_table = None
self._line = False
self._feature_model = DomainModel(valid_types=DiscreteVariable,
separators=False)
self._feature_model.set_domain(None)
self._init_mas()
self._legend = None
form = QFormLayout(labelAlignment=Qt.AlignLeft,
formAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QFormLayout.AllNonFixedFieldsGrow,
verticalSpacing=10)
# Data source indicator
box = gui.vBox(self.controlArea, "Data source indicator")
gui.comboBox(
box,
self,
"source_id",
sendSelectedValue=True,
callback=self._update_combo_source_id,
model=self._feature_model,
)
# Canonical correlation analysis
box = gui.vBox(self.controlArea, "Canonical correlation analysis")
gui.spin(box,
self,
"ncomponents",
1,
MAX_COMPONENTS,
callback=self._update_selection_component_spin,
keyboardTracking=False,
label="Num. of components")
# Shared genes
box = gui.vBox(self.controlArea, "Shared genes")
gui.spin(
box,
self,
"ngenes",
1,
MAX_GENES,
callback=self._update_ngenes_spin,
keyboardTracking=False,
)
form.addRow("Num. of genes", self.controls.ngenes)
gui.comboBox(
box,
self,
"scoring",
callback=self._update_scoring_combo,
items=list(SCORINGS.keys()),
sendSelectedValue=True,
editable=False,
)
form.addRow("Scoring:", self.controls.scoring)
box.layout().addLayout(form)
# Post-processing
box = gui.vBox(self.controlArea, "Post-processing")
gui.doubleSpin(
box,
self,
"quantile_normalization_perc",
minv=0,
maxv=49,
step=5e-1,
callback=self._update_quantile_normalization,
checkCallback=self._update_quantile_normalization,
controlWidth=80,
alignment=Qt.AlignRight,
label="Quantile normalization",
checked="quantile_normalization",
)
self.controls.quantile_normalization_perc.setSuffix("%")
b = gui.vBox(box)
gui.checkBox(b,
self,
"dynamic_time_warping",
callback=self._update_dynamic_time_warping,
label="Dynamic time warping")
self.controlArea.layout().addStretch()
gui.auto_commit(self.controlArea,
self,
"auto_commit",
"Apply",
callback=self._invalidate_selection(),
checkbox_label="Apply automatically")
self.plot = pg.PlotWidget(background="w")
axis = self.plot.getAxis("bottom")
axis.setLabel("Correlation components")
axis = self.plot.getAxis("left")
axis.setLabel("Correlation strength")
self.plot_horlabels = []
self.plot_horlines = []
self.plot.getViewBox().setMenuEnabled(False)
self.plot.getViewBox().setMouseEnabled(False, False)
self.plot.showGrid(True, True, alpha=0.5)
self.plot.setRange(xRange=(0.0, 1.0), yRange=(0.0, 1.0))
self.mainArea.layout().addWidget(self.plot)
def __init__(self):
super().__init__()
self.results = None
self.classifier_names = []
self.perf_line = None
self.colors = []
self._curve_data = {}
self._plot_curves = {}
self._rocch = None
self._perf_line = None
self._tooltip_cache = None
box = gui.vBox(self.controlArea, "绘制")
self.target_cb = gui.comboBox(box,
self,
"target_index",
label="目标",
orientation=Qt.Horizontal,
callback=self._on_target_changed,
contentsLength=8,
searchable=True)
gui.widgetLabel(box, "分类器")
line_height = 4 * QFontMetrics(self.font()).lineSpacing()
self.classifiers_list_box = gui.listBox(
box,
self,
"selected_classifiers",
"classifier_names",
selectionMode=QListView.MultiSelection,
callback=self._on_classifiers_changed,
sizeHint=QSize(0, line_height))
abox = gui.vBox(self.controlArea, "曲线")
gui.comboBox(abox,
self,
"roc_averaging",
items=["合并折叠预测", "平均真阳性率", "阈值处的平均真阳性率和假阳性率", "显示单个曲线"],
callback=self._replot)
gui.checkBox(abox,
self,
"display_convex_curve",
"显示凸ROC曲线",
callback=self._replot)
gui.checkBox(abox,
self,
"display_convex_hull",
"显示ROC凸包",
callback=self._replot)
box = gui.vBox(self.controlArea, "分析")
gui.checkBox(box,
self,
"display_def_threshold",
"默认阈值（0.5）点",
callback=self._on_display_def_threshold_changed)
gui.checkBox(box,
self,
"display_perf_line",
"显示性能线",
callback=self._on_display_perf_line_changed)
grid = QGridLayout()
gui.indentedBox(box, orientation=grid)
sp = gui.spin(box,
self,
"fp_cost",
1,
1000,
10,
alignment=Qt.AlignRight,
callback=self._on_display_perf_line_changed)
grid.addWidget(QLabel("假阳性率损失:"), 0, 0)
grid.addWidget(sp, 0, 1)
sp = gui.spin(box,
self,
"fn_cost",
1,
1000,
10,
alignment=Qt.AlignRight,
callback=self._on_display_perf_line_changed)
grid.addWidget(QLabel("假阴性率损失:"))
grid.addWidget(sp, 1, 1)
self.target_prior_sp = gui.spin(box,
self,
"target_prior",
1,
99,
alignment=Qt.AlignRight,
spinType=float,
callback=self._on_target_prior_changed)
self.target_prior_sp.setSuffix(" %")
self.target_prior_sp.addAction(QAction("Auto", sp))
grid.addWidget(QLabel("先验概率:"))
grid.addWidget(self.target_prior_sp, 2, 1)
self.plotview = GraphicsView(background=None)
self.plotview.setFrameStyle(QFrame.StyledPanel)
self.plotview.scene().sigMouseMoved.connect(self._on_mouse_moved)
self.plot = PlotItem(enableMenu=False)
self.plot.setMouseEnabled(False, False)
self.plot.hideButtons()
tickfont = QFont(self.font())
tickfont.setPixelSize(max(int(tickfont.pixelSize() * 2 // 3), 11))
axis = self.plot.getAxis("bottom")
axis.setTickFont(tickfont)
axis.setLabel("假阳性率 (1-特异度)")
axis.setGrid(16)
axis = self.plot.getAxis("left")
axis.setTickFont(tickfont)
axis.setLabel("真阳性率 (灵敏度)")
axis.setGrid(16)
self.plot.showGrid(True, True, alpha=0.2)
self.plot.setRange(xRange=(0.0, 1.0), yRange=(0.0, 1.0), padding=0.05)
self.plotview.setCentralItem(self.plot)
self.mainArea.layout().addWidget(self.plotview)
def __init__(self):
super().__init__()
self.data = None
self._effective_data = None
self._matrix = None
self._silhouette = None
self._labels = None
self._silplot = None
box = gui.widgetBox(
self.controlArea,
"Settings",
)
gui.comboBox(box,
self,
"distance_idx",
label="Distance",
items=[name for name, _ in OWSilhouettePlot.Distances],
callback=self._invalidate_distances)
self.cluster_var_cb = gui.comboBox(box,
self,
"cluster_var_idx",
label="Cluster",
callback=self._invalidate_scores)
self.cluster_var_model = itemmodels.VariableListModel(parent=self)
self.cluster_var_cb.setModel(self.cluster_var_model)
gui.spin(box,
self,
"bar_size",
minv=1,
maxv=10,
label="Bar Size",
callback=self._update_bar_size)
gui.checkBox(box,
self,
"group_by_cluster",
"Group by cluster",
callback=self._replot)
self.annotation_cb = gui.comboBox(box,
self,
"annotation_var_idx",
label="Annotations",
callback=self._update_annotations)
self.annotation_var_model = itemmodels.VariableListModel(parent=self)
self.annotation_var_model[:] = ["None"]
self.annotation_cb.setModel(self.annotation_var_model)
gui.rubber(self.controlArea)
box = gui.widgetBox(self.controlArea, "Output")
gui.checkBox(
box,
self,
"add_scores",
"Add silhouette scores",
)
gui.auto_commit(box, self, "auto_commit", "Commit", box=False)
self.scene = QtGui.QGraphicsScene()
self.view = QtGui.QGraphicsView(self.scene)
self.view.setRenderHint(QtGui.QPainter.Antialiasing, True)
self.view.setAlignment(Qt.AlignTop | Qt.AlignLeft)
self.mainArea.layout().addWidget(self.view)
def __init__(self):
super().__init__()
self.data = None
self.km = None
self.optimization_runs = []
box = gui.vBox(self.controlArea, "Number of Clusters")
layout = QGridLayout()
self.n_clusters = bg = gui.radioButtonsInBox(
box, self, "optimize_k", [], orientation=layout,
callback=self.update)
layout.addWidget(
gui.appendRadioButton(bg, "Fixed:", addToLayout=False),
1, 1)
sb = gui.hBox(None, margin=0)
self.fixedSpinBox = gui.spin(
sb, self, "k", minv=2, maxv=30,
controlWidth=60, alignment=Qt.AlignRight, callback=self.update_k)
gui.rubber(sb)
layout.addWidget(sb, 1, 2)
layout.addWidget(
gui.appendRadioButton(bg, "Optimized from", addToLayout=False), 2, 1)
ftobox = gui.hBox(None)
ftobox.layout().setContentsMargins(0, 0, 0, 0)
layout.addWidget(ftobox)
gui.spin(
ftobox, self, "k_from", minv=2, maxv=29,
controlWidth=60, alignment=Qt.AlignRight,
callback=self.update_from)
gui.widgetLabel(ftobox, "to")
self.fixedSpinBox = gui.spin(
ftobox, self, "k_to", minv=3, maxv=30,
controlWidth=60, alignment=Qt.AlignRight,
callback=self.update_to)
gui.rubber(ftobox)
layout.addWidget(gui.widgetLabel(None, "Scoring: "),
5, 1, Qt.AlignRight)
layout.addWidget(
gui.comboBox(
None, self, "scoring", label="Scoring",
items=list(zip(*self.SCORING_METHODS))[0],
callback=self.update), 5, 2)
box = gui.vBox(self.controlArea, "Initialization")
gui.comboBox(
box, self, "smart_init", items=self.INIT_METHODS,
callback=self.update)
layout = QGridLayout()
box2 = gui.widgetBox(box, orientation=layout)
box2.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Maximum)
layout.addWidget(gui.widgetLabel(None, "Re-runs: "),
0, 0, Qt.AlignLeft)
sb = gui.hBox(None, margin=0)
layout.addWidget(sb, 0, 1)
gui.lineEdit(
sb, self, "n_init", controlWidth=60,
valueType=int, validator=QIntValidator(),
callback=self.update)
layout.addWidget(gui.widgetLabel(None, "Maximal iterations: "),
1, 0, Qt.AlignLeft)
sb = gui.hBox(None, margin=0)
layout.addWidget(sb, 1, 1)
gui.lineEdit(sb, self, "max_iterations",
controlWidth=60, valueType=int,
validator=QIntValidator(),
callback=self.update)
box = gui.vBox(self.controlArea, "Output")
gui.comboBox(box, self, "place_cluster_ids",
label="Append cluster ID as:", orientation=Qt.Horizontal,
callback=self.send_data, items=self.OUTPUT_METHODS)
gui.lineEdit(box, self, "output_name",
label="Name:", orientation=Qt.Horizontal,
callback=self.send_data)
gui.separator(self.buttonsArea, 30)
self.apply_button = gui.auto_commit(
self.buttonsArea, self, "auto_run", "Apply", box=None,
commit=self.commit
)
gui.rubber(self.controlArea)
self.table_model = QStandardItemModel(self)
self.table_model.setHorizontalHeaderLabels(["k", "Score"])
self.table_model.setColumnCount(2)
self.table_box = gui.vBox(
self.mainArea, "Optimization Report", addSpace=0)
table = self.table_view = QTableView(self.table_box)
table.setHorizontalScrollMode(QTableView.ScrollPerPixel)
table.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
table.setSelectionMode(QTableView.SingleSelection)
table.setSelectionBehavior(QTableView.SelectRows)
table.verticalHeader().hide()
table.setItemDelegateForColumn(1, gui.TableBarItem(self))
table.setModel(self.table_model)
table.selectionModel().selectionChanged.connect(
self.table_item_selected)
table.setColumnWidth(0, 40)
table.setColumnWidth(1, 120)
table.horizontalHeader().setStretchLastSection(True)
self.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
self.mainArea.setSizePolicy(QSizePolicy.Maximum,
QSizePolicy.Preferred)
self.table_box.setSizePolicy(QSizePolicy.Fixed,
QSizePolicy.MinimumExpanding)
self.table_view.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.MinimumExpanding)
self.table_box.layout().addWidget(self.table_view)
self.hide_show_opt_results()
def __init__(self):
super().__init__()
self.data = None
self.valid_data = self.valid_group_data = None
self.bar_items = []
self.curve_items = []
self.curve_descriptions = None
self.binnings = []
self.last_click_idx = None
self.drag_operation = self.DragNone
self.key_operation = None
self._user_var_bins = {}
gui.listView(self.controlArea,
self,
"var",
box="Variable",
model=DomainModel(valid_types=DomainModel.PRIMITIVE,
separators=False),
callback=self._on_var_changed)
box = self.continuous_box = gui.vBox(self.controlArea, "Distribution")
slider = gui.hSlider(box,
self,
"number_of_bins",
label="Bin width",
orientation=Qt.Horizontal,
minValue=0,
maxValue=max(1,
len(self.binnings) - 1),
createLabel=False,
callback=self._on_bins_changed)
self.bin_width_label = gui.widgetLabel(slider.box)
self.bin_width_label.setFixedWidth(35)
self.bin_width_label.setAlignment(Qt.AlignRight)
slider.sliderReleased.connect(self._on_bin_slider_released)
gui.comboBox(box,
self,
"fitted_distribution",
label="Fitted distribution",
orientation=Qt.Horizontal,
items=(name[0] for name in self.Fitters),
callback=self._on_fitted_dist_changed)
self.smoothing_box = gui.indentedBox(box, 40)
gui.hSlider(self.smoothing_box,
self,
"kde_smoothing",
label="Smoothing",
orientation=Qt.Horizontal,
minValue=2,
maxValue=20,
callback=self.replot)
gui.checkBox(box,
self,
"hide_bars",
"Hide bars",
stateWhenDisabled=False,
callback=self._on_hide_bars_changed,
disabled=not self.fitted_distribution)
box = gui.vBox(self.controlArea, "Columns")
gui.comboBox(box,
self,
"cvar",
label="Split by",
orientation=Qt.Horizontal,
model=DomainModel(
placeholder="(None)",
valid_types=(DiscreteVariable),
),
callback=self._on_cvar_changed,
contentsLength=18)
gui.checkBox(box,
self,
"stacked_columns",
"Stack columns",
callback=self.replot)
gui.checkBox(box,
self,
"show_probs",
"Show probabilities",
callback=self._on_show_probabilities_changed)
gui.checkBox(box,
self,
"cumulative_distr",
"Show cumulative distribution",
callback=self.replot)
gui.auto_apply(self.controlArea, self, commit=self.apply)
self._set_smoothing_visibility()
self._setup_plots()
self._setup_legend()
def __init__(self, *args, **kwargs):
"""Initialize a Length widget"""
super().__init__(*args, **kwargs)
self.windowSize = 1
self.infoBox = InfoBox(
widget=self.controlArea,
stringClickSend=u", please click 'Send' when ready.",
)
self.sendButton = SendButton(
widget=self.controlArea,
master=self,
callback=self.sendData,
infoBoxAttribute='infoBox',
buttonLabel=u'Send',
checkboxLabel=u'Send automatically',
sendIfPreCallback=self.updateGUI,
)
# GUI...
# Units box
self.unitsBox = gui.widgetBox(
widget=self.controlArea,
box=u'Units',
orientation='vertical',
addSpace=True,
)
self.unitSegmentationCombo = gui.comboBox(
widget=self.unitsBox,
master=self,
value='units',
orientation='horizontal',
label=u'Segmentation:',
labelWidth=190,
callback=self.sendButton.settingsChanged,
tooltip=(
u"The segmentation whose segments constitute the\n"
u"units of length."
),
)
self.unitSegmentationCombo.setMinimumWidth(120)
gui.separator(widget=self.unitsBox, height=3)
# Averaging box...
self.averagingBox = gui.widgetBox(
widget=self.controlArea,
box=u'Averaging',
orientation='vertical',
addSpace=True,
)
averagingBoxLine1 = gui.widgetBox(
widget=self.averagingBox,
box=False,
orientation='horizontal',
addSpace=True,
)
gui.checkBox(
widget=averagingBoxLine1,
master=self,
value='computeAverage',
label=u'Average over segmentation:',
labelWidth=190,
callback=self.sendButton.settingsChanged,
tooltip=(
u"Check this box in order to measure the average\n"
u"length of segments.\n\n"
u"Leaving this box unchecked implies that no\n"
u"averaging will take place."
),
)
self.averagingSegmentationCombo = gui.comboBox(
widget=averagingBoxLine1,
master=self,
value='averagingSegmentation',
orientation='horizontal',
callback=self.sendButton.settingsChanged,
tooltip=(
u"The segmentation whose segment length will be\n"
u"measured and averaged (if the box to the left\n"
u"is checked)."
),
)
self.computeStdevCheckBox = gui.checkBox(
widget=self.averagingBox,
master=self,
value='computeStdev',
label=u'Compute standard deviation',
callback=self.sendButton.settingsChanged,
tooltip=(
u"Check this box to compute not only length average\n"
u"but also standard deviation (if the above box\n"
u"is checked).\n\n"
u"Note that computing standard deviation can be a\n"
u"lengthy operation for large segmentations."
),
)
gui.separator(widget=self.averagingBox, height=2)
# Contexts box...
self.contextsBox = gui.widgetBox(
widget=self.controlArea,
box=u'Contexts',
orientation='vertical',
addSpace=True,
)
self.modeCombo = gui.comboBox(
widget=self.contextsBox,
master=self,
value='mode',
sendSelectedValue=True,
items=[
u'No context',
u'Sliding window',
u'Containing segmentation',
],
orientation='horizontal',
label=u'Mode:',
labelWidth=190,
callback=self.sendButton.settingsChanged,
tooltip=(
u"Context specification mode.\n\n"
u"Contexts define the rows of the resulting table.\n\n"
u"'No context': simply return the length of the\n"
u"'Units' segmentation, or the average length of\n"
u"segments in the 'Averaging' segmentation (if any),\n"
u"so that the output table contains a single row.\n\n"
u"'Sliding window': contexts are defined as all the\n"
u"successive, overlapping sequences of n segments\n"
u"in the 'Averaging' segmentation; this mode is\n"
u"available only if the 'Averaging' box is checked.\n\n"
u"'Containing segmentation': contexts are defined\n"
u"as the distinct segments occurring in a given\n"
u"segmentation (which may or may not be the same\n"
u"as the 'Units' and/or 'Averaging' segmentation)."
),
)
self.slidingWindowBox = gui.widgetBox(
widget=self.contextsBox,
orientation='vertical',
)
gui.separator(widget=self.slidingWindowBox, height=3)
self.windowSizeSpin = gui.spin(
widget=self.slidingWindowBox,
master=self,
value='windowSize',
minv=1,
maxv=1,
step=1,
orientation='horizontal',
label=u'Window size:',
labelWidth=190,
callback=self.sendButton.settingsChanged,
keyboardTracking=False,
tooltip=(
u"The length of segment sequences defining contexts."
),
)
self.containingSegmentationBox = gui.widgetBox(
widget=self.contextsBox,
orientation='vertical',
)
gui.separator(widget=self.containingSegmentationBox, height=3)
self.contextSegmentationCombo = gui.comboBox(
widget=self.containingSegmentationBox,
master=self,
value='_contexts',
orientation='horizontal',
label=u'Segmentation:',
labelWidth=190,
callback=self.sendButton.settingsChanged,
tooltip=(
u"The segmentation whose segment types define\n"
u"the contexts in which length will be measured."
),
)
gui.separator(widget=self.containingSegmentationBox, height=3)
self.contextAnnotationCombo = gui.comboBox(
widget=self.containingSegmentationBox,
master=self,
value='contextAnnotationKey',
sendSelectedValue=True,
emptyString=u'(none)',
orientation='horizontal',
label=u'Annotation key:',
labelWidth=190,
callback=self.sendButton.settingsChanged,
tooltip=(
u"Indicate whether context types are defined by\n"
u"the content of segments in the above specified\n"
u"segmentation (value 'none') or by their\n"
u"annotation values for a specific annotation key."
),
)
gui.separator(widget=self.containingSegmentationBox, height=3)
gui.checkBox(
widget=self.containingSegmentationBox,
master=self,
value='mergeContexts',
label=u'Merge contexts',
callback=self.sendButton.settingsChanged,
tooltip=(
u"Check this box if you want to treat all segments\n"
u"of the above specified segmentation as forming\n"
u"a single context (hence the resulting table\n"
u"contains a single row)."
),
)
gui.separator(widget=self.contextsBox, height=3)
gui.rubber(self.controlArea)
# Send button...
self.sendButton.draw()
# Info box...
self.infoBox.draw()
self.sendButton.sendIf()
self.adjustSizeWithTimer()
def __init__(self):
super().__init__()
self.__pending_selection = self.selected_rows
# A kingdom for a save_state/restore_state
self.col_clustering = enum_get(Clustering, self.col_clustering_method,
Clustering.None_)
self.row_clustering = enum_get(Clustering, self.row_clustering_method,
Clustering.None_)
@self.settingsAboutToBePacked.connect
def _():
self.col_clustering_method = self.col_clustering.name
self.row_clustering_method = self.row_clustering.name
self.keep_aspect = False
#: The original data with all features (retained to
#: preserve the domain on the output)
self.input_data = None
#: The effective data striped of discrete features, and often
#: merged using k-means
self.data = None
self.effective_data = None
#: kmeans model used to merge rows of input_data
self.kmeans_model = None
#: merge indices derived from kmeans
#: a list (len==k) of int ndarray where the i-th item contains
#: the indices which merge the input_data into the heatmap row i
self.merge_indices = None
self.parts: Optional[Parts] = None
self.__rows_cache = {}
self.__columns_cache = {}
# GUI definition
colorbox = gui.vBox(self.controlArea, "Color")
self.color_cb = gui.palette_combo_box(self.palette_name)
self.color_cb.currentIndexChanged.connect(self.update_color_schema)
colorbox.layout().addWidget(self.color_cb)
form = QFormLayout(formAlignment=Qt.AlignLeft,
labelAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QFormLayout.AllNonFixedFieldsGrow)
lowslider = gui.hSlider(colorbox,
self,
"threshold_low",
minValue=0.0,
maxValue=1.0,
step=0.05,
ticks=True,
intOnly=False,
createLabel=False,
callback=self.update_lowslider)
highslider = gui.hSlider(colorbox,
self,
"threshold_high",
minValue=0.0,
maxValue=1.0,
step=0.05,
ticks=True,
intOnly=False,
createLabel=False,
callback=self.update_highslider)
form.addRow("Low:", lowslider)
form.addRow("High:", highslider)
colorbox.layout().addLayout(form)
mergebox = gui.vBox(
self.controlArea,
"Merge",
)
gui.checkBox(mergebox,
self,
"merge_kmeans",
"Merge by k-means",
callback=self.__update_row_clustering)
ibox = gui.indentedBox(mergebox)
gui.spin(ibox,
self,
"merge_kmeans_k",
minv=5,
maxv=500,
label="Clusters:",
keyboardTracking=False,
callbackOnReturn=True,
callback=self.update_merge)
cluster_box = gui.vBox(self.controlArea, "Clustering")
# Row clustering
self.row_cluster_cb = cb = ComboBox()
cb.setModel(create_list_model(ClusteringModelData, self))
cbselect(cb, self.row_clustering, ClusteringRole)
self.connect_control(
"row_clustering",
lambda value, cb=cb: cbselect(cb, value, ClusteringRole))
@cb.activated.connect
def _(idx, cb=cb):
self.set_row_clustering(cb.itemData(idx, ClusteringRole))
# Column clustering
self.col_cluster_cb = cb = ComboBox()
cb.setModel(create_list_model(ClusteringModelData, self))
cbselect(cb, self.col_clustering, ClusteringRole)
self.connect_control(
"col_clustering",
lambda value, cb=cb: cbselect(cb, value, ClusteringRole))
@cb.activated.connect
def _(idx, cb=cb):
self.set_col_clustering(cb.itemData(idx, ClusteringRole))
form = QFormLayout(
labelAlignment=Qt.AlignLeft,
formAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QFormLayout.AllNonFixedFieldsGrow,
)
form.addRow("Rows:", self.row_cluster_cb)
form.addRow("Columns:", self.col_cluster_cb)
cluster_box.layout().addLayout(form)
box = gui.vBox(self.controlArea, "Split By")
self.row_split_model = DomainModel(
placeholder="(None)",
valid_types=(Orange.data.DiscreteVariable, ),
parent=self,
)
self.row_split_cb = cb = ComboBoxSearch(
enabled=not self.merge_kmeans,
sizeAdjustPolicy=ComboBox.AdjustToMinimumContentsLengthWithIcon,
minimumContentsLength=14,
toolTip="Split the heatmap vertically by a categorical column")
self.row_split_cb.setModel(self.row_split_model)
self.connect_control("split_by_var",
lambda value, cb=cb: cbselect(cb, value))
self.connect_control("merge_kmeans", self.row_split_cb.setDisabled)
self.split_by_var = None
self.row_split_cb.activated.connect(self.__on_split_rows_activated)
box.layout().addWidget(self.row_split_cb)
box = gui.vBox(self.controlArea, 'Annotation && Legends')
gui.checkBox(box,
self,
'legend',
'Show legend',
callback=self.update_legend)
gui.checkBox(box,
self,
'averages',
'Stripes with averages',
callback=self.update_averages_stripe)
annotbox = QGroupBox("Row Annotations", flat=True)
form = QFormLayout(annotbox,
formAlignment=Qt.AlignLeft,
labelAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QFormLayout.AllNonFixedFieldsGrow)
self.annotation_model = DomainModel(placeholder="(None)")
self.annotation_text_cb = ComboBoxSearch(
minimumContentsLength=12,
sizeAdjustPolicy=QComboBox.AdjustToMinimumContentsLength)
self.annotation_text_cb.setModel(self.annotation_model)
self.annotation_text_cb.activated.connect(self.set_annotation_var)
self.connect_control("annotation_var", self.annotation_var_changed)
self.row_side_color_model = DomainModel(
order=(DomainModel.CLASSES, DomainModel.Separator,
DomainModel.METAS),
placeholder="(None)",
valid_types=DomainModel.PRIMITIVE,
flags=Qt.ItemIsSelectable | Qt.ItemIsEnabled,
parent=self,
)
self.row_side_color_cb = ComboBoxSearch(
sizeAdjustPolicy=QComboBox.AdjustToMinimumContentsLength,
minimumContentsLength=12)
self.row_side_color_cb.setModel(self.row_side_color_model)
self.row_side_color_cb.activated.connect(self.set_annotation_color_var)
self.connect_control("annotation_color_var",
self.annotation_color_var_changed)
form.addRow("Text", self.annotation_text_cb)
form.addRow("Color", self.row_side_color_cb)
box.layout().addWidget(annotbox)
posbox = gui.vBox(box, "Column Labels Position", addSpace=False)
posbox.setFlat(True)
cb = gui.comboBox(posbox,
self,
"column_label_pos",
callback=self.update_column_annotations)
cb.setModel(create_list_model(ColumnLabelsPosData, parent=self))
cb.setCurrentIndex(self.column_label_pos)
gui.checkBox(self.controlArea,
self,
"keep_aspect",
"Keep aspect ratio",
box="Resize",
callback=self.__aspect_mode_changed)
gui.rubber(self.controlArea)
gui.auto_send(self.controlArea, self, "auto_commit")
# Scene with heatmap
class HeatmapScene(QGraphicsScene):
widget: Optional[HeatmapGridWidget] = None
self.scene = self.scene = HeatmapScene(parent=self)
self.view = GraphicsView(
self.scene,
verticalScrollBarPolicy=Qt.ScrollBarAlwaysOn,
horizontalScrollBarPolicy=Qt.ScrollBarAlwaysOn,
viewportUpdateMode=QGraphicsView.FullViewportUpdate,
widgetResizable=True,
)
self.view.setContextMenuPolicy(Qt.CustomContextMenu)
self.view.customContextMenuRequested.connect(
self._on_view_context_menu)
self.mainArea.layout().addWidget(self.view)
self.selected_rows = []
self.__font_inc = QAction("Increase Font",
self,
shortcut=QKeySequence("ctrl+>"))
self.__font_dec = QAction("Decrease Font",
self,
shortcut=QKeySequence("ctrl+<"))
self.__font_inc.triggered.connect(lambda: self.__adjust_font_size(1))
self.__font_dec.triggered.connect(lambda: self.__adjust_font_size(-1))
if hasattr(QAction, "setShortcutVisibleInContextMenu"):
apply_all([self.__font_inc, self.__font_dec],
lambda a: a.setShortcutVisibleInContextMenu(True))
self.addActions([self.__font_inc, self.__font_dec])
def __init__(self):
super().__init__()
self.data = None
self.discrete_data = None
self.subset_data = None
self.subset_indices = None
self.__pending_selection = self.selection
self.selection = set()
self.color_data = None
self.areas = []
self.canvas = QGraphicsScene(self)
self.canvas_view = ViewWithPress(self.canvas,
handler=self.clear_selection)
self.mainArea.layout().addWidget(self.canvas_view)
self.canvas_view.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.canvas_view.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.canvas_view.setRenderHint(QPainter.Antialiasing)
box = gui.vBox(self.controlArea, box=True)
self.model_1 = DomainModel(order=DomainModel.MIXED,
valid_types=DomainModel.PRIMITIVE)
self.model_234 = DomainModel(order=DomainModel.MIXED,
valid_types=DomainModel.PRIMITIVE,
placeholder="(None)")
self.attr_combos = [
gui.comboBox(box,
self,
value="variable{}".format(i),
orientation=Qt.Horizontal,
contentsLength=12,
searchable=True,
callback=self.attr_changed,
model=self.model_1 if i == 1 else self.model_234)
for i in range(1, 5)
]
self.vizrank, self.vizrank_button = MosaicVizRank.add_vizrank(
box, self, "Find Informative Mosaics", self.set_attr)
box2 = gui.vBox(self.controlArea, box="Interior Coloring")
self.color_model = DomainModel(order=DomainModel.MIXED,
valid_types=DomainModel.PRIMITIVE,
placeholder="(Pearson residuals)")
self.cb_attr_color = gui.comboBox(box2,
self,
value="variable_color",
orientation=Qt.Horizontal,
contentsLength=12,
labelWidth=50,
searchable=True,
callback=self.set_color_data,
model=self.color_model)
self.bar_button = gui.checkBox(box2,
self,
'use_boxes',
label='Compare with total',
callback=self.update_graph)
gui.rubber(self.controlArea)
def __init__(self):
"""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.__pending_selection = self.selection
self._optimizer = None
self._optimizer_thread = None
self.stop_optimization = False
self.data = self.cont_x = None
self.cells = self.member_data = None
self.selection = None
self.colors = self.thresholds = self.bin_labels = None
box = gui.vBox(self.controlArea, box="SOM")
shape = gui.comboBox(box,
self,
"",
items=("Hexagonal grid", "Square grid"))
shape.setCurrentIndex(1 - self.hexagonal)
box2 = gui.indentedBox(box, 10)
auto_dim = gui.checkBox(box2,
self,
"auto_dimension",
"Set dimensions automatically",
callback=self.on_auto_dimension_changed)
self.manual_box = box3 = gui.hBox(box2)
spinargs = dict(value="",
widget=box3,
master=self,
minv=5,
maxv=100,
step=5,
alignment=Qt.AlignRight)
spin_x = gui.spin(**spinargs)
spin_x.setValue(self.size_x)
gui.widgetLabel(box3, "×")
spin_y = gui.spin(**spinargs)
spin_y.setValue(self.size_y)
gui.rubber(box3)
self.manual_box.setEnabled(not self.auto_dimension)
initialization = gui.comboBox(box,
self,
"initialization",
items=("Initialize with PCA",
"Random initialization",
"Replicable random"))
start = gui.button(box,
self,
"Restart",
callback=self.restart_som_pressed,
sizePolicy=(QSizePolicy.MinimumExpanding,
QSizePolicy.Fixed))
self.opt_controls = self.OptControls(shape, auto_dim, spin_x, spin_y,
initialization, start)
box = gui.vBox(self.controlArea, "Color")
gui.comboBox(box,
self,
"attr_color",
maximumContentsLength=15,
callback=self.on_attr_color_change,
model=DomainModel(placeholder="(Same color)",
valid_types=DomainModel.PRIMITIVE))
gui.checkBox(box,
self,
"pie_charts",
label="Show pie charts",
callback=self.on_pie_chart_change)
gui.checkBox(box,
self,
"size_by_instances",
label="Size by number of instances",
callback=self.on_attr_size_change)
gui.rubber(self.controlArea)
self.scene = QGraphicsScene(self)
self.view = SomView(self.scene)
self.view.setMinimumWidth(400)
self.view.setMinimumHeight(400)
self.view.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.view.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.view.setRenderHint(QPainter.Antialiasing)
self.view.selection_changed.connect(self.on_selection_change)
self.view.selection_moved.connect(self.on_selection_move)
self.view.selection_mark_changed.connect(self.on_selection_mark_change)
self.mainArea.layout().addWidget(self.view)
self.elements = None
self.grid = None
self.grid_cells = None
self.legend = None
def _combo(self, widget, value, label, cb_name, items=(), model=None):
gui.comboBox(widget, self._plot, value, label=label, items=items,
model=model, callback=self._get_callback(cb_name),
labelWidth=50, orientation=Qt.Horizontal, valueType=str,
sendSelectedValue=True, contentsLength=12)
def __init__(self):
super().__init__()
self.data = None
self.distributions = None
self.contingencies = None
self.var = self.cvar = None
varbox = gui.vBox(self.controlArea, "Variable")
self.varmodel = itemmodels.VariableListModel()
self.groupvarmodel = []
self.varview = QListView(
selectionMode=QListView.SingleSelection)
self.varview.setSizePolicy(
QSizePolicy.Minimum, QSizePolicy.Expanding)
self.varview.setModel(self.varmodel)
self.varview.setSelectionModel(
itemmodels.ListSingleSelectionModel(self.varmodel))
self.varview.selectionModel().selectionChanged.connect(
self._on_variable_idx_changed)
varbox.layout().addWidget(self.varview)
box = gui.vBox(self.controlArea, "Precision")
gui.separator(self.controlArea, 4, 4)
box2 = gui.hBox(box)
self.l_smoothing_l = gui.widgetLabel(box2, "Smooth")
gui.hSlider(box2, self, "smoothing_index",
minValue=0, maxValue=len(self.smoothing_facs) - 1,
callback=self._on_set_smoothing, createLabel=False)
self.l_smoothing_r = gui.widgetLabel(box2, "Precise")
self.cb_disc_cont = gui.checkBox(
gui.indentedBox(box, sep=4),
self, "disc_cont", "Bin continuous variables",
callback=self._on_groupvar_idx_changed,
tooltip="Show continuous variables as discrete.")
box = gui.vBox(self.controlArea, "Group by")
self.icons = gui.attributeIconDict
self.groupvarview = gui.comboBox(box, self, "groupvar_idx",
callback=self._on_groupvar_idx_changed, valueType=str,
contentsLength=12)
box2 = gui.indentedBox(box, sep=4)
self.cb_rel_freq = gui.checkBox(
box2, self, "relative_freq", "Show relative frequencies",
callback=self._on_relative_freq_changed,
tooltip="Normalize probabilities so that probabilities for each group-by value sum to 1.")
gui.separator(box2)
self.cb_prob = gui.comboBox(
box2, self, "show_prob", label="Show probabilities:",
orientation=Qt.Horizontal,
callback=self._on_relative_freq_changed,
tooltip="Show probabilities for a chosen group-by value (at each point probabilities for all group-by values sum to 1).")
self.plotview = pg.PlotWidget(background=None)
self.plotview.setRenderHint(QPainter.Antialiasing)
self.mainArea.layout().addWidget(self.plotview)
w = QLabel()
w.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
self.mainArea.layout().addWidget(w, Qt.AlignCenter)
self.ploti = pg.PlotItem()
self.plot = self.ploti.vb
self.ploti.hideButtons()
self.plotview.setCentralItem(self.ploti)
self.plot_prob = pg.ViewBox()
self.ploti.hideAxis('right')
self.ploti.scene().addItem(self.plot_prob)
self.ploti.getAxis("right").linkToView(self.plot_prob)
self.ploti.getAxis("right").setLabel("Probability")
self.plot_prob.setZValue(10)
self.plot_prob.setXLink(self.ploti)
self.update_views()
self.ploti.vb.sigResized.connect(self.update_views)
self.plot_prob.setRange(yRange=[0,1])
def disable_mouse(plot):
plot.setMouseEnabled(False, False)
plot.setMenuEnabled(False)
disable_mouse(self.plot)
disable_mouse(self.plot_prob)
self.tooltip_items = []
self.plot.scene().installEventFilter(
HelpEventDelegate(self.help_event, self))
pen = QPen(self.palette().color(QPalette.Text))
for axis in ("left", "bottom"):
self.ploti.getAxis(axis).setPen(pen)
self._legend = LegendItem()
self._legend.setParentItem(self.plot)
self._legend.hide()
self._legend.anchor((1, 0), (1, 0))
def __init__(self):
super().__init__()
self.matrix = None
self.data = None
self.matrix_data = None
self.signal_data = None
self._pen_data = None
self._shape_data = None
self._size_data = None
self._label_data = None
self._similar_pairs = None
self._scatter_item = None
self._legend_item = None
self._selection_mask = None
self._invalidated = False
self._effective_matrix = None
self.__update_loop = None
self.__state = OWMDS.Waiting
self.__in_next_step = False
self.__draw_similar_pairs = False
box = gui.widgetBox(self.controlArea, "MDS Optimization")
form = QtGui.QFormLayout(
labelAlignment=Qt.AlignLeft,
formAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QtGui.QFormLayout.AllNonFixedFieldsGrow,
verticalSpacing=10)
form.addRow("Max iterations:",
gui.spin(box, self, "max_iter", 10, 10**4, step=1))
form.addRow(
"Initialization",
gui.comboBox(box,
self,
"initialization",
items=["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.widgetBox(self.controlArea, "Graph")
self.colorvar_model = itemmodels.VariableListModel()
common_options = {
"sendSelectedValue": True,
"valueType": str,
"orientation": "horizontal",
"labelWidth": 50,
"contentsLength": 12
}
self.cb_color_value = gui.comboBox(
box,
self,
"color_value",
label="Color",
callback=self._on_color_index_changed,
**common_options)
self.cb_color_value.setModel(self.colorvar_model)
self.shapevar_model = itemmodels.VariableListModel()
self.cb_shape_value = gui.comboBox(
box,
self,
"shape_value",
label="Shape",
callback=self._on_shape_index_changed,
**common_options)
self.cb_shape_value.setModel(self.shapevar_model)
self.sizevar_model = itemmodels.VariableListModel()
self.cb_size_value = gui.comboBox(box,
self,
"size_value",
label="Size",
callback=self._on_size_index_changed,
**common_options)
self.cb_size_value.setModel(self.sizevar_model)
self.labelvar_model = itemmodels.VariableListModel()
self.cb_label_value = gui.comboBox(
box,
self,
"label_value",
label="Label",
callback=self._on_label_index_changed,
**common_options)
self.cb_label_value.setModel(self.labelvar_model)
form = QtGui.QFormLayout(
labelAlignment=Qt.AlignLeft,
formAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QtGui.QFormLayout.AllNonFixedFieldsGrow,
verticalSpacing=10)
form.addRow(
"Symbol size",
gui.hSlider(box,
self,
"symbol_size",
minValue=1,
maxValue=20,
callback=self._on_size_index_changed,
createLabel=False))
form.addRow(
"Symbol opacity",
gui.hSlider(box,
self,
"symbol_opacity",
minValue=100,
maxValue=255,
step=100,
callback=self._on_color_index_changed,
createLabel=False))
form.addRow(
"Show similar pairs",
gui.hSlider(gui.widgetBox(self.controlArea,
orientation="horizontal"),
self,
"connected_pairs",
minValue=0,
maxValue=20,
createLabel=False,
callback=self._on_connected_changed))
form.addRow(
"Jitter",
gui.comboBox(box,
self,
"jitter",
items=[text for text, _ in self.JitterAmount],
callback=self._update_plot))
box.layout().addLayout(form)
gui.rubber(self.controlArea)
box = QtGui.QGroupBox("Zoom/Select", )
box.setLayout(QtGui.QHBoxLayout())
box.layout().setMargin(2)
group = QtGui.QActionGroup(self, exclusive=True)
def icon(name):
path = "icons/Dlg_{}.png".format(name)
path = pkg_resources.resource_filename(widget.__name__, path)
return QtGui.QIcon(path)
action_select = QtGui.QAction(
"Select",
self,
checkable=True,
checked=True,
icon=icon("arrow"),
shortcut=QtGui.QKeySequence(Qt.ControlModifier + Qt.Key_1))
action_zoom = QtGui.QAction(
"Zoom",
self,
checkable=True,
checked=False,
icon=icon("zoom"),
shortcut=QtGui.QKeySequence(Qt.ControlModifier + Qt.Key_2))
action_pan = QtGui.QAction(
"Pan",
self,
checkable=True,
checked=False,
icon=icon("pan_hand"),
shortcut=QtGui.QKeySequence(Qt.ControlModifier + Qt.Key_3))
action_reset_zoom = QtGui.QAction(
"Zoom to fit",
self,
icon=icon("zoom_reset"),
shortcut=QtGui.QKeySequence(Qt.ControlModifier + Qt.Key_0))
action_reset_zoom.triggered.connect(lambda: self.plot.autoRange(
padding=0.1, items=[self._scatter_item]))
group.addAction(action_select)
group.addAction(action_zoom)
group.addAction(action_pan)
self.addActions(group.actions() + [action_reset_zoom])
action_select.setChecked(True)
def button(action):
b = QtGui.QToolButton()
b.setToolButtonStyle(Qt.ToolButtonIconOnly)
b.setDefaultAction(action)
return b
box.layout().addWidget(button(action_select))
box.layout().addWidget(button(action_zoom))
box.layout().addWidget(button(action_pan))
box.layout().addSpacing(4)
box.layout().addWidget(button(action_reset_zoom))
box.layout().addStretch()
self.controlArea.layout().addWidget(box)
box = gui.widgetBox(self.controlArea, "Output")
self.output_combo = gui.comboBox(box,
self,
"output_embedding_role",
items=[
"Original features only",
"Coordinates only",
"Coordinates as features",
"Coordinates as meta attributes"
],
callback=self._invalidate_output,
addSpace=4)
gui.auto_commit(box,
self,
"autocommit",
"Send data",
checkbox_label="Send after any change",
box=None)
self.inline_graph_report()
self.plot = pg.PlotWidget(background="w", enableMenu=False)
self.plot.getPlotItem().hideAxis("bottom")
self.plot.getPlotItem().hideAxis("left")
self.plot.getPlotItem().hideButtons()
self.plot.setRenderHint(QtGui.QPainter.Antialiasing)
self.mainArea.layout().addWidget(self.plot)
self.selection_tool = PlotSelectionTool(parent=self)
self.zoom_tool = PlotZoomTool(parent=self)
self.pan_tool = PlotPanTool(parent=self)
self.pinch_tool = PlotPinchZoomTool(parent=self)
self.pinch_tool.setViewBox(self.plot.getViewBox())
self.selection_tool.setViewBox(self.plot.getViewBox())
self.selection_tool.selectionFinished.connect(self.__selection_end)
self.current_tool = self.selection_tool
def activate_tool(action):
self.current_tool.setViewBox(None)
if action is action_select:
active, cur = self.selection_tool, Qt.ArrowCursor
elif action is action_zoom:
active, cur = self.zoom_tool, Qt.ArrowCursor
elif action is action_pan:
active, cur = self.pan_tool, Qt.OpenHandCursor
self.current_tool = active
self.current_tool.setViewBox(self.plot.getViewBox())
self.plot.getViewBox().setCursor(QtGui.QCursor(cur))
group.triggered[QtGui.QAction].connect(activate_tool)
self.graphButton.clicked.connect(self.save_graph)
self._initialize()
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_commit(self.controlArea,
self,
"auto_commit",
"Apply",
commit=self.apply)
box.layout().insertWidget(0, self.report_button)
box.layout().insertSpacing(1, 20)
def __init__(self):
super().__init__()
self.corpus = None # corpus taken from distances
self.linkage = None # hierarchical clustering linkage as returned by Orange
self.distances = None # DistMatrix on input
self.clustering_mask = None # 1D array of clusters for self.corpus
self.threshold_spin = None
# Info
self.n_documents = ''
self.n_unique = ''
self.n_duplicates = ''
info_box = gui.widgetBox(self.controlArea, box='Info')
gui.label(info_box, self, 'Documents: %(n_documents)s')
gui.label(info_box, self, ' ◦ unique: %(n_unique)s')
gui.label(info_box, self, ' ◦ duplicates: %(n_duplicates)s')
# Threshold Histogram & Cluster View
self.histogram = Histogram(self)
self.table_view = gui.TableView(
selectionMode=QListView.SingleSelection)
self.table_model = PyTableModel()
self.table_model.setHorizontalHeaderLabels(['Cluster', 'Size'])
self.table_view.setModel(self.table_model)
self.table_view.selectionModel().selectionChanged.connect(
self.send_duplicates)
# Add to main area
height = 300
main_area = gui.hBox(self.mainArea)
self.histogram.setMinimumWidth(500)
self.histogram.setMinimumHeight(height)
self.table_view.setFixedWidth(140)
main_area.layout().addWidget(self.histogram)
main_area.layout().addWidget(self.table_view)
# Controls
gui.comboBox(self.controlArea,
self,
'linkage_method',
items=self.LINKAGE,
box='Linkage',
callback=self.recalculate_linkage,
orientation=Qt.Horizontal)
self.threshold_spin = gui.doubleSpin(self.controlArea,
self,
'threshold',
0,
float('inf'),
0.01,
decimals=2,
label='Distance threshold',
box='Distances',
callback=self.threshold_changed,
keyboardTracking=False,
controlWidth=60)
self.histogram.region.sigRegionChangeFinished.connect(
self.threshold_from_histogram_region)
self.threshold_spin.setEnabled(False)
gui.rubber(self.controlArea)
# Output
gui.comboBox(self.controlArea,
self,
"cluster_role",
box='Output',
label='Append Cluster IDs to:',
callback=self.send_corpus,
items=self.CLUSTER_ROLES)
def add_main_layout(self):
self.data = None
self.preprocessors = 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__()
self.results = None
self.classifier_names = []
self.perf_line = None
self.colors = []
self._curve_data = {}
self._plot_curves = {}
self._rocch = None
self._perf_line = None
self._tooltip_cache = None
box = gui.vBox(self.controlArea, "Plot")
tbox = gui.vBox(box, "Target Class")
tbox.setFlat(True)
self.target_cb = gui.comboBox(tbox,
self,
"target_index",
callback=self._on_target_changed,
contentsLength=8)
cbox = gui.vBox(box, "Classifiers")
cbox.setFlat(True)
self.classifiers_list_box = gui.listBox(
cbox,
self,
"selected_classifiers",
"classifier_names",
selectionMode=QListView.MultiSelection,
callback=self._on_classifiers_changed)
abox = gui.vBox(box, "Combine ROC Curves From Folds")
abox.setFlat(True)
gui.comboBox(abox,
self,
"roc_averaging",
items=[
"Merge Predictions from Folds", "Mean TP Rate",
"Mean TP and FP at Threshold",
"Show Individual Curves"
],
callback=self._replot)
hbox = gui.vBox(box, "ROC Convex Hull")
hbox.setFlat(True)
gui.checkBox(hbox,
self,
"display_convex_curve",
"Show convex ROC curves",
callback=self._replot)
gui.checkBox(hbox,
self,
"display_convex_hull",
"Show ROC convex hull",
callback=self._replot)
box = gui.vBox(self.controlArea, "Analysis")
gui.checkBox(box,
self,
"display_def_threshold",
"Default threshold (0.5) point",
callback=self._on_display_def_threshold_changed)
gui.checkBox(box,
self,
"display_perf_line",
"Show performance line",
callback=self._on_display_perf_line_changed)
grid = QGridLayout()
gui.indentedBox(box, orientation=grid)
sp = gui.spin(box,
self,
"fp_cost",
1,
1000,
10,
alignment=Qt.AlignRight,
callback=self._on_display_perf_line_changed)
grid.addWidget(QLabel("FP Cost:"), 0, 0)
grid.addWidget(sp, 0, 1)
sp = gui.spin(box,
self,
"fn_cost",
1,
1000,
10,
alignment=Qt.AlignRight,
callback=self._on_display_perf_line_changed)
grid.addWidget(QLabel("FN Cost:"))
grid.addWidget(sp, 1, 1)
self.target_prior_sp = gui.spin(box,
self,
"target_prior",
1,
99,
alignment=Qt.AlignRight,
callback=self._on_target_prior_changed)
self.target_prior_sp.setSuffix(" %")
self.target_prior_sp.addAction(QAction("Auto", sp))
grid.addWidget(QLabel("Prior target class probability:"))
grid.addWidget(self.target_prior_sp, 2, 1)
self.plotview = pg.GraphicsView(background="w")
self.plotview.setFrameStyle(QFrame.StyledPanel)
self.plotview.scene().sigMouseMoved.connect(self._on_mouse_moved)
self.plot = pg.PlotItem(enableMenu=False)
self.plot.setMouseEnabled(False, False)
self.plot.hideButtons()
pen = QPen(self.palette().color(QPalette.Text))
tickfont = QFont(self.font())
tickfont.setPixelSize(max(int(tickfont.pixelSize() * 2 // 3), 11))
axis = self.plot.getAxis("bottom")
axis.setTickFont(tickfont)
axis.setPen(pen)
axis.setLabel("FP Rate (1-Specificity)")
axis = self.plot.getAxis("left")
axis.setTickFont(tickfont)
axis.setPen(pen)
axis.setLabel("TP Rate (Sensitivity)")
self.plot.showGrid(True, True, alpha=0.1)
self.plot.setRange(xRange=(0.0, 1.0), yRange=(0.0, 1.0), padding=0.05)
self.plotview.setCentralItem(self.plot)
self.mainArea.layout().addWidget(self.plotview)