def init(self, parent):
""" Finishes initializing the editor by creating the underlying toolkit
widget.
"""
factory = self.factory
adapter = self.adapter = factory.adapter
self.model = TabularModel(editor=self)
# Create the control
control = self.control = self.widget_factory(self)
# Set up the selection listener
if factory.multi_select:
self.sync_value(factory.selected,
'multi_selected',
'both',
is_list=True)
self.sync_value(factory.selected_row,
'multi_selected_rows',
'both',
is_list=True)
else:
self.sync_value(factory.selected, 'selected', 'both')
self.sync_value(factory.selected_row, 'selected_row', 'both')
# Connect to the mode specific selection handler
if factory.multi_select:
slot = self._on_rows_selection
else:
slot = self._on_row_selection
signal = 'selectionChanged(QItemSelection,QItemSelection)'
QtCore.QObject.connect(self.control.selectionModel(),
QtCore.SIGNAL(signal), slot)
# Synchronize other interesting traits as necessary:
self.sync_value(factory.update, 'update', 'from')
self.sync_value(factory.refresh, 'refresh', 'from')
self.sync_value(factory.activated, 'activated', 'to')
self.sync_value(factory.activated_row, 'activated_row', 'to')
self.sync_value(factory.clicked, 'clicked', 'to')
self.sync_value(factory.dclicked, 'dclicked', 'to')
self.sync_value(factory.right_clicked, 'right_clicked', 'to')
self.sync_value(factory.right_dclicked, 'right_dclicked', 'to')
self.sync_value(factory.column_clicked, 'column_clicked', 'to')
self.sync_value(factory.column_right_clicked, 'column_right_clicked',
'to')
self.sync_value(factory.scroll_to_row, 'scroll_to_row', 'from')
# Connect other signals as necessary
signal = QtCore.SIGNAL('activated(QModelIndex)')
QtCore.QObject.connect(control, signal, self._on_activate)
signal = QtCore.SIGNAL('clicked(QModelIndex)')
QtCore.QObject.connect(control, signal, self._on_click)
signal = QtCore.SIGNAL('clicked(QModelIndex)')
QtCore.QObject.connect(control, signal, self._on_right_click)
signal = QtCore.SIGNAL('doubleClicked(QModelIndex)')
QtCore.QObject.connect(control, signal, self._on_dclick)
signal = QtCore.SIGNAL('sectionClicked(int)')
QtCore.QObject.connect(control.horizontalHeader(), signal,
self._on_column_click)
control.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
signal = QtCore.SIGNAL('customContextMenuRequested(QPoint)')
QtCore.QObject.connect(control, signal, self._on_context_menu)
self.header_event_filter = HeaderEventFilter(self)
control.horizontalHeader().installEventFilter(self.header_event_filter)
# Make sure we listen for 'items' changes as well as complete list
# replacements:
try:
self.context_object.on_trait_change(self.update_editor,
self.extended_name + '_items',
dispatch='ui')
except:
pass
# If the user has requested automatic update, attempt to set up the
# appropriate listeners:
if factory.auto_update:
self.context_object.on_trait_change(self.refresh_editor,
self.extended_name + '.-',
dispatch='ui')
# Create the mapping from user supplied images to QImages:
for image_resource in factory.images:
self._add_image(image_resource)
# Refresh the editor whenever the adapter changes:
self.on_trait_change(self.refresh_editor,
'adapter.+update',
dispatch='ui')
# Rebuild the editor columns and headers whenever the adapter's
# 'columns' changes:
self.on_trait_change(self.update_editor,
'adapter.columns',
dispatch='ui')
# separate data into training and test data
batch_size = 60000
test_size = int(batch_size * 0.2)
cat_train = cats[:batch_size - test_size]
cat_test = cats[batch_size - test_size:batch_size]
con_train = conts[:batch_size - test_size]
con_test = conts[batch_size - test_size:batch_size]
y_train = y[:batch_size - test_size]
y_test = y[batch_size - test_size:batch_size]
# Neural Networky stuff
selfembeds = nn.ModuleList([nn.Embedding(ni, nf) for ni, nf in emb_szs])
torch.manual_seed(33)
model = TabularModel(emb_szs, conts.shape[1], 1, [200, 100], p=0.4)
criterion = nn.MSELoss() # we'll convert this to RMSE later
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
start_time = time.time()
epochs = 300
losses = []
for i in range(epochs):
i += 1
y_pred = model(cat_train, con_train)
loss = torch.sqrt(criterion(y_pred, y_train)) # RMSE
losses.append(loss)
