VisualizationConnection.py

import numpy as np
from copy import deepcopy
import pandas as pd

from PyQt5.QtWidgets import *
from GUI.Visualization import Ui_Visualization

from FAE.FeatureAnalysis.Classifier import *
from FAE.FeatureAnalysis.FeaturePipeline import FeatureAnalysisPipelines

from FAE.Visualization.DrawROCList import DrawROCList
from FAE.Visualization.PlotMetricVsFeatureNumber import DrawCurve, DrawBar
from FAE.Visualization.FeatureSort import GeneralFeatureSort, SortRadiomicsFeature

import os

class VisualizationConnection(QWidget, Ui_Visualization):
    def __init__(self, parent=None):
        self._root_folder = ''
        self._fae = FeatureAnalysisPipelines()
        self.sheet_dict = dict()

        super(VisualizationConnection, self).__init__(parent)
        self.setupUi(self)

        self.buttonLoadResult.clicked.connect(self.LoadAll)
        self.buttonClearResult.clicked.connect(self.ClearAll)
        self.buttonSaveFigure.clicked.connect(self.Save)

        self.__plt_roc = self.canvasROC.getFigure().add_subplot(111)
        self.__plt_plot = self.canvasPlot.getFigure().add_subplot(111)
        self.__contribution = self.canvasFeature.getFigure().add_subplot(111)

        # Update Sheet
        self.comboSheet.currentIndexChanged.connect(self.UpdateSheet)
        self.checkMaxFeatureNumber.stateChanged.connect(self.UpdateSheet)

        # Update ROC canvas
        self.comboNormalizer.currentIndexChanged.connect(self.UpdateROC)
        self.comboDimensionReduction.currentIndexChanged.connect(self.UpdateROC)
        self.comboFeatureSelector.currentIndexChanged.connect(self.UpdateROC)
        self.comboClassifier.currentIndexChanged.connect(self.UpdateROC)
        self.spinBoxFeatureNumber.valueChanged.connect(self.UpdateROC)
        self.checkROCTrain.stateChanged.connect(self.UpdateROC)
        self.checkROCValidation.stateChanged.connect(self.UpdateROC)
        self.checkROCTest.stateChanged.connect(self.UpdateROC)

        # Update Plot canvas
        self.comboPlotX.currentIndexChanged.connect(self.UpdatePlot)
        self.comboPlotY.currentIndexChanged.connect(self.UpdatePlot)
        self.checkPlotMaximum.stateChanged.connect(self.UpdatePlot)
        self.comboPlotNormalizer.currentIndexChanged.connect(self.UpdatePlot)
        self.comboPlotDimensionReduction.currentIndexChanged.connect(self.UpdatePlot)
        self.comboPlotFeatureSelector.currentIndexChanged.connect(self.UpdatePlot)
        self.comboPlotClassifier.currentIndexChanged.connect(self.UpdatePlot)
        self.spinPlotFeatureNumber.valueChanged.connect(self.UpdatePlot)

        self.checkPlotTrain.stateChanged.connect(self.UpdatePlot)
        self.checkPlotValidation.stateChanged.connect(self.UpdatePlot)
        self.checkPlotTest.stateChanged.connect(self.UpdatePlot)

        # Update Contribution canvas
        self.checkContributionShow.stateChanged.connect(self.UpdateContribution)
        self.radioContributionFeatureSelector.toggled.connect(self.UpdateContribution)
        self.radioContributionClassifier.toggled.connect(self.UpdateContribution)
        self.comboContributionFeatureSelector.currentIndexChanged.connect(self.UpdateContribution)
        self.comboContributionClassifier.currentIndexChanged.connect(self.UpdateContribution)
        self.spinFeatureSelectorFeatureNumber.valueChanged.connect(self.UpdateContribution)
        self.spinClassifierFeatureNumber.valueChanged.connect(self.UpdateContribution)

    def LoadAll(self):
        dlg = QFileDialog()
        dlg.setFileMode(QFileDialog.DirectoryOnly)
        dlg.setOption(QFileDialog.ShowDirsOnly)

        if dlg.exec_():
            self._root_folder = dlg.selectedFiles()[0]

            if not os.path.exists(self._root_folder):
                return
            if not r'.FAEresult4129074093819729087' in os.listdir(self._root_folder):
                QMessageBox.about(self, 'Load Error', 'This folder is not supported for import')
                return

            try:
                self.lineEditResultPath.setText(self._root_folder)
                self._fae.LoadAll(self._root_folder)
                self.SetResultDescription()
                self.SetResultTable()
                self.InitialUi()
            except Exception as ex:
                QMessageBox.about(self,"Load Error", ex.__str__())
                self.ClearAll()
                return

            self.buttonClearResult.setEnabled(True)
            self.buttonSaveFigure.setEnabled(True)
            self.buttonLoadResult.setEnabled(False)

    def ClearAll(self):

        self.buttonLoadResult.setEnabled(True)
        self.buttonSaveFigure.setEnabled(False)
        self.buttonClearResult.setEnabled(False)

        self.checkROCTrain.setChecked(False)
        self.checkROCTest.setChecked(False)
        self.checkROCValidation.setChecked(False)
        self.checkPlotTrain.setChecked(False)
        self.checkPlotTest.setChecked(False)
        self.checkPlotValidation.setChecked(False)
        self.checkPlotMaximum.setChecked(False)
        self.checkContributionShow.setChecked(False)
        self.radioContributionFeatureSelector.setChecked(True)
        self.radioContributionFeatureSelector.setChecked(False)
        self.checkMaxFeatureNumber.setChecked(False)
        self.canvasROC.getFigure().clear()
        self.canvasPlot.getFigure().clear()
        self.canvasFeature.getFigure().clear()
        self.__plt_roc = self.canvasROC.getFigure().add_subplot(111)
        self.__plt_plot = self.canvasPlot.getFigure().add_subplot(111)
        self.__contribution = self.canvasFeature.getFigure().add_subplot(111)
        self.canvasROC.draw()
        self.canvasPlot.draw()
        self.canvasFeature.draw()

        self.textEditDescription.clear()
        self.lineEditResultPath.clear()

        self.comboSheet.clear()
        self.comboClassifier.clear()
        self.comboDimensionReduction.clear()
        self.comboNormalizer.clear()
        self.comboFeatureSelector.clear()

        self.comboPlotClassifier.clear()
        self.comboPlotDimensionReduction.clear()
        self.comboPlotFeatureSelector.clear()
        self.comboPlotNormalizer.clear()
        self.comboPlotX.clear()
        self.comboPlotY.clear()

        self.comboContributionClassifier.clear()
        self.comboContributionFeatureSelector.clear()

        self.spinBoxFeatureNumber.setValue(0)
        self.spinPlotFeatureNumber.setValue(0)
        self.spinPlotFeatureNumber.setEnabled(False)
        self.spinFeatureSelectorFeatureNumber.setValue(1)
        self.spinClassifierFeatureNumber.setValue(1)

        self.tableClinicalStatistic.clear()

        self.tableClinicalStatistic.setRowCount(0)
        self.tableClinicalStatistic.setColumnCount(0)
        self.tableClinicalStatistic.setHorizontalHeaderLabels(list([]))
        self.tableClinicalStatistic.setVerticalHeaderLabels(list([]))

        self._fae = FeatureAnalysisPipelines()
        self._root_folder = ''
        self.sheet_dict = dict()

    def Save(self):
        dlg = QFileDialog()
        dlg.setFileMode(QFileDialog.DirectoryOnly)
        dlg.setOption(QFileDialog.ShowDirsOnly)

        if dlg.exec_():
            store_folder = dlg.selectedFiles()[0]
            self.canvasROC.getFigure().savefig(os.path.join(store_folder, 'ROC.eps'), dpi=1200)
            self.canvasROC.getFigure().savefig(os.path.join(store_folder, 'ROC.jpg'), dpi=300)
            self.canvasPlot.getFigure().savefig(os.path.join(store_folder, 'Compare.eps'), dpi=1200)
            self.canvasPlot.getFigure().savefig(os.path.join(store_folder, 'Compare.jpg'), dpi=300)
            self.canvasFeature.getFigure().savefig(os.path.join(store_folder, 'FeatureWeights.eps'), dpi=1200)
            self.canvasFeature.getFigure().savefig(os.path.join(store_folder, 'FeatureWeights.jpg'), dpi=300)

    def InitialUi(self):
        # Update ROC canvers
        for normalizer in self._fae.GetNormalizerList():
            self.comboNormalizer.addItem(normalizer.GetName())
        for dimension_reduction in self._fae.GetDimensionReductionList():
            self.comboDimensionReduction.addItem(dimension_reduction.GetName())
        for classifier in self._fae.GetClassifierList():
            self.comboClassifier.addItem(classifier.GetName())
        for feature_selector in self._fae.GetFeatureSelectorList():
            self.comboFeatureSelector.addItem(feature_selector.GetName())
        self.spinBoxFeatureNumber.setMinimum(int(self._fae.GetFeatureNumberList()[0]))
        self.spinBoxFeatureNumber.setMaximum(int(self._fae.GetFeatureNumberList()[-1]))

        # Update Plot canvars
        if len(self._fae.GetNormalizerList()) > 1:
            self.comboPlotX.addItem('Normaliaztion')
        if len(self._fae.GetDimensionReductionList()) > 1:
            self.comboPlotX.addItem('Dimension Reduction')
        if len(self._fae.GetFeatureSelectorList()) > 1:
            self.comboPlotX.addItem('Feature Selector')
        if len(self._fae.GetClassifierList()) > 1:
            self.comboPlotX.addItem('Classifier')
        if len(self._fae.GetFeatureNumberList()) > 1:
            self.comboPlotX.addItem('Feature Number')

        self.comboPlotY.addItem('AUC')
        self.comboPlotY.addItem('Accuracy')

        for index in self._fae.GetNormalizerList():
            self.comboPlotNormalizer.addItem(index.GetName())
        for index in self._fae.GetDimensionReductionList():
            self.comboPlotDimensionReduction.addItem(index.GetName())
        for index in self._fae.GetFeatureSelectorList():
            self.comboPlotFeatureSelector.addItem(index.GetName())
        for index in self._fae.GetClassifierList():
            self.comboPlotClassifier.addItem(index.GetName())
        self.spinPlotFeatureNumber.setMinimum(int(self._fae.GetFeatureNumberList()[0]))
        self.spinPlotFeatureNumber.setMaximum(int(self._fae.GetFeatureNumberList()[-1]))

        # Update Contribution canvas
        # self.spinFeatureSelectorFeatureNumber.setMaximum(int(self._fae.GetFeatureNumberList()[-1]))
        self.spinClassifierFeatureNumber.setMinimum(int(self._fae.GetFeatureNumberList()[0]))
        self.spinClassifierFeatureNumber.setMaximum(int(self._fae.GetFeatureNumberList()[-1]))
        for selector in self._fae.GetFeatureSelectorList():
            self.comboContributionFeatureSelector.addItem(selector.GetName())
        for classifier in self._fae.GetClassifierList():
            specific_name = classifier.GetName() + '_coef.csv'
            if self._SearchSpecificFile(specific_name, int(self._fae.GetFeatureNumberList()[0])):
                self.comboContributionClassifier.addItem(classifier.GetName())

    def UpdateROC(self):
        if (self.comboNormalizer.count() == 0) or \
                (self.comboDimensionReduction.count() == 0) or \
                (self.comboFeatureSelector.count() == 0) or \
                (self.comboClassifier.count() == 0) or \
                (self.spinBoxFeatureNumber.value() == 0):
            return

        case_name = self.comboNormalizer.currentText() + '_' + \
                    self.comboDimensionReduction.currentText() + '_' + \
                    self.comboFeatureSelector.currentText() + '_' + \
                    str(self.spinBoxFeatureNumber.value()) + '_' + \
                    self.comboClassifier.currentText()

        case_folder = os.path.join(self._root_folder, case_name)

        pred_list, label_list, name_list = [], [], []
        if self.checkROCTrain.isChecked():
            train_pred = np.load(os.path.join(case_folder, 'train_predict.npy'))
            train_label = np.load(os.path.join(case_folder, 'train_label.npy'))
            pred_list.append(train_pred)
            label_list.append(train_label)
            name_list.append('train')
        if self.checkROCValidation.isChecked():
            val_pred = np.load(os.path.join(case_folder, 'val_predict.npy'))
            val_label = np.load(os.path.join(case_folder, 'val_label.npy'))
            pred_list.append(val_pred)
            label_list.append(val_label)
            name_list.append('validation')
        if self.checkROCTest.isChecked():
            if os.path.exists(os.path.join(case_folder, 'test_label.npy')):
                test_pred = np.load(os.path.join(case_folder, 'test_predict.npy'))
                test_label = np.load(os.path.join(case_folder, 'test_label.npy'))
                pred_list.append(test_pred)
                label_list.append(test_label)
                name_list.append('Test')

        if len(pred_list) > 0:
            DrawROCList(pred_list, label_list, name_list=name_list, is_show=False, fig=self.canvasROC.getFigure())

        self.canvasROC.draw()

    def _UpdatePlotButtons(self, selected_index):
        index = [0, 0, 0, 0, 0]
        if self.checkPlotMaximum.isChecked():
            self.comboPlotNormalizer.setEnabled(False)
            self.comboPlotDimensionReduction.setEnabled(False)
            self.comboPlotFeatureSelector.setEnabled(False)
            self.comboPlotClassifier.setEnabled(False)
            self.spinPlotFeatureNumber.setEnabled(False)
        else:
            self.comboPlotNormalizer.setEnabled(True)
            self.comboPlotDimensionReduction.setEnabled(True)
            self.comboPlotFeatureSelector.setEnabled(True)
            self.comboPlotClassifier.setEnabled(True)
            self.spinPlotFeatureNumber.setEnabled(True)
            index[0] = self.comboPlotNormalizer.currentIndex()
            index[1] = self.comboPlotDimensionReduction.currentIndex()
            index[2] = self.comboPlotFeatureSelector.currentIndex()
            index[4] = self.comboPlotClassifier.currentIndex()
            index[3] = self.spinPlotFeatureNumber.value()

            if selected_index == 0:
                self.comboPlotNormalizer.setEnabled(False)
                index[0] = [temp for temp in range(len(self._fae.GetNormalizerList()))]
            elif selected_index == 1:
                self.comboPlotDimensionReduction.setEnabled(False)
                index[1] = [temp for temp in range(len(self._fae.GetDimensionReductionList()))]
            elif selected_index == 2:
                self.comboPlotFeatureSelector.setEnabled(False)
                index[2] = [temp for temp in range(len(self._fae.GetFeatureSelectorList()))]
            elif selected_index == 4:
                self.comboPlotClassifier.setEnabled(False)
                index[4] = [temp for temp in range(len(self._fae.GetClassifierList()))]
            elif selected_index == 3:
                self.spinPlotFeatureNumber.setEnabled(False)
                index[3] = [temp for temp in range(len(self._fae.GetFeatureNumberList()))]

        return index

    def UpdatePlot(self):
        if self.comboPlotX.count() == 0:
            return

        x_ticks = []
        x_label = ''
        selected_index = -1
        if self.comboPlotX.currentText() == 'Normaliaztion':
            selected_index = 0
            x_ticks = [instance.GetName() for instance in self._fae.GetNormalizerList()]
            x_label = 'Normalization Method'
        elif self.comboPlotX.currentText() == 'Dimension Reduction':
            selected_index = 1
            x_ticks = [instance.GetName() for instance in self._fae.GetDimensionReductionList()]
            x_label = 'Dimension Reduction Method'
        elif self.comboPlotX.currentText() == 'Feature Selector':
            selected_index = 2
            x_ticks = [instance.GetName() for instance in self._fae.GetFeatureSelectorList()]
            x_label = 'Feature Selecotr Method'
        elif self.comboPlotX.currentText() == 'Classifier':
            selected_index = 4
            x_ticks = [instance.GetName() for instance in self._fae.GetClassifierList()]
            x_label = 'Classifier Method'
        elif self.comboPlotX.currentText() == 'Feature Number':
            selected_index = 3
            x_ticks = list(map(int, self._fae.GetFeatureNumberList()))
            x_label = 'Feature Number'

        max_axis_list = [0, 1, 2, 3, 4]
        max_axis_list.remove(selected_index)
        max_axis = tuple(max_axis_list)

        index = self._UpdatePlotButtons(selected_index)

        show_data = []
        name_list = []

        if self.comboPlotY.currentText() == 'AUC':
            if self.checkPlotTrain.isChecked():
                temp = deepcopy(self._fae.GetAUCMetric()['train'])
                if self.checkPlotMaximum.isChecked():
                    show_data.append(np.max(temp, axis=max_axis).tolist())
                else:
                    show_data.append(temp[index].tolist())
                name_list.append('Train')
            if self.checkPlotValidation.isChecked():
                temp = deepcopy(self._fae.GetAUCMetric()['val'])
                if self.checkPlotMaximum.isChecked():
                    show_data.append(np.max(temp, axis=max_axis).tolist())
                else:
                    show_data.append(temp[index].tolist())
                name_list.append('Validation')
            if self.checkPlotTest.isChecked():
                temp = deepcopy(self._fae.GetAUCMetric()['test'])
                if temp.size > 0:
                    if self.checkPlotMaximum.isChecked():
                        show_data.append(np.max(temp, axis=max_axis).tolist())
                    else:
                        show_data.append(temp[index].tolist())
                    name_list.append('Test')
        elif self.comboPlotY.currentText() == 'Accuracy':
            if self.checkPlotTrain.isChecked():
                temp = deepcopy(self._fae.GetAccuracyMetric()['train'])
                if self.checkPlotMaximum.isChecked():
                    show_data.append(np.max(temp, axis=max_axis).tolist())
                else:
                    show_data.append(temp[index].tolist())
                name_list.append('Train')
            if self.checkPlotValidation.isChecked():
                temp = deepcopy(self._fae.GetAccuracyMetric()['val'])
                if self.checkPlotMaximum.isChecked():
                    show_data.append(np.max(temp, axis=max_axis).tolist())
                else:
                    show_data.append(temp[index].tolist())
                name_list.append('Validation')
            if self.checkPlotTest.isChecked():
                temp = deepcopy(self._fae.GetAccuracyMetric()['test'])
                if temp.size > 0:
                    if self.checkPlotMaximum.isChecked():
                        show_data.append(np.max(temp, axis=max_axis).tolist())
                    else:
                        show_data.append(temp[index].tolist())
                    name_list.append('Test')

        if len(show_data) > 0:
            if selected_index == 3:
                DrawCurve(x_ticks, show_data, xlabel=x_label, ylabel=self.comboPlotY.currentText(),
                          name_list=name_list, is_show=False, fig=self.canvasPlot.getFigure())
            else:
                DrawBar(x_ticks, show_data, ylabel=self.comboPlotY.currentText(),
                          name_list=name_list, is_show=False, fig=self.canvasPlot.getFigure())

        self.canvasPlot.draw()

    def UpdateContribution(self):
        if not self.checkContributionShow.isChecked():
            return

        if self.radioContributionFeatureSelector.isChecked():
            file_name = self.comboContributionFeatureSelector.currentText() + '_sort.csv'
            file_path = self._SearchSpecificFile(file_name, int(self._fae.GetFeatureNumberList()[0]))
            if file_path:
                df = pd.read_csv(file_path, index_col=0)

                feature_name = list(df.index)
                value = list(np.abs(df.iloc[:, 0]))

                GeneralFeatureSort(feature_name, value, max_num=self.spinFeatureSelectorFeatureNumber.value(),
                                   is_show=False, fig=self.canvasFeature.getFigure())
        elif self.radioContributionClassifier.isChecked():
            specific_name = self.comboContributionClassifier.currentText() + '_coef.csv'
            file_path = self._SearchSpecificFile(specific_name, self.spinClassifierFeatureNumber.value())
            if file_path:
                df = pd.read_csv(file_path, index_col=0)
                feature_name = list(df.index)
                value = list(np.abs(df.iloc[:, 0]))
                try:
                    SortRadiomicsFeature(feature_name, value, is_show=False, fig=self.canvasFeature.getFigure())
                except:
                    GeneralFeatureSort(feature_name, value,
                                       is_show=False, fig=self.canvasFeature.getFigure())


        self.canvasFeature.draw()

    def SetResultDescription(self):
        text = "Normalizer:\n"
        for index in self._fae.GetNormalizerList():
            text += (index.GetName() + '\n')
        text += '\n'

        text += "Dimension Reduction:\n"
        for index in self._fae.GetDimensionReductionList():
            text += (index.GetName() + '\n')
        text += '\n'

        text += "Feature Selector:\n"
        for index in self._fae.GetFeatureSelectorList():
            text += (index.GetName() + '\n')
        text += '\n'

        text += "Feature Number:\n"
        text += "{:s} - {:s}\n".format(self._fae.GetFeatureNumberList()[0], self._fae.GetFeatureNumberList()[-1])
        text += '\n'

        text += "Classifier:\n"
        for index in self._fae.GetClassifierList():
            text += (index.GetName() + '\n')
        text += '\n'

        self.textEditDescription.setPlainText(text)

    def UpdateSheet(self):
        data = np.array([])
        df = pd.DataFrame()
        if self.comboSheet.currentText() == 'Train':
            data = self._fae.GetAUCMetric()['train']
            df = self.sheet_dict['train']
        elif self.comboSheet.currentText() == 'Validation':
            data = self._fae.GetAUCMetric()['val']
            df = self.sheet_dict['val']
        elif self.comboSheet.currentText() == 'Test':
            data = self._fae.GetAUCMetric()['test']
            df = self.sheet_dict['test']
        elif self.comboSheet.currentText() == 'Test On Val':
            data = self._fae.GetAUCMetric()['val']
            df = self.sheet_dict['test']
        else:
            return

        if self.checkMaxFeatureNumber.isChecked():
            name_list = []
            arg_max_index = np.argmax(data, axis=3)
            for normalizer, normalizer_index in zip(self._fae.GetNormalizerList(), range(len(self._fae.GetNormalizerList()))):
                for dimension_reducer, dimension_reducer_index in zip(self._fae.GetDimensionReductionList(),
                                                                      range(len(self._fae.GetDimensionReductionList()))):
                    for feature_selector, feature_selector_index in zip(self._fae.GetFeatureSelectorList(),
                                                                        range(len(self._fae.GetFeatureSelectorList()))):
                        for classifier, classifier_index in zip(self._fae.GetClassifierList(),
                                                                range(len(self._fae.GetClassifierList()))):
                            name = normalizer.GetName() + '_' + \
                                   dimension_reducer.GetName() + '_' + \
                                   feature_selector.GetName() + '_' + \
                                   self._fae.GetFeatureNumberList()[arg_max_index[normalizer_index, dimension_reducer_index, feature_selector_index, classifier_index]] + '_' + \
                                   classifier.GetName()
                            name_list.append(name)

            df = df.loc[name_list]

        self.tableClinicalStatistic.setRowCount(df.shape[0])
        self.tableClinicalStatistic.setColumnCount(df.shape[1])
        self.tableClinicalStatistic.setHorizontalHeaderLabels(list(df.columns))
        self.tableClinicalStatistic.setVerticalHeaderLabels(list(df.index))

        for row_index in range(df.shape[0]):
            for col_index in range(df.shape[1]):
                self.tableClinicalStatistic.setItem(row_index, col_index, QTableWidgetItem(str(df.iloc[row_index, col_index])))

    def SetResultTable(self):
        self.sheet_dict['train'] = pd.read_csv(os.path.join(self._root_folder, 'train_result.csv'), index_col=0)
        self.comboSheet.addItem('Train')
        self.sheet_dict['val'] = pd.read_csv(os.path.join(self._root_folder, 'val_result.csv'), index_col=0)
        self.comboSheet.addItem('Validation')
        if os.path.exists(os.path.join(self._root_folder, 'test_result.csv')):
            self.sheet_dict['test'] = pd.read_csv(os.path.join(self._root_folder, 'test_result.csv'), index_col=0)
            self.comboSheet.addItem('Test')
            self.comboSheet.addItem('Test On Val')

        self.UpdateSheet()

    def _SearchSpecificFile(self, specific_file_name, feature_number):
        for rt, folder, files in os.walk(self._root_folder):
            for file_name in files:
                # print(file_name)
                if (file_name.lower() == specific_file_name.lower()) and ('_{:d}_'.format(feature_number) in rt):
                    return os.path.join(rt, file_name)

        return ''