promote main GUI, complete potential classifier

Author: Centauria

classifier/classifier_potential.py

@@ -17,8 +17,8 @@ class PotentialClassifier(classifier.AbstractClassifier):
 
     def __init__(self, X, y, classes: iter = None,
                  potential_function=PotentialFunctions.exponential()):
-        self.X = X
-        self.y = y
+        self.X = np.array(X)
+        self.y = np.array(y)
         self.W = None
         classes = classes or set(y)
         self.class_binder = utils.Binder.create_standard_binder(classes)
@@ -37,15 +37,16 @@ def initialize(self):
 
         point_flag = np.zeros((data_num, 1))
         point_potential = np.zeros((data_num, len(self.class_binder.input_names)))
-        for i in range(data_num):
+        i = 0
+        while i < data_num:
             if point_potential[i, self.data_type(i)] == np.max(np.squeeze(point_potential[i, :])) \
                     and point_potential[i, self.data_type(i)] != 0:
-                pass
+                i += 1
             else:
                 point_flag[i] += 1
                 for j in range(data_num):
                     point_potential[j, self.data_type(i)] += potential[i, j]
-                i = 1
+                i = 0
         self.W = point_flag
         return point_flag
 
@@ -62,8 +63,8 @@ def evaluate(self, test_data: np.ndarray):
         for i in range(test_len):
             for j in range(train_len):
                 test_potential[i, self.data_type(j)] += self.W[j] * potential[i, j]
-        
-        test_type = np.zeros((test_len, 1))
+
+        test_type = np.zeros((test_len, 1), dtype=np.object)
         for i in range(test_len):
             height = np.max(test_potential[i, :])
             test_flag = np.argmax(test_potential[i, :])

main.py

@@ -1,13 +1,15 @@
-from PyQt5.QtWidgets import QApplication, QMainWindow, QFileDialog, QMessageBox, QTableWidgetItem, QComboBox, \
-    QTableView, QMenu, QListWidgetItem, QPushButton
+from PyQt5.QtWidgets import QApplication, QMainWindow, QFileDialog, QInputDialog, QMessageBox, QTableWidgetItem, \
+    QComboBox, QCheckBox, QTableView, QMenu, QListWidgetItem, QPushButton
 from PyQt5.QtCore import pyqtSignal, pyqtSlot, QUrl, QModelIndex
 from PyQt5.QtGui import QCursor
 import sys
 import os
 import pandas as pd
+import numpy as np
 import ui
 import qtutils
 import utils
+import classifier
 
 
 class HelpWindow(QMainWindow, ui.Ui_HelpWindow):
@@ -41,16 +43,30 @@ def __init__(self, parent=None):
         self.options_tableWidget.setEditTriggers(QTableView.NoEditTriggers)
         self.options_tableWidget.itemSelectionChanged.connect(self.on_column_selected)
         self.plotQt = qtutils.PlotQt()
-        self.xButton.clicked.connect(lambda: self.actionset_x.trigger())
-        self.yButton.clicked.connect(lambda: self.actionset_y.trigger())
-        self.cButton.clicked.connect(lambda: self.actionset_c.trigger())
+        self.xButton.clicked.connect(self.actionset_x.trigger)
+        self.yButton.clicked.connect(self.actionset_y.trigger)
+        self.cButton.clicked.connect(self.actionset_c.trigger)
+        self.classifier_property_pushButton.clicked.connect(self.set_property)
+        self.create_classifier_pushButton.clicked.connect(self.create_classifier)
+        self.show_test_pushButton.clicked.connect(self.evaluate_classifier)
+        self.train_checkBox.toggled.connect(lambda toggled: self.on_checkBoxes_toggled(self.train_checkBox, toggled))
+        self.test_checkBox.toggled.connect(lambda toggled: self.on_checkBoxes_toggled(self.test_checkBox, toggled))
+        self.result_checkBox.toggled.connect(lambda toggled: self.on_checkBoxes_toggled(self.result_checkBox, toggled))
         """Initialize data"""
-        self.data = []
+        self.data = dict()
         self.currentData = None
         self.currentDataBinder = utils.Binder(input_names=('c', 'x', 'y'))
+        self.currentTestData = None
+        self.currentTestResult = None
+        self.currentTestAccuracy = None
         self.fileBinder = utils.Binder(input_names=('train', 'test'))
         self.currentTrace = []
         self.supportedFormat = ['csv files (*.csv)', 'Microsoft Excel (*.xls *.xlsx)']
+        self.classifier: classifier.AbstractClassifier = None
+        self.classifier_property = ('exp', 1.0)
+        self.show_train_data = True
+        self.show_test_data = False
+        self.show_result_data = False
 
     def resizeEvent(self, event):
         # self.root_horizontal.resize(event.size().width(), event.size().height() - 25)
@@ -61,36 +77,56 @@ def open_help_window(self):
         self.helpWindow.show()
 
     def open_open_dialog(self):
+        self.statusbar.showMessage('正在选择文件……')
         fname, format = QFileDialog.getOpenFileName(self, caption='打开文件', filter=';;'.join(self.supportedFormat))
         if format == self.supportedFormat[0]:
+            self.statusbar.showMessage('正在打开文件……')
             data = pd.read_csv(fname)
         elif format == self.supportedFormat[1]:
+            self.statusbar.showMessage('正在打开文件……')
             data = pd.read_excel(fname)
         elif fname and format:
             QMessageBox.warning(self, '文件格式不正确', fname + '的文件格式不正确！', QMessageBox.Ok)
+            self.statusbar.clearMessage()
             return
         else:
+            self.statusbar.clearMessage()
             return
 
-        self.data.append(data)
-        self.action_insert_file(os.path.split(fname)[1])
+        file_name = os.path.split(fname)[1]
+        self.data[file_name] = data
+        self.insert_file(file_name)
+        self.statusbar.clearMessage()
 
-    def action_insert_file(self, file_name):
+    def insert_file(self, file_name):
         self.fileBinder.output_names += (file_name,)
         self.files_tableWidget.setRowCount(self.files_tableWidget.rowCount() + 1)
         self.files_tableWidget.setItem(self.files_tableWidget.rowCount() - 1, 0, QTableWidgetItem(file_name))
         self.files_tableWidget.setItem(self.files_tableWidget.rowCount() - 1, 1, QTableWidgetItem())
 
     @pyqtSlot(int, int)
     def on_file_dblclicked(self, i, j):
-        self.currentData = self.data[i]
+        self.statusbar.showMessage('正在加载文件……')
+        current_index = list(self.data.keys())[i]
+        self.currentData = self.data[current_index]
         self.options_tableWidget.setRowCount(0)
+        self.currentDataBinder.output_names = self.currentData.columns
+        self.actionset_train.trigger()
         for c in self.currentData.columns:
-            self.currentDataBinder.output_names += (c,)
             self.options_tableWidget.setRowCount(self.options_tableWidget.rowCount() + 1)
             self.options_tableWidget.setItem(self.options_tableWidget.rowCount() - 1, 0, QTableWidgetItem(c))
             self.options_tableWidget.setItem(self.options_tableWidget.rowCount() - 1, 1, QTableWidgetItem())
+        self.statusbar.clearMessage()
 
+    def on_checkBoxes_toggled(self, cb: QCheckBox, toggled):
+        if cb == self.train_checkBox:
+            self.show_train_data = toggled
+        elif cb == self.test_checkBox:
+            self.show_test_data = toggled
+        elif cb == self.result_checkBox:
+            self.show_result_data = toggled
+        self.plot_refresh()
+    
     def on_file_selected(self):
         have_selected = len(self.files_tableWidget.selectedItems()) != 0
         self.menuset_current_file_as.setEnabled(have_selected)
@@ -117,8 +153,16 @@ def on_file_set(self, option, trig):
         selected_item: QTableWidgetItem = self.files_tableWidget.item(selected_index.row(), 0)
         if trig:
             self.fileBinder.connect(option, selected_item.text())
+            if option == 'train':
+                self.currentData = self.data[selected_item.text()]
+            elif option == 'test':
+                self.currentTestData = self.data[selected_item.text()]
         else:
             self.fileBinder.disconnect(option, selected_item.text())
+            if option == 'train':
+                self.currentData = None
+            elif option == 'test':
+                self.currentTestData = None
         for i in range(self.files_tableWidget.rowCount()):
             col: QTableWidgetItem = self.files_tableWidget.item(i, 0)
             op: QTableWidgetItem = self.files_tableWidget.item(i, 1)
@@ -133,17 +177,7 @@ def on_option_set(self, option, trig):
             self.currentDataBinder.connect(option, selected_item.text())
         else:
             self.currentDataBinder.disconnect(option, selected_item.text())
-        data_x = self.currentDataBinder.infer('x')
-        data_y = self.currentDataBinder.infer('y')
-        data_c = self.currentDataBinder.infer('c')
-        if data_x and data_y:
-            if data_c:
-                html_path, self.currentTrace = self.plotQt.scatter(self.currentData[data_x], self.currentData[data_y],
-                                                                   self.currentData[data_c])
-                self.plotter.load(QUrl.fromLocalFile(html_path))
-            else:
-                html_path, self.currentTrace = self.plotQt.scatter(self.currentData[data_x], self.currentData[data_y])
-                self.plotter.load(QUrl.fromLocalFile(html_path))
+        self.plot_refresh()
         for i in range(self.options_tableWidget.rowCount()):
             col: QTableWidgetItem = self.options_tableWidget.item(i, 0)
             op: QTableWidgetItem = self.options_tableWidget.item(i, 1)
@@ -180,6 +214,148 @@ def set_column_menu_status(self, option):
             self.actionset_y.setChecked(False)
             self.actionset_c.setChecked(False)
 
+    def set_property(self):
+        func, ok = QInputDialog.getItem(self, 'Parameters', '势函数', ['exp', 'cauchy'])
+        if ok:
+            alpha, ok = QInputDialog.getDouble(self, 'Parameters', 'alpha', 1.0)
+            if ok:
+                self.classifier_property = (func, alpha)
+
+    def plot_new(self, x, y, c=None, marker=None):
+        html_path, self.currentTrace = self.plotQt.scatter(x, y, c, marker=marker)
+        self.plotter.load(QUrl.fromLocalFile(html_path))
+
+    def plot_append(self, x, y, c=None, marker=None):
+        html_path, self.currentTrace = self.plotQt.scatter(x, y, c, traces=self.currentTrace, marker=marker)
+        self.plotter.load(QUrl.fromLocalFile(html_path))
+
+    def plot_clear(self):
+        self.plotter.setHtml('')
+
+    def plot_refresh(self):
+        self.statusbar.showMessage('正在自动绘图……')
+        data_x = self.currentDataBinder.infer('x')
+        data_y = self.currentDataBinder.infer('y')
+        data_c = self.currentDataBinder.infer('c')
+        self.plot_clear()
+        self.currentTrace = None
+        if data_x and data_y:
+            if self.show_train_data:
+                if data_c:
+                    self.plot_append(
+                            self.currentData[data_x],
+                            self.currentData[data_y],
+                            self.currentData[data_c],
+                            marker=dict(
+                                    size=3
+                            )
+                    )
+                else:
+                    self.plot_append(
+                            self.currentData[data_x],
+                            self.currentData[data_y],
+                            marker=dict(
+                                    size=3
+                            )
+                    )
+            if self.show_test_data:
+                if self.currentTestData is not None:
+                    if data_c:
+                        self.plot_append(
+                                self.currentTestData[data_x],
+                                self.currentTestData[data_y],
+                                self.currentTestData[data_c],
+                                marker=dict(
+                                        size=6,
+                                        symbol='circle-open'
+                                )
+                        )
+                    else:
+                        self.plot_append(
+                                self.currentTestData[data_x],
+                                self.currentTestData[data_y],
+                                marker=dict(
+                                        size=6,
+                                        symbol='circle-open'
+                                )
+                        )
+            if self.show_result_data:
+                if self.currentTestResult is not None:
+                    test_result = self.currentTestData[[data_x, data_y]]
+                    test_result[data_c] = self.currentTestResult
+                    if data_c:
+                        self.plot_append(
+                                test_result[data_x],
+                                test_result[data_y],
+                                test_result[data_c],
+                                marker=dict(
+                                        size=6,
+                                        symbol='cross'
+                                )
+                        )
+                    else:
+                        self.plot_append(
+                                test_result[data_x],
+                                test_result[data_y],
+                                marker=dict(
+                                        size=6,
+                                        symbol='cross'
+                                )
+                        )
+        self.statusbar.clearMessage()
+
+    def create_classifier(self):
+        self.statusbar.showMessage('正在创建分类器……')
+        if not self.currentDataBinder.infer('c'):
+            QMessageBox.warning(self, '警告', '请指定输入数据的类别列！', QMessageBox.Ok)
+            self.statusbar.clearMessage()
+            return
+        # index = list(set(self.currentData.columns) - {self.currentDataBinder.infer('c')})
+        index = list(self.currentData.columns).copy()
+        index.remove(self.currentDataBinder.infer('c'))
+        func, alpha = self.classifier_property
+        if func == 'exp':
+            self.classifier = classifier.PotentialClassifier(
+                    self.currentData[index],
+                    self.currentData[self.currentDataBinder.infer('c')],
+                    potential_function=classifier.PotentialFunctions.exponential(alpha)
+            )
+        elif func == 'cauchy':
+            self.classifier = classifier.PotentialClassifier(
+                    self.currentData[index],
+                    self.currentData[self.currentDataBinder.infer('c')],
+                    potential_function=classifier.PotentialFunctions.cauchy(alpha)
+            )
+        QMessageBox.information(self, '提示', '设置成功！', QMessageBox.Ok)
+        self.statusbar.clearMessage()
+
+    def evaluate_classifier(self):
+        if self.classifier is not None:
+            file_test = self.fileBinder.infer('test')
+            if file_test:
+                self.currentTestData = self.data[file_test]
+                index = list(self.currentData.columns).copy()
+                has_answer = self.currentDataBinder.infer('c') in self.currentTestData.columns
+                index.remove(self.currentDataBinder.infer('c'))
+                for k in index:
+                    if k not in self.currentTestData.columns:
+                        QMessageBox.warning(self, '警告', '测试数据格式不完整！', QMessageBox.Ok)
+                        return
+                test_data = self.currentTestData[index].to_numpy()
+                self.currentTestResult = self.classifier.evaluate(test_data)
+                if has_answer:
+                    correct: np.ndarray = self.currentTestResult == self.currentTestData[
+                        self.currentDataBinder.infer('c')].to_numpy().reshape(-1, 1)
+                    self.currentTestAccuracy = correct.sum() / self.currentTestResult.shape[0]
+                    QMessageBox.information(self, '提示', '测试成功！正确率%.3f' % self.currentTestAccuracy, QMessageBox.Ok)
+                else:
+                    QMessageBox.information(self, '提示', '测试成功！', QMessageBox.Ok)
+                self.plot_refresh()
+            else:
+                QMessageBox.warning(self, '警告', '请先指定测试集文件！', QMessageBox.Ok)
+        else:
+            QMessageBox.warning(self, '警告', '请先创建分类器！', QMessageBox.Ok)
+
 
 if __name__ == '__main__':
     app = QApplication(sys.argv)

qtutils/ParameterDialog.py

@@ -0,0 +1,46 @@
+from PyQt5.QtWidgets import QDialog, QComboBox, QFormLayout, QHBoxLayout, QLabel, QSlider, QLineEdit
+from PyQt5.QtGui import QDoubleValidator
+from PyQt5.QtCore import Qt
+
+
+class ParameterDialog(QDialog):
+    ComboBox = 0
+    IntSlider = 1
+    FloatSlider = 2
+    
+    def __init__(self, parameter_dict: dict, parent=None):
+        super(ParameterDialog, self).__init__(parent)
+        self.setWindowTitle('Parameters')
+        self.setWindowModality(Qt.NonModal)
+        self.parameters = parameter_dict
+        self.ui()
+    
+    def ui(self):
+        layout = QFormLayout(self)
+        for k, v in self.parameters.items():
+            if v['kind'] == ParameterDialog.ComboBox:
+                comboBox = QComboBox()
+                comboBox.addItems(v['items'])
+                layout.addRow(k, comboBox)
+            elif v['kind'] == ParameterDialog.FloatSlider:
+                f = lambda n: v['min'] + n / 100 * (v['max'] - v['min'])
+                g = lambda x: int((x - v['min']) / (v['max'] - v['min']) * 100)
+                slider = QSlider(Qt.Horizontal)
+                slider.setMinimum(0)
+                slider.setMaximum(100)
+                slider.setSingleStep(1)
+                slider.setValue(g(v['init']))
+                le = QLineEdit()
+                le.setPlaceholderText(v['init'])
+                dv = QDoubleValidator(self)
+                dv.setRange(v['min'], v['max'])
+                dv.setNotation(QDoubleValidator.StandardNotation)
+                dv.setDecimals(2)
+                le.setValidator(dv)
+                # slider.valueChanged.connect(lambda n: le.setText(f(n)))
+                # le.textChanged.connect(lambda x: slider.setValue(g(x)))
+                hlayout = QHBoxLayout()
+                hlayout.addWidget(slider, alignment=Qt.AlignLeft)
+                hlayout.addWidget(le, alignment=Qt.AlignRight)
+                layout.addRow(k, hlayout)
+        self.setLayout(layout)