def addHistogramControls(self):
boxGeneral = gui.widgetBox(self.controlArea, box="Edges")
ribg = gui.widgetBox(boxGeneral, None, orientation=Qt.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=Qt.Horizontal, addSpace=False)
gui.doubleSpin(boxGeneral, self, "percentil", 0, 100, 0.1,
label="Percentile", orientation=Qt.Horizontal,
callback=self.setPercentil,
callbackOnReturn=1, controlWidth=60)
hbox = gui.widgetBox(boxGeneral, orientation=Qt.Horizontal)
knn_cb = gui.checkBox(hbox, self, 'include_knn',
label='Include closest neighbors',
callback=self.generateGraph)
knn = gui.spin(hbox, self, "kNN", 1, 1000, 1,
orientation=Qt.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)
grid = QGridLayout()
ribg.layout().addLayout(grid)
grid.addWidget(
gui.appendRadioButton(ribg, "Keep all nodes", addToLayout=False),
0, 0
)
exclude_limit = gui.spin(
ribg, self, "excludeLimit", 2, 100, 1,
callback=(lambda h=True: self.generateGraph(h)),
controlWidth=60
)
grid.addWidget(
gui.appendRadioButton(ribg, "Components with at least nodes",
addToLayout=False), 1, 0)
grid.addWidget(exclude_limit, 1, 1)
grid.addWidget(
gui.appendRadioButton(ribg, "Largest connected component",
addToLayout=False), 2, 0)
ribg = gui.radioButtonsInBox(self.controlArea, self, "edge_weights",
box="Edge weights",
callback=self.generateGraph)
hb = gui.widgetBox(ribg, None, orientation=Qt.Horizontal, addSpace=False)
gui.appendRadioButton(ribg, "Proportional to distance", insertInto=hb)
gui.appendRadioButton(ribg, "Inverted distance", insertInto=hb)
def __init__(self):
super().__init__()
self.data = None
self.pairwise_correlations = True
self.correlations_type = 0
self.selected_index = None
self.changed_flag = False
self.auto_commit = True
self.splitter_state = None
self.corr_graph = CorrelationsGraph(self)
self.mainArea.layout().addWidget(self.corr_graph.plot_widget)
self.resize(1000, 500) # TODO better size handling
gui.radioButtonsInBox(
self.controlArea,
self,
"correlations_type",
("Pairwise Pearson correlation", "Pairwise Spearman correlation"),
box="Correlations",
callback=self.on_corr_type_change)
self.corr_table = CorrelationsTableView()
self.corr_model = QStandardItemModel()
self.corr_table.setModel(self.corr_model)
self.controlArea.layout().addWidget(self.corr_table)
self.corr_table.selectionModel().selectionChanged.connect(
self.on_table_selection_change)
def __init__(self):
super().__init__()
self.corpus = None
# GUI
box = gui.widgetBox(self.controlArea, "Info")
self.info = gui.widgetLabel(
box, 'Connect an input corpus to start querying')
self.import_box = gui.vBox(self.controlArea, 'Dictionary')
self.import_box.setVisible(False)
gui.button(self.import_box,
self,
'Use dictionary',
toggleButton=True,
value='dictionary_on',
buttonType=QCheckBox)
self.dictionarybox = ListEdit(self, 'dictionary_text', '', 60, self)
self.dictionarybox.setTextColor(QColor(100, 100, 100))
self.dictionarybox.setReadOnly(True)
self.import_box.layout().addWidget(self.dictionarybox)
query_box = gui.widgetBox(self.controlArea, 'Query', addSpace=True)
self.querytextbox = ListEdit(self, 'queries', '', 80, self)
query_box.layout().addWidget(self.querytextbox)
query_parameter_box = gui.hBox(self.controlArea, self)
gui.radioButtonsInBox(query_parameter_box,
self,
'query_mode',
btnLabels=QUERY_MODES,
box="Query mode",
callback=self.toggle_mode)
self.count_mode_parameters = gui.vBox(query_parameter_box, self)
gui.checkBox(self.count_mode_parameters,
self,
'include_unmatched',
label="Include unmatched documents")
self.filter_mode_parameters = gui.widgetBox(query_parameter_box, self)
gui.lineEdit(self.filter_mode_parameters,
self,
"context_window",
'Output words in context window',
validator=QIntValidator())
self.toggle_mode()
info_box = gui.hBox(self.controlArea, 'Status')
self.status = 'Waiting for input'
gui.label(info_box, self, '%(status)s')
self.search_button = gui.button(self.controlArea,
self,
'Search',
self.start_stop,
focusPolicy=Qt.NoFocus)
def _set_control_area(self):
box = gui.widgetBox(self.controlArea, '设置:')
box.layout().setAlignment(Qt.AlignTop)
dir_box = gui.widgetBox(box, '图片文件夹:', orientation=Qt.Horizontal)
self.filesCB = gui.comboBox(
dir_box, self, "selectedIndex", callback=self._on_recent)
self.filesCB.setMinimumContentsLength(20)
self.filesCB.setSizeAdjustPolicy(
QComboBox.AdjustToMinimumContentsLength)
self.loadbutton = gui.button(dir_box, self, "...", callback=self.browse)
self.loadbutton.setIcon(
self.style().standardIcon(QStyle.SP_DirOpenIcon))
self.loadbutton.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Fixed)
# filter valid existing filenames
self.history = list(filter(os.path.isdir, self.history))[:20]
for dir_name in self.history:
self.filesCB.addItem(os.path.basename(dir_name), userData=dir_name)
# restore the current selection if the filename is
# in the history list
if self.dir_name in self.history:
self.selectedIndex = self.history.index(self.dir_name)
else:
self.selectedIndex = -1
self.dir_name = None
gui.radioButtonsInBox(box, self, 'for_train',
btnLabels=['需要训练', '只要预测'],
label='是否需要训练',
orientation=Qt.Horizontal,
callback=self.update_batch_setting)
gui.separator(box, height=10)
self.batch_box = gui.comboBox(
box,
self,
'batch_size',
items=self.batch_sizes,
callback=self.set_size,
label='batch size'
)
gui.separator(box, height=10)
gui.button(box,
self,
"载入图片",
callback=self.load_images,
)
self.next_image_button = gui.button(box,
self,
"下一组图片",
callback=self.next_image,
)
self.next_image_button.setEnabled(False)
def _add_mode_selection_box(self):
mode_box = gui.hBox(self.controlArea, "模式选择")
gui.radioButtonsInBox(
mode_box,
self,
"mode",
btnLabels=['手动模式', '自动模式'],
)
def __init__(self):
super().__init__()
self.corpus = None
self.api = None
self.output_info = ''
# API token
self.api_dlg = self.CredentialsDialog(self)
self.api_dlg.accept(silent=True)
gui.button(self.controlArea, self, 'Facebook login',
callback=self.api_dlg.exec_,
focusPolicy=Qt.NoFocus)
# Query
self.query_box = gui.widgetBox(self.controlArea, 'Posts', addSpace=True)
gui.label(self.query_box, self, 'Page IDs (or page URLs)')
self.query_box.layout().addWidget(ListEdit(self, 'page_ids',
'One page ID per line', 80, self))
def date_changed():
d.picker_to.setVisible(self.date_option in [DATE_BETWEEN])
d.picker_from.setVisible(self.date_option in [DATE_FROM, DATE_BETWEEN])
gui.comboBox(self.query_box, self, 'date_option', items=DATE_OPTIONS, label="Date filter",
callback = date_changed)
date_box = gui.hBox(self.query_box)
d = DatePickerInterval(date_box, self, 'date_from', 'date_to',
min_date=None, max_date=date.today(),
margin=(0, 3, 0, 0))
date_changed()
self.mode_box = gui.widgetBox(self.query_box, box=True)
mode_box_h = gui.hBox(self.mode_box)
gui.radioButtonsInBox(mode_box_h, self, 'mode', btnLabels=['only posts from page itself', 'all public posts on page'], orientation=2)
# gui.radioButtonsInBox(mode_box_h, self, 'accumulate', btnLabels=['new results', 'add to previous results'], orientation=2, label='On search:')
gui.lineEdit(mode_box_h, self, 'max_documents', label='Max docs per page:', valueType=str, controlWidth=50)
comments_box = gui.widgetBox(self.controlArea, box='Comments')
gui.radioButtonsInBox(comments_box, self, 'comments', btnLabels=['ignore', 'direct comments', 'all comments'], orientation=2)
# Text includes features
self.query_box.layout().addWidget(
CheckListLayout('Text includes', self, 'text_includes',
self.attributes,
cols=2, callback=self.set_text_features))
# Output
info_box = gui.hBox(self.controlArea, 'Output')
gui.label(info_box, self, 'Articles: %(output_info)s')
# Buttons
self.button_box = gui.hBox(self.controlArea)
self.button_box.layout().addWidget(self.report_button)
self.search_button = gui.button(self.button_box, self, 'Search',
self.start_stop,
focusPolicy=Qt.NoFocus)
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):
super().__init__()
box = gui.vBox(self.controlArea, "Multinomial Attributes")
gui.radioButtonsInBox(
box, self, "multinomial_treatment",
btnLabels=[x[0] for x in self.multinomial_treats],
callback=self.settings_changed)
box = gui.vBox(self.controlArea, "Continuous Attributes")
gui.radioButtonsInBox(
box, self, "continuous_treatment",
btnLabels=[x[0] for x in self.continuous_treats],
callback=self.settings_changed)
box = gui.vBox(self.controlArea, "Discrete Class Attribute")
gui.radioButtonsInBox(
box, self, "class_treatment",
btnLabels=[t[0] for t in self.class_treats],
callback=self.settings_changed)
zbbox = gui.vBox(self.controlArea, "Value Range")
gui.radioButtonsInBox(
zbbox, self, "zero_based",
btnLabels=self.value_ranges,
callback=self.settings_changed)
gui.auto_commit(self.buttonsArea, self, "autosend", "Apply", box=False)
self.data = None
def __init__(self):
super().__init__()
box = gui.vBox(self.controlArea, "Multinomial Attributes")
gui.radioButtonsInBox(
box, self, "multinomial_treatment",
btnLabels=[x[0] for x in self.multinomial_treats],
callback=self.settings_changed)
box = gui.vBox(self.controlArea, "Continuous Attributes")
gui.radioButtonsInBox(
box, self, "continuous_treatment",
btnLabels=[x[0] for x in self.continuous_treats],
callback=self.settings_changed)
box = gui.vBox(self.controlArea, "Discrete Class Attribute")
gui.radioButtonsInBox(
box, self, "class_treatment",
btnLabels=[t[0] for t in self.class_treats],
callback=self.settings_changed)
zbbox = gui.vBox(self.controlArea, "Value Range")
gui.radioButtonsInBox(
zbbox, self, "zero_based",
btnLabels=self.value_ranges,
callback=self.settings_changed)
gui.auto_commit(self.buttonsArea, self, "autosend", "Apply", box=False)
self.data = None
def __init__(self, parent=None):
widget.OWWidget.__init__(self, parent)
box = gui.widgetBox(self.controlArea, "Multinomial attributes")
gui.radioButtonsInBox(
box, self, "multinomial_treatment",
btnLabels=[x[0] for x in self.multinomial_treats],
callback=self.settings_changed)
box = gui.widgetBox(self.controlArea, "Continuous attributes")
gui.radioButtonsInBox(
box, self, "continuous_treatment",
btnLabels=[x[0] for x in self.continuous_treats],
callback=self.settings_changed)
box = gui.widgetBox(self.controlArea, "Discrete class attribute")
gui.radioButtonsInBox(
box, self, "class_treatment",
btnLabels=[t[0] for t in self.class_treats],
callback=self.settings_changed)
zbbox = gui.widgetBox(self.controlArea, "Value range")
gui.radioButtonsInBox(
zbbox, self, "zero_based",
btnLabels=self.value_ranges,
callback=self.settings_changed)
gui.auto_commit(self.controlArea, self, "autosend", "Apply")
self.data = None
self.resize(150, 300)
def __init__(self):
super().__init__()
box = gui.vBox(self.controlArea, "分类特征")
gui.radioButtonsInBox(
box, self, "multinomial_treatment",
btnLabels=[x[0] for x in self.multinomial_treats],
callback=self.settings_changed)
box = gui.vBox(self.controlArea, "数值特征")
gui.radioButtonsInBox(
box, self, "continuous_treatment",
btnLabels=[x[0] for x in self.continuous_treats],
callback=self.settings_changed)
box = gui.vBox(self.controlArea, "分类结果")
gui.radioButtonsInBox(
box, self, "class_treatment",
btnLabels=[t[0] for t in self.class_treats],
callback=self.settings_changed)
zbbox = gui.vBox(self.controlArea, "值范围")
gui.radioButtonsInBox(
zbbox, self, "zero_based",
btnLabels=self.value_ranges,
callback=self.settings_changed)
gui.auto_commit(self.buttonsArea, self, "autosend", "应用", box=False)
self.data = None
def __init__(self):
super().__init__()
box = gui.vBox(self.controlArea, "分类特征")
gui.radioButtonsInBox(
box, self, "multinomial_treatment",
btnLabels=[x[0] for x in self.multinomial_treats],
callback=self.settings_changed)
box = gui.vBox(self.controlArea, "数值特征")
gui.radioButtonsInBox(
box, self, "continuous_treatment",
btnLabels=[x[0] for x in self.continuous_treats],
callback=self.settings_changed)
box = gui.vBox(self.controlArea, "分类目标")
gui.radioButtonsInBox(
box, self, "class_treatment",
btnLabels=[t[0] for t in self.class_treats],
callback=self.settings_changed)
zbbox = gui.vBox(self.controlArea, "数值范围")
gui.radioButtonsInBox(
zbbox, self, "zero_based",
btnLabels=self.value_ranges,
callback=self.settings_changed)
gui.auto_apply(self.buttonsArea, self, "autosend", box=False)
self.data = None
self.info.set_input_summary(self.info.NoInput)
self.info.set_output_summary(self.info.NoOutput)
def __init__(self, parent=None):
widget.OWWidget.__init__(self, parent)
self.data_changed = False
box = gui.widgetBox(self.controlArea, "Multinomial attributes")
gui.radioButtonsInBox(
box,
self,
"multinomial_treatment",
btnLabels=[x[0] for x in self.multinomial_treats],
callback=self.sendDataIf)
self.controlArea.layout().addSpacing(4)
box = gui.widgetBox(self.controlArea, "Continuous attributes")
gui.radioButtonsInBox(box,
self,
"continuous_treatment",
btnLabels=[x[0] for x in self.continuous_treats],
callback=self.sendDataIf)
self.controlArea.layout().addSpacing(4)
box = gui.widgetBox(self.controlArea, "Discrete class attribute")
gui.radioButtonsInBox(box,
self,
"class_treatment",
btnLabels=[t[0] for t in self.class_treats],
callback=self.sendDataIf)
self.controlArea.layout().addSpacing(4)
zbbox = gui.widgetBox(self.controlArea, "Value range")
gui.radioButtonsInBox(zbbox,
self,
"zero_based",
btnLabels=self.value_ranges,
callback=self.sendDataIf)
self.controlArea.layout().addSpacing(4)
snbox = gui.widgetBox(self.controlArea, "Send data")
gui.button(snbox,
self,
"Send data",
callback=self.sendData,
default=True)
gui.checkBox(snbox,
self,
"autosend",
"Send automatically",
callback=self.enableAuto)
self.data = None
self.resize(150, 300)
def _init_layout(self):
"""Initialize widget layout."""
# Control area
info_box = gui.widgetBox(self.controlArea, "Info", addSpace=True)
self._info_label = gui.widgetLabel(info_box, "Initializing\n\n")
box = gui.vBox(self.controlArea, "Average intervals:")
self.ch_month = gui.checkBox(box, self, "include_month", "Month",
callback=self.commit_if)
self.ch_year = gui.checkBox(box, self, "include_year", 'Year',
callback=self.commit_if)
self.ch_decade = gui.checkBox(box, self, "include_decade", 'Decade',
callback=self.commit_if)
box = gui.vBox(self.controlArea, "Data Types")
gui.checkBox(box, self, "include_temperature", "Temperature",
callback=self.commit_if)
gui.checkBox(box, self, "include_precipitation", 'Precipitation',
callback=self.commit_if)
output_box = gui.widgetBox(self.controlArea, "Output", addSpace=True)
gui.radioButtonsInBox(output_box, self, "output_type",
["Countries", "Time Series"], "Rows",
callback=self.output_type_selected)
gui.checkBox(output_box, self, "use_country_names",
"Use Country names", callback=self.commit_if)
self.output_type = 0
# pylint: disable=duplicate-code
gui.separator(output_box)
gui.auto_commit(self.controlArea, self, "auto_commit", "Commit",
box="Commit")
gui.rubber(self.controlArea)
# Main area
box = gui.widgetBox(self.mainArea, "Countries")
self.country_tree = CountryTreeWidget(
self.mainArea,
self.country_selection,
commit_callback=self.commit_if,
default_colapse=True,
default_select=False,
)
self.country_tree.set_data(countries.get_countries_dict())
box.layout().addWidget(self.country_tree)
self.resize(500, 400) # why does this not work
def _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 __init__(self):
super().__init__()
self.net = None
commit = lambda: self.commit()
gui.spin(self.controlArea, self, "iterations", 1, 100000, 1, label="Max. iterations:", callback=commit)
ribg = gui.radioButtonsInBox(
self.controlArea,
self,
"method",
btnLabels=[
"Label propagation clustering (Raghavan et al., 2007)",
"Label propagation clustering (Leung et al., 2009)",
],
box="Clustering method",
callback=commit,
)
gui.doubleSpin(gui.indentedBox(ribg), self, "hop_attenuation", 0, 1, 0.01, label="Hop attenuation (delta): ")
self.info = gui.widgetLabel(self.controlArea, " ")
gui.auto_commit(self.controlArea, self, "autoApply", "Commit", checkbox_label="Auto-commit")
commit()
def __init__(self):
super().__init__()
self.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__()
# Diagram update is in progress
self._updating = False
# Input update is in progress
self._inputUpdate = False
# Input datasets in the order they were 'connected'.
self.data = {}
# Extracted input item sets in the order they were 'connected'
self.itemsets = {}
# A list with 2 ** len(self.data) elements that store item sets
# belonging to each area
self.disjoint = []
# A list with 2 ** len(self.data) elements that store keys of tables
# intersected in each area
self.area_keys = []
# 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._resize()
self.vennwidget.itemTextEdited.connect(self._on_itemTextEdited)
self.scene.selectionChanged.connect(self._on_selectionChanged)
self.scene.addItem(self.vennwidget)
controls = gui.hBox(self.mainArea)
box = gui.radioButtonsInBox(controls,
self,
'rowwise', [
"Columns (features)",
"Rows (instances), matched by",
],
box="Elements",
callback=self._on_matching_changed)
gui.comboBox(gui.indentedBox(box),
self,
"selected_feature",
model=itemmodels.VariableListModel(
placeholder="Instance identity"),
callback=self._on_inputAttrActivated)
box.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Fixed)
self.outputs_box = box = gui.vBox(controls, "Output")
self.output_duplicates_cb = gui.checkBox(
box,
self,
"output_duplicates",
"Output duplicates",
callback=lambda: self.commit()) # pylint: disable=unnecessary-lambda
gui.auto_send(box, self, "autocommit", box=False)
self.output_duplicates_cb.setEnabled(bool(self.rowwise))
self._queue = []
def _add_type_box(self):
form = QtGui.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(QtGui.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 _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 __init__(self):
super().__init__()
self.net = None
self.method = 0
self.iterationHistory = 0
self.autoApply = 0
self.iterations = 1000
self.hop_attenuation = 0.1
commit = lambda: self.commit()
gui.spin(self.controlArea, self, "iterations", 1,
100000, 1, label="Iterations: ",
callback=commit)
ribg = gui.radioButtonsInBox(
self.controlArea, self, "method",
btnLabels=["Label propagation clustering (Raghavan et al., 2007)",
"Label propagation clustering (Leung et al., 2009)"],
label="Method", callback=commit)
gui.doubleSpin(gui.indentedBox(ribg), self, "hop_attenuation",
0, 1, 0.01, label="Hop attenuation (delta): ")
self.info = gui.widgetLabel(self.controlArea, ' ')
gui.checkBox(self.controlArea, self, "iterationHistory",
"Append clustering data on each iteration",
callback=commit)
gui.auto_commit(self.controlArea, self, "autoApply", 'Commit',
checkbox_label='Auto-commit')
commit()
def __init__(self):
super().__init__()
self.data = None
self.discrete_data = None
self.unprocessed_subset_data = None
self.subset_data = None
self.areas = []
self.canvas = QGraphicsScene()
self.canvas_view = ViewWithPress(self.canvas,
handler=self.clear_selection)
self.mainArea.layout().addWidget(self.canvas_view)
self.canvas_view.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.canvas_view.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.canvas_view.setRenderHint(QPainter.Antialiasing)
box = gui.vBox(self.controlArea, box=True)
self.attr_combos = [
gui.comboBox(
box, self, value="variable{}".format(i),
orientation=Qt.Horizontal, contentsLength=12,
callback=self.reset_graph,
sendSelectedValue=True, valueType=str)
for i in range(1, 5)]
self.rb_colors = gui.radioButtonsInBox(
self.controlArea, self, "interior_coloring",
self.interior_coloring_opts, box="Interior Coloring",
callback=self.update_graph)
self.bar_button = gui.checkBox(
gui.indentedBox(self.rb_colors),
self, 'use_boxes', label='Compare with total',
callback=self._compare_with_total)
gui.rubber(self.controlArea)
def _add_controls_placement(self, box):
self.radio_placement = gui.radioButtonsInBox(
box,
self,
"placement",
btnLabels=[self.Projection_name[x] for x in Placement],
callback=self.__placement_radio_changed)
def __init__(self):
super().__init__()
self.net = None
self.cluster_feature = None
commit = lambda: self.commit()
gui.spin(self.controlArea, self, "iterations", 1,
100000, 1, label="Max. iterations:",
callback=commit)
self.random_state = gui.checkBox(self.controlArea, self, "use_random_state",
label="Replicable clustering",
callback=commit)
ribg = gui.radioButtonsInBox(
self.controlArea, self, "method",
btnLabels=["Label propagation clustering (Raghavan et al., 2007)",
"Label propagation clustering (Leung et al., 2009)"],
box="Clustering method", callback=commit)
gui.doubleSpin(gui.indentedBox(ribg), self, "hop_attenuation",
0, 1, 0.01, label="Hop attenuation (delta): ")
self.infolabel = gui.widgetLabel(self.controlArea, ' ')
gui.auto_commit(self.controlArea, self, "autoApply", 'Commit',
checkbox_label='Auto-commit', orientation=Qt.Horizontal)
commit()
def _add_kernel_box(self):
# Initialize with the widest label to measure max width
self.kernel_eq = self.kernels[-1][1]
self.kernel_box = box = gui.widgetBox(
self.controlArea, "Kernel", orientation="horizontal")
buttonbox = gui.radioButtonsInBox(
box, self, "kernel_type", btnLabels=[k[0] for k in self.kernels],
callback=self._on_kernel_changed, addSpace=20)
buttonbox.layout().setSpacing(10)
gui.rubber(buttonbox)
parambox = gui.widgetBox(box)
gui.label(parambox, self, "Kernel: %(kernel_eq)s")
common = dict(orientation="horizontal",
alignment=Qt.AlignRight, controlWidth=80)
spbox = gui.widgetBox(parambox, orientation="horizontal")
gui.rubber(spbox)
inbox = gui.widgetBox(spbox)
gamma = gui.doubleSpin(
inbox, self, "gamma", 0.0, 10.0, 0.01, label=" g: ", **common)
coef0 = gui.doubleSpin(
inbox, self, "coef0", 0.0, 10.0, 0.01, label=" c: ", **common)
degree = gui.doubleSpin(
inbox, self, "degree", 0.0, 10.0, 0.5, label=" d: ", **common)
self._kernel_params = [gamma, coef0, degree]
gui.rubber(parambox)
# This is the maximal height (all double spins are visible)
# and the maximal width (the label is initialized to the widest one)
box.layout().activate()
box.setFixedHeight(box.sizeHint().height())
box.setMinimumWidth(box.sizeHint().width())
def setup_control_area(self):
# Control area
self.input_info = widgetLabel(
widgetBox(self.controlArea, "Info", addSpace=True),
'No data on input.\n')
self.custom_gs_col_box = box = vBox(self.controlArea,
'Custom Gene Set Term Column')
box.hide()
self.reference_radio_box = radioButtonsInBox(
self.controlArea,
self,
"use_reference_data",
["Entire genome", "Reference gene set (input)"],
tooltips=[
"Use entire genome (for gene set enrichment)",
"Use reference set of genes"
],
box="Reference",
callback=self.invalidate,
)
self.reference_radio_box.setEnabled(False)
gene_sets_box = widgetBox(self.controlArea, "Gene Sets")
self.gs_widget = GeneSetsSelection(gene_sets_box, self,
'stored_gene_sets_selection')
self.gs_widget.hierarchy_tree_widget.itemClicked.connect(
self.update_tree_view)
self.commit_button = auto_commit(self.controlArea,
self,
"auto_commit",
"&Commit",
box=False)
def __init__(self):
super().__init__()
self.data = None
# GUI
box = gui.vBox(self.controlArea, "Feature names")
self.feature_radio = gui.radioButtonsInBox(
box,
self,
"feature_type",
callback=lambda: self.apply(),
btnLabels=["Generic", "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(self.feature_radio.buttons[0])),
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)
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 _add_kernel_box(self):
# this is part of init, pylint: disable=attribute-defined-outside-init
# Initialize with the widest label to measure max width
self.kernel_eq = self.kernels[-1][1]
box = gui.hBox(self.controlArea, "Kernel")
self.kernel_box = buttonbox = gui.radioButtonsInBox(
box, self, "kernel_type", btnLabels=[k[0] for k in self.kernels],
callback=self._on_kernel_changed)
buttonbox.layout().setSpacing(10)
gui.rubber(buttonbox)
parambox = gui.vBox(box)
gui.label(parambox, self, "Kernel: %(kernel_eq)s")
common = dict(orientation=Qt.Horizontal, callback=self.settings_changed,
alignment=Qt.AlignRight, controlWidth=80)
spbox = gui.hBox(parambox)
gui.rubber(spbox)
inbox = gui.vBox(spbox)
gamma = gui.doubleSpin(
inbox, self, "gamma", 0.0, 10.0, 0.01, label=" g: ", **common)
gamma.setSpecialValueText(self._default_gamma)
coef0 = gui.doubleSpin(
inbox, self, "coef0", 0.0, 10.0, 0.01, label=" c: ", **common)
degree = gui.doubleSpin(
inbox, self, "degree", 0.0, 10.0, 0.5, label=" d: ", **common)
self._kernel_params = [gamma, coef0, degree]
gui.rubber(parambox)
# This is the maximal height (all double spins are visible)
# and the maximal width (the label is initialized to the widest one)
box.layout().activate()
box.setFixedHeight(box.sizeHint().height())
box.setMinimumWidth(box.sizeHint().width())
def __init__(self):
super().__init__()
self.data = None
self.discrete_data = None
self.unprocessed_subset_data = None
self.subset_data = None
self.areas = []
self.canvas = QGraphicsScene()
self.canvas_view = ViewWithPress(self.canvas,
handler=self.clear_selection)
self.mainArea.layout().addWidget(self.canvas_view)
self.canvas_view.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.canvas_view.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.canvas_view.setRenderHint(QPainter.Antialiasing)
box = gui.vBox(self.controlArea, box=True)
self.attr_combos = [
gui.comboBox(
box, self, value="variable{}".format(i),
orientation="horizontal", contentsLength=12,
callback=self.reset_graph,
sendSelectedValue=True, valueType=str)
for i in range(1, 5)]
self.rb_colors = gui.radioButtonsInBox(
self.controlArea, self, "interior_coloring",
self.interior_coloring_opts, box="Interior coloring",
callback=self.update_graph)
self.bar_button = gui.checkBox(
gui.indentedBox(self.rb_colors),
self, 'use_boxes', label='Compare with total',
callback=self._compare_with_total)
gui.rubber(self.controlArea)
def __init__(self):
super().__init__()
self.distribution_idx = 0
self.var_data = np.array([])
self.column_data = np.array([])
self.dataset = None
self.column_idx = 0
self.var_idx = 0
self.available_plot = ["Probability Plot", "Q-Q Plot", "P-P Plot",
"Q-Q Plot of 2 samples"]
self.attrs = VariableListModel()
self.all_attrs = VariableListModel()
gui.listView(
self.controlArea, self, "attribute", box="First variable",
model=self.attrs, callback=self.attr_changed)
self.view2 = gui.listView(
self.controlArea, self, "group_var", box="Second variable",
model=self.attrs, callback=self.var_changed)
box = gui.vBox(self.controlArea, 'Type of plot')
self.distribution_choose = gui.radioButtonsInBox(
box, self, 'distribution_idx',
btnLabels=self.available_plot,
callback=self.plot_changed,
)
self.figure = plt.figure()
self.canvas = FigureCanvas(self.figure)
self.mainArea.frameGeometry().width()
self.mainArea.layout().addWidget(self.canvas)
def __init__(self):
super().__init__()
self.n = None
self.product = 0
gui.radioButtonsInBox(self.controlArea, self, "factor",
("None", "Double", "Triple", "Quadruple"),
box="Multiply", callback=self.do_multiply)
self.result = gui.label(self.controlArea, self,
"The product is %(product)i",
box="Result")
self.result.hide()
gui.rubber(self.controlArea)
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):
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.data = None
self.extra_data = None
self.extra_data = None
self.model = itemmodels.VariableListModel()
self.model_unique_with_id = itemmodels.VariableListModel()
self.extra_model_unique = itemmodels.VariableListModel()
self.extra_model_unique_with_id = itemmodels.VariableListModel()
box = gui.hBox(self.controlArea, box=None)
self.infoBoxData = gui.label(
box, self, self.dataInfoText(None), box="Data")
self.infoBoxExtraData = gui.label(
box, self, self.dataInfoText(None), box="Extra Data")
grp = gui.radioButtonsInBox(
self.controlArea, self, "merging", box="Merging",
callback=self.change_merging)
self.attr_boxes = []
radio_width = \
QApplication.style().pixelMetric(QStyle.PM_ExclusiveIndicatorWidth)
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),
contentsLength=12, 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),
contentsLength=12, callback=self._invalidate,
model=extra_model)
cb.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Fixed)
cb.setFixedWidth(190)
vbox.layout().addSpacing(6)
add_option("Append columns from Extra Data",
"by matching", "with", "augment",
self.model, self.extra_model_unique)
add_option("Find matching rows", "where",
"equals", "merge",
self.model_unique_with_id, self.extra_model_unique_with_id)
add_option("Concatenate tables, merge rows",
"where", "equals", "combine",
self.model_unique_with_id, self.extra_model_unique_with_id)
self.set_merging()
def _add_kernel_box(self):
# Initialize with the widest label to measure max width
self.kernel_eq = self.kernels[-1][1]
self.kernel_box = box = gui.widgetBox(self.controlArea,
"Kernel",
orientation="horizontal")
buttonbox = gui.radioButtonsInBox(
box,
self,
"kernel_type",
btnLabels=[k[0] for k in self.kernels],
callback=self._on_kernel_changed,
addSpace=20)
buttonbox.layout().setSpacing(10)
gui.rubber(buttonbox)
parambox = gui.widgetBox(box)
gui.label(parambox, self, "Kernel: %(kernel_eq)s")
common = dict(orientation="horizontal",
alignment=Qt.AlignRight,
controlWidth=80)
spbox = gui.widgetBox(parambox, orientation="horizontal")
gui.rubber(spbox)
inbox = gui.widgetBox(spbox)
gamma = gui.doubleSpin(inbox,
self,
"gamma",
0.0,
10.0,
0.01,
label=" g: ",
**common)
coef0 = gui.doubleSpin(inbox,
self,
"coef0",
0.0,
10.0,
0.01,
label=" c: ",
**common)
degree = gui.doubleSpin(inbox,
self,
"degree",
0.0,
10.0,
0.5,
label=" d: ",
**common)
self._kernel_params = [gamma, coef0, degree]
gui.rubber(parambox)
# This is the maximal height (all double spins are visible)
# and the maximal width (the label is initialized to the widest one)
box.layout().activate()
box.setFixedHeight(box.sizeHint().height())
box.setMinimumWidth(box.sizeHint().width())
def __init__(self):
super().__init__()
self.data = None
self.extra_data = None
self.extra_data = None
self.model = itemmodels.VariableListModel()
self.model_unique_with_id = itemmodels.VariableListModel()
self.extra_model_unique = itemmodels.VariableListModel()
self.extra_model_unique_with_id = itemmodels.VariableListModel()
box = gui.hBox(self.controlArea, box=None)
self.infoBoxData = gui.label(
box, self, self.dataInfoText(None), box="Data")
self.infoBoxExtraData = gui.label(
box, self, self.dataInfoText(None), box="Extra Data")
grp = gui.radioButtonsInBox(
self.controlArea, self, "merging", box="Merging",
callback=self.change_merging)
self.attr_boxes = []
radio_width = \
QApplication.style().pixelMetric(QStyle.PM_ExclusiveIndicatorWidth)
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)
add_option("Append columns from Extra Data",
"by matching", "with", "augment",
self.model, self.extra_model_unique)
add_option("Find matching rows", "where",
"equals", "merge",
self.model_unique_with_id, self.extra_model_unique_with_id)
add_option("Concatenate tables, merge rows",
"where", "equals", "combine",
self.model_unique_with_id, self.extra_model_unique_with_id)
self.set_merging()
def _add_controls_placement(self):
box = gui.widgetBox(
self.controlArea, True,
sizePolicy=(QSizePolicy.Minimum, QSizePolicy.Maximum)
)
self.radio_placement = gui.radioButtonsInBox(
box, self, "placement",
btnLabels=[self.Projection_name[x] for x in Placement],
callback=self.__placement_radio_changed
)
def __init__(self):
super().__init__()
self.stats = []
self.dataset = None
self.posthoc_lines = []
self.label_txts = self.mean_labels = self.boxes = self.labels = \
self.label_txts_all = self.attr_labels = self.order = []
self.p = -1.0
self.scale_x = self.scene_min_x = self.scene_width = 0
self.label_width = 0
common_options = dict(
callback=self.attr_changed, sizeHint=(200, 100))
self.attrs = VariableListModel()
gui.listView(
self.controlArea, self, "attribute", box="Variable",
model=self.attrs, **common_options)
self.group_vars = VariableListModel()
gui.listView(
self.controlArea, self, "group_var", box="Grouping",
model=self.group_vars, **common_options)
# TODO: move Compare median/mean to grouping box
self.display_box = gui.vBox(self.controlArea, "Display")
gui.checkBox(self.display_box, self, "show_annotations", "Annotate",
callback=self.display_changed)
self.compare_rb = gui.radioButtonsInBox(
self.display_box, self, 'compare',
btnLabels=["No comparison", "Compare medians", "Compare means"],
callback=self.display_changed)
self.stretching_box = gui.checkBox(
self.controlArea, self, 'stretched', "Stretch bars", box='Display',
callback=self.display_changed).box
gui.vBox(self.mainArea, addSpace=True)
self.box_scene = QGraphicsScene()
self.box_view = QGraphicsView(self.box_scene)
self.box_view.setRenderHints(QPainter.Antialiasing |
QPainter.TextAntialiasing |
QPainter.SmoothPixmapTransform)
self.box_view.viewport().installEventFilter(self)
self.mainArea.layout().addWidget(self.box_view)
e = gui.hBox(self.mainArea, addSpace=False)
self.infot1 = gui.widgetLabel(e, "<center>No test results.</center>")
self.mainArea.setMinimumWidth(650)
self.stats = self.dist = self.conts = []
self.is_continuous = False
self.update_display_box()
def __init__(self):
super().__init__()
self.stats = []
self.dataset = None
self.posthoc_lines = []
self.label_txts = self.mean_labels = self.boxes = self.labels = \
self.label_txts_all = self.attr_labels = self.order = []
self.p = -1.0
self.scale_x = self.scene_min_x = self.scene_width = 0
self.label_width = 0
common_options = dict(
callback=self.attr_changed, sizeHint=(200, 100))
self.attrs = VariableListModel()
gui.listView(
self.controlArea, self, "attribute", box="Variable",
model=self.attrs, **common_options)
self.group_vars = VariableListModel()
gui.listView(
self.controlArea, self, "group_var", box="Grouping",
model=self.group_vars, **common_options)
# TODO: move Compare median/mean to grouping box
self.display_box = gui.vBox(self.controlArea, "Display")
gui.checkBox(self.display_box, self, "show_annotations", "Annotate",
callback=self.display_changed)
self.compare_rb = gui.radioButtonsInBox(
self.display_box, self, 'compare',
btnLabels=["No comparison", "Compare medians", "Compare means"],
callback=self.display_changed)
self.stretching_box = gui.checkBox(
self.controlArea, self, 'stretched', "Stretch bars", box='Display',
callback=self.display_changed).box
gui.vBox(self.mainArea, addSpace=True)
self.box_scene = QtGui.QGraphicsScene()
self.box_view = QtGui.QGraphicsView(self.box_scene)
self.box_view.setRenderHints(QtGui.QPainter.Antialiasing |
QtGui.QPainter.TextAntialiasing |
QtGui.QPainter.SmoothPixmapTransform)
self.box_view.viewport().installEventFilter(self)
self.mainArea.layout().addWidget(self.box_view)
e = gui.hBox(self.mainArea, addSpace=False)
self.infot1 = gui.widgetLabel(e, "<center>No test results.</center>")
self.mainArea.setMinimumWidth(650)
self.stats = self.dist = self.conts = []
self.is_continuous = False
self.update_display_box()
def __init__(self):
super().__init__()
layout = QGridLayout()
gui.widgetBox(self.controlArea, orientation=layout)
box = gui.radioButtonsInBox(
None,
self,
"multinomial_treatment",
box="Categorical Features",
btnLabels=[x[0] for x in self.multinomial_treats],
callback=self.settings_changed)
gui.rubber(box)
layout.addWidget(box, 0, 0, 2, 1)
box = gui.radioButtonsInBox(
None,
self,
"continuous_treatment",
box="Numeric Features",
btnLabels=[x[0] for x in self.continuous_treats],
callback=self.settings_changed)
box.layout().addStretch(10)
layout.addWidget(box, 0, 1, 2, 1)
box = gui.radioButtonsInBox(
None,
self,
"class_treatment",
box="Categorical Outcome(s)",
btnLabels=[t[0] for t in self.class_treats],
callback=self.settings_changed)
box.layout().addStretch(10)
layout.addWidget(box, 0, 2)
ac = gui.auto_apply(None, self, "autosend", box=False)
layout.addWidget(ac, 1, 2)
self.data = None
self.info.set_input_summary(self.info.NoInput)
self.info.set_output_summary(self.info.NoOutput)
def __init__(self):
super().__init__()
box = gui.vBox(self.controlArea, "Categorical Features")
gui.radioButtonsInBox(
box,
self,
"multinomial_treatment",
btnLabels=[x[0] for x in self.multinomial_treats],
callback=self.settings_changed)
box = gui.vBox(self.controlArea, "Numeric Features")
gui.radioButtonsInBox(box,
self,
"continuous_treatment",
btnLabels=[x[0] for x in self.continuous_treats],
callback=self.settings_changed)
box = gui.vBox(self.controlArea, "Categorical Outcome(s)")
gui.radioButtonsInBox(box,
self,
"class_treatment",
btnLabels=[t[0] for t in self.class_treats],
callback=self.settings_changed)
gui.auto_apply(self.buttonsArea, self, "autosend", box=False)
self.data = None
self.info.set_input_summary(self.info.NoInput)
self.info.set_output_summary(self.info.NoOutput)
def __init__(self):
super().__init__()
layout = QGridLayout()
gui.widgetBox(self.controlArea, orientation=layout)
box = gui.radioButtonsInBox(
None,
self,
"multinomial_treatment",
box="分类特征",
btnLabels=[x[0] for x in self.multinomial_treats],
callback=self.commit.deferred)
gui.rubber(box)
layout.addWidget(box, 0, 0, 2, 1)
box = gui.radioButtonsInBox(
None,
self,
"continuous_treatment",
box="数值特征",
btnLabels=[x[0] for x in self.continuous_treats],
callback=self.commit.deferred)
gui.rubber(box)
layout.addWidget(box, 0, 1, 2, 1)
box = gui.radioButtonsInBox(
None,
self,
"class_treatment",
box="分类结果",
btnLabels=[t[0] for t in self.class_treats],
callback=self.commit.deferred)
gui.rubber(box)
layout.addWidget(box, 0, 2, 2, 1)
gui.auto_apply(self.buttonsArea, self, "autosend")
self.data = None
def __init__(self):
super().__init__()
layout = QGridLayout()
gui.widgetBox(self.controlArea, orientation=layout)
box = gui.radioButtonsInBox(
None,
self,
"multinomial_treatment",
box="Categorical Features",
btnLabels=[x[0] for x in self.multinomial_treats],
callback=self.settings_changed)
gui.rubber(box)
layout.addWidget(box, 0, 0, 2, 1)
box = gui.radioButtonsInBox(
None,
self,
"continuous_treatment",
box="Numeric Features",
btnLabels=[x[0] for x in self.continuous_treats],
callback=self.settings_changed)
gui.rubber(box)
layout.addWidget(box, 0, 1, 2, 1)
box = gui.radioButtonsInBox(
None,
self,
"class_treatment",
box="Categorical Outcome(s)",
btnLabels=[t[0] for t in self.class_treats],
callback=self.settings_changed)
gui.rubber(box)
layout.addWidget(box, 0, 2, 2, 1)
gui.auto_apply(self.buttonsArea, self, "autosend")
self.data = None
def __init__(self):
super().__init__()
self.grouping = []
self.attributes = []
self.stats = []
self.ddataset = None
self.label_txts = self.mean_labels = self.boxes = self.labels = \
self.attr_labels = self.order = []
self.p = -1.0
self.scale_x = self.scene_min_x = self.scene_width = self.label_width \
= 0
self.attr_list_box = gui.listBox(
self.controlArea, self, "attributes_select", "attributes",
box="Variable", callback=self.attr_changed)
self.attrCombo = gui.listBox(
self.controlArea, self, 'grouping_select', "grouping",
box="Grouping", callback=self.attr_changed)
self.sorting_combo = gui.radioButtonsInBox(
self.controlArea, self, 'display', box='Display',
callback=self.display_changed,
btnLabels=["Box plots", "Annotated boxes",
"Compare medians", "Compare means"])
self.stretching_box = gui.checkBox(
self.controlArea, self, 'stretched', "Stretch bars", box='Display',
callback=self.display_changed).box
gui.rubber(self.controlArea)
gui.widgetBox(self.mainArea, addSpace=True)
self.boxScene = QtGui.QGraphicsScene()
self.boxView = QtGui.QGraphicsView(self.boxScene)
self.boxView.setRenderHints(QtGui.QPainter.Antialiasing |
QtGui.QPainter.TextAntialiasing |
QtGui.QPainter.SmoothPixmapTransform)
self.mainArea.layout().addWidget(self.boxView)
self.posthoc_lines = []
e = gui.widgetBox(self.mainArea, addSpace=False, orientation=0)
self.infot1 = gui.widgetLabel(e, "<center>No test results.</center>")
self.mainArea.setMinimumWidth(650)
self.warning = gui.widgetBox(self.controlArea, "Warning:")
self.warning_info = gui.widgetLabel(self.warning, "")
self.warning.hide()
self.stats = self.dist = self.conts = []
self.is_continuous = False
self.set_display_box()
dlg = self.createColorDialog()
self.discPalette = dlg.getDiscretePalette("discPalette")
def __init__(self, parent=None):
widget.OWWidget.__init__(self, parent)
self.data_changed = False
box = gui.widgetBox(self.controlArea, "Multinomial attributes")
gui.radioButtonsInBox(
box, self, "multinomial_treatment",
btnLabels=[x[0] for x in self.multinomial_treats],
callback=self.sendDataIf)
self.controlArea.layout().addSpacing(4)
box = gui.widgetBox(self.controlArea, "Continuous attributes")
gui.radioButtonsInBox(
box, self, "continuous_treatment",
btnLabels=[x[0] for x in self.continuous_treats],
callback=self.sendDataIf)
self.controlArea.layout().addSpacing(4)
box = gui.widgetBox(self.controlArea, "Discrete class attribute")
gui.radioButtonsInBox(
box, self, "class_treatment",
btnLabels=[t[0] for t in self.class_treats],
callback=self.sendDataIf
)
self.controlArea.layout().addSpacing(4)
zbbox = gui.widgetBox(self.controlArea, "Value range")
gui.radioButtonsInBox(
zbbox, self, "zero_based",
btnLabels=self.value_ranges,
callback=self.sendDataIf)
self.controlArea.layout().addSpacing(4)
snbox = gui.widgetBox(self.controlArea, "Send data")
gui.button(snbox, self, "Send data", callback=self.sendData,
default=True)
gui.checkBox(snbox, self, "autosend", "Send automatically",
callback=self.enableAuto)
self.data = None
self.resize(150, 300)
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_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):
super().__init__()
self.data = None
# GUI
box = gui.vBox(self.controlArea, "Feature names")
self.feature_radio = gui.radioButtonsInBox(
box, self, "feature_type", callback=lambda: self.apply(), btnLabels=["Generic", "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(self.feature_radio.buttons[0])),
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
)
def __init__(self,parent=None, signalManager = None, name = "Continuizer"):
widget.OWWidget.__init__(self, parent, signalManager, name, wantMainArea = 0)
self.targetValue = 0
self.autosend = 0
self.dataChanged = False
bgMultiTreatment = gui.widgetBox(self.controlArea, "Multinomial attributes")
gui.radioButtonsInBox(bgMultiTreatment, self, "multinomialTreatment", btnLabels=[x[0] for x in self.multinomialTreats], callback=self.sendDataIf)
self.controlArea.layout().addSpacing(4)
bgMultiTreatment = gui.widgetBox(self.controlArea, "Continuous attributes")
gui.radioButtonsInBox(bgMultiTreatment, self, "continuousTreatment", btnLabels=[x[0] for x in self.continuousTreats], callback=self.sendDataIf)
self.controlArea.layout().addSpacing(4)
bgClassTreatment = gui.widgetBox(self.controlArea, "Discrete class attribute")
self.ctreat =gui.radioButtonsInBox(bgClassTreatment, self, "classTreatment", btnLabels=[x[0] for x in self.classTreats], callback=self.sendDataIf)
# hbox = OWGUI.widgetBox(bgClassTreatment, orientation = "horizontal")
# OWGUI.separator(hbox, 19, 4)
hbox = gui.indentedBox(bgClassTreatment, sep=gui.checkButtonOffsetHint(self.ctreat.buttons[-1]), orientation="horizontal")
self.cbTargetValue = gui.comboBox(hbox, self, "targetValue", label="Target Value ", items=[], orientation="horizontal", callback=self.cbTargetSelected)
def setEnabled(*args):
self.cbTargetValue.setEnabled(self.classTreatment == 3)
self.ctreat.group.buttonClicked.connect(setEnabled)
setEnabled()
self.controlArea.layout().addSpacing(4)
zbbox = gui.widgetBox(self.controlArea, "Value range")
gui.radioButtonsInBox(zbbox, self, "zeroBased", btnLabels=self.valueRanges, callback=self.sendDataIf)
self.controlArea.layout().addSpacing(4)
snbox = gui.widgetBox(self.controlArea, "Send data")
gui.button(snbox, self, "Send data", callback=self.sendData, default=True)
gui.checkBox(snbox, self, "autosend", "Send automatically", callback=self.enableAuto)
self.data = None
#self.sendPreprocessor()
self.resize(150,300)
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")
box = gui.widgetBox(self.controlArea, self.tr("Regularization"))
form = QtGui.QFormLayout()
form.setContentsMargins(0, 0, 0, 0)
box.layout().addLayout(form)
buttonbox = gui.radioButtonsInBox(
box, self, "penalty_type", btnLabels=("L1", "L2"),
orientation="horizontal"
)
form.addRow(self.tr("Penalty type:"), buttonbox)
spin = gui.doubleSpin(box, self, "C", 0.0, 1024.0, step=0.0001)
form.addRow("Reg (C):", spin)
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(250)
self.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.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, parent=None):
super().__init__(self, parent)
self.clusterDataset = None
self.referenceDataset = None
self.ontology = None
self.annotations = None
self.loadedAnnotationCode = "---"
self.treeStructRootKey = None
self.probFunctions = [stats.Binomial(), stats.Hypergeometric()]
self.selectedTerms = []
self.selectionChanging = 0
self.__state = OWGOEnrichmentAnalysis.Initializing
self.annotationCodes = []
#############
## GUI
#############
self.tabs = gui.tabWidget(self.controlArea)
## Input tab
self.inputTab = gui.createTabPage(self.tabs, "Input")
box = gui.widgetBox(self.inputTab, "Info")
self.infoLabel = gui.widgetLabel(box, "No data on input\n")
gui.button(box, self, "Ontology/Annotation Info",
callback=self.ShowInfo,
tooltip="Show information on loaded ontology and annotations")
box = gui.widgetBox(self.inputTab, "Organism")
self.annotationComboBox = gui.comboBox(
box, self, "annotationIndex", items=self.annotationCodes,
callback=self._updateEnrichment, tooltip="Select organism")
genebox = gui.widgetBox(self.inputTab, "Gene Names")
self.geneAttrIndexCombo = gui.comboBox(
genebox, self, "geneAttrIndex", callback=self._updateEnrichment,
tooltip="Use this attribute to extract gene names from input data")
self.geneAttrIndexCombo.setDisabled(self.useAttrNames)
cb = gui.checkBox(genebox, self, "useAttrNames", "Use column names",
tooltip="Use column names for gene names",
callback=self._updateEnrichment)
cb.toggled[bool].connect(self.geneAttrIndexCombo.setDisabled)
gui.button(genebox, self, "Gene matcher settings",
callback=self.UpdateGeneMatcher,
tooltip="Open gene matching settings dialog")
self.referenceRadioBox = gui.radioButtonsInBox(
self.inputTab, self, "useReferenceDataset",
["Entire genome", "Reference set (input)"],
tooltips=["Use entire genome for reference",
"Use genes from Referece Examples input signal as reference"],
box="Reference", callback=self._updateEnrichment)
self.referenceRadioBox.buttons[1].setDisabled(True)
gui.radioButtonsInBox(
self.inputTab, self, "aspectIndex",
["Biological process", "Cellular component", "Molecular function"],
box="Aspect", callback=self._updateEnrichment)
## Filter tab
self.filterTab = gui.createTabPage(self.tabs, "Filter")
box = gui.widgetBox(self.filterTab, "Filter GO Term Nodes")
gui.checkBox(box, self, "filterByNumOfInstances", "Genes",
callback=self.FilterAndDisplayGraph,
tooltip="Filter by number of input genes mapped to a term")
ibox = gui.indentedBox(box)
gui.spin(ibox, self, 'minNumOfInstances', 1, 100,
step=1, label='#:', labelWidth=15,
callback=self.FilterAndDisplayGraph,
callbackOnReturn=True,
tooltip="Min. number of input genes mapped to a term")
gui.checkBox(box, self, "filterByPValue_nofdr", "p-value",
callback=self.FilterAndDisplayGraph,
tooltip="Filter by term p-value")
gui.doubleSpin(gui.indentedBox(box), self, 'maxPValue_nofdr', 1e-8, 1,
step=1e-8, label='p:', labelWidth=15,
callback=self.FilterAndDisplayGraph,
callbackOnReturn=True,
tooltip="Max term p-value")
#use filterByPValue for FDR, as it was the default in prior versions
gui.checkBox(box, self, "filterByPValue", "FDR",
callback=self.FilterAndDisplayGraph,
tooltip="Filter by term FDR")
gui.doubleSpin(gui.indentedBox(box), self, 'maxPValue', 1e-8, 1,
step=1e-8, label='p:', labelWidth=15,
callback=self.FilterAndDisplayGraph,
callbackOnReturn=True,
tooltip="Max term p-value")
box = gui.widgetBox(box, "Significance test")
gui.radioButtonsInBox(box, self, "probFunc", ["Binomial", "Hypergeometric"],
tooltips=["Use binomial distribution test",
"Use hypergeometric distribution test"],
callback=self._updateEnrichment)
box = gui.widgetBox(self.filterTab, "Evidence codes in annotation",
addSpace=True)
self.evidenceCheckBoxDict = {}
for etype in go.evidenceTypesOrdered:
ecb = QCheckBox(
etype, toolTip=go.evidenceTypes[etype],
checked=self.useEvidenceType[etype])
ecb.toggled.connect(self.__on_evidenceChanged)
box.layout().addWidget(ecb)
self.evidenceCheckBoxDict[etype] = ecb
## Select tab
self.selectTab = gui.createTabPage(self.tabs, "Select")
box = gui.radioButtonsInBox(
self.selectTab, self, "selectionDirectAnnotation",
["Directly or Indirectly", "Directly"],
box="Annotated genes",
callback=self.ExampleSelection)
box = gui.widgetBox(self.selectTab, "Output", addSpace=True)
gui.radioButtonsInBox(
box, self, "selectionDisjoint",
btnLabels=["All selected genes",
"Term-specific genes",
"Common term genes"],
tooltips=["Outputs genes annotated to all selected GO terms",
"Outputs genes that appear in only one of selected GO terms",
"Outputs genes common to all selected GO terms"],
callback=[self.ExampleSelection,
self.UpdateAddClassButton])
self.addClassCB = gui.checkBox(
box, self, "selectionAddTermAsClass", "Add GO Term as class",
callback=self.ExampleSelection)
# ListView for DAG, and table for significant GOIDs
self.DAGcolumns = ['GO term', 'Cluster', 'Reference', 'p-value',
'FDR', 'Genes', 'Enrichment']
self.splitter = QSplitter(Qt.Vertical, self.mainArea)
self.mainArea.layout().addWidget(self.splitter)
# list view
self.listView = GOTreeWidget(self.splitter)
self.listView.setSelectionMode(QTreeView.ExtendedSelection)
self.listView.setAllColumnsShowFocus(1)
self.listView.setColumnCount(len(self.DAGcolumns))
self.listView.setHeaderLabels(self.DAGcolumns)
self.listView.header().setSectionsClickable(True)
self.listView.header().setSortIndicatorShown(True)
self.listView.setSortingEnabled(True)
self.listView.setItemDelegateForColumn(
6, EnrichmentColumnItemDelegate(self))
self.listView.setRootIsDecorated(True)
self.listView.itemSelectionChanged.connect(self.ViewSelectionChanged)
# table of significant GO terms
self.sigTerms = QTreeWidget(self.splitter)
self.sigTerms.setColumnCount(len(self.DAGcolumns))
self.sigTerms.setHeaderLabels(self.DAGcolumns)
self.sigTerms.setSortingEnabled(True)
self.sigTerms.setSelectionMode(QTreeView.ExtendedSelection)
self.sigTerms.setItemDelegateForColumn(
6, EnrichmentColumnItemDelegate(self))
self.sigTerms.itemSelectionChanged.connect(self.TableSelectionChanged)
self.sigTableTermsSorted = []
self.graph = {}
self.inputTab.layout().addStretch(1)
self.filterTab.layout().addStretch(1)
self.selectTab.layout().addStretch(1)
self.setBlocking(True)
self._executor = ThreadExecutor()
self._init = EnsureDownloaded(
[(taxonomy.Taxonomy.DOMAIN, taxonomy.Taxonomy.FILENAME),
("GO", "taxonomy.pickle")]
)
self._init.finished.connect(self.__initialize_finish)
self._executor.submit(self._init)
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__()
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__()
# 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 = []
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 = QGridLayout()
typebox = gui.radioButtonsInBox(self.controlArea, self, "lossfunc", [], orientation=form)
# Loss function control
box = gui.widgetBox(self.controlArea, self.tr("Loss function to be used"))
buttonbox = gui.radioButtonsInBox(
box,
self,
"loss_function",
btnLabels=["Squared loss", "Huber", "Epsilon insensitive", "Squared Epsilon insensitive"],
callback=self._on_func_changed,
)
parambox = gui.widgetBox(box, orientation="horizontal")
box = gui.widgetBox(self.controlArea, self.tr("Penalty"))
buttonbox = gui.radioButtonsInBox(
box,
self,
"penalty_type",
btnLabels=["Absolute norm (L1)", "Euclidean norm (L2)", "Elastic Net (both)"],
callback=self._on_penalty_changed,
)
parambox = gui.widgetBox(box, orientation="horizontal")
box = gui.widgetBox(self.controlArea, self.tr("Learning rate"))
buttonbox = gui.radioButtonsInBox(
box, self, "learning_rate", btnLabels=["Inverse scaling", "Constant"], callback=self._on_lrate_changed
)
box = gui.widgetBox(self.controlArea, self.tr("Constants"))
form = QtGui.QFormLayout()
form.setContentsMargins(0, 0, 0, 0)
box.layout().addLayout(form)
alpha = gui.doubleSpin(box, self, "alpha", 0.0, 10.0, step=0.0001)
form.addRow("Alpha:", alpha)
spin = gui.doubleSpin(box, self, "eta0", 0.0, 10, step=0.01)
form.addRow("Eta0:", spin)
epsilon = gui.doubleSpin(box, self, "epsilon", 0.0, 10.0, step=0.01)
form.addRow("Epsilon:", epsilon)
l1_ratio = gui.doubleSpin(box, self, "l1_ratio", 0.0, 10.0, step=0.01)
form.addRow("L1 ratio:", l1_ratio)
power_t = gui.doubleSpin(box, self, "power_t", 0.0, 10.0, step=0.01)
form.addRow("Power t:", power_t)
# Number of iterations control
box = gui.widgetBox(self.controlArea, "Number of iterations")
gui.doubleSpin(box, self, "n_iter", 0, 1e6, step=1)
self._func_params = [epsilon]
self._penalty_params = [l1_ratio]
self._lrate_params = [power_t]
gui.button(self.controlArea, self, "&Apply", callback=self.apply, default=True)
self._on_func_changed()
self.apply()