def getDatasetByName(self, name) -> DataSet:
if name not in self.datasets:
return None
dataset = DataSet()
dataSetPath = os.path.join(self.project_location, "data", name,
name + ".json")
dataset.loadDataSet(dataSetPath)
return dataset
def evaluate(self):
# Data presentation
evalSet = []
testSet = DataSet()
testSet.loadDataSet(self.currentProfile.testSetPath)
evalSet.append(testSet)
if self.ui.training_set.isChecked():
trainSet = DataSet()
trainSet.loadDataSet(self.currentProfile.trainSetPath)
evalSet.append(trainSet)
if self.ui.validation_set.isChecked():
valSet = DataSet()
valSet.loadDataSet(self.currentProfile.valSetPath)
evalSet.append(valSet)
# Feature extraction
samples, inputs, expectedOutput = prepare_input_output(evalSet,
self.currentProfile.features,
save_features_folder=self.currentProfile.featureFolder,
traceCallBack=self.displayState,
returnSamples=True)
# Load model
self.displayState("Loading model ...")
model = loadModel(self.currentProfile.trainedModelPath)
# Predictions
self.displayState("Predicting ...")
predictions = model.predict(inputs)
# Result classification
result_matrix = np.zeros((len(evalSet[0].labels) + 1, len(evalSet[0].labels) + 1))
for sample, prediction, expectedResult in zip(samples, predictions, expectedOutput):
ct = np.where(expectedResult > 0.0)[0] # Class truth
if len(ct) == 0:
ct = 0
else:
ct = ct[0] + 1
triggered = max(prediction) > self.ui.threshold.value()
if not triggered:
cp = 0
else:
cp = np.argmax(prediction) + 1 # Class predicted
result_matrix[ct][cp] += 1
if ct != cp:
self.addFalseSample(sample, (ct, cp))
# Display results
self.setTableValues(result_matrix)
self.displayMetrics(result_matrix)
def onRemoveClicked(self):
selectedSamples = []
for i in range(self.ui.false_samples.count()):
item = self.ui.false_samples.item(i)
widget = self.ui.false_samples.itemWidget(item)
if widget.CB.isChecked():
selectedSamples.append(widget.sample)
if len(selectedSamples) == 0:
return
testSet = DataSet()
testSet.loadDataSet(self.currentProfile.testSetPath)
trainSet = DataSet()
trainSet.loadDataSet(self.currentProfile.trainSetPath)
valSet = DataSet()
valSet.loadDataSet(self.currentProfile.valSetPath)
dialog = RemoveSamplesDialog(self, selectedSamples,
[testSet, trainSet, valSet],
self.currentProfile.dataset,
outputFolder=self.currentProfile.folder)
dialog.on_removed.connect(self.onSamplesRemoved)
dialog.show()
def train(self):
# Training session
if self.trainingSession is None:
if self.currentTrained.hasModel:
model = loadModel(self.currentTrained.trainedModelPath)
else:
self.updateState("Creating neural net")
model = self.currentTrained.model.toKerasModel(
self.currentTrained.features.feature_shape,
len(self.project.keywords))
saveModel(model, self.currentTrained.trainedModelPath)
self.currentTrained.hasModel = True
self.trainingSession = TrainingSession(model,
self.currentTrained.epoch)
# Set charts ranges
self.accChart.setRangeX(
0, self.trainingSession.epoch + self.ui.epoch_SB.value())
self.lossChart.setRangeX(
0, self.trainingSession.epoch + self.ui.epoch_SB.value())
# Fetch sets
trainSet = DataSet()
trainSet.loadDataSet(self.currentTrained.trainSetPath)
valSet = DataSet()
valSet.loadDataSet(self.currentTrained.valSetPath)
# prepare inputs / outputs
train_input, train_output = prepare_input_output(
[trainSet],
self.currentTrained.features,
traceCallBack=self.updateState,
save_features_folder=self.currentTrained.featureFolder)
val_input, val_output = prepare_input_output(
[valSet],
self.currentTrained.features,
traceCallBack=self.updateState,
save_features_folder=self.currentTrained.featureFolder)
# Set callbacks
callbacks = callbacksDef(self.currentTrained.trainedModelPath,
self.train_callback)
# training
self.trainingSession.model.fit(
train_input,
train_output,
batch_size=self.ui.batch_SB.value(),
initial_epoch=self.trainingSession.epoch,
epochs=self.trainingSession.epoch + self.ui.epoch_SB.value() + 1,
callbacks=callbacks,
validation_data=(val_input, val_output),
verbose=0,
shuffle=self.ui.shuffle_CB.isChecked())
self.currentTrained.isTrained = True
self.currentTrained.writeTrained()
self.project.trained_updated.emit()
self.currentTrained.epoch = self.trainingSession.epoch
self.currentTrained.writeTrained()
# Write training logs
self.writeLogs()