In this tutorial, we’ll build SalaryPredictor v2.0, a desktop app that predicts employee salaries using Machine Learning. It supports batch predictions, real-time previews, filtering, and live search—all in a beautiful GUI with tkinter and ttkbootstrap.
We’ll break it down step by step so even beginners can follow along.
Step 1: Install Required Packages
Before we start, make sure you have Python installed. Then install the dependencies:
pip install pandas joblib tkinterdnd2 ttkbootstrap
pandas: For handling CSV files
joblib: To load ML models
tkinter + ttkbootstrap: For GUI
tkinterdnd2: Optional, for drag-and-drop support
Step 2: Set Up the Imports
Create a Python file called salary_predictor.py and start with the imports:
import os
import sys
import threading
import pandas as pd
import joblib
import tkinter as tk
from tkinter import filedialog, messagebox, ttk
import ttkbootstrap as tb
from ttkbootstrap.constants import *
Optional drag-and-drop support:
try:
from tkinterdnd2 import TkinterDnD, DND_FILES
DND_ENABLED = True
except ImportError:
DND_ENABLED = False
print("Drag & Drop requires tkinterdnd2: pip install tkinterdnd2")
✅ Explanation:
We import packages for GUI, CSV handling, threading, and machine learning. tkinterdnd2 enables drag-and-drop of files for convenience.
Step 3: Helper Function for Resource Paths
If you package your app using PyInstaller, you need a helper to locate files:
def resource_path(file_name):
base_path = getattr(sys, "_MEIPASS", os.path.dirname(os.path.abspath(__file__)))
return os.path.join(base_path, file_name)
Helps the app locate icons or other files when bundled.
Step 4: Create the Salary Prediction Worker
This class handles predictions in a background thread, so the GUI doesn’t freeze:
class SalaryPredictWorker:
def __init__(self, files, model_path, callbacks):
self.files = files
self.model = joblib.load(model_path)
self.callbacks = callbacks
self._running = True
def stop(self):
self._running = False
The main prediction loop:
def run(self):
feature_cols = ["Age", "Experience", "EducationLevel"]
for path in self.files:
if not self._running:
break
df = pd.read_csv(path)
X = df[feature_cols]
df['PredictedSalary'] = self.model.predict(X)
for idx, row in df.iterrows():
if not self._running:
break
row_data = row.to_dict()
row_data['_row_id'] = idx
if "found" in self.callbacks:
self.callbacks["found"](path, row_data)
✅ Explanation:
Reads each CSV file.
Uses only the model’s features (Age, Experience, EducationLevel).
Predicts salary for each employee.
Sends results back to GUI via callback functions.
Step 5: Build the GUI App
The main app class:
class SalaryPredictApp:
APP_NAME = "SalaryPredictor"
APP_VERSION = "2.0"
def __init__(self):
self.root = tb.Window(themename="darkly") # Use ttkbootstrap for a nice theme
self.root.title(f"{self.APP_NAME} v{self.APP_VERSION}")
self.root.minsize(1300, 750)
self.file_set = set()
self.model_path = tk.StringVar()
self.filter_min = tk.DoubleVar(value=0)
self.filter_max = tk.DoubleVar(value=1e9)
self.search_var = tk.StringVar()
Sets up main variables and GUI window.
Step 6: File Selection and Drag-and-Drop
Allow users to select files or folders:
def browse(self):
folder = filedialog.askdirectory(title="Select Folder with CSV files")
if folder:
self._scan_and_queue_files_thread([folder])
Drag-and-drop (if tkinterdnd2 is installed):
def on_drop(self, event):
dropped_paths = self.root.tk.splitlist(event.data)
self._scan_and_queue_files_thread(dropped_paths)
Step 7: Display Employee Predictions in a Table
Use ttk.Treeview to show real-time results:
self.tree = ttk.Treeview(main, columns=("selected", "filename", "employee_name", "predicted_salary"), show="headings")
self.tree.heading("selected", text="✅")
self.tree.heading("filename", text="Filename")
self.tree.heading("employee_name", text="Employee")
self.tree.heading("predicted_salary", text="Predicted Salary")
self.tree.pack(fill="both", expand=True)
✅ Explanation:
Each row shows:
File name
Employee name
Predicted salary
Checkbox for selecting rows
Step 8: Start Prediction
Start worker in a background thread:
def start(self):
selected_files = [self.tree.item(i)['values'][1] for i in self.tree.get_children()]
self.worker_obj = SalaryPredictWorker(selected_files, self.model_path.get(), callbacks={
"found": self.add_result,
"progress": self.set_target,
"finished": self.finish
})
threading.Thread(target=self.worker_obj.run, daemon=True).start()
Step 9: Filter and Search
Filter by min/max salary and search by employee name:
def apply_filters(self):
min_salary = self.filter_min.get()
max_salary = self.filter_max.get()
search_text = self.search_var.get().lower()
self.tree.delete(*self.tree.get_children())
for key, row in self.all_rows.items():
if min_salary <= row['predicted_salary'] <= max_salary:
if search_text in row['employee_name'].lower():
self.tree.insert("", "end", iid=key, values=(row['selected'], row['filename'], row['employee_name'], f"${row['predicted_salary']:,.2f}"))
✅ Explanation:
Users can filter the table dynamically as data is processed.
Step 10: Export Results
Export selected rows to a CSV:
def export_results(self):
path = filedialog.asksaveasfilename(defaultextension=".csv")
if path:
with open(path, "w", encoding="utf-8") as f:
f.write("Filename,Employee,PredictedSalary\n")
for i in self.tree.get_children():
values = self.tree.item(i)['values']
f.write(f"{values[1]},{values[2]},{values[3]}\n")
Step 11: Run the App
Finally, start the GUI loop:
if __name__ == "__main__":
app = SalaryPredictApp()
app.run()
Step 12: Clone the Full Project
You can find the full source code and download it here:
👉 https://github.com/rogers-cyber/python-tiny-tools/tree/main/Salary-prediction-system
✅ Key Features Recap
Drag & drop CSV files or folders
Real-time per-employee salary prediction
Filter by min/max salary
Search employees live
Batch processing with progress bar
Export results to CSV
This tutorial is designed to be beginner-friendly and easy to follow.
SOCIAL SHARE CARD GENERATOR