def _add_type_box(self):
form = QtGui.QGridLayout()
self.type_box = box = gui.radioButtonsInBox(
self.controlArea, self, "svmtype", [], box="SVM Type",
orientation=form, callback=self.settings_changed)
form.addWidget(gui.appendRadioButton(box, "C-SVM", addToLayout=False),
0, 0, Qt.AlignLeft)
form.addWidget(QtGui.QLabel("Cost (C)"),
0, 1, Qt.AlignRight)
form.addWidget(gui.doubleSpin(box, self, "C", 1e-3, 1000.0, 0.1,
decimals=3, alignment=Qt.AlignRight,
controlWidth=80, addToLayout=False,
callback=self.settings_changed),
0, 2)
form.addWidget(gui.appendRadioButton(box, "ν-SVM", addToLayout=False),
1, 0, Qt.AlignLeft)
form.addWidget(QtGui.QLabel("Complexity (ν)"),
1, 1, Qt.AlignRight)
form.addWidget(gui.doubleSpin(box, self, "nu", 0.05, 1.0, 0.05,
decimals=2, alignment=Qt.AlignRight,
controlWidth=80, addToLayout=False,
callback=self.settings_changed),
1, 2)
def _add_type_box(self):
form = QGridLayout()
self.type_box = box = gui.radioButtonsInBox(
self.controlArea, self, "svrtype", [], box="SVR Type",
orientation=form)
self.epsilon_radio = gui.appendRadioButton(box, "ε-SVR",
addToLayout=False)
self.epsilon_C_spin = gui.doubleSpin(box, self, "epsilon_C", 0.1, 512.0,
0.1, decimals=2, addToLayout=False)
self.epsilon_spin = gui.doubleSpin(box, self, "epsilon", 0.1, 512.0,
0.1, decimals=2, addToLayout=False)
form.addWidget(self.epsilon_radio, 0, 0, Qt.AlignLeft)
form.addWidget(QLabel("Cost (C):"), 0, 1, Qt.AlignRight)
form.addWidget(self.epsilon_C_spin, 0, 2)
form.addWidget(QLabel("Loss epsilon (ε):"), 1, 1, Qt.AlignRight)
form.addWidget(self.epsilon_spin, 1, 2)
self.nu_radio = gui.appendRadioButton(box, "ν-SVR", addToLayout=False)
self.nu_C_spin = gui.doubleSpin(box, self, "nu_C", 0.1, 512.0, 0.1,
decimals=2, addToLayout=False)
self.nu_spin = gui.doubleSpin(box, self, "nu", 0.05, 1.0, 0.05,
decimals=2, addToLayout=False)
form.addWidget(self.nu_radio, 2, 0, Qt.AlignLeft)
form.addWidget(QLabel("Cost (C):"), 2, 1, Qt.AlignRight)
form.addWidget(self.nu_C_spin, 2, 2)
form.addWidget(QLabel("Complexity bound (ν):"), 3, 1, Qt.AlignRight)
form.addWidget(self.nu_spin, 3, 2)
def __init__(self):
super().__init__()
self.data = None
box = gui.radioButtons(
self.controlArea, self, "feature_type", box="Feature names",
callback=lambda: self.apply())
button = gui.appendRadioButton(box, "Generic")
edit = gui.lineEdit(
gui.indentedBox(box, gui.checkButtonOffsetHint(button)), self,
"feature_name",
placeholderText="Type a prefix ...", toolTip="Custom feature name")
edit.editingFinished.connect(self._apply_editing)
self.meta_button = gui.appendRadioButton(box, "From meta attribute:")
self.feature_model = DomainModel(
order=DomainModel.METAS, valid_types=StringVariable,
alphabetical=True)
self.feature_combo = gui.comboBox(
gui.indentedBox(box, gui.checkButtonOffsetHint(button)), self,
"feature_names_column", callback=self._feature_combo_changed,
model=self.feature_model)
self.apply_button = gui.auto_commit(
self.controlArea, self, "auto_apply", "&Apply",
box=False, commit=self.apply)
self.apply_button.button.setAutoDefault(False)
self.set_controls()
def __init__(self, parent=None):
super().__init__(parent)
self.train_data = None
self.test_data = None
#: An Ordered dictionary with current inputs and their testing
#: results.
self.learners = OrderedDict()
sbox = gui.widgetBox(self.controlArea, "Sampling")
rbox = gui.radioButtons(
sbox, self, "resampling", callback=self._param_changed
)
gui.appendRadioButton(rbox, "Cross validation")
ibox = gui.indentedBox(rbox)
gui.spin(ibox, self, "k_folds", 2, 50, label="Number of folds:",
callback=self.kfold_changed)
gui.appendRadioButton(rbox, "Leave one out")
gui.appendRadioButton(rbox, "Random sampling")
ibox = gui.indentedBox(rbox)
gui.spin(ibox, self, "n_repeat", 2, 50, label="Repeat train/test",
callback=self.bootstrap_changed)
gui.widgetLabel(ibox, "Relative training set size:")
gui.hSlider(ibox, self, "sample_p", minValue=1, maxValue=100,
ticks=20, vertical=False, labelFormat="%d %%",
callback=self.bootstrap_changed)
gui.appendRadioButton(rbox, "Test on train data")
gui.appendRadioButton(rbox, "Test on test data")
rbox.layout().addSpacing(5)
gui.button(rbox, self, "Apply", callback=self.apply)
self.cbox = gui.widgetBox(self.controlArea, "Target class")
self.class_selection_combo = gui.comboBox(self.cbox, self, "class_selection",
items=[],
callback=self._select_class,
sendSelectedValue=True, valueType=str)
gui.rubber(self.controlArea)
self.view = QTreeView(
rootIsDecorated=False,
uniformRowHeights=True,
wordWrap=True,
editTriggers=QTreeView.NoEditTriggers
)
header = self.view.header()
header.setResizeMode(QHeaderView.ResizeToContents)
header.setDefaultAlignment(Qt.AlignCenter)
header.setStretchLastSection(False)
self.result_model = QStandardItemModel()
self.view.setModel(self.result_model)
self.view.setItemDelegate(ItemDelegate())
self._update_header()
box = gui.widgetBox(self.mainArea, "Evaluation Results")
box.layout().addWidget(self.view)
def __init__(self):
super().__init__()
box = gui.widgetBox(self.controlArea, "Movie Selection (from %d)" % len(movielens.get_all_movie_names()))
methodbox = gui.radioButtons(box, self, "method", callback=self._on_method_changed)
gui.appendRadioButton(methodbox, "Fraction of movies")
percent = gui.hSlider(
gui.indentedBox(methodbox), self, "percent", minValue=1, maxValue=100, step=1, ticks=10, labelFormat="%d %%"
)
gui.appendRadioButton(methodbox, "Time period:")
ibox = gui.indentedBox(methodbox)
start = gui.spin(ibox, self, "start", 1907, 2015, 1, label="Starting year: ")
end = gui.spin(ibox, self, "end", 1907, 2015, 1, label="Ending year: ")
self.method_params = [percent, start, end]
gui.button(self.controlArea, self, "&Apply", callback=self.send_output, default=True)
self.setSizePolicy(QtGui.QSizePolicy(QtGui.QSizePolicy.Fixed, QtGui.QSizePolicy.Fixed))
self.setMinimumWidth(250)
self.setMaximumWidth(250)
self._on_method_changed()
self.send_output()
def __init__(self):
super().__init__()
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.relation = None
form = QtGui.QGridLayout()
methodbox = gui.radioButtonsInBox(
self.controlArea, self, "method", [],
box=self.tr("Sampling method"), orientation=form)
rows = gui.appendRadioButton(methodbox, "Rows", addToLayout=False)
form.addWidget(rows, 0, 0, Qt.AlignLeft)
cols = gui.appendRadioButton(methodbox, "Columns", addToLayout=False)
form.addWidget(cols, 0, 1, Qt.AlignLeft)
rows_and_cols = gui.appendRadioButton(methodbox, "Rows and columns", addToLayout=False)
form.addWidget(rows_and_cols, 1, 0, Qt.AlignLeft)
entries = gui.appendRadioButton(methodbox, "Entries", addToLayout=False)
form.addWidget(entries, 1, 1, Qt.AlignLeft)
sample_size = gui.widgetBox(self.controlArea, "Proportion of data in the sample")
percent = gui.hSlider(
sample_size, self, 'percent', minValue=1, maxValue=100, step=5,
ticks=10, labelFormat=" %d%%")
gui.button(self.controlArea, self, "&Apply",
callback=self.send_output, default=True)
self.setSizePolicy(
QtGui.QSizePolicy(QtGui.QSizePolicy.Fixed,
QtGui.QSizePolicy.Fixed))
self.setMinimumWidth(250)
self.send_output()
def addHistogramControls(self, parent=None):
if parent is None:
parent = self.controlArea
boxGeneral = gui.widgetBox(parent, box="Edges")
ribg = gui.widgetBox(boxGeneral, None, orientation="horizontal", addSpace=False)
ribg.layout().addWidget(QLabel("Distance threshold", self),
4, Qt.AlignVCenter | Qt.AlignLeft)
self.spin_low = gui.doubleSpin(ribg, self, "spinLowerThreshold",
0.0, float("inf"), 0.001, decimals=3,
callback=self.changeLowerSpin,
keyboardTracking=False)
ribg.layout().addWidget(QLabel("to", self), 1, Qt.AlignCenter)
self.spin_high = gui.doubleSpin(ribg, self, "spinUpperThreshold",
0.0, float("inf"), 0.001, decimals=3,
callback=self.changeUpperSpin,
keyboardTracking=False)
self.histogram.region.sigRegionChangeFinished.connect(self.spinboxFromHistogramRegion)
# gui.lineEdit(ribg, self, "spinLowerThreshold", "Distance threshold ", orientation='horizontal', callback=self.changeLowerSpin, valueType=float, validator=self.validator, enterPlaceholder=True, controlWidth=60)
# gui.lineEdit(ribg, self, "spinUpperThreshold", "", orientation='horizontal', callback=self.changeUpperSpin, valueType=float, validator=self.validator, enterPlaceholder=True, controlWidth=60)
# ribg.layout().addStretch(1)
#ribg = gui.radioButtonsInBox(boxGeneral, self, "andor", [], orientation='horizontal', callback = self.generateGraph)
#gui.appendRadioButton(ribg, self, "andor", "OR", callback = self.generateGraph)
#b = gui.appendRadioButton(ribg, self, "andor", "AND", callback = self.generateGraph)
#b.setEnabled(False)
#ribg.hide(False)
ribg = gui.widgetBox(boxGeneral, None, orientation="horizontal", addSpace=False)
gui.doubleSpin(boxGeneral, self, "percentil", 0, 100, 0.1, label="Percentile", orientation='horizontal', callback=self.setPercentil, callbackOnReturn=1, controlWidth=60)
gui.spin(boxGeneral, self, "kNN", 0, 1000, 1, label="Include closest neighbors", orientation='horizontal', callback=self.generateGraph, callbackOnReturn=1, controlWidth=60)
ribg.layout().addStretch(1)
# Options
self.attrColor = ""
ribg = gui.radioButtonsInBox(parent, self, "netOption", [], "Node selection", callback=self.generateGraph)
gui.appendRadioButton(ribg, "Keep all nodes")
hb = gui.widgetBox(ribg, None, orientation="horizontal", addSpace=False)
gui.appendRadioButton(ribg, "Components with at least nodes", insertInto=hb)
gui.spin(hb, self, "excludeLimit", 2, 100, 1, callback=(lambda h=True: self.generateGraph(h)), controlWidth=60)
gui.appendRadioButton(ribg, "Largest connected component")
#gui.appendRadioButton(ribg, self, "netOption", "Connected component with vertex")
self.attribute = None
### FILTER NETWORK BY ATTRIBUTE IS OBSOLETE - USE SELECT DATA WIDGET ###
#self.attributeCombo = gui.comboBox(parent, self, "attribute", box="Filter attribute", orientation='horizontal')#, callback=self.setVertexColor)
#self.label = ''
#self.searchString = gui.lineEdit(self.attributeCombo.box, self, "label", callback=self.setSearchStringTimer, callbackOnType=True)
#self.searchStringTimer = QTimer(self)
#self.connect(self.searchStringTimer, SIGNAL("timeout()"), self.generateGraph)
#if str(self.netOption) != '3':
# self.attributeCombo.box.setEnabled(False)
ribg = gui.radioButtonsInBox(parent, self, "dstWeight", [], "Edge weights", callback=self.generateGraph)
hb = gui.widgetBox(ribg, None, orientation="horizontal", addSpace=False)
gui.appendRadioButton(ribg, "Proportional to distance", insertInto=hb)
gui.appendRadioButton(ribg, "Inverted distance", insertInto=hb)
def __init__(self, parent=None):
super().__init__(parent)
self.train_data = None
self.test_data = None
#: An Ordered dictionary with current inputs and their testing
#: results.
self.learners = OrderedDict()
sbox = gui.widgetBox(self.controlArea, "Sampling")
rbox = gui.radioButtons(
sbox, self, "resampling", callback=self._param_changed
)
gui.appendRadioButton(rbox, "Cross validation")
ibox = gui.indentedBox(rbox)
gui.spin(ibox, self, "k_folds", 2, 50, label="Number of folds:",
callback=self._param_changed)
gui.appendRadioButton(rbox, "Leave one out")
gui.appendRadioButton(rbox, "Random sampling")
ibox = gui.indentedBox(rbox)
gui.spin(ibox, self, "n_repeat", 2, 50, label="Repeat train/test",
callback=self._param_changed)
gui.widgetLabel(ibox, "Relative training set size:")
gui.hSlider(ibox, self, "sample_p", minValue=1, maxValue=100,
ticks=20, vertical=False,
callback=self._param_changed)
gui.appendRadioButton(rbox, "Test on train data")
gui.appendRadioButton(rbox, "Test on test data")
rbox.layout().addSpacing(5)
gui.button(rbox, self, "Apply", callback=self.apply)
gui.rubber(self.controlArea)
self.view = QTreeView(
rootIsDecorated=False,
uniformRowHeights=True,
wordWrap=True,
editTriggers=QTreeView.NoEditTriggers
)
self.result_model = QStandardItemModel()
self.result_model.setHorizontalHeaderLabels(
["Method"] + classification_stats.headers
)
self.view.setModel(self.result_model)
box = gui.widgetBox(self.mainArea, "Evaluation Results")
box.layout().addWidget(self.view)
def __init__(self):
super().__init__()
self.data = None
self.groups = None
self.CVSettings = (self.stratified, self.numberOfFolds)
infoBox = gui.widgetBox(self.controlArea, "Information")
self.dataInfoLabel = gui.widgetLabel(infoBox, 'No data on input.')
self.outputInfoLabel = gui.widgetLabel(infoBox, ' ')
optionsBox = gui.widgetBox(self.controlArea, "Options")
le = gui.lineEdit(optionsBox, self, "randomSeed", "Random seed: ",
orientation=0, controlWidth=60,
validator=QtGui.QIntValidator())
s = le.sizeHint().height() - 2
b = gui.toolButton(le.box, self, width=s, height=s,
callback=lambda: le.setText(""))
b.setIcon(b.style().standardIcon(b.style().SP_DialogCancelButton))
gui.rubber(le.box)
gui.checkBox(optionsBox, self, "stratified", "Stratified, if possible")
sampling = gui.radioButtons(
self.controlArea, self, "samplingType", box="Sampling type",
addSpace=True)
gui.appendRadioButton(sampling, "Random Sampling:")
indRndSmpl = gui.indentedBox(sampling)
sizeType = gui.radioButtons(
indRndSmpl, self, "sampleSizeType",
callback=lambda: self.chooseSampling(0))
gui.appendRadioButton(sizeType, "Sample size:", insertInto=indRndSmpl)
self.sampleSizeSpin = gui.spin(
gui.indentedBox(indRndSmpl), self, "sampleSizeNumber",
1, 1000000000, callback=[lambda: self.chooseSampling(0),
lambda: self.chooseSizeType(0)])
gui.appendRadioButton(sizeType, "Sample proportions:",
insertInto=indRndSmpl)
gui.hSlider(gui.indentedBox(indRndSmpl), self,
"sampleSizePercentage",
minValue=1, maxValue=100, ticks=10, labelFormat="%d%%",
callback=[lambda: self.chooseSampling(0),
lambda: self.chooseSizeType(1)])
gui.appendRadioButton(sampling, "Cross Validation:")
crossValidIndent = gui.indentedBox(sampling)
gui.spin(
crossValidIndent, self, "numberOfFolds", 2, 100,
label="Number of folds:",
callback=[self.updateSelectedFoldSpin,
lambda: self.chooseSampling(1)])
self.selectedFoldSpin = gui.spin(
crossValidIndent, self, "selectedFold", 1, 100,
label="Selected fold:",
callback=[self.updateSelectedFoldSpin,
lambda: self.chooseSampling(1)])
gui.button(self.controlArea, self, "Sample Data",
callback=self.sendData)
def __init__(self):
super().__init__()
self.data = None
self.n_inliers = self.n_outliers = None
box = gui.vBox(self.controlArea, "Information")
self.data_info_label = gui.widgetLabel(box, self.data_info_default)
self.in_out_info_label = gui.widgetLabel(box,
self.in_out_info_default)
box = gui.vBox(self.controlArea, "Outlier Detection Method")
detection = gui.radioButtons(box, self, "outlier_method")
gui.appendRadioButton(detection,
"One class SVM with non-linear kernel (RBF)")
ibox = gui.indentedBox(detection)
tooltip = "An upper bound on the fraction of training errors and a " \
"lower bound of the fraction of support vectors"
gui.widgetLabel(ibox, 'Nu:', tooltip=tooltip)
self.nu_slider = gui.hSlider(
ibox, self, "nu", minValue=1, maxValue=100, ticks=10,
labelFormat="%d %%", callback=self.nu_changed, tooltip=tooltip)
self.gamma_spin = gui.spin(
ibox, self, "gamma", label="Kernel coefficient:", step=1e-2,
spinType=float, minv=0.01, maxv=10, callback=self.gamma_changed)
gui.separator(detection, 12)
self.rb_cov = gui.appendRadioButton(detection, "Covariance estimator")
ibox = gui.indentedBox(detection)
self.l_cov = gui.widgetLabel(ibox, 'Contamination:')
self.cont_slider = gui.hSlider(
ibox, self, "cont", minValue=0, maxValue=100, ticks=10,
labelFormat="%d %%", callback=self.cont_changed)
ebox = gui.hBox(ibox)
self.cb_emp_cov = gui.checkBox(
ebox, self, "empirical_covariance",
"Support fraction:", callback=self.empirical_changed)
self.support_fraction_spin = gui.spin(
ebox, self, "support_fraction", step=1e-1, spinType=float,
minv=0.1, maxv=10, callback=self.support_fraction_changed)
gui.separator(detection, 12)
gui.button(self.buttonsArea, self, "Detect Outliers",
callback=self.commit)
self.layout().setSizeConstraint(QtGui.QLayout.SetFixedSize)
def addHistogramControls(self):
boxGeneral = gui.widgetBox(self.controlArea, box="Edges")
ribg = gui.widgetBox(boxGeneral, None, orientation="horizontal", addSpace=False)
self.spin_high = gui.doubleSpin(boxGeneral, self, 'spinUpperThreshold',
0, float('inf'), 0.001, decimals=3,
label='Distance threshold',
callback=self.changeUpperSpin,
keyboardTracking=False,
controlWidth=60)
self.histogram.region.sigRegionChangeFinished.connect(self.spinboxFromHistogramRegion)
ribg = gui.widgetBox(boxGeneral, None, orientation="horizontal", addSpace=False)
gui.doubleSpin(boxGeneral, self, "percentil", 0, 100, 0.1,
label="Percentile", orientation='horizontal',
callback=self.setPercentil,
callbackOnReturn=1, controlWidth=60)
hbox = gui.widgetBox(boxGeneral, orientation='horizontal')
knn_cb = gui.checkBox(hbox, self, 'include_knn',
label='Include also closest neighbors',
callback=self.generateGraph)
knn = gui.spin(hbox, self, "kNN", 1, 1000, 1,
orientation='horizontal',
callback=self.generateGraph, callbackOnReturn=1, controlWidth=60)
knn_cb.disables = [knn]
knn_cb.makeConsistent()
ribg.layout().addStretch(1)
# Options
ribg = gui.radioButtonsInBox(self.controlArea, self, "node_selection",
box="Node selection",
callback=self.generateGraph)
gui.appendRadioButton(ribg, "Keep all nodes")
hb = gui.widgetBox(ribg, None, orientation="horizontal", addSpace=False)
gui.appendRadioButton(ribg, "Components with at least nodes", insertInto=hb)
gui.spin(hb, self, "excludeLimit", 2, 100, 1,
callback=(lambda h=True: self.generateGraph(h)), controlWidth=60)
gui.appendRadioButton(ribg, "Largest connected component")
self.attribute = None
ribg = gui.radioButtonsInBox(self.controlArea, self, "edge_weights",
box="Edge weights",
callback=self.generateGraph)
hb = gui.widgetBox(ribg, None, orientation="horizontal", addSpace=False)
gui.appendRadioButton(ribg, "Proportional to distance", insertInto=hb)
gui.appendRadioButton(ribg, "Inverted distance", insertInto=hb)
def __init__(self):
super().__init__()
self._nhops = 2
self._edge_threshold = 0.5
self._n_max_neighbors = 20
self.selected_titles = []
self.titles = []
self.filter = ""
self.ids = []
self._selected_nodes = []
self._algorithm = 0
self._k_algorithm = 0.3
box = gui.widgetBox(self.controlArea, "Paper Selection", orientation="vertical")
gui.lineEdit(box, self, "filter", callback=self.filter_list, callbackOnType=True)
self.list_titles = gui.listBox(
box, self, "selected_titles", "titles", selectionMode=QListWidget.MultiSelection, callback=self.update_view
)
gui.separator(self.controlArea)
box_pref = gui.widgetBox(self.controlArea, "Preferences", orientation="vertical")
gui.spin(box_pref, self, "_nhops", 1, 6, 1, label="Number of hops: ", callback=self.update_view)
gui.spin(
box_pref, self, "_n_max_neighbors", 1, 100, 1, label="Max number of neighbors: ", callback=self.update_view
)
gui.doubleSpin(
box_pref, self, "_edge_threshold", 0, 1, step=0.01, label="Edge threshold: ", callback=self.update_view
)
gui.separator(self.controlArea)
box_alg = gui.widgetBox(self.controlArea, "Interest Propagation Algorithm", orientation="vertical")
radio_box = gui.radioButtonsInBox(box_alg, self, "_algorithm", [], callback=self.update_view)
gui.appendRadioButton(radio_box, self, "_algorithm", "Without Clustering", callback=self.update_view)
gui.doubleSpin(
gui.indentedBox(radio_box),
self,
"_k_algorithm",
0,
1,
step=0.01,
label="Parameter k: ",
callback=self.update_view,
)
gui.appendRadioButton(radio_box, self, "_algorithm", "With Clustering", callback=self.update_view)
self.inside_view = PubmedNetworkView(self)
self.send("Nx View", self.inside_view)
def add_option(label, pre_label, between_label,
merge_type, model, extra_model):
gui.appendRadioButton(grp, label)
vbox = gui.vBox(grp)
box = gui.hBox(vbox)
box.layout().addSpacing(radio_width)
self.attr_boxes.append(box)
gui.widgetLabel(box, pre_label)
model[:] = [getattr(self, 'attr_{}_data'.format(merge_type))]
extra_model[:] = [getattr(self, 'attr_{}_extra'.format(merge_type))]
cb = gui.comboBox(box, self, 'attr_{}_data'.format(merge_type),
callback=self._invalidate, model=model)
cb.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Fixed)
cb.setFixedWidth(190)
gui.widgetLabel(box, between_label)
cb = gui.comboBox(box, self, 'attr_{}_extra'.format(merge_type),
callback=self._invalidate, model=extra_model)
cb.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Fixed)
cb.setFixedWidth(190)
vbox.layout().addSpacing(6)
def __init__(self):
self.data = None
box = gui.vBox(self.controlArea, 'Sequence')
group = gui.radioButtons(box, self, 'radio_sequential',
callback=self.on_changed)
hbox = gui.hBox(box)
gui.appendRadioButton(group, 'Sequential attribute:',
insertInto=hbox)
attrs_model = self.attrs_model = VariableListModel()
combo_attrs = self.combo_attrs = gui.comboBox(
hbox, self, 'selected_attr',
callback=self.on_changed,
sendSelectedValue=True)
combo_attrs.setModel(attrs_model)
gui.appendRadioButton(group, 'Sequence is implied by instance order',
insertInto=box)
gui.auto_commit(self.controlArea, self, 'autocommit', '&Apply')
def __init__(self):
super().__init__()
self.data_points_interpolate = None
dbox = gui.widgetBox(self.controlArea, "Interpolation")
rbox = gui.radioButtons(
dbox, self, "input_radio", callback=self._change_input)
gui.appendRadioButton(rbox, "Enable automatic interpolation")
gui.appendRadioButton(rbox, "Linear interval")
ibox = gui.indentedBox(rbox)
form = QWidget()
formlayout = QFormLayout()
form.setLayout(formlayout)
ibox.layout().addWidget(form)
self.xmin_edit = lineEditFloatOrNone(ibox, self, "xmin", callback=self.commit)
formlayout.addRow("Min", self.xmin_edit)
self.xmax_edit = lineEditFloatOrNone(ibox, self, "xmax", callback=self.commit)
formlayout.addRow("Max", self.xmax_edit)
self.dx_edit = lineEditFloatOrNone(ibox, self, "dx", callback=self.commit)
formlayout.addRow("Δ", self.dx_edit)
gui.appendRadioButton(rbox, "Reference data")
self.data = None
gui.auto_commit(self.controlArea, self, "autocommit", "Interpolate")
self._change_input()
def _add_type_box(self):
form = QGridLayout()
self.type_box = box = gui.radioButtonsInBox(
self.controlArea, self, "svm_type", [], box="SVM Type",
orientation=form, callback=self._update_type)
self.epsilon_radio = gui.appendRadioButton(
box, "SVM", addToLayout=False)
self.C_spin = gui.doubleSpin(
box, self, "C", 0.1, 512.0, 0.1, decimals=2,
alignment=Qt.AlignRight, addToLayout=False,
callback=self.settings_changed)
self.epsilon_spin = gui.doubleSpin(
box, self, "epsilon", 0.1, 512.0, 0.1, decimals=2,
alignment=Qt.AlignRight, addToLayout=False,
callback=self.settings_changed)
form.addWidget(self.epsilon_radio, 0, 0, Qt.AlignLeft)
form.addWidget(QLabel("Cost (C):"), 0, 1, Qt.AlignRight)
form.addWidget(self.C_spin, 0, 2)
form.addWidget(QLabel(
"Regression loss epsilon (ε):"), 1, 1, Qt.AlignRight)
form.addWidget(self.epsilon_spin, 1, 2)
self.nu_radio = gui.appendRadioButton(box, "ν-SVM", addToLayout=False)
self.nu_C_spin = gui.doubleSpin(
box, self, "nu_C", 0.1, 512.0, 0.1, decimals=2,
alignment=Qt.AlignRight, addToLayout=False,
callback=self.settings_changed)
self.nu_spin = gui.doubleSpin(
box, self, "nu", 0.05, 1.0, 0.05, decimals=2,
alignment=Qt.AlignRight, addToLayout=False,
callback=self.settings_changed)
form.addWidget(self.nu_radio, 2, 0, Qt.AlignLeft)
form.addWidget(QLabel("Regression cost (C):"), 2, 1, Qt.AlignRight)
form.addWidget(self.nu_C_spin, 2, 2)
form.addWidget(QLabel("Complexity bound (ν):"), 3, 1, Qt.AlignRight)
form.addWidget(self.nu_spin, 3, 2)
# Correctly enable/disable the appropriate boxes
self._update_type()
def __init__(self, parent=None):
super().__init__(parent)
self.data = None
self.preprocessors = None
box = gui.widgetBox(self.controlArea, "Learner/Predictor Name")
gui.lineEdit(box, self, "learner_name")
box = gui.widgetBox(self.controlArea, "Options")
box = gui.radioButtons(box, self, "reg_type",
callback=self._reg_type_changed)
gui.appendRadioButton(box, "Ordinary linear regression")
gui.appendRadioButton(box, "Ridge regression")
ibox = gui.indentedBox(box)
gui.doubleSpin(ibox, self, "ridgealpha", 0.0, 1000.0, label="alpha:")
self.ridge_box = ibox
gui.appendRadioButton(box, "Lasso regression")
ibox = gui.indentedBox(box)
gui.doubleSpin(ibox, self, "lassoalpha", 0.0, 1000.0, label="alpha")
self.lasso_box = ibox
gui.button(self.controlArea, self, "Apply", callback=self.apply,
default=True)
self.layout().setSizeConstraint(QLayout.SetFixedSize)
self.ridge_box.setEnabled(self.reg_type == self.Ridge)
self.lasso_box.setEnabled(self.reg_type == self.Lasso)
self.apply()
def __init__(self, parent=None):
super().__init__(parent)
self.classes = []
self.data = None
self.data_subset = None
self.subset_selection = []
self.group_variables = []
self.graph_variables = []
self.__groups = None
# Setup GUI
infobox = gui.widgetBox(self.controlArea, "Info")
self.infoLabel = gui.widgetLabel(infobox, "No data on input.")
displaybox = gui.widgetBox(self.controlArea, "Display")
radiobox = gui.radioButtons(displaybox,
self,
"display_index",
callback=self.__update_visibility)
gui.appendRadioButton(radiobox, "Line plot")
gui.appendRadioButton(radiobox, "Mean")
gui.appendRadioButton(radiobox, "Line plot with mean")
showbox = gui.widgetBox(self.controlArea, "Show")
gui.checkBox(showbox,
self,
"display_quartiles",
"Error bars",
callback=self.__update_visibility)
group_box = gui.widgetBox(self.controlArea, "Group by")
self.cb_attr = gui.comboBox(group_box,
self,
"group_var",
sendSelectedValue=True,
callback=self.update_group_var)
self.group_listbox = gui.listBox(
group_box,
self,
"selected_classes",
"classes",
selectionMode=QListWidget.MultiSelection,
callback=self.__on_class_selection_changed)
self.group_listbox.setVisible(False)
self.gui = OWPlotGUI(self)
self.box_zoom_select(self.controlArea)
gui.rubber(self.controlArea)
gui.auto_commit(self.controlArea, self, "auto_commit",
"Send Selection", "Send Automatically")
self.graph = LinePlotGraph(self)
self.graph.getPlotItem().buttonsHidden = True
self.graph.setRenderHint(QPainter.Antialiasing, True)
self.mainArea.layout().addWidget(self.graph)
def __init__(self):
self.data = None
box = gui.vBox(self.controlArea, 'Sequence')
group = gui.radioButtons(box,
self,
'radio_sequential',
callback=self.on_changed)
hbox = gui.hBox(box)
gui.appendRadioButton(group, 'Sequential attribute:', insertInto=hbox)
attrs_model = self.attrs_model = VariableListModel()
combo_attrs = self.combo_attrs = gui.comboBox(hbox,
self,
'selected_attr',
callback=self.on_changed,
sendSelectedValue=True)
combo_attrs.setModel(attrs_model)
gui.appendRadioButton(group,
'Sequence is implied by instance order',
insertInto=box)
gui.auto_commit(self.controlArea, self, 'autocommit', '&Apply')
def __init__(self):
super().__init__()
self.corpus = None
form = QGridLayout()
self.method_box = box = gui.radioButtonsInBox(
self.controlArea, self, "method_idx", [], box="Method",
orientation=form, callback=self._method_changed)
self.liu_hu = gui.appendRadioButton(box, "Liu Hu", addToLayout=False)
self.liu_lang = gui.comboBox(None, self, 'language',
sendSelectedValue=True,
items=self.LANG,
callback=self._method_changed)
self.vader = gui.appendRadioButton(box, "Vader", addToLayout=False)
form.addWidget(self.liu_hu, 0, 0, Qt.AlignLeft)
form.addWidget(QLabel("Language:"), 0, 1, Qt.AlignRight)
form.addWidget(self.liu_lang, 0, 2, Qt.AlignRight)
form.addWidget(self.vader, 1, 0, Qt.AlignLeft)
ac = gui.auto_commit(self.controlArea, self, 'autocommit', 'Commit',
'Autocommit is on')
ac.layout().insertSpacing(1, 8)
def __init__(self):
super().__init__()
self.corpus = None
form = QGridLayout()
self.method_box = box = gui.radioButtonsInBox(
self.controlArea, self, "method_idx", [], box="Method",
orientation=form, callback=self._method_changed)
self.liu_hu = gui.appendRadioButton(box, "Liu Hu", addToLayout=False)
self.liu_lang = gui.comboBox(None, self, 'language',
sendSelectedValue=True,
items=self.LANG,
callback=self._method_changed)
self.vader = gui.appendRadioButton(box, "Vader", addToLayout=False)
form.addWidget(self.liu_hu, 0, 0, Qt.AlignLeft)
form.addWidget(QLabel("Language:"), 0, 1, Qt.AlignRight)
form.addWidget(self.liu_lang, 0, 2, Qt.AlignRight)
form.addWidget(self.vader, 1, 0, Qt.AlignLeft)
ac = gui.auto_commit(self.controlArea, self, 'autocommit', 'Commit',
'Autocommit is on')
ac.layout().insertSpacing(1, 8)
def __init__(self):
def space(a, b):
if not isinstance(a, str) or a[-1] in string.ascii_letters \
and not isinstance(b, str) or b[0] in string.ascii_letters:
return " "
else:
return ""
super().__init__()
rb = self.radios = gui.radioButtons(self.controlArea,
self,
"graph_type",
box=True,
callback=self.on_type_changed)
rb.layout().setSpacing(6)
self.arg_spins = {}
for (_1, name, _2, *arguments), defaults \
in zip(self.GRAPH_TYPES, self.arguments.values()):
argbox = gui.hBox(rb)
argbox.layout().setSpacing(0)
rbb = gui.appendRadioButton(rb, name, argbox)
rbb.setAttribute(Qt.WA_LayoutUsesWidgetRect)
argbox.setAttribute(Qt.WA_LayoutUsesWidgetRect)
self.arg_spins[name] = box = []
values = iter(defaults)
argno = 0
for prev, arg, post in \
zip([""] + arguments, arguments, arguments + [""]):
if isinstance(arg, str):
label = space(prev, arg) + arg + space(arg, post)
box.append(gui.widgetLabel(argbox, label))
else:
assert isinstance(arg, tuple)
_value, minv, maxv = arg
spin = QSpinBox(value=next(values),
minimum=minv,
maximum=maxv)
argbox.layout().addWidget(spin)
spin.valueChanged.connect(
lambda value, name=name, argidx=argno: self.update_arg(
value, name, argidx))
argno += 1
box.append(spin)
self.bt_generate = gui.button(self.controlArea,
self,
"Regenerate Network",
callback=self.generate)
self.on_type_changed()
def __init__(self):
super().__init__()
dbox = gui.widgetBox(self.controlArea, "Integration")
rbox = gui.radioButtons(dbox,
self,
"integration_method",
callback=self._change_integration)
gui.appendRadioButton(rbox, "Integrate from 0")
gui.appendRadioButton(rbox, "Integrate from baseline")
gui.appendRadioButton(rbox, "Peak from 0")
gui.appendRadioButton(rbox, "Peak from baseline")
gui.rubber(self.controlArea)
splitter = QSplitter(self)
splitter.setOrientation(Qt.Vertical)
self.imageplot = ImagePlot(self)
self.curveplot = CurvePlot(self, select=SELECTONE)
splitter.addWidget(self.imageplot)
splitter.addWidget(self.curveplot)
self.mainArea.layout().addWidget(splitter)
self.line1 = MovableVlineWD(position=self.lowlim,
label="",
setvalfn=self.set_lowlim,
confirmfn=self.edited,
report=self.curveplot)
self.line2 = MovableVlineWD(position=self.highlim,
label="",
setvalfn=self.set_highlim,
confirmfn=self.edited,
report=self.curveplot)
self.curveplot.add_marking(self.line1)
self.curveplot.add_marking(self.line2)
self.resize(900, 700)
self.graph_name = "imageplot.plotview"
def __init__(self, parent=None):
super().__init__(parent)
self.__groups = None
self.__profiles = None
self.data = None
self.data_subset = None
self.subset_selection = []
self.graph_variables = []
# Setup GUI
infobox = gui.widgetBox(self.controlArea, "Info")
self.infoLabel = gui.widgetLabel(infobox, "No data on input.")
displaybox = gui.widgetBox(self.controlArea, "Display")
radiobox = gui.radioButtons(displaybox, self, "display_index",
callback=self.__update_visibility)
gui.appendRadioButton(radiobox, "Line plot")
gui.appendRadioButton(radiobox, "Mean")
gui.appendRadioButton(radiobox, "Line plot with mean")
showbox = gui.widgetBox(self.controlArea, "Show")
gui.checkBox(showbox, self, "display_quartiles", "Error bars",
callback=self.__update_visibility)
self.group_vars = DomainModel(
placeholder="None", separators=False,
valid_types=DiscreteVariable)
self.group_view = gui.listView(
self.controlArea, self, "group_var", box="Group by",
model=self.group_vars, callback=self.__group_var_changed)
self.group_view.setEnabled(False)
self.group_view.setMinimumSize(QSize(30, 100))
self.group_view.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Ignored)
self.gui = OWPlotGUI(self)
self.box_zoom_select(self.controlArea)
gui.rubber(self.controlArea)
gui.auto_commit(self.controlArea, self, "auto_commit",
"Send Selection", "Send Automatically")
self.graph = LinePlotGraph(self)
self.graph.getPlotItem().buttonsHidden = True
self.graph.setRenderHint(QPainter.Antialiasing, True)
self.mainArea.layout().addWidget(self.graph)
def __init__(self):
super().__init__()
self.data_points = None
dbox = gui.widgetBox(self.controlArea, "Interpolation")
rbox = gui.radioButtons(dbox,
self,
"input_radio",
callback=self._change_input)
gui.appendRadioButton(rbox, "Enable automatic interpolation")
gui.appendRadioButton(rbox, "Linear interval")
ibox = gui.indentedBox(rbox)
self.xmin_edit = lineEditFloatOrNone(ibox,
self,
"xmin",
label="Min",
labelWidth=50,
orientation=Qt.Horizontal,
callback=self.commit)
self.xmax_edit = lineEditFloatOrNone(ibox,
self,
"xmax",
label="Max",
labelWidth=50,
orientation=Qt.Horizontal,
callback=self.commit)
self.dx_edit = lineEditFloatOrNone(ibox,
self,
"dx",
label="Δ",
labelWidth=50,
orientation=Qt.Horizontal,
callback=self.commit)
gui.appendRadioButton(rbox, "Reference data")
self.data = None
gui.auto_commit(self.controlArea, self, "autocommit", "Interpolate")
self._change_input()
def __init__(self):
super().__init__()
self.data_points_interpolate = None
dbox = gui.widgetBox(self.controlArea, "Interpolation")
rbox = gui.radioButtons(dbox,
self,
"input_radio",
callback=self._change_input)
gui.appendRadioButton(rbox, "Enable automatic interpolation")
gui.appendRadioButton(rbox, "Linear interval")
ibox = gui.indentedBox(rbox)
form = QWidget()
formlayout = QFormLayout()
form.setLayout(formlayout)
ibox.layout().addWidget(form)
self.xmin_edit = lineEditFloatOrNone(ibox,
self,
"xmin",
callback=self.commit)
formlayout.addRow("Min", self.xmin_edit)
self.xmax_edit = lineEditFloatOrNone(ibox,
self,
"xmax",
callback=self.commit)
formlayout.addRow("Max", self.xmax_edit)
self.dx_edit = lineEditFloatOrNone(ibox,
self,
"dx",
callback=self.commit)
formlayout.addRow("Δ", self.dx_edit)
gui.appendRadioButton(rbox, "Reference data")
self.data = None
gui.auto_commit(self.controlArea, self, "autocommit", "Interpolate")
self._change_input()
def __init__(self, parent=None):
super().__init__(parent)
self.data = None
self.preprocessors = None
box = gui.widgetBox(self.controlArea, "Learner/Predictor Name")
gui.lineEdit(box, self, "learner_name")
box = gui.widgetBox(self.controlArea, "Options")
box = gui.radioButtons(box,
self,
"reg_type",
callback=self._reg_type_changed)
gui.appendRadioButton(box, "Ordinary linear regression")
gui.appendRadioButton(box, "Ridge regression")
ibox = gui.indentedBox(box)
gui.doubleSpin(ibox, self, "ridgealpha", 0.0, 1000.0, label="alpha:")
self.ridge_box = ibox
gui.appendRadioButton(box, "Lasso regression")
ibox = gui.indentedBox(box)
gui.doubleSpin(ibox, self, "lassoalpha", 0.0, 1000.0, label="alpha")
self.lasso_box = ibox
gui.button(self.controlArea,
self,
"Apply",
callback=self.apply,
default=True)
self.layout().setSizeConstraint(QLayout.SetFixedSize)
self.ridge_box.setEnabled(self.reg_type == self.Ridge)
self.lasso_box.setEnabled(self.reg_type == self.Lasso)
self.apply()
def __init__(self):
super().__init__()
self.data = None
self.samplingBox = [None, None]
self.sampleSizeBox = [None, None]
self.cvBox = [None, None]
box = gui.widgetBox(self.controlArea, "Information")
self.dataInfoLabel = gui.widgetLabel(box, 'No data on input.')
self.outputInfoLabel = gui.widgetLabel(box, ' ')
form = QtGui.QFormLayout(
formAlignment=Qt.AlignLeft | Qt.AlignTop,
labelAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QtGui.QFormLayout.AllNonFixedFieldsGrow
)
box = gui.widgetBox(self.controlArea, "Options", orientation=form)
cb = gui.checkBox(box, self, "stratified", "Stratified (if possible)",
callback=self.settingsChanged, addToLayout=False)
form.addRow(cb, QtGui.QWidget())
cb = gui.checkBox(box, self, "useSeed", "Random seed:",
callback=self.settingsChanged, addToLayout=False)
spin = gui.spin(box, self, "seed", minv=0, maxv=2 ** 31 - 1,
callback=self.settingsChanged, addToLayout=False)
form.addRow(cb, spin)
box = gui.widgetBox(self.controlArea, self.tr("Sampling Type"))
sampling = gui.radioButtons(box, self, "samplingType",
callback=self.samplingTypeChanged)
gui.appendRadioButton(sampling, "Random Sampling:")
self.samplingBox[0] = ibox = gui.indentedBox(sampling)
ibox.setEnabled(self.samplingType == OWDataSampler.RandomSampling)
ibox = gui.radioButtons(ibox, self, "sampleSizeType",
callback=self.sampleSizeTypeChanged)
gui.checkBox(ibox, self, "replacement", "With replacement",
callback=self.settingsChanged)
gui.appendRadioButton(ibox, "Sample size:")
self.sampleSizeSpin = gui.spin(
gui.indentedBox(ibox), self, "sampleSizeNumber",
minv=1, maxv=2 ** 31 - 1, callback=self.settingsChanged
)
self.sampleSizeSpin.setEnabled(self.sampleSizeType == self.Fixed)
gui.appendRadioButton(ibox, "Sample proportions:")
self.sampleSizePercentageSlider = gui.hSlider(
gui.indentedBox(ibox), self,
"sampleSizePercentage",
minValue=1, maxValue=100, ticks=10, labelFormat="%d%%",
callback=self.settingsChanged
)
self.sampleSizePercentageSlider.setEnabled(
self.sampleSizeType == self.Ratio)
self.sampleSizeBox = [self.sampleSizeSpin,
self.sampleSizePercentageSlider]
gui.appendRadioButton(sampling, "Cross Validation:")
self.samplingBox[1] = ibox = gui.indentedBox(sampling, addSpace=True)
ibox.setEnabled(self.samplingType == OWDataSampler.CrossValidation)
form = QtGui.QFormLayout(
formAlignment=Qt.AlignLeft | Qt.AlignTop,
labelAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QtGui.QFormLayout.AllNonFixedFieldsGrow
)
bbox = gui.radioButtons(ibox, self, "cvType", orientation=form,
callback=self.cvTypeChanged, addSpace=True)
bbox.setContentsMargins(1, 1, 1, 1)
kfold_rb = gui.appendRadioButton(bbox, "K-Fold:", insertInto=None,
addToLayout=False)
loo_rb = gui.appendRadioButton(bbox, "Leave one out", insertInto=None,
addToLayout=False)
kfold_spin = gui.spin(ibox, self, "numberOfFolds", 2, 100,
addToLayout=False,
callback=self.numberOfFoldsChanged)
kfold_spin.setEnabled(self.cvType == self.KFold)
form.addRow(kfold_rb, kfold_spin)
form.addRow(loo_rb)
self.cvBox = [kfold_spin]
self.selectedFoldSpin = gui.spin(
ibox, self, "selectedFold", 1, 100,
addToLayout=False)
form.addRow(QtGui.QLabel("Selected fold:"), self.selectedFoldSpin)
gui.button(self.controlArea, self, "Sample Data",
callback=self.commit)
def __init__(self):
super().__init__()
self.data = None
self.domainmodels = []
self.unmatched = []
top = self.controlArea
def _radioChanged():
self.mainArea.setVisible(self.is_decoding == 0
and len(self.unmatched))
self.commit()
modes = gui.radioButtons(top,
self,
'is_decoding',
callback=_radioChanged)
gui.appendRadioButton(
modes,
'&Encode region names into geographical coordinates:',
insertInto=top)
box = gui.indentedBox(top)
model = DomainModel(parent=self,
valid_types=(StringVariable, DiscreteVariable))
self.domainmodels.append(model)
combo = gui.comboBox(box,
self,
'str_attr',
label='Region identifier:',
orientation=Qt.Horizontal,
callback=self.region_attr_changed,
sendSelectedValue=True,
model=model)
gui.comboBox(box,
self,
'str_type',
label='Identifier type:',
orientation=Qt.Horizontal,
items=tuple(self.ID_TYPE.keys()),
callback=lambda: self.commit(),
sendSelectedValue=True)
# Select first mode if any of its combos are changed
for combo in box.findChildren(QComboBox):
combo.activated.connect(lambda: setattr(self, 'is_decoding', 0))
gui.appendRadioButton(modes,
'&Decode latitude and longitude into regions:',
insertInto=top)
box = gui.indentedBox(top)
model = DomainModel(parent=self, valid_types=ContinuousVariable)
self.domainmodels.append(model)
combo = gui.comboBox(box,
self,
'lat_attr',
label='Latitude:',
orientation=Qt.Horizontal,
callback=lambda: self.commit(),
sendSelectedValue=True,
model=model)
combo = gui.comboBox(box,
self,
'lon_attr',
label='Longitude:',
orientation=Qt.Horizontal,
callback=lambda: self.commit(),
sendSelectedValue=True,
model=model)
gui.comboBox(
box,
self,
'admin',
label='Administrative level:',
orientation=Qt.Horizontal,
callback=lambda: self.commit(),
items=
('Country',
'1st-level subdivision (state, region, province, municipality, ...)',
'2nd-level subdivisions (1st-level & US counties)'),
)
# Select second mode if any of its combos are changed
for combo in box.findChildren(QComboBox):
combo.activated.connect(lambda: setattr(self, 'is_decoding', 1))
gui.checkBox(
top,
self,
'append_features',
label='E&xtend coded data with additional region properties',
callback=lambda: self.commit(),
toolTip='Extend coded data with region properties, such as'
'ISO codes, continent, subregion, region type, '
'economy type, FIPS/HASC codes, region capital etc. as available.')
gui.auto_commit(self.controlArea, self, 'autocommit', '&Apply')
gui.rubber(self.controlArea)
model = self.replacementsModel = PyTableModel(self.replacements,
parent=self,
editable=[False, True])
view = gui.TableView(self,
sortingEnabled=False,
selectionMode=gui.TableView.NoSelection,
editTriggers=gui.TableView.AllEditTriggers)
view.horizontalHeader().setResizeMode(QHeaderView.Stretch)
view.verticalHeader().setSectionResizeMode(0)
view.setModel(model)
owwidget = self
class TableItemDelegate(QItemDelegate):
def createEditor(self, parent, options, index):
nonlocal owwidget
edit = QLineEdit(parent)
wordlist = [''] + ToLatLon.valid_values(
owwidget.ID_TYPE[owwidget.str_type])
edit.setCompleter(
QCompleter(wordlist,
edit,
caseSensitivity=Qt.CaseInsensitive,
filterMode=Qt.MatchContains))
def save_and_commit():
if edit.text() and edit.text() in wordlist:
model = index.model()
pindex = QPersistentModelIndex(index)
if pindex.isValid():
new_index = pindex.sibling(pindex.row(),
pindex.column())
save = model.setData(new_index, edit.text(),
Qt.EditRole)
if save:
owwidget.commit()
return
edit.clear()
edit.editingFinished.connect(save_and_commit)
return edit
view.setItemDelegate(TableItemDelegate())
model.setHorizontalHeaderLabels(
['Unmatched Identifier', 'Custom Replacement'])
box = gui.vBox(self.mainArea)
self.info_str = ' /'
gui.label(box, self, 'Unmatched identifiers: %(info_str)s')
box.layout().addWidget(view)
self.mainArea.setVisible(self.is_decoding == 0)
def __init__(self):
super().__init__()
self.data = None # type: Optional[Table]
self.clusterings = {}
self.__executor = ThreadExecutor(parent=self)
self.__task = None # type: Optional[Task]
layout = QGridLayout()
bg = gui.radioButtonsInBox(
self.controlArea,
self,
"optimize_k",
orientation=layout,
box="Number of Clusters",
callback=self.update_method,
)
layout.addWidget(
gui.appendRadioButton(bg, "Fixed:", addToLayout=False), 1, 1)
sb = gui.hBox(None, margin=0)
gui.spin(sb,
self,
"k",
minv=2,
maxv=30,
controlWidth=60,
alignment=Qt.AlignRight,
callback=self.update_k)
gui.rubber(sb)
layout.addWidget(sb, 1, 2)
layout.addWidget(gui.appendRadioButton(bg, "From", addToLayout=False),
2, 1)
ftobox = gui.hBox(None)
ftobox.layout().setContentsMargins(0, 0, 0, 0)
layout.addWidget(ftobox, 2, 2)
gui.spin(ftobox,
self,
"k_from",
minv=2,
maxv=29,
controlWidth=60,
alignment=Qt.AlignRight,
callback=self.update_from)
gui.widgetLabel(ftobox, "to")
gui.spin(ftobox,
self,
"k_to",
minv=3,
maxv=30,
controlWidth=60,
alignment=Qt.AlignRight,
callback=self.update_to)
gui.rubber(ftobox)
box = gui.vBox(self.controlArea, "Initialization")
gui.comboBox(box,
self,
"smart_init",
items=[m[0] for m in self.INIT_METHODS],
callback=self.invalidate)
layout = QGridLayout()
gui.widgetBox(box, orientation=layout)
layout.addWidget(gui.widgetLabel(None, "Re-runs: "), 0, 0,
Qt.AlignLeft)
sb = gui.hBox(None, margin=0)
layout.addWidget(sb, 0, 1)
gui.lineEdit(sb,
self,
"n_init",
controlWidth=60,
valueType=int,
validator=QIntValidator(),
callback=self.invalidate)
layout.addWidget(gui.widgetLabel(None, "Maximum iterations: "), 1, 0,
Qt.AlignLeft)
sb = gui.hBox(None, margin=0)
layout.addWidget(sb, 1, 1)
gui.lineEdit(sb,
self,
"max_iterations",
controlWidth=60,
valueType=int,
validator=QIntValidator(),
callback=self.invalidate)
self.apply_button = gui.auto_commit(self.buttonsArea,
self,
"auto_commit",
"Apply",
box=None,
commit=self.commit)
gui.rubber(self.controlArea)
box = gui.vBox(self.mainArea, box="Silhouette Scores")
self.mainArea.setVisible(self.optimize_k)
self.table_model = ClusterTableModel(self)
table = self.table_view = QTableView(self.mainArea)
table.setModel(self.table_model)
table.setSelectionMode(QTableView.SingleSelection)
table.setSelectionBehavior(QTableView.SelectRows)
table.setItemDelegate(gui.ColoredBarItemDelegate(self, color=Qt.cyan))
table.selectionModel().selectionChanged.connect(self.select_row)
table.setMaximumWidth(200)
table.horizontalHeader().setStretchLastSection(True)
table.horizontalHeader().hide()
table.setShowGrid(False)
box.layout().addWidget(table)
def __init__(self):
super().__init__()
self.data = None
self.km = None
self.optimization_runs = []
box = gui.widgetBox(self.controlArea, "Number of Clusters")
layout = QGridLayout()
bg = gui.radioButtonsInBox(
box, self, "optimize_k", [], orientation=layout,
callback=self.update)
layout.addWidget(
gui.appendRadioButton(bg, "Fixed", addToLayout=False),
1, 1)
sb = gui.widgetBox(None, margin=0, orientation="horizontal")
self.fixedSpinBox = gui.spin(
sb, self, "k", minv=2, maxv=30,
controlWidth=60, alignment=Qt.AlignRight, callback=self.update_k)
gui.rubber(sb)
layout.addWidget(sb, 1, 2)
layout.addWidget(
gui.appendRadioButton(bg, "Optimized", addToLayout=False), 2, 1)
ftobox = gui.widgetBox(None, orientation="horizontal")
ftobox.layout().setMargin(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.widgetBox(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.widgetBox(None, margin=0, orientation="horizontal")
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.widgetBox(None, margin=0, orientation="horizontal")
layout.addWidget(sb, 1, 1)
gui.lineEdit(sb, self, "max_iterations",
controlWidth=60, valueType=int,
validator=QIntValidator(),
callback=self.update)
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.table_model = QStandardItemModel(self)
self.table_model.setHorizontalHeaderLabels(["k", "Score"])
self.table_model.setColumnCount(2)
self.table_box = gui.widgetBox(
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.preprocessors = None
box = gui.widgetBox(self.controlArea, self.tr("Name"))
gui.lineEdit(box, self, "learner_name")
form = QtGui.QGridLayout()
typebox = gui.radioButtonsInBox(
self.controlArea, self, "svmtype", [],
box=self.tr("SVM Type"),
orientation=form,
)
c_svm = gui.appendRadioButton(typebox, "C-SVM", addToLayout=False)
form.addWidget(c_svm, 0, 0, Qt.AlignLeft)
form.addWidget(QtGui.QLabel(self.tr("Cost (C)")), 0, 1, Qt.AlignRight)
c_spin = gui.doubleSpin(
typebox, self, "C", 1e-3, 1000.0, 0.1,
decimals=3, addToLayout=False
)
form.addWidget(c_spin, 0, 2)
nu_svm = gui.appendRadioButton(typebox, "ν-SVM", addToLayout=False)
form.addWidget(nu_svm, 1, 0, Qt.AlignLeft)
form.addWidget(
QtGui.QLabel(self.trUtf8("Complexity bound (\u03bd)")),
1, 1, Qt.AlignRight
)
nu_spin = gui.doubleSpin(
typebox, self, "nu", 0.05, 1.0, 0.05,
decimals=2, addToLayout=False
)
form.addWidget(nu_spin, 1, 2)
box = gui.widgetBox(self.controlArea, self.tr("Kernel"))
buttonbox = gui.radioButtonsInBox(
box, self, "kernel_type",
btnLabels=["Linear, x∙y",
"Polynomial, (g x∙y + c)^d",
"RBF, exp(-g|x-y|²)",
"Sigmoid, tanh(g x∙y + c)"],
callback=self._on_kernel_changed
)
parambox = gui.widgetBox(box, orientation="horizontal")
gamma = gui.doubleSpin(
parambox, self, "gamma", 0.0, 10.0, 0.0001,
label=" g: ", orientation="horizontal",
alignment=Qt.AlignRight
)
coef0 = gui.doubleSpin(
parambox, self, "coef0", 0.0, 10.0, 0.0001,
label=" c: ", orientation="horizontal",
alignment=Qt.AlignRight
)
degree = gui.doubleSpin(
parambox, self, "degree", 0.0, 10.0, 0.5,
label=" d: ", orientation="horizontal",
alignment=Qt.AlignRight
)
self._kernel_params = [gamma, coef0, degree]
box = gui.widgetBox(self.controlArea, "Optimization parameters")
gui.doubleSpin(box, self, "tol", 1e-7, 1.0, 5e-7,
label="Numerical Tolerance")
gui.spin(box, self, "max_iter", 0, 1e6, 100,
label="Iteration Limit", checked="limit_iter")
gui.button(self.controlArea, self, "&Apply",
callback=self.apply, default=True)
self._on_kernel_changed()
self.apply()
def __init__(self):
super().__init__()
#: input data
self.data = None
self.class_var = None
#: Current variable discretization state
self.var_state = {}
#: Saved variable discretization settings (context setting)
self.saved_var_states = {}
self.method = Methods.Default
self.k = 5
self.cutpoints = ()
box = gui.vBox(self.controlArea, self.tr("Default Discretization"))
self._default_method_ = 0
self.default_bbox = rbox = gui.radioButtons(
box, self, "_default_method_", callback=self._default_disc_changed)
self.default_button_group = bg = rbox.findChild(QButtonGroup)
bg.buttonClicked[int].connect(self.set_default_method)
rb = gui.hBox(rbox)
self.left = gui.vBox(rb)
right = gui.vBox(rb)
rb.layout().setStretch(0, 1)
rb.layout().setStretch(1, 1)
self.options = [
(Methods.Default, self.tr("Default")),
(Methods.Leave, self.tr("Leave numeric")),
(Methods.MDL, self.tr("Entropy-MDL discretization")),
(Methods.EqualFreq, self.tr("Equal-frequency discretization")),
(Methods.EqualWidth, self.tr("Equal-width discretization")),
(Methods.Remove, self.tr("Remove numeric variables")),
(Methods.Custom, self.tr("Manual")),
]
for id_, opt in self.options[1:]:
t = gui.appendRadioButton(rbox, opt)
bg.setId(t, id_)
t.setChecked(id_ == self.default_method)
[right, self.left][opt.startswith("Equal")].layout().addWidget(t)
def _intbox(parent, attr, callback):
box = gui.indentedBox(parent)
s = gui.spin(
box, self, attr, minv=2, maxv=10, label="Num. of intervals:",
callback=callback)
s.setMaximumWidth(60)
s.setAlignment(Qt.AlignRight)
gui.rubber(s.box)
return box.box
self.k_general = _intbox(self.left, "default_k",
self._default_disc_changed)
self.k_general.layout().setContentsMargins(0, 0, 0, 0)
def manual_cut_editline(text="", enabled=True) -> QLineEdit:
edit = QLineEdit(
text=text,
placeholderText="e.g. 0.0, 0.5, 1.0",
toolTip="Enter fixed discretization cut points (a comma "
"separated list of strictly increasing numbers e.g. "
"0.0, 0.5, 1.0).",
enabled=enabled,
)
@edit.textChanged.connect
def update():
validator = edit.validator()
if validator is not None:
state, _, _ = validator.validate(edit.text(), 0)
else:
state = QValidator.Acceptable
palette = edit.palette()
colors = {
QValidator.Intermediate: (Qt.yellow, Qt.black),
QValidator.Invalid: (Qt.red, Qt.black),
}.get(state, None)
if colors is None:
palette = QPalette()
else:
palette.setColor(QPalette.Base, colors[0])
palette.setColor(QPalette.Text, colors[1])
cr = edit.cursorRect()
p = edit.mapToGlobal(cr.bottomRight())
edit.setPalette(palette)
if state != QValidator.Acceptable and edit.isVisible():
show_tip(edit, p, edit.toolTip(), textFormat=Qt.RichText)
else:
show_tip(edit, p, "")
return edit
self.manual_cuts_edit = manual_cut_editline(
text=", ".join(map(str, self.default_cutpoints)),
enabled=self.default_method == Methods.Custom,
)
def set_manual_default_cuts():
text = self.manual_cuts_edit.text()
self.default_cutpoints = tuple(
float(s.strip()) for s in text.split(",") if s.strip())
self._default_disc_changed()
self.manual_cuts_edit.editingFinished.connect(set_manual_default_cuts)
validator = IncreasingNumbersListValidator()
self.manual_cuts_edit.setValidator(validator)
ibox = gui.indentedBox(right, orientation=Qt.Horizontal)
ibox.layout().addWidget(self.manual_cuts_edit)
right.layout().addStretch(10)
self.left.layout().addStretch(10)
self.connect_control(
"default_cutpoints",
lambda values: self.manual_cuts_edit.setText(", ".join(map(str, values)))
)
vlayout = QHBoxLayout()
box = gui.widgetBox(
self.controlArea, "Individual Attribute Settings",
orientation=vlayout, spacing=8
)
# List view with all attributes
self.varview = ListViewSearch(
selectionMode=QListView.ExtendedSelection,
uniformItemSizes=True,
)
self.varview.setItemDelegate(DiscDelegate())
self.varmodel = itemmodels.VariableListModel()
self.varview.setModel(self.varmodel)
self.varview.selectionModel().selectionChanged.connect(
self._var_selection_changed
)
vlayout.addWidget(self.varview)
# Controls for individual attr settings
self.bbox = controlbox = gui.radioButtons(
box, self, "method", callback=self._disc_method_changed
)
vlayout.addWidget(controlbox)
self.variable_button_group = bg = controlbox.findChild(QButtonGroup)
for id_, opt in self.options[:5]:
b = gui.appendRadioButton(controlbox, opt)
bg.setId(b, id_)
self.k_specific = _intbox(controlbox, "k", self._disc_method_changed)
gui.appendRadioButton(controlbox, "Remove attribute", id=Methods.Remove)
b = gui.appendRadioButton(controlbox, "Manual", id=Methods.Custom)
self.manual_cuts_specific = manual_cut_editline(
text=", ".join(map(str, self.cutpoints)),
enabled=self.method == Methods.Custom
)
self.manual_cuts_specific.setValidator(validator)
b.toggled[bool].connect(self.manual_cuts_specific.setEnabled)
def set_manual_cuts():
text = self.manual_cuts_specific.text()
points = [t for t in text.split(",") if t.split()]
self.cutpoints = tuple(float(t) for t in points)
self._disc_method_changed()
self.manual_cuts_specific.editingFinished.connect(set_manual_cuts)
self.connect_control(
"cutpoints",
lambda values: self.manual_cuts_specific.setText(", ".join(map(str, values)))
)
ibox = gui.indentedBox(controlbox, orientation=Qt.Horizontal)
self.copy_current_to_manual_button = b = FixedSizeButton(
text="CC", toolTip="Copy the current cut points to manual mode",
enabled=False
)
b.clicked.connect(self._copy_to_manual)
ibox.layout().addWidget(self.manual_cuts_specific)
ibox.layout().addWidget(b)
gui.rubber(controlbox)
controlbox.setEnabled(False)
bg.button(self.method)
self.controlbox = controlbox
gui.auto_apply(self.buttonsArea, self, "autosend")
self._update_spin_positions()
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, parent=None):
super().__init__(parent)
# Output changed flag
self._changed = False
# Diagram update is in progress
self._updating = False
# Input update is in progress
self._inputUpdate = False
# All input tables have the same domain.
self.samedomain = True
# Input datasets in the order they were 'connected'.
self.data = OrderedDict()
# Extracted input item sets in the order they were 'connected'
self.itemsets = OrderedDict()
# GUI
box = gui.widgetBox(self.controlArea, "Info")
self.info = gui.widgetLabel(box, "No data on input\n")
self.identifiersBox = gui.radioButtonsInBox(
self.controlArea,
self,
"useidentifiers", [],
box="Data Instance Identifiers",
callback=self._on_useidentifiersChanged)
self.useequalityButton = gui.appendRadioButton(
self.identifiersBox, "Use instance equality")
rb = gui.appendRadioButton(self.identifiersBox, "Use identifiers")
self.inputsBox = gui.indentedBox(self.identifiersBox,
sep=gui.checkButtonOffsetHint(rb))
self.inputsBox.setEnabled(bool(self.useidentifiers))
for i in range(5):
box = gui.widgetBox(self.inputsBox,
"Data set #%i" % (i + 1),
addSpace=False)
box.setFlat(True)
model = itemmodels.VariableListModel(parent=self)
cb = QComboBox()
cb.setModel(model)
cb.activated[int].connect(self._on_inputAttrActivated)
box.setEnabled(False)
# Store the combo in the box for later use.
box.combo_box = cb
box.layout().addWidget(cb)
gui.rubber(self.controlArea)
box = gui.widgetBox(self.controlArea, "Output")
cb = gui.checkBox(box, self, "autocommit", "Commit on any change")
b = gui.button(box, self, "Commit", callback=self.commit, default=True)
gui.setStopper(self, b, cb, "_changed", callback=self.commit)
# Main area view
self.scene = QGraphicsScene()
self.view = QGraphicsView(self.scene)
self.view.setRenderHint(QPainter.Antialiasing)
self.view.setBackgroundRole(QPalette.Window)
self.view.setFrameStyle(QGraphicsView.StyledPanel)
self.mainArea.layout().addWidget(self.view)
self.vennwidget = VennDiagram()
self.vennwidget.resize(400, 400)
self.vennwidget.itemTextEdited.connect(self._on_itemTextEdited)
self.scene.selectionChanged.connect(self._on_selectionChanged)
self.scene.addItem(self.vennwidget)
self.resize(self.controlArea.sizeHint().width() + 550,
max(self.controlArea.sizeHint().height(), 550))
self._queue = []
def __init__(self):
super().__init__()
self.data = None
self.indices = None
box = gui.widgetBox(self.controlArea, "Information")
self.dataInfoLabel = gui.widgetLabel(box, 'No data on input.')
self.outputInfoLabel = gui.widgetLabel(box, ' ')
box = gui.widgetBox(self.controlArea, "Sampling Type")
sampling = gui.radioButtons(box,
self,
"sampling_type",
callback=self.sampling_type_changed)
def set_sampling_type(i):
def f():
self.sampling_type = i
self.sampling_type_changed()
return f
gui.appendRadioButton(sampling, "Fixed sample size:")
ibox = gui.indentedBox(sampling)
self.sampleSizeSpin = gui.spin(ibox,
self,
"sampleSizeNumber",
label="Instances: ",
minv=1,
maxv=2**31 - 1,
callback=set_sampling_type(
self.FixedSize))
gui.checkBox(ibox,
self,
"replacement",
"Sample with replacement",
callback=set_sampling_type(self.FixedSize))
gui.separator(sampling, 12)
gui.appendRadioButton(sampling, "Fixed proportion of data:")
self.sampleSizePercentageSlider = gui.hSlider(
gui.indentedBox(sampling),
self,
"sampleSizePercentage",
minValue=0,
maxValue=100,
ticks=10,
labelFormat="%d %%",
callback=set_sampling_type(self.FixedProportion))
gui.separator(sampling, 12)
gui.appendRadioButton(sampling, "Cross Validation:")
form = QtGui.QFormLayout(
formAlignment=Qt.AlignLeft | Qt.AlignTop,
labelAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QtGui.QFormLayout.AllNonFixedFieldsGrow)
ibox = gui.indentedBox(sampling, addSpace=True, orientation=form)
form.addRow(
"Number of folds",
gui.spin(ibox,
self,
"number_of_folds",
2,
100,
addToLayout=False,
callback=self.number_of_folds_changed))
self.selected_fold_spin = gui.spin(ibox,
self,
"selectedFold",
1,
100,
addToLayout=False,
callback=self.fold_changed)
form.addRow("Selected fold", self.selected_fold_spin)
box = gui.widgetBox(self.controlArea, "Options")
gui.checkBox(box,
self,
"use_seed",
"Replicable (deterministic) sampling",
callback=self.settings_changed)
gui.checkBox(box,
self,
"stratify",
"Stratify sample (when possible)",
callback=self.settings_changed)
gui.button(self.controlArea, self, "Sample Data", callback=self.commit)
self.layout().setSizeConstraint(QtGui.QLayout.SetFixedSize)
def __init__(self):
super().__init__()
self.data = None
self.n_inliers = self.n_outliers = None
box = gui.vBox(self.controlArea, "Information")
self.data_info_label = gui.widgetLabel(box, self.data_info_default)
self.in_out_info_label = gui.widgetLabel(box, self.in_out_info_default)
box = gui.vBox(self.controlArea, "Outlier detection method")
detection = gui.radioButtons(box, self, "outlier_method")
gui.appendRadioButton(detection,
"One class SVM with non-linear kernel (RBF):")
ibox = gui.indentedBox(detection)
tooltip = "An upper bound on the fraction of training errors and a " \
"lower bound of the fraction of support vectors"
gui.widgetLabel(ibox, 'Nu:', tooltip=tooltip)
self.nu_slider = gui.hSlider(ibox,
self,
"nu",
minValue=1,
maxValue=100,
ticks=10,
labelFormat="%d %%",
callback=self.nu_changed,
tooltip=tooltip)
self.gamma_spin = gui.spin(ibox,
self,
"gamma",
label="Kernel coefficient:",
step=1e-2,
spinType=float,
minv=0.01,
maxv=10,
callback=self.gamma_changed)
gui.separator(detection, 12)
self.rb_cov = gui.appendRadioButton(detection, "Covariance estimator:")
ibox = gui.indentedBox(detection)
self.l_cov = gui.widgetLabel(ibox, 'Contamination:')
self.cont_slider = gui.hSlider(ibox,
self,
"cont",
minValue=0,
maxValue=100,
ticks=10,
labelFormat="%d %%",
callback=self.cont_changed)
ebox = gui.hBox(ibox)
self.cb_emp_cov = gui.checkBox(ebox,
self,
"empirical_covariance",
"Support fraction:",
callback=self.empirical_changed)
self.support_fraction_spin = gui.spin(
ebox,
self,
"support_fraction",
step=1e-1,
spinType=float,
minv=0.1,
maxv=10,
callback=self.support_fraction_changed)
gui.separator(detection, 12)
gui.button(self.buttonsArea,
self,
"Detect Outliers",
callback=self.commit)
self.layout().setSizeConstraint(QtGui.QLayout.SetFixedSize)
def __add_annotation_controls(self):
combo_options = {
"labelWidth": 50,
"orientation": Qt.Horizontal,
"searchable": True,
"sendSelectedValue": True,
"contentsLength": 14
}
box = gui.vBox(self.controlArea, box="Axes")
order = DomainModel.METAS, DomainModel.ATTRIBUTES, DomainModel.CLASSES
mod = DomainModel(order, valid_types=ContinuousVariable)
gui.comboBox(box,
self,
"attr_x",
label="Axis x:",
model=mod,
callback=self.__on_axis_attr_changed,
**combo_options)
gui.comboBox(box,
self,
"attr_y",
label="Axis y:",
model=mod,
callback=self.__on_axis_attr_changed,
**combo_options)
box = gui.vBox(self.controlArea, box="Annotation")
rbuttons = gui.radioButtons(box,
self,
"clustering_type",
callback=self.__on_clustering_type_changed)
gui.appendRadioButton(rbuttons, "DBSCAN")
self.dbscan_box = ibox = gui.indentedBox(rbuttons,
20,
orientation=Qt.Horizontal)
gui.checkBox(ibox,
self,
"use_epsilon",
"epsilon:",
labelWidth=80,
callback=self.__on_epsilon_check_changed)
gui.doubleSpin(ibox,
self,
"epsilon",
0.1,
10,
0.1,
callback=self.__on_epsilon_changed)
gui.appendRadioButton(rbuttons, "Gaussian mixture models")
self.gmm_box = ibox = gui.indentedBox(rbuttons,
20,
orientation=Qt.Horizontal)
gui.checkBox(ibox,
self,
"use_n_components",
"clusters:",
labelWidth=80,
callback=self.__on_n_components_check_changed)
gui.spin(ibox,
self,
"n_components",
1,
100,
callback=self.__on_n_components_changed)
gui.appendRadioButton(rbuttons, "From variable")
self.var_box = ibox = gui.indentedBox(rbuttons,
20,
orientation=Qt.Horizontal)
gui.comboBox(ibox,
self,
"cluster_var",
model=DomainModel(order, valid_types=DiscreteVariable),
callback=self.__on_cluster_var_changed,
**combo_options)
gui.doubleSpin(box,
self,
"p_threshold",
0,
1,
0.01,
label="FDR threshold:",
labelWidth=100,
callback=self.__on_fdr_threshold_changed)
def __init__(self):
super().__init__()
self.primary_data = None
self._more_data_input: List[Optional[Orange.data.Table]] = []
self.mergebox = gui.vBox(self.controlArea, "Variable Merging")
box = gui.radioButtons(self.mergebox,
self,
"merge_type",
callback=self._merge_type_changed)
gui.widgetLabel(
box,
self.tr("When there is no primary table, " +
"the output should contain:"))
for opts in self.domain_opts:
gui.appendRadioButton(box, self.tr(opts))
gui.separator(box)
label = gui.widgetLabel(
box,
self.tr("The resulting table will have a class only if there " +
"is no conflict between input classes."))
label.setWordWrap(True)
gui.separator(box)
gui.checkBox(
box,
self,
"ignore_compute_value",
"Treat variables with the same name as the same variable,\n"
"even if they are computed using different formulae.",
callback=self.commit.deferred,
stateWhenDisabled=False)
###
box = gui.vBox(
self.controlArea,
self.tr("Source Identification"),
)
cb = gui.checkBox(box,
self,
"append_source_column",
self.tr("Append data source IDs"),
callback=self._source_changed)
ibox = gui.indentedBox(box, sep=gui.checkButtonOffsetHint(cb))
form = QFormLayout(spacing=8,
labelAlignment=Qt.AlignLeft,
formAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QFormLayout.AllNonFixedFieldsGrow)
form.addRow(
self.tr("Feature name:"),
gui.lineEdit(ibox,
self,
"source_attr_name",
valueType=str,
callback=self._source_changed))
form.addRow(
self.tr("Place:"),
gui.comboBox(ibox,
self,
"source_column_role",
items=self.id_roles,
callback=self._source_changed))
ibox.layout().addLayout(form)
mleft, mtop, mright, _ = ibox.layout().getContentsMargins()
ibox.layout().setContentsMargins(mleft, mtop, mright, 4)
cb.disables.append(ibox)
cb.makeConsistent()
gui.auto_apply(self.buttonsArea, self, "auto_commit")
def __init__(self, parent=None):
super().__init__(parent)
self.data = None
self.preprocessors = None
box = gui.widgetBox(self.controlArea, self.tr("Name"))
gui.lineEdit(box, self, "learner_name")
form = QtGui.QGridLayout()
typebox = gui.radioButtonsInBox(
self.controlArea,
self,
"svmtype",
[],
box=self.tr("SVM Type"),
orientation=form,
)
c_svm = gui.appendRadioButton(typebox, "C-SVM", addToLayout=False)
form.addWidget(c_svm, 0, 0, Qt.AlignLeft)
form.addWidget(QtGui.QLabel(self.tr("Cost (C)")), 0, 1, Qt.AlignRight)
c_spin = gui.doubleSpin(typebox,
self,
"C",
0.1,
512.0,
0.1,
decimals=2,
addToLayout=False)
form.addWidget(c_spin, 0, 2)
nu_svm = gui.appendRadioButton(typebox, "ν-SVM", addToLayout=False)
form.addWidget(nu_svm, 1, 0, Qt.AlignLeft)
form.addWidget(QtGui.QLabel(self.trUtf8("Complexity bound (\u03bd)")),
1, 1, Qt.AlignRight)
nu_spin = gui.doubleSpin(typebox,
self,
"nu",
0.05,
1.0,
0.05,
decimals=2,
addToLayout=False)
form.addWidget(nu_spin, 1, 2)
box = gui.widgetBox(self.controlArea, self.tr("Kernel"))
buttonbox = gui.radioButtonsInBox(box,
self,
"kernel_type",
btnLabels=[
"Linear, x∙y",
"Polynomial, (g x∙y + c)^d",
"RBF, exp(-g|x-y|²)",
"Sigmoid, tanh(g x∙y + c)"
],
callback=self._on_kernel_changed)
parambox = gui.widgetBox(box, orientation="horizontal")
gamma = gui.doubleSpin(parambox,
self,
"gamma",
0.0,
10.0,
0.0001,
label=" g: ",
orientation="horizontal",
alignment=Qt.AlignRight)
coef0 = gui.doubleSpin(parambox,
self,
"coef0",
0.0,
10.0,
0.0001,
label=" c: ",
orientation="horizontal",
alignment=Qt.AlignRight)
degree = gui.doubleSpin(parambox,
self,
"degree",
0.0,
10.0,
0.5,
label=" d: ",
orientation="horizontal",
alignment=Qt.AlignRight)
self._kernel_params = [gamma, coef0, degree]
box = gui.widgetBox(self.controlArea, "Numerical Tolerance")
gui.doubleSpin(box, self, "tol", 1e-7, 1e-3, 5e-7)
gui.button(self.controlArea,
self,
"&Apply",
callback=self.apply,
default=True)
self.setSizePolicy(
QtGui.QSizePolicy(QtGui.QSizePolicy.Fixed,
QtGui.QSizePolicy.Fixed))
self.setMinimumWidth(300)
self._on_kernel_changed()
self.apply()
def __init__(self):
super().__init__()
#: input data
self.data = None
#: Current variable discretization state
self.var_state = {}
#: Saved variable discretization settings (context setting)
self.saved_var_states = {}
self.method = 0
self.k = 5
box = gui.vBox(self.controlArea, self.tr("Default Discretization"))
self.default_bbox = rbox = gui.radioButtons(
box, self, "default_method", callback=self._default_disc_changed)
rb = gui.hBox(rbox)
self.left = gui.vBox(rb)
right = gui.vBox(rb)
rb.layout().setStretch(0, 1)
rb.layout().setStretch(1, 1)
options = self.options = [
self.tr("Default"),
self.tr("Leave numeric"),
self.tr("Entropy-MDL discretization"),
self.tr("Equal-frequency discretization"),
self.tr("Equal-width discretization"),
self.tr("Remove numeric variables")
]
for opt in options[1:]:
t = gui.appendRadioButton(rbox, opt)
# This condition is ugly, but it keeps the same order of
# options for backward compatibility of saved schemata
[right, self.left][opt.startswith("Equal")].layout().addWidget(t)
gui.separator(right, 18, 18)
def _intbox(widget, attr, callback):
box = gui.indentedBox(widget)
s = gui.spin(
box, self, attr, minv=2, maxv=10, label="Num. of intervals:",
callback=callback)
s.setMaximumWidth(60)
s.setAlignment(Qt.AlignRight)
gui.rubber(s.box)
return box.box
self.k_general = _intbox(self.left, "default_k",
self._default_disc_changed)
self.k_general.layout().setContentsMargins(0, 0, 0, 0)
vlayout = QHBoxLayout()
box = gui.widgetBox(
self.controlArea, "Individual Attribute Settings",
orientation=vlayout, spacing=8
)
# List view with all attributes
self.varview = QListView(selectionMode=QListView.ExtendedSelection)
self.varview.setItemDelegate(DiscDelegate())
self.varmodel = itemmodels.VariableListModel()
self.varview.setModel(self.varmodel)
self.varview.selectionModel().selectionChanged.connect(
self._var_selection_changed
)
vlayout.addWidget(self.varview)
# Controls for individual attr settings
self.bbox = controlbox = gui.radioButtons(
box, self, "method", callback=self._disc_method_changed
)
vlayout.addWidget(controlbox)
for opt in options[:5]:
gui.appendRadioButton(controlbox, opt)
self.k_specific = _intbox(controlbox, "k", self._disc_method_changed)
gui.appendRadioButton(controlbox, "Remove attribute")
gui.rubber(controlbox)
controlbox.setEnabled(False)
self.controlbox = controlbox
box = gui.auto_commit(
self.controlArea, self, "autosend", "Apply",
orientation=Qt.Horizontal,
checkbox_label="Apply automatically")
box.layout().insertSpacing(0, 20)
box.layout().insertWidget(0, self.report_button)
self._update_spin_positions()
def __init__(self):
super().__init__()
self.primary_data = None
self.more_data = OrderedDict()
mergebox = gui.vBox(self.controlArea, "Domain Merging")
box = gui.radioButtons(
mergebox, self, "merge_type",
callback=self._merge_type_changed)
gui.widgetLabel(
box, self.tr("When there is no primary table, " +
"the domain should be:"))
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"))
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))
form.addRow(
self.tr("Place:"),
gui.comboBox(ibox, self, "source_column_role", items=self.id_roles)
)
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.data = None
self.indices = None
box = gui.widgetBox(self.controlArea, "Information")
self.dataInfoLabel = gui.widgetLabel(box, 'No data on input.')
self.outputInfoLabel = gui.widgetLabel(box, ' ')
self.sampling_box = gui.widgetBox(self.controlArea, "Sampling Type")
sampling = gui.radioButtons(self.sampling_box, self, "sampling_type",
callback=self.sampling_type_changed)
def set_sampling_type(i):
def f():
self.sampling_type = i
self.sampling_type_changed()
return f
gui.appendRadioButton(sampling, "Fixed proportion of data:")
self.sampleSizePercentageSlider = gui.hSlider(
gui.indentedBox(sampling), self,
"sampleSizePercentage",
minValue=0, maxValue=99, ticks=10, labelFormat="%d %%",
callback=set_sampling_type(self.FixedProportion))
gui.appendRadioButton(sampling, "Fixed sample size:")
ibox = gui.indentedBox(sampling)
self.sampleSizeSpin = gui.spin(
ibox, self, "sampleSizeNumber", label="Instances: ",
minv=1, maxv=2 ** 31 - 1,
callback=set_sampling_type(self.FixedSize))
gui.checkBox(
ibox, self, "replacement", "Sample with replacement",
callback=set_sampling_type(self.FixedSize))
gui.separator(sampling, 12)
gui.separator(sampling, 12)
gui.appendRadioButton(sampling, "Cross Validation:")
form = QtGui.QFormLayout(
formAlignment=Qt.AlignLeft | Qt.AlignTop,
labelAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QtGui.QFormLayout.AllNonFixedFieldsGrow)
ibox = gui.indentedBox(sampling, addSpace=True, orientation=form)
form.addRow("Number of folds",
gui.spin(
ibox, self, "number_of_folds", 2, 100,
addToLayout=False,
callback=self.number_of_folds_changed))
self.selected_fold_spin = gui.spin(
ibox, self, "selectedFold", 1, self.number_of_folds,
addToLayout=False, callback=self.fold_changed)
form.addRow("Selected fold", self.selected_fold_spin)
self.sql_box = gui.widgetBox(self.controlArea, "Sampling Type")
sampling = gui.radioButtons(self.sql_box, self, "sampling_type",
callback=self.sampling_type_changed)
gui.appendRadioButton(sampling, "Time:")
ibox = gui.indentedBox(sampling)
spin = gui.spin(ibox, self, "sampleSizeSqlTime", minv=1, maxv=3600,
callback=set_sampling_type(self.SqlTime))
spin.setSuffix(" sec")
gui.appendRadioButton(sampling, "Percentage")
ibox = gui.indentedBox(sampling)
spin = gui.spin(ibox, self, "sampleSizeSqlPercentage", spinType=float,
minv=0.0001, maxv=100, step=0.1, decimals=4,
callback=set_sampling_type(self.SqlProportion))
spin.setSuffix(" %")
self.sql_box.setVisible(False)
self.options_box = gui.widgetBox(self.controlArea, "Options")
self.cb_seed = gui.checkBox(
self.options_box, self, "use_seed",
"Replicable (deterministic) sampling",
callback=self.settings_changed)
self.cb_stratify = gui.checkBox(
self.options_box, self, "stratify",
"Stratify sample (when possible)", callback=self.settings_changed)
self.cb_sql_dl = gui.checkBox(
self.options_box, self, "sql_dl", "Download data to local memory",
callback=self.settings_changed)
self.cb_sql_dl.setVisible(False)
gui.button(self.controlArea, self, "Sample Data",
callback=self.commit)
def __init__(self):
super().__init__()
RecentPathsWComboMixin.__init__(self)
self.domain = None
self.data = None
self.loaded_file = ""
self.reader = None
layout = QGridLayout()
gui.widgetBox(self.controlArea, margin=0, orientation=layout)
vbox = gui.radioButtons(None,
self,
"source",
box=True,
addSpace=True,
callback=self.load_data,
addToLayout=False)
rb_button = gui.appendRadioButton(vbox, "File:", addToLayout=False)
layout.addWidget(rb_button, 0, 0, Qt.AlignVCenter)
box = gui.hBox(None, addToLayout=False, margin=0)
box.setSizePolicy(Policy.MinimumExpanding, Policy.Fixed)
self.file_combo.setSizePolicy(Policy.MinimumExpanding, Policy.Fixed)
self.file_combo.activated[int].connect(self.select_file)
box.layout().addWidget(self.file_combo)
layout.addWidget(box, 0, 1)
file_button = gui.button(None,
self,
'...',
callback=self.browse_file,
autoDefault=False)
file_button.setIcon(self.style().standardIcon(QStyle.SP_DirOpenIcon))
file_button.setSizePolicy(Policy.Maximum, Policy.Fixed)
layout.addWidget(file_button, 0, 2)
reload_button = gui.button(None,
self,
"Reload",
callback=self.load_data,
autoDefault=False)
reload_button.setIcon(self.style().standardIcon(
QStyle.SP_BrowserReload))
reload_button.setSizePolicy(Policy.Fixed, Policy.Fixed)
layout.addWidget(reload_button, 0, 3)
self.sheet_box = gui.hBox(None, addToLayout=False, margin=0)
self.sheet_combo = gui.comboBox(
None,
self,
"xls_sheet",
callback=self.select_sheet,
sendSelectedValue=True,
)
self.sheet_combo.setSizePolicy(Policy.MinimumExpanding, Policy.Fixed)
self.sheet_label = QLabel()
self.sheet_label.setText('Sheet')
self.sheet_label.setSizePolicy(Policy.MinimumExpanding, Policy.Fixed)
self.sheet_box.layout().addWidget(self.sheet_label, Qt.AlignLeft)
self.sheet_box.layout().addWidget(self.sheet_combo, Qt.AlignVCenter)
layout.addWidget(self.sheet_box, 2, 1)
self.sheet_box.hide()
rb_button = gui.appendRadioButton(vbox, "URL:", addToLayout=False)
layout.addWidget(rb_button, 3, 0, Qt.AlignVCenter)
self.url_combo = url_combo = QComboBox()
url_model = NamedURLModel(self.sheet_names)
url_model.wrap(self.recent_urls)
url_combo.setLineEdit(LineEditSelectOnFocus())
url_combo.setModel(url_model)
url_combo.setSizePolicy(Policy.Ignored, 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)
# whit completer we set that combo box is case sensitive when
# matching the history
completer = QCompleter()
completer.setCaseSensitivity(Qt.CaseSensitive)
url_combo.setCompleter(completer)
box = gui.vBox(self.controlArea, "Info")
self.infolabel = gui.widgetLabel(box, 'No data loaded.')
self.warnings = gui.widgetLabel(box, '')
box = gui.widgetBox(self.controlArea, "Columns (Double click to edit)")
self.domain_editor = DomainEditor(self)
self.editor_model = self.domain_editor.model()
box.layout().addWidget(self.domain_editor)
box = gui.hBox(self.controlArea)
gui.button(box,
self,
"Browse documentation datasets",
callback=lambda: self.browse_file(True),
autoDefault=False)
gui.rubber(box)
gui.button(box, self, "Reset", callback=self.reset_domain_edit)
self.apply_button = gui.button(box,
self,
"Apply",
callback=self.apply_domain_edit)
self.apply_button.setEnabled(False)
self.apply_button.setFixedWidth(170)
self.editor_model.dataChanged.connect(
lambda: self.apply_button.setEnabled(True))
self.set_file_list()
# Must not call open_file from within __init__. open_file
# explicitly re-enters the event loop (by a progress bar)
self.setAcceptDrops(True)
if self.source == self.LOCAL_FILE:
last_path = self.last_path()
if last_path and os.path.exists(last_path) and \
os.path.getsize(last_path) > self.SIZE_LIMIT:
self.Warning.file_too_big()
return
QTimer.singleShot(0, self.load_data)
def __init__(self):
super().__init__()
#: input data
self.data = None
#: Current variable discretization state
self.var_state = {}
#: Saved variable discretization settings (context setting)
self.saved_var_states = {}
self.method = 0
self.k = 5
box = gui.vBox(self.controlArea, self.tr("Default Discretization"))
self.default_bbox = rbox = gui.radioButtons(
box, self, "default_method", callback=self._default_disc_changed)
rb = gui.hBox(rbox)
self.left = gui.vBox(rb)
right = gui.vBox(rb)
rb.layout().setStretch(0, 1)
rb.layout().setStretch(1, 1)
options = self.options = [
self.tr("Default"),
self.tr("Leave numeric"),
self.tr("Entropy-MDL discretization"),
self.tr("Equal-frequency discretization"),
self.tr("Equal-width discretization"),
self.tr("Remove numeric variables")
]
for opt in options[1:]:
t = gui.appendRadioButton(rbox, opt)
# This condition is ugly, but it keeps the same order of
# options for backward compatibility of saved schemata
[right, self.left][opt.startswith("Equal")].layout().addWidget(t)
gui.separator(right, 18, 18)
def _intbox(widget, attr, callback):
box = gui.indentedBox(widget)
s = gui.spin(box,
self,
attr,
minv=2,
maxv=10,
label="Num. of intervals:",
callback=callback)
s.setMaximumWidth(60)
s.setAlignment(Qt.AlignRight)
gui.rubber(s.box)
return box.box
self.k_general = _intbox(self.left, "default_k",
self._default_disc_changed)
self.k_general.layout().setContentsMargins(0, 0, 0, 0)
vlayout = QHBoxLayout()
box = gui.widgetBox(self.controlArea,
"Individual Attribute Settings",
orientation=vlayout,
spacing=8)
# List view with all attributes
self.varview = QListView(selectionMode=QListView.ExtendedSelection)
self.varview.setItemDelegate(DiscDelegate())
self.varmodel = itemmodels.VariableListModel()
self.varview.setModel(self.varmodel)
self.varview.selectionModel().selectionChanged.connect(
self._var_selection_changed)
vlayout.addWidget(self.varview)
# Controls for individual attr settings
self.bbox = controlbox = gui.radioButtons(
box, self, "method", callback=self._disc_method_changed)
vlayout.addWidget(controlbox)
for opt in options[:5]:
gui.appendRadioButton(controlbox, opt)
self.k_specific = _intbox(controlbox, "k", self._disc_method_changed)
gui.appendRadioButton(controlbox, "Remove attribute")
gui.rubber(controlbox)
controlbox.setEnabled(False)
self.controlbox = controlbox
box = gui.auto_commit(self.controlArea,
self,
"autosend",
"Apply",
orientation=Qt.Horizontal,
checkbox_label="Apply automatically")
box.layout().insertSpacing(0, 20)
box.layout().insertWidget(0, self.report_button)
self._update_spin_positions()
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__()
#: input data
self.data = None
#: Current variable discretization state
self.var_state = {}
#: Saved variable discretization settings (context setting)
self.saved_var_states = {}
self.method = 0
self.k = 5
box = gui.vBox(self.controlArea, self.tr("Default Discretization"))
self.default_bbox = rbox = gui.radioButtons(
box, self, "default_method", callback=self._default_disc_changed)
options = self.options = [
self.tr("Default"),
self.tr("Leave numeric"),
self.tr("Entropy-MDL discretization"),
self.tr("Equal-frequency discretization"),
self.tr("Equal-width discretization"),
self.tr("Remove numeric variables")
]
for opt in options[1:5]:
gui.appendRadioButton(rbox, opt)
s = gui.hSlider(gui.indentedBox(rbox),
self, "default_k", minValue=2, maxValue=10,
label="Num. of intervals:",
callback=self._default_disc_changed)
s.setTracking(False)
gui.appendRadioButton(rbox, options[-1])
vlayout = QHBoxLayout()
box = gui.widgetBox(
self.controlArea, "Individual Attribute Settings",
orientation=vlayout, spacing=8
)
# List view with all attributes
self.varview = QListView(selectionMode=QListView.ExtendedSelection)
self.varview.setItemDelegate(DiscDelegate())
self.varmodel = itemmodels.VariableListModel()
self.varview.setModel(self.varmodel)
self.varview.selectionModel().selectionChanged.connect(
self._var_selection_changed
)
vlayout.addWidget(self.varview)
# Controls for individual attr settings
self.bbox = controlbox = gui.radioButtons(
box, self, "method", callback=self._disc_method_changed
)
vlayout.addWidget(controlbox)
for opt in options[:5]:
gui.appendRadioButton(controlbox, opt)
s = gui.hSlider(gui.indentedBox(controlbox),
self, "k", minValue=2, maxValue=10,
label="Num. of intervals:",
callback=self._disc_method_changed)
s.setTracking(False)
gui.appendRadioButton(controlbox, "Remove attribute")
gui.rubber(controlbox)
controlbox.setEnabled(False)
self.controlbox = controlbox
box = gui.auto_commit(
self.controlArea, self, "autosend", "Apply",
orientation=Qt.Horizontal,
checkbox_label="Send data after every change")
box.layout().insertSpacing(0, 20)
box.layout().insertWidget(0, self.report_button)
def __init__(self):
super().__init__()
self.instances = None
self.domain = None
self.data = None
self.classifier = None
self.align = OWNomogram.ALIGN_ZERO
self.log_odds_ratios = []
self.log_reg_coeffs = []
self.log_reg_coeffs_orig = []
self.log_reg_cont_data_extremes = []
self.p = None
self.b0 = None
self.points = []
self.feature_items = {}
self.feature_marker_values = []
self.scale_marker_values = lambda x: x
self.nomogram_main = None
self.vertical_line = None
self.hidden_vertical_line = None
self.old_target_class_index = self.target_class_index
self.repaint = False
# GUI
box = gui.vBox(self.controlArea, "目标类")
self.class_combo = gui.comboBox(
box, self, "target_class_index", callback=self._class_combo_changed,
contentsLength=12)
self.norm_check = gui.checkBox(
box, self, "normalize_probabilities", "Normalize probabilities",
hidden=True, callback=self.update_scene,
tooltip="For multiclass data 1 vs. all probabilities do not"
" sum to 1 and therefore could be normalized.")
self.scale_radio = gui.radioButtons(
self.controlArea, self, "scale", ["点量表", "记录比值比"],
box="规模", callback=self.update_scene)
box = gui.vBox(self.controlArea, "显示特征")
grid = QGridLayout()
radio_group = gui.radioButtonsInBox(
box, self, "display_index", [], orientation=grid,
callback=self.update_scene)
radio_all = gui.appendRadioButton(
radio_group, "所有", addToLayout=False)
radio_best = gui.appendRadioButton(
radio_group, "最佳排名:", addToLayout=False)
spin_box = gui.hBox(None, margin=0)
self.n_spin = gui.spin(
spin_box, self, "n_attributes", 1, self.MAX_N_ATTRS, label=" ",
controlWidth=60, callback=self._n_spin_changed)
grid.addWidget(radio_all, 1, 1)
grid.addWidget(radio_best, 2, 1)
grid.addWidget(spin_box, 2, 2)
self.sort_combo = gui.comboBox(
box, self, "sort_index", label="排名靠前:", items=SortBy.items(),
orientation=Qt.Horizontal, callback=self.update_scene)
self.cont_feature_dim_combo = gui.comboBox(
box, self, "cont_feature_dim_index", label="数字特征: ",
items=["1维投影", "二维曲线"], orientation=Qt.Horizontal,
callback=self.update_scene)
gui.rubber(self.controlArea)
class _GraphicsView(QGraphicsView):
def __init__(self, scene, parent, **kwargs):
for k, v in dict(verticalScrollBarPolicy=Qt.ScrollBarAlwaysOff,
horizontalScrollBarPolicy=Qt.ScrollBarAlwaysOff,
viewportUpdateMode=QGraphicsView.BoundingRectViewportUpdate,
renderHints=(QPainter.Antialiasing |
QPainter.TextAntialiasing |
QPainter.SmoothPixmapTransform),
alignment=(Qt.AlignTop |
Qt.AlignLeft),
sizePolicy=QSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.MinimumExpanding)).items():
kwargs.setdefault(k, v)
super().__init__(scene, parent, **kwargs)
class GraphicsView(_GraphicsView):
def __init__(self, scene, parent):
super().__init__(scene, parent,
verticalScrollBarPolicy=Qt.ScrollBarAlwaysOn,
styleSheet='QGraphicsView {background: white}')
self.viewport().setMinimumWidth(300) # XXX: This prevents some tests failing
self._is_resizing = False
w = self
def resizeEvent(self, resizeEvent):
# Recompute main scene on window width change
if resizeEvent.size().width() != resizeEvent.oldSize().width():
self._is_resizing = True
self.w.update_scene()
self._is_resizing = False
return super().resizeEvent(resizeEvent)
def is_resizing(self):
return self._is_resizing
def sizeHint(self):
return QSize(400, 200)
class FixedSizeGraphicsView(_GraphicsView):
def __init__(self, scene, parent):
super().__init__(scene, parent,
sizePolicy=QSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.Minimum))
def sizeHint(self):
return QSize(400, 85)
scene = self.scene = QGraphicsScene(self)
top_view = self.top_view = FixedSizeGraphicsView(scene, self)
mid_view = self.view = GraphicsView(scene, self)
bottom_view = self.bottom_view = FixedSizeGraphicsView(scene, self)
for view in (top_view, mid_view, bottom_view):
self.mainArea.layout().addWidget(view)
def __init__(self):
super().__init__()
RecentPathsWComboMixin.__init__(self)
self.domain = None
self.data = None
self.loaded_file = ""
self.reader = None
layout = QGridLayout()
gui.widgetBox(self.controlArea, margin=0, orientation=layout)
vbox = gui.radioButtons(None, self, "source", box=True, addSpace=True,
callback=self.load_data, addToLayout=False)
rb_button = gui.appendRadioButton(vbox, "File:", addToLayout=False)
layout.addWidget(rb_button, 0, 0, Qt.AlignVCenter)
box = gui.hBox(None, addToLayout=False, margin=0)
box.setSizePolicy(Policy.MinimumExpanding, Policy.Fixed)
self.file_combo.setSizePolicy(Policy.MinimumExpanding, Policy.Fixed)
self.file_combo.activated[int].connect(self.select_file)
box.layout().addWidget(self.file_combo)
layout.addWidget(box, 0, 1)
file_button = gui.button(
None, self, '...', callback=self.browse_file, autoDefault=False)
file_button.setIcon(self.style().standardIcon(QStyle.SP_DirOpenIcon))
file_button.setSizePolicy(Policy.Maximum, Policy.Fixed)
layout.addWidget(file_button, 0, 2)
reload_button = gui.button(
None, self, "Reload", callback=self.load_data, autoDefault=False)
reload_button.setIcon(self.style().standardIcon(
QStyle.SP_BrowserReload))
reload_button.setSizePolicy(Policy.Fixed, Policy.Fixed)
layout.addWidget(reload_button, 0, 3)
self.sheet_box = gui.hBox(None, addToLayout=False, margin=0)
self.sheet_combo = gui.comboBox(None, self, "xls_sheet",
callback=self.select_sheet,
sendSelectedValue=True,)
self.sheet_combo.setSizePolicy(
Policy.MinimumExpanding, Policy.Fixed)
self.sheet_label = QLabel()
self.sheet_label.setText('Sheet')
self.sheet_label.setSizePolicy(
Policy.MinimumExpanding, Policy.Fixed)
self.sheet_box.layout().addWidget(
self.sheet_label, Qt.AlignLeft)
self.sheet_box.layout().addWidget(
self.sheet_combo, Qt.AlignVCenter)
layout.addWidget(self.sheet_box, 2, 1)
self.sheet_box.hide()
rb_button = gui.appendRadioButton(vbox, "URL:", addToLayout=False)
layout.addWidget(rb_button, 3, 0, Qt.AlignVCenter)
self.url_combo = url_combo = QComboBox()
url_model = NamedURLModel(self.sheet_names)
url_model.wrap(self.recent_urls)
url_combo.setLineEdit(LineEditSelectOnFocus())
url_combo.setModel(url_model)
url_combo.setSizePolicy(Policy.MinimumExpanding, Policy.Fixed)
url_combo.setEditable(True)
url_combo.setInsertPolicy(url_combo.InsertAtTop)
url_edit = url_combo.lineEdit()
l, t, r, b = url_edit.getTextMargins()
url_edit.setTextMargins(l + 5, t, r, b)
layout.addWidget(url_combo, 3, 1, 3, 3)
url_combo.activated.connect(self._url_set)
box = gui.vBox(self.controlArea, "Info")
self.infolabel = gui.widgetLabel(box, 'No data loaded.')
self.warnings = gui.widgetLabel(box, '')
box = gui.widgetBox(self.controlArea, "Columns (Double click to edit)")
self.domain_editor = DomainEditor(self)
self.editor_model = self.domain_editor.model()
box.layout().addWidget(self.domain_editor)
box = gui.hBox(self.controlArea)
gui.button(
box, self, "Browse documentation datasets",
callback=lambda: self.browse_file(True), autoDefault=False)
gui.rubber(box)
gui.button(
box, self, "Reset", callback=self.reset_domain_edit)
self.apply_button = gui.button(
box, self, "Apply", callback=self.apply_domain_edit)
self.apply_button.setEnabled(False)
self.apply_button.setFixedWidth(170)
self.editor_model.dataChanged.connect(
lambda: self.apply_button.setEnabled(True))
self.set_file_list()
# Must not call open_file from within __init__. open_file
# explicitly re-enters the event loop (by a progress bar)
self.setAcceptDrops(True)
if self.source == self.LOCAL_FILE:
last_path = self.last_path()
if last_path and os.path.exists(last_path) and \
os.path.getsize(last_path) > self.SIZE_LIMIT:
self.Warning.file_too_big()
return
QTimer.singleShot(0, self.load_data)
def __init__(self):
super().__init__()
self.instances = None
self.domain = None
self.data = None
self.classifier = None
self.align = OWNomogram.ALIGN_ZERO
self.log_odds_ratios = []
self.log_reg_coeffs = []
self.log_reg_coeffs_orig = []
self.log_reg_cont_data_extremes = []
self.p = None
self.b0 = None
self.points = []
self.feature_items = {}
self.feature_marker_values = []
self.scale_marker_values = lambda x: x
self.nomogram_main = None
self.vertical_line = None
self.hidden_vertical_line = None
self.old_target_class_index = self.target_class_index
self.repaint = False
# GUI
box = gui.vBox(self.controlArea, "Target class")
self.class_combo = gui.comboBox(
box, self, "target_class_index", callback=self._class_combo_changed,
contentsLength=12)
self.norm_check = gui.checkBox(
box, self, "normalize_probabilities", "Normalize probabilities",
hidden=True, callback=self.update_scene,
tooltip="For multiclass data 1 vs. all probabilities do not"
" sum to 1 and therefore could be normalized.")
self.scale_radio = gui.radioButtons(
self.controlArea, self, "scale", ["Point scale", "Log odds ratios"],
box="Scale", callback=self.update_scene)
box = gui.vBox(self.controlArea, "Display features")
grid = QGridLayout()
radio_group = gui.radioButtonsInBox(
box, self, "display_index", [], orientation=grid,
callback=self.update_scene)
radio_all = gui.appendRadioButton(
radio_group, "All", addToLayout=False)
radio_best = gui.appendRadioButton(
radio_group, "Best ranked:", addToLayout=False)
spin_box = gui.hBox(None, margin=0)
self.n_spin = gui.spin(
spin_box, self, "n_attributes", 1, self.MAX_N_ATTRS, label=" ",
controlWidth=60, callback=self._n_spin_changed)
grid.addWidget(radio_all, 1, 1)
grid.addWidget(radio_best, 2, 1)
grid.addWidget(spin_box, 2, 2)
self.sort_combo = gui.comboBox(
box, self, "sort_index", label="Rank by:", items=SortBy.items(),
orientation=Qt.Horizontal, callback=self.update_scene)
self.cont_feature_dim_combo = gui.comboBox(
box, self, "cont_feature_dim_index", label="Numeric features: ",
items=["1D projection", "2D curve"], orientation=Qt.Horizontal,
callback=self.update_scene)
gui.rubber(self.controlArea)
class _GraphicsView(QGraphicsView):
def __init__(self, scene, parent, **kwargs):
for k, v in dict(verticalScrollBarPolicy=Qt.ScrollBarAlwaysOff,
horizontalScrollBarPolicy=Qt.ScrollBarAlwaysOff,
viewportUpdateMode=QGraphicsView.BoundingRectViewportUpdate,
renderHints=(QPainter.Antialiasing |
QPainter.TextAntialiasing |
QPainter.SmoothPixmapTransform),
alignment=(Qt.AlignTop |
Qt.AlignLeft),
sizePolicy=QSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.MinimumExpanding)).items():
kwargs.setdefault(k, v)
super().__init__(scene, parent, **kwargs)
class GraphicsView(_GraphicsView):
def __init__(self, scene, parent):
super().__init__(scene, parent,
verticalScrollBarPolicy=Qt.ScrollBarAlwaysOn,
styleSheet='QGraphicsView {background: white}')
self.viewport().setMinimumWidth(300) # XXX: This prevents some tests failing
self._is_resizing = False
w = self
def resizeEvent(self, resizeEvent):
# Recompute main scene on window width change
if resizeEvent.size().width() != resizeEvent.oldSize().width():
self._is_resizing = True
self.w.update_scene()
self._is_resizing = False
return super().resizeEvent(resizeEvent)
def is_resizing(self):
return self._is_resizing
def sizeHint(self):
return QSize(400, 200)
class FixedSizeGraphicsView(_GraphicsView):
def __init__(self, scene, parent):
super().__init__(scene, parent,
sizePolicy=QSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.Minimum))
def sizeHint(self):
return QSize(400, 85)
scene = self.scene = QGraphicsScene(self)
top_view = self.top_view = FixedSizeGraphicsView(scene, self)
mid_view = self.view = GraphicsView(scene, self)
bottom_view = self.bottom_view = FixedSizeGraphicsView(scene, self)
for view in (top_view, mid_view, bottom_view):
self.mainArea.layout().addWidget(view)
def __init__(self):
super().__init__()
RecentPathsWComboMixin.__init__(self)
self.domain = None
self.data = None
self.loaded_file = ""
layout = QtGui.QGridLayout()
gui.widgetBox(self.controlArea, margin=0, orientation=layout)
vbox = gui.radioButtons(None,
self,
"source",
box=True,
addSpace=True,
callback=self.load_data,
addToLayout=False)
rb_button = gui.appendRadioButton(vbox, "File", addToLayout=False)
layout.addWidget(rb_button, 0, 0, QtCore.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(
QtGui.QStyle.SP_DirOpenIcon))
file_button.setSizePolicy(Policy.Maximum, Policy.Fixed)
layout.addWidget(file_button, 0, 2)
reload_button = gui.button(None,
self,
"Reload",
callback=self.reload,
autoDefault=False)
reload_button.setIcon(self.style().standardIcon(
QtGui.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.load_data,
sendSelectedValue=True)
self.sheet_combo.setSizePolicy(Policy.MinimumExpanding, Policy.Fixed)
self.sheet_label = QtGui.QLabel()
self.sheet_label.setText('Sheet')
self.sheet_label.setSizePolicy(Policy.MinimumExpanding, Policy.Fixed)
self.sheet_box.layout().addWidget(self.sheet_label,
QtCore.Qt.AlignLeft)
self.sheet_box.layout().addWidget(self.sheet_combo,
QtCore.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, QtCore.Qt.AlignVCenter)
self.url_combo = url_combo = QtGui.QComboBox()
url_model = NamedURLModel(self.sheet_names)
url_model.wrap(self.recent_urls)
url_combo.setModel(url_model)
url_combo.setSizePolicy(Policy.MinimumExpanding, Policy.Fixed)
url_combo.setMaximumWidth(500)
url_combo.setEditable(True)
url_combo.setInsertPolicy(url_combo.InsertAtTop)
url_edit = url_combo.lineEdit()
l, t, r, b = url_edit.getTextMargins()
url_edit.setTextMargins(l + 5, t, r, b)
layout.addWidget(url_combo, 3, 1, 3, 3)
url_combo.activated.connect(self._url_set)
box = gui.vBox(self.controlArea, "Info")
self.info = gui.widgetLabel(box, 'No data loaded.')
self.warnings = gui.widgetLabel(box, '')
box = gui.hBox(self.controlArea)
gui.button(box,
self,
"Browse documentation data sets",
callback=lambda: self.browse_file(True),
autoDefault=False)
gui.rubber(box)
box.layout().addWidget(self.report_button)
self.report_button.setFixedWidth(170)
# Set word wrap, so long warnings won't expand the widget
self.warnings.setWordWrap(True)
self.warnings.setSizePolicy(Policy.Ignored, Policy.MinimumExpanding)
self.set_file_list()
if self.last_path() is not None:
self.fill_sheet_combo(self.last_path())
# Must not call open_file from within __init__. open_file
# explicitly re-enters the event loop (by a progress bar)
QtCore.QTimer.singleShot(0, self.load_data)
def __init__(self, parent=None):
super().__init__(parent)
self.data = None
self.preprocessors = None
box = gui.widgetBox(self.controlArea, self.tr("Name"))
gui.lineEdit(box, self, "learner_name")
form = QGridLayout()
typebox = gui.radioButtonsInBox(
self.controlArea, self, "svrtype", [],
box=self.tr("SVM Regression Type"),
orientation=form,
)
eps_svr = gui.appendRadioButton(typebox, "ε-SVR", addToLayout=False)
form.addWidget(eps_svr, 0, 0, Qt.AlignLeft)
form.addWidget(QtGui.QLabel(self.tr("Cost (C)")), 0, 1, Qt.AlignRight)
c_spin = gui.doubleSpin(
typebox, self, "epsilon_C", 0.1, 512.0, 0.1,
decimals=2, addToLayout=False
)
form.addWidget(c_spin, 0, 2)
form.addWidget(QLabel("Loss Epsilon (ε)"), 1, 1, Qt.AlignRight)
eps_spin = gui.doubleSpin(
typebox, self, "epsilon", 0.1, 512.0, 0.1,
decimals=2, addToLayout=False
)
form.addWidget(eps_spin, 1, 2)
nu_svr = gui.appendRadioButton(typebox, "ν-SVR", addToLayout=False)
form.addWidget(nu_svr, 2, 0, Qt.AlignLeft)
form.addWidget(QLabel(self.tr("Cost (C)")), 2, 1, Qt.AlignRight)
c_spin = gui.doubleSpin(
typebox, self, "nu_C", 0.1, 512.0, 0.1,
decimals=2, addToLayout=False
)
form.addWidget(c_spin, 2, 2)
form.addWidget(QLabel("Complexity bound (ν)"),
3, 1, Qt.AlignRight)
nu_spin = gui.doubleSpin(
typebox, self, "nu", 0.05, 1.0, 0.05,
decimals=2, addToLayout=False
)
form.addWidget(nu_spin, 3, 2)
# Kernel control
box = gui.widgetBox(self.controlArea, self.tr("Kernel"))
buttonbox = gui.radioButtonsInBox(
box, self, "kernel_type",
btnLabels=["Linear, x∙y",
"Polynomial, (g x∙y + c)^d",
"RBF, exp(-g|x-y|²)",
"Sigmoid, tanh(g x∙y + c)"],
callback=self._on_kernel_changed
)
parambox = gui.widgetBox(box, orientation="horizontal")
gamma = gui.doubleSpin(
parambox, self, "gamma", 0.0, 10.0, 0.0001,
label=" g: ", orientation="horizontal",
alignment=Qt.AlignRight
)
coef0 = gui.doubleSpin(
parambox, self, "coef0", 0.0, 10.0, 0.0001,
label=" c: ", orientation="horizontal",
alignment=Qt.AlignRight
)
degree = gui.doubleSpin(
parambox, self, "degree", 0.0, 10.0, 0.5,
label=" d: ", orientation="horizontal",
alignment=Qt.AlignRight
)
self._kernel_params = [gamma, coef0, degree]
# Numerical tolerance control
box = gui.widgetBox(self.controlArea, "Numerical Tolerance")
gui.doubleSpin(box, self, "tol", 1e-7, 1e-3, 5e-7)
gui.button(self.controlArea, self, "&Apply",
callback=self.apply, default=True)
self.setSizePolicy(
QtGui.QSizePolicy(QtGui.QSizePolicy.Fixed,
QtGui.QSizePolicy.Fixed)
)
self.setMinimumWidth(300)
self._on_kernel_changed()
self.apply()
def __init__(self):
super().__init__()
if self.compatibility_mode:
self.Information.compatibility_mode()
self.data = None
self.indices = None
self.sampled_instances = self.remaining_instances = None
self.info.set_input_summary(self.info.NoInput)
self.info.set_output_summary(self.info.NoInput)
self.sampling_box = gui.vBox(self.controlArea, "Sampling Type")
sampling = gui.radioButtons(self.sampling_box,
self,
"sampling_type",
callback=self.sampling_type_changed)
def set_sampling_type(i):
def set_sampling_type_i():
self.sampling_type = i
self.sampling_type_changed()
return set_sampling_type_i
gui.appendRadioButton(sampling, "Fixed proportion of data:")
self.sampleSizePercentageSlider = gui.hSlider(
gui.indentedBox(sampling),
self,
"sampleSizePercentage",
minValue=0,
maxValue=100,
ticks=10,
labelFormat="%d %%",
callback=set_sampling_type(self.FixedProportion),
addSpace=12)
gui.appendRadioButton(sampling, "Fixed sample size")
ibox = gui.indentedBox(sampling)
self.sampleSizeSpin = gui.spin(ibox,
self,
"sampleSizeNumber",
label="Instances: ",
minv=1,
maxv=self._MAX_SAMPLE_SIZE,
callback=set_sampling_type(
self.FixedSize),
controlWidth=90)
gui.checkBox(ibox,
self,
"replacement",
"Sample with replacement",
callback=set_sampling_type(self.FixedSize),
addSpace=12)
gui.appendRadioButton(sampling, "Cross validation")
form = QFormLayout(formAlignment=Qt.AlignLeft | Qt.AlignTop,
labelAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QFormLayout.AllNonFixedFieldsGrow)
ibox = gui.indentedBox(sampling, addSpace=True, orientation=form)
form.addRow(
"Number of subsets:",
gui.spin(ibox,
self,
"number_of_folds",
2,
100,
addToLayout=False,
callback=self.number_of_folds_changed))
self.selected_fold_spin = gui.spin(ibox,
self,
"selectedFold",
1,
self.number_of_folds,
addToLayout=False,
callback=self.fold_changed)
form.addRow(
"Unused subset:" if not self.compatibility_mode else
"Selected subset:", self.selected_fold_spin)
gui.appendRadioButton(sampling, "Bootstrap")
self.sql_box = gui.vBox(self.controlArea, "Sampling Type")
sampling = gui.radioButtons(self.sql_box,
self,
"sampling_type",
callback=self.sampling_type_changed)
gui.appendRadioButton(sampling, "Time:")
ibox = gui.indentedBox(sampling)
spin = gui.spin(ibox,
self,
"sampleSizeSqlTime",
minv=1,
maxv=3600,
callback=set_sampling_type(self.SqlTime))
spin.setSuffix(" sec")
gui.appendRadioButton(sampling, "Percentage")
ibox = gui.indentedBox(sampling)
spin = gui.spin(ibox,
self,
"sampleSizeSqlPercentage",
spinType=float,
minv=0.0001,
maxv=100,
step=0.1,
decimals=4,
callback=set_sampling_type(self.SqlProportion))
spin.setSuffix(" %")
self.sql_box.setVisible(False)
self.options_box = gui.vBox(self.controlArea, "Options")
self.cb_seed = gui.checkBox(self.options_box,
self,
"use_seed",
"Replicable (deterministic) sampling",
callback=self.settings_changed)
self.cb_stratify = gui.checkBox(self.options_box,
self,
"stratify",
"Stratify sample (when possible)",
callback=self.settings_changed)
self.cb_sql_dl = gui.checkBox(self.options_box,
self,
"sql_dl",
"Download data to local memory",
callback=self.settings_changed)
self.cb_sql_dl.setVisible(False)
gui.button(self.buttonsArea, self, "Sample Data", callback=self.commit)
def __init__(self):
super().__init__()
self.instances = None
self.domain = None
self.data = None
self.classifier = None
self.align = OWNomogram.ALIGN_ZERO
self.log_odds_ratios = []
self.log_reg_coeffs = []
self.log_reg_coeffs_orig = []
self.log_reg_cont_data_extremes = []
self.p = None
self.b0 = None
self.points = []
self.feature_items = []
self.feature_marker_values = []
self.scale_back = lambda x: x
self.scale_forth = lambda x: x
self.nomogram = None
self.nomogram_main = None
self.vertical_line = None
self.hidden_vertical_line = None
self.old_target_class_index = self.target_class_index
self.markers_set = False
self.repaint = False
# GUI
box = gui.vBox(self.controlArea, "Target class")
self.class_combo = gui.comboBox(box,
self,
"target_class_index",
callback=self._class_combo_changed,
contentsLength=12)
self.norm_check = gui.checkBox(
box,
self,
"normalize_probabilities",
"Normalize probabilities",
hidden=True,
callback=self._norm_check_changed,
tooltip="For multiclass data 1 vs. all probabilities do not"
" sum to 1 and therefore could be normalized.")
self.scale_radio = gui.radioButtons(
self.controlArea,
self,
"scale", ["Point scale", "Log odds ratios"],
box="Scale",
callback=self._radio_button_changed)
box = gui.vBox(self.controlArea, "Display features")
grid = QGridLayout()
self.display_radio = gui.radioButtonsInBox(
box,
self,
"display_index", [],
orientation=grid,
callback=self._display_radio_button_changed)
radio_all = gui.appendRadioButton(self.display_radio,
"All:",
addToLayout=False)
radio_best = gui.appendRadioButton(self.display_radio,
"Best ranked:",
addToLayout=False)
spin_box = gui.hBox(None, margin=0)
self.n_spin = gui.spin(spin_box,
self,
"n_attributes",
1,
self.MAX_N_ATTRS,
label=" ",
controlWidth=60,
callback=self._n_spin_changed)
grid.addWidget(radio_all, 1, 1)
grid.addWidget(radio_best, 2, 1)
grid.addWidget(spin_box, 2, 2)
self.sort_combo = gui.comboBox(box,
self,
"sort_index",
label="Sort by: ",
items=SortBy.items(),
orientation=Qt.Horizontal,
callback=self._sort_combo_changed)
self.cont_feature_dim_combo = gui.comboBox(
box,
self,
"cont_feature_dim_index",
label="Continuous features: ",
items=["1D projection", "2D curve"],
orientation=Qt.Horizontal,
callback=self._cont_feature_dim_combo_changed)
gui.rubber(self.controlArea)
self.scene = QGraphicsScene()
self.view = QGraphicsView(
self.scene,
horizontalScrollBarPolicy=Qt.ScrollBarAlwaysOff,
renderHints=QPainter.Antialiasing | QPainter.TextAntialiasing
| QPainter.SmoothPixmapTransform,
alignment=Qt.AlignLeft)
self.view.viewport().installEventFilter(self)
self.view.viewport().setMinimumWidth(300)
self.view.sizeHint = lambda: QSize(600, 500)
self.mainArea.layout().addWidget(self.view)
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.view = gui.TableView(wordWrap=True, )
header = self.view.horizontalHeader()
header.setSectionResizeMode(QHeaderView.ResizeToContents)
header.setDefaultAlignment(Qt.AlignCenter)
header.setStretchLastSection(False)
header.setContextMenuPolicy(Qt.CustomContextMenu)
header.customContextMenuRequested.connect(self.show_column_chooser)
self.result_model = QStandardItemModel(self)
self.result_model.setHorizontalHeaderLabels(["Method"])
self.view.setModel(self.result_model)
self.view.setItemDelegate(ItemDelegate())
box = gui.vBox(self.mainArea, "Evaluation Results")
box.layout().addWidget(self.view)
def __init__(self):
super().__init__(self)
gui.rubber(self.controlArea)
gui.rubber(self.mainArea)
self.info.set_output_summary(self.info.NoOutput)
box = gui.vBox(self.mainArea, "Configure data query")
self.radiobox = gui.radioButtons(box, self, "query_type", callback=self.radio_changed)
gui.appendRadioButton(self.radiobox, "All data")
gui.appendRadioButton(self.radiobox, "Interesting intervals")
ibox = gui.indentedBox(self.radiobox)
gui.spin(
ibox, self, "interval_len", 1, 100000, label="Interval length",
controlWidth=60, callback=self.number_changed)
gui.spin(
ibox, self, "n_intervals", 1, 100000, label="Number of intervals",
controlWidth=60, callback=self.number_changed)
gui.appendRadioButton(self.radiobox, "Custom intervals")
gui.appendRadioButton(self.radiobox, "Last n seconds")
nbox = gui.indentedBox(self.radiobox)
gui.spin(
nbox, self, "last_seconds", 1, 10000000, label="Last seconds",
controlWidth=60, callback=self.number_changed)
gui.appendRadioButton(self.radiobox, "Last n measurements on each sensor")
nmbox = gui.indentedBox(self.radiobox)
gui.spin(
nmbox, self, "last_measurements", 1, 10000000, label="Last measurements",
controlWidth=60, callback=self.number_changed)
self.radiobox.setDisabled(not self.query_controls)
self.objects = {}
self.lb_objects = gui.listBox(self.controlArea, self, "selected", "lb_labels", box="Deployments",
callback=self.sel_changed,
sizeHint=QSize(300, 300))
self.lb_objects.setFocusPolicy(Qt.NoFocus)
out_box = gui.vBox(self.mainArea, "Output")
self.out_box = gui.radioButtons(out_box, self, "output_type", callback=self.output_changed)
gui.appendRadioButton(self.out_box, "Matrix")
gui.appendRadioButton(self.out_box, "Tensor")
self.apply_button = gui.button(self.mainArea, self, self.tr("&Apply"),
callback=self.apply)
self.out_box.setDisabled(not self.query_controls)
self._executor = ThreadPoolExecutor(max_workers=1)
self._executor.submit(self.get_deployments())
def __init__(self):
super().__init__()
self.data = None
self.test_data = None
self.preprocessor = None
self.train_data_missing_vals = False
self.test_data_missing_vals = False
self.scorers = []
self.__pending_comparison_criterion = self.comparison_criterion
#: An Ordered dictionary with current inputs and their testing results.
self.learners = OrderedDict() # type: Dict[Any, Input]
self.__state = State.Waiting
# Do we need to [re]test any learners, set by _invalidate and
# cleared by __update
self.__needupdate = False
self.__task = None # type: Optional[TaskState]
self.__executor = ThreadExecutor()
sbox = gui.vBox(self.controlArea, "Sampling")
rbox = gui.radioButtons(sbox,
self,
"resampling",
callback=self._param_changed)
gui.appendRadioButton(rbox, "Cross validation")
ibox = gui.indentedBox(rbox)
gui.comboBox(ibox,
self,
"n_folds",
label="Number of folds: ",
items=[str(x) for x in self.NFolds],
maximumContentsLength=3,
orientation=Qt.Horizontal,
callback=self.kfold_changed)
gui.checkBox(ibox,
self,
"cv_stratified",
"Stratified",
callback=self.kfold_changed)
gui.appendRadioButton(rbox, "Cross validation by feature")
ibox = gui.indentedBox(rbox)
self.feature_model = DomainModel(order=DomainModel.METAS,
valid_types=DiscreteVariable)
self.features_combo = gui.comboBox(ibox,
self,
"fold_feature",
model=self.feature_model,
orientation=Qt.Horizontal,
callback=self.fold_feature_changed)
gui.appendRadioButton(rbox, "Random sampling")
ibox = gui.indentedBox(rbox)
gui.comboBox(ibox,
self,
"n_repeats",
label="Repeat train/test: ",
items=[str(x) for x in self.NRepeats],
maximumContentsLength=3,
orientation=Qt.Horizontal,
callback=self.shuffle_split_changed)
gui.comboBox(ibox,
self,
"sample_size",
label="Training set size: ",
items=["{} %".format(x) for x in self.SampleSizes],
maximumContentsLength=5,
orientation=Qt.Horizontal,
callback=self.shuffle_split_changed)
gui.checkBox(ibox,
self,
"shuffle_stratified",
"Stratified",
callback=self.shuffle_split_changed)
gui.appendRadioButton(rbox, "Leave one out")
gui.appendRadioButton(rbox, "Test on train data")
gui.appendRadioButton(rbox, "Test on test data")
self.cbox = gui.vBox(self.controlArea, "Target Class")
self.class_selection_combo = gui.comboBox(
self.cbox,
self,
"class_selection",
items=[],
sendSelectedValue=True,
valueType=str,
callback=self._on_target_class_changed,
contentsLength=8)
self.modcompbox = box = gui.vBox(self.controlArea, "Model Comparison")
gui.comboBox(box,
self,
"comparison_criterion",
model=PyListModel(),
callback=self.update_comparison_table)
hbox = gui.hBox(box)
gui.checkBox(hbox,
self,
"use_rope",
"Negligible difference: ",
callback=self._on_use_rope_changed)
gui.lineEdit(hbox,
self,
"rope",
validator=QDoubleValidator(),
controlWidth=70,
callback=self.update_comparison_table,
alignment=Qt.AlignRight)
self.controls.rope.setEnabled(self.use_rope)
gui.rubber(self.controlArea)
self.score_table = ScoreTable(self)
self.score_table.shownScoresChanged.connect(self.update_stats_model)
view = self.score_table.view
view.setSizeAdjustPolicy(view.AdjustToContents)
box = gui.vBox(self.mainArea, "Evaluation Results")
box.layout().addWidget(self.score_table.view)
self.compbox = box = gui.vBox(self.mainArea, box="Model comparison")
table = self.comparison_table = QTableWidget(
wordWrap=False,
editTriggers=QTableWidget.NoEditTriggers,
selectionMode=QTableWidget.NoSelection)
table.setSizeAdjustPolicy(table.AdjustToContents)
header = table.verticalHeader()
header.setSectionResizeMode(QHeaderView.Fixed)
header.setSectionsClickable(False)
header = table.horizontalHeader()
header.setTextElideMode(Qt.ElideRight)
header.setDefaultAlignment(Qt.AlignCenter)
header.setSectionsClickable(False)
header.setStretchLastSection(False)
header.setSectionResizeMode(QHeaderView.ResizeToContents)
avg_width = self.fontMetrics().averageCharWidth()
header.setMinimumSectionSize(8 * avg_width)
header.setMaximumSectionSize(15 * avg_width)
header.setDefaultSectionSize(15 * avg_width)
box.layout().addWidget(table)
box.layout().addWidget(
QLabel(
"<small>Table shows probabilities that the score for the model in "
"the row is higher than that of the model in the column. "
"Small numbers show the probability that the difference is "
"negligible.</small>",
wordWrap=True))
def __init__(self):
super().__init__()
# Diagram update is in progress
self._updating = False
# Input update is in progress
self._inputUpdate = False
# All input tables have the same domain.
self.samedomain = True
# Input datasets in the order they were 'connected'.
self.data = OrderedDict()
# Extracted input item sets in the order they were 'connected'
self.itemsets = OrderedDict()
# GUI
box = gui.vBox(self.controlArea, "Info")
self.info = gui.widgetLabel(box, "No data on input.\n")
self.identifiersBox = gui.radioButtonsInBox(
self.controlArea,
self,
"useidentifiers",
[],
box="Data Instance Identifiers",
callback=self._on_useidentifiersChanged,
)
self.useequalityButton = gui.appendRadioButton(self.identifiersBox, "Use instance equality")
self.useidentifiersButton = rb = gui.appendRadioButton(self.identifiersBox, "Use identifiers")
self.inputsBox = gui.indentedBox(self.identifiersBox, sep=gui.checkButtonOffsetHint(rb))
self.inputsBox.setEnabled(bool(self.useidentifiers))
for i in range(5):
box = gui.vBox(self.inputsBox, "Data set #%i" % (i + 1), addSpace=False)
box.setFlat(True)
model = itemmodels.VariableListModel(parent=self)
cb = QComboBox(minimumContentsLength=12, sizeAdjustPolicy=QComboBox.AdjustToMinimumContentsLengthWithIcon)
cb.setModel(model)
cb.activated[int].connect(self._on_inputAttrActivated)
box.setEnabled(False)
# Store the combo in the box for later use.
box.combo_box = cb
box.layout().addWidget(cb)
gui.rubber(self.controlArea)
box = gui.vBox(self.controlArea, "Output")
gui.checkBox(box, self, "output_duplicates", "Output duplicates", callback=lambda: self.commit())
gui.auto_commit(box, self, "autocommit", "Send Selection", "Send Automatically", box=False)
# Main area view
self.scene = QGraphicsScene()
self.view = QGraphicsView(self.scene)
self.view.setRenderHint(QPainter.Antialiasing)
self.view.setBackgroundRole(QPalette.Window)
self.view.setFrameStyle(QGraphicsView.StyledPanel)
self.mainArea.layout().addWidget(self.view)
self.vennwidget = VennDiagram()
self.vennwidget.resize(400, 400)
self.vennwidget.itemTextEdited.connect(self._on_itemTextEdited)
self.scene.selectionChanged.connect(self._on_selectionChanged)
self.scene.addItem(self.vennwidget)
self.resize(self.controlArea.sizeHint().width() + 550, max(self.controlArea.sizeHint().height(), 550))
self._queue = []