Source code for gui.core.LocalRegression

import numpy as np
import pandas as pd
from PyQt5 import QtWidgets

from gui.ui.LocalRegression import Ui_Form
from gui.util.Modules import Modules
from libpyhat.regression import local_regression
from libpyhat.spectral_data import SpectralData



[docs]
class LocalRegression(Ui_Form, Modules):
    count = -1

    def __init__(self):
        LocalRegression.count += 1
        self.curr_count = LocalRegression.count


[docs]
    def delete(self):
        try:
            LocalRegression.count -= 1
            del self.models[self.modelkeys[-1]]
            del self.modelkeys[-1]
        except:
            pass

        LocalRegression.count -= 1
        self.modelkeys = self.modelkeys[:-1]



[docs]
    def setupUi(self, Form):
        self.Form = Form
        super().setupUi(Form)
        Modules.setupUi(self, Form)



[docs]
    def get_widget(self):
        return self.groupLayout



[docs]
    def make_regression_widget(self, alg, params=None):
        self.hideAll()
        # print(alg)
        try:
            self.alg[alg].setHidden(False)
        except:
            pass



[docs]
    def connectWidgets(self):
        self.setComboBox(self.choosedata_train, self.datakeys)
        self.setComboBox(self.choosedata_predict, self.datakeys)
        self.changeComboListVars(self.yVariableList, self.yvar_choices())
        self.changeComboListVars(self.xVariableList, self.xvar_choices())
        self.xvar_choices()
        self.choosedata_train.currentIndexChanged.connect(
            lambda: self.changeComboListVars(self.yVariableList, self.yvar_choices())
        )
        self.choosedata_train.currentIndexChanged.connect(
            lambda: self.changeComboListVars(self.xVariableList, self.xvar_choices())
        )



[docs]
    def run(self):
        self.chooseAlgorithmComboBox.currentText()
        xvars = [str(x.text()) for x in self.xVariableList.selectedItems()]

        params = {
            "fit_intercept": self.fit_intercept.isChecked(),
            "max_iter": 10000,
            "positive": self.forcepositive.isChecked(),
            "selection": "random",
            "l1_ratio": [0.1, 0.5, 0.7, 0.9, 0.95, 0.99, 1],
        }
        localmodel = local_regression.LocalRegression(
            params, n_neighbors=self.n_neighbors_spin.value()
        )
        traindata = self.data[self.choosedata_train.currentText()]
        predictdata = self.data[self.choosedata_predict.currentText()]
        yvars = [
            (traindata.comp_label, str(y.text()))
            for y in self.yVariableList.selectedItems()
        ]
        x_train = np.array(traindata.df[xvars])
        y_train = np.array(traindata.df[yvars])
        x_predict = np.array(predictdata.df[xvars])
        predictions, coefs, intercepts = localmodel.fit_predict(
            x_train, y_train, x_predict
        )
        predictname = (
            "predict",
            "Local LASSO - " + self.choosedata_predict.currentText() + " - Predict",
        )
        self.data[self.choosedata_predict.currentText()].df[predictname] = predictions

        coefs = pd.DataFrame(
            coefs,
            columns=pd.MultiIndex.from_tuples(
                self.data[self.choosedata_predict.currentText()]
                .df[xvars]
                .columns.values
            ),
        )
        coefs[("meta", "Intercept")] = intercepts
        try:
            self.data["Model Coefficients"] = SpectralData(
                pd.concat([self.data["Model Coefficients"].df, coefs]),
                name="Model Coefficients",
            )
        except:
            self.data["Model Coefficients"] = SpectralData(
                coefs, name="Model " "Coefficients"
            )
            self.datakeys.append("Model Coefficients")



[docs]
    def yvar_choices(self):
        try:
            yvarchoices = (
                self.data[self.choosedata_train.currentText()].df["comp"].columns.values
            )
            yvarchoices = [
                i for i in yvarchoices if "Unnamed" not in i
            ]  # remove unnamed columns
            # from choices
        except:
            yvarchoices = ["No composition columns!"]
        return yvarchoices



[docs]
    def xvar_choices(self):
        try:
            xvarchoices = (
                self.data[self.choosedata_train.currentText()]
                .df.columns.levels[0]
                .values
            )
            xvarchoices = [
                i for i in xvarchoices if "Unnamed" not in i
            ]  # remove unnamed columns
            # from choices
        except:
            xvarchoices = ["No valid choices!"]
        return xvarchoices




if __name__ == "__main__":
    import sys

    app = QtWidgets.QApplication(sys.argv)
    Form = QtWidgets.QWidget()
    ui = LocalRegression()
    ui.setupUi(Form)
    Form.show()
    sys.exit(app.exec_())