plots

.idea/other.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="PySciProjectComponent">
+    <option name="PY_INTERACTIVE_PLOTS_SUGGESTED" value="true" />
+  </component>
+</project>
\ No newline at end of file

DisplayWindow.py

 import sys
 import pandas as pd
 from PyQt6.QtCore import Qt
+from sklearn.ensemble import RandomForestRegressor
+
+import modeling
 from data_processing import DataPreprocessor as dp
 from modeling import Model
-import RegressionModel
+
 from pyqtgraph import PlotWidget, plot
 import pyqtgraph as pg
-from PyQt6.QtWidgets import (QApplication, QMainWindow, QWidget,
+from PyQt6.QtWidgets import (QApplication, QMainWindow, QWidget, QDialog,
                              QVBoxLayout, QHBoxLayout, QGridLayout,
                              QLabel, QPushButton, QSlider, QDateTimeEdit,
                              QLineEdit, QComboBox, QDateEdit, QTabWidget, QCheckBox)
@@ -14,18 +17,52 @@ from PyQt6.QtGui import QPalette, QColor, QIcon
 from sklearn.model_selection import train_test_split
 import joblib
 
+diamonds = pd.read_csv('diamonds.csv')
+diamonds.dropna(inplace=True)
+cut = list(diamonds["cut"].unique())
+colors = list(diamonds["color"].unique())
+clarity = list(diamonds["clarity"].unique())
+# diamonds_numerical = diamonds.copy()
+# cut_mapping = {cut: i for i, cut in enumerate(diamonds['cut'].unique())}
+# color_mapping = {color: i for i, color in enumerate(diamonds['color'].unique())}
+# clarity_mapping = {clarity: i for i, clarity in enumerate(diamonds['clarity'].unique())}
+# diamonds_numerical['cut'] = diamonds['cut'].map(cut_mapping)
+# diamonds_numerical['color'] = diamonds['color'].map(color_mapping)
+# diamonds_numerical['clarity'] = diamonds['clarity'].map(clarity_mapping)
+# X = diamonds_numerical.drop('price', axis = 1)
+# y = diamonds_numerical['price']
+# X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+# model = Model(X_train, X_test, y_train, y_test,'RF')
+# model.train()
+# joblib.dump(model, 'RF.joblib')
+model = joblib.load('RF.joblib')
+price = 0
+
+
 class MyTabs(QMainWindow):
+    @staticmethod
+    def numericise(df):
+        if Advanced.Advanced_selections['cut']:
+            df['cut'] = df['cut'].map({'Ideal': 0, 'Premium': 1, 'Very Good': 2, 'Good': 3, 'Fair': 4})
+        if Advanced.Advanced_selections['color']:
+            df['color'] = df['color'].map({'E': 0, 'I': 1, 'J': 2, 'H': 3, 'F': 4, 'G': 5, 'D': 6})
+        if Advanced.Advanced_selections['clarity']:
+            df['clarity'] = df['clarity'].map({'SI2': 0, 'SI1': 1, 'VS1': 2, 'VS2': 3, 'VVS2': 4, 'VVS1': 5,
+                                               'IF': 7, 'I1': 6})
+        return df
+
     def __init__(self):
         super().__init__()
-
+        self.setWindowIcon(QIcon("icon.ico"))
+        self.setMinimumSize(720, 640)
         # Create your custom pages (e.g., TradeView and OrderView)
-        trade_view = MainWindow()
-        order_view = Advanced()
+        self.calc = MainWindow()
+        self.adjust = Advanced()
 
         # Create a tab widget
         tab_widget = QTabWidget(self)
-        tab_widget.addTab(trade_view, "Main")
-        tab_widget.addTab(order_view, "Advanced")
+        tab_widget.addTab(self.calc, "Main")
+        tab_widget.addTab(self.adjust, "Advanced")
 
         # Set the central widget
         self.setCentralWidget(tab_widget)
@@ -35,8 +72,6 @@ class MainWindow(QMainWindow):
 
     def __init__(self):
         super().__init__()
-        self.setWindowIcon(QIcon("icon.ico"))
-        self.setMinimumSize(720, 640)
 
         # Create a central widget
         central_widget = QWidget(self)
@@ -44,9 +79,12 @@ class MainWindow(QMainWindow):
 
         # Create a grid layout and set it to the central widget
         grid_layout = QGridLayout(central_widget)
+        # List of Menu Items in dict
+        self.menu_items = {3: 'carat', 0: 'cut', 1: 'color', 2: 'clarity', 4: 'depth', 5: 'table', 6: 'x',
+                           7: 'y', 8: 'z'}
+        self.GUI_selections = {}
 
         # Create labels and input fields
-        self.labels_text = ['Cut', 'Colour', 'Clarity', 'Carat', 'Depth', 'Table', 'X', 'Y', 'Z']
         self.input_fields = [QComboBox(self), QComboBox(self), QComboBox(self), QLineEdit(self),
                              QLineEdit(self), QLineEdit(self), QLineEdit(self), QLineEdit(self),
                              QLineEdit(self)]
@@ -58,8 +96,8 @@ class MainWindow(QMainWindow):
         self.calculate_button.clicked.connect(self.update_values)
 
         # Add labels and input fields to the grid layout
-        for i in range(len(self.labels_text)):
-            label = QLabel(self.labels_text[i], self)
+        for i, val in self.menu_items.items():
+            label = QLabel(val, self)
             grid_layout.addWidget(label, 0, i)
             grid_layout.addWidget(self.input_fields[i], 1, i)
 
@@ -72,50 +110,60 @@ class MainWindow(QMainWindow):
         grid_layout.addWidget(self.calculate_button, 2, 0, 1, 2)
         grid_layout.addWidget(graphWidget, 3, 0, 1, 9)
         grid_layout.addWidget(QLabel("Predicted Price: ", self), 4, 0, 1, 1)
-        self.display_price = QLabel(str(RegressionModel.price))
+        self.display_price = QLabel(str(0))
         grid_layout.addWidget(self.display_price, 4, 2, 1, 1)
-        # grid_layout.addWidget(QLabel(str(RegressionModel.price), self), 4, 2, 1, 1)
-        # Remember to add the predicted price
 
         self.setWindowTitle('Assistance Systems')
         self.show()
 
     def update_values(self):
-        menu_items = {3: 'carat',
-                        0: 'cut',
-                        1: 'color',
-                        2: 'clarity',
-                       4: 'depth', 5: 'table',
-                      6: 'x', 7: 'y', 8: 'z'}
-        for key, value in menu_items.items():
-            # print(key)
-            if key < 3:
-                RegressionModel.GUI_selections[value] = self.input_fields[key].currentText()
-            else:
-                RegressionModel.GUI_selections[value] = self.input_fields[key].text()
-            # print(RegressionModel.GUI_selections)
-        
-        # convert GUI_selections to dataframe
-        X_test = pd.DataFrame(RegressionModel.GUI_selections, index=[0])
-        
-        X_test['cut'] = X_test['cut'].map({'Ideal': 0, 'Premium': 1, 'Very Good': 2, 'Good': 3, 'Fair': 4})
-        X_test['color'] = X_test['color'].map({'E': 0, 'I': 1, 'J': 2, 'H': 3, 'F': 4, 'G': 5, 'D': 6})
-        X_test['clarity'] = X_test['clarity'].map({'SI2': 0, 'SI1': 1, 'VS1': 2, 'VS2': 3, 'VVS2': 4, 'VVS1': 5, 'IF': 7, 'I1': 6})
 
-        price = model.predict_price(X_test)
-        # price = model.predict(X_test)[0]
-        self.display_price.setText(str(price))
+        for key, value in self.menu_items.items():
+            if Advanced.Advanced_selections[value]:
+                if key < 3:
+                    self.GUI_selections[value] = self.input_fields[key].currentText()
+                else:
+                    if self.validate_inputs(self.input_fields[key].text(), value):
+                        self.GUI_selections[value] = self.input_fields[key].text()
+                    else:
+                        return
+
+        # convert GUI_selections to dataframe
+        X_test = pd.DataFrame(self.GUI_selections, index=[0])
+        print(X_test.head())
 
-        
+        X_test = MyTabs.numericise(X_test)
 
+        # price = model.predict(X_test)[0]
+        self.display_price.setText(str(model.predict_price(X_test)))
+
+    def validate_inputs(self, val, attribute):
+        if Advanced.Advanced_selections[attribute]:
+            try:
+                isinstance(float(val), float)
+                return True
+            except ValueError:
+                dlg = QDialog(self)
+                dlg.setGeometry(400, 500, 200, 100)
+                dlg.setWindowTitle("ERROR")
+                layout = QVBoxLayout()
+                layout.addWidget(QLabel(f"{attribute} numerical value required"))
+                button = QPushButton("OK")
+                button.clicked.connect(lambda: dlg.reject())
+                layout.addWidget(button)
+                dlg.setLayout(layout)
+                dlg.exec()
+                return False
+        else:
+            return True
 
 
 class Advanced(QMainWindow):
+    Advanced_selections = {'cut': True, 'color': True, 'clarity': True, 'carat': True, 'depth': True,
+                           'table': True, 'x': True, 'y': True, 'z': True}
 
     def __init__(self):
         super().__init__()
-        self.setWindowIcon(QIcon("icon.ico"))
-        self.setMinimumSize(720, 640)
 
         central_widget = QWidget(self)
         self.setCentralWidget(central_widget)
@@ -125,21 +173,31 @@ class Advanced(QMainWindow):
         self.graph_selector_X = QComboBox(self)
         self.graph_selector_Y = QComboBox(self)
         self.regression_model = QComboBox(self)
-        self.check_labels = ['Cut', 'Colour', 'Clarity', 'Carat', 'Depth', 'Table', 'X', 'Y', 'Z']
+        self.R2 = QLabel("R-Squared Error = ")
+        self.MSE = QLabel("Mean Squared Error = ")
+        self.check_labels = ['cut', 'color', 'clarity', 'carat', 'depth', 'table', 'x', 'y', 'z']
         self.graph_selector_X.addItems((self.check_labels + ['price']))
         self.graph_selector_Y.addItems((self.check_labels + ['price']))
-        self.regression_model.addItems(["Linear Regression", "XG Boost", "XGBRegressor", "Neural Network"])
-        self.checkboxes = []
+        self.regression_model.addItems(["Linear Regression", "XGBRegressor", "Neural Network",
+                                        "Random Forest Regressor"])
+        self.teach = QPushButton('Re-Teach', self)
+        self.teach.clicked.connect(self.re_teach)
+        self.plot_graph = QPushButton('PLOT', self)
+        self.plot_graph.clicked.connect(self.create_graph)
 
+        self.checkboxes = []
 
         grid_layout.addWidget(QLabel("select features to include in Modelling"), 0, 0, 1, 0)
-        # grid_layout.addWidget(self.graph_selector_X, 1, 2)
-        # grid_layout.addWidget(self.graph_selector_Y, 1, 3)
+        grid_layout.addWidget(self.graph_selector_X, 3, 1)
+        grid_layout.addWidget(self.graph_selector_Y, 3, 3)
         grid_layout.addWidget(self.regression_model, 2, 1)
-        # grid_layout.addWidget(QLabel("X-PLOT", self), 0, 2)
-        # grid_layout.addWidget(QLabel("Y-PLOT", self), 0, 3)
-        grid_layout.addWidget(QLabel("Regression Model : ", self), 2, 0,1,1)
-
+        grid_layout.addWidget(QLabel("X-PLOT", self), 3, 0)
+        grid_layout.addWidget(QLabel("Y-PLOT", self), 3, 2)
+        grid_layout.addWidget(QLabel("Regression Model : ", self), 2, 0, 1, 1)
+        grid_layout.addWidget(self.plot_graph, 2, 6)
+        grid_layout.addWidget(self.teach, 2, 7, 1, 2)
+        grid_layout.addWidget(self.R2, 2, 4, 1, 2)
+        grid_layout.addWidget(self.MSE, 2, 2, 1, 2)
 
         for i, label in enumerate(self.check_labels):
             checkbox = QCheckBox(label, self)
@@ -149,44 +207,37 @@ class Advanced(QMainWindow):
             self.checkboxes.append(checkbox)  # Store checkboxes in the list
 
     def handle_checkbox_state(self):
-        RegressionModel.Advanced_selections = []
         for i, checkbox in enumerate(self.checkboxes):
             state = checkbox.checkState()
             if state == Qt.CheckState.Unchecked:
-                RegressionModel.Advanced_selections.append(checkbox.text())
-
-
-
-
-diamonds = pd.read_csv('diamonds.csv')
-diamonds.dropna(inplace=True)
-cut = list(diamonds["cut"].unique())
-colors = list(diamonds["color"].unique())
-clarity = list(diamonds["clarity"].unique())
-# diamonds_numerical = diamonds.copy()
-# cut_mapping = {cut: i for i, cut in enumerate(diamonds['cut'].unique())}
-# color_mapping = {color: i for i, color in enumerate(diamonds['color'].unique())}
-# clarity_mapping = {clarity: i for i, clarity in enumerate(diamonds['clarity'].unique())}
-# diamonds_numerical['cut'] = diamonds['cut'].map(cut_mapping)
-# diamonds_numerical['color'] = diamonds['color'].map(color_mapping)
-# diamonds_numerical['clarity'] = diamonds['clarity'].map(clarity_mapping)
-# X = diamonds_numerical.drop('price', axis = 1)
-# y = diamonds_numerical['price']
-# X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
-# model = Model(X_train, X_test, y_train, y_test,'RF')
-# model.train()
-# joblib.dump(model, 'RF.joblib')
-model = joblib.load('RF.joblib')
-print(type(model))
-price = 0
-
-
-
+                Advanced.Advanced_selections[checkbox.text()] = False
+            else:
+                Advanced.Advanced_selections[checkbox.text()] = True
+
+    def re_teach(self):
+        global diamonds
+        X = diamonds.copy()
+        for key, value in Advanced.Advanced_selections.items():
+            if not value:
+                X = X.drop(key, axis=1)
+        y = X['price']
+        X = X.drop('price', axis=1)
+        X = MyTabs.numericise(X)
+        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+        global model
+        model = modeling.Model(X_train, X_test, y_train, y_test, self.regression_model.currentText())
+        training = model.train()
+        model.evaluate()
+
+        self.R2.setText(str(model.r2))
+        self.MSE.setText(str(model.mse))
+
+    def create_graph(self):
+        pass
 
 
 app = QApplication(sys.argv)
 
 window = MyTabs()
 window.show()
-
 app.exec()

RegressionModel.py

-# Shared data to GUI
-import random
-import pandas as pd
-import json
-import matplotlib.pyplot as plt
-
-from data_processing import DataPreprocessor as dp
-from modeling import Model
-
-# diamonds = pd.read_csv('diamonds.csv')
-# cut = list(diamonds["cut"].unique())
-# colors = list(diamonds["color"].unique())
-# clarity = list(diamonds["clarity"].unique())
-GUI_selections = {}  # user inputs
-Advanced_selections = []
-price_caret = []
-price = 70
-
-
-
-# diamonds = dp('diamonds.csv')
-# diamonds.load_data()
-# diamonds.clean_data()
-# diamonds.convert_to_numeric(diamonds.data)
-# X = diamonds.get_X()
-# y = diamonds.get_y()
-# X_train, X_test, y_train, y_test = dp.split_data(X, y)
-
-# model = Model(X_train, X_test, y_train, y_test, model='LR')
-# model.train()
-# price
-
-
-

modeling.py

@@ -11,25 +11,27 @@ from joblib import dump, load
 class Model:
     def __init__(self, X_train, X_test, y_train, y_test, modelname='RF'):
         self.X_train = X_train
-        self.X_test  = X_test
+        self.X_test = X_test
         self.y_train = y_train
-        self.y_test  = y_test
-        self.modelname   = modelname
+        self.y_test = y_test
+        self.modelname = modelname
         self.model = RandomForestRegressor(random_state=42, n_estimators=100)
 
     def train(self):
-        if self.modelname == 'LR':
+        if self.modelname == "Linear Regression":
             self.model = LinearRegression()
-        elif self.modelname == 'XGB':
+        elif self.modelname == "XGBRegressor":
             self.model = XGBRegressor(random_state=42, n_estimators=100)
-        elif self.modelname == 'MLP':
+        elif self.modelname == "Neural Network":
             self.model = MLPRegressor(random_state=42, max_iter=500)
-        elif self.modelname == 'RF':
+        elif self.modelname == "Random Forest Regressor":
             self.model = RandomForestRegressor(random_state=42, n_estimators=100)
         else:
             raise Exception("Model not implemented")
         
         self.model.fit(self.X_train, self.y_train)
+        print('done')
+        return True
 
     def save_model(self, filename):
         dump(self.model, filename)
@@ -43,6 +45,6 @@ class Model:
         return self.model.predict(X)[0]
 
     def evaluate(self):
-        self.mse = mean_squared_error(self.y_test, self.predict(self.X_test))
-        self.r2  = r2_score(self.y_test, self.predict(self.X_test))
+        self.mse = mean_squared_error(self.y_test, self.model.predict(self.X_test))
+        self.r2  = r2_score(self.y_test, self.model.predict(self.X_test))
         
\ No newline at end of file

training3 copy.ipynb

+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "initial_id",
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 2
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython2",
+   "version": "2.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}