From a9271d5e96a3871027d47c4c271ba5e174fcf253 Mon Sep 17 00:00:00 2001
From: armaganngul <armagan.gul@mail.utoronto.ca>
Date: Sun, 1 Dec 2024 15:28:41 -0500
Subject: [PATCH] Changed testing

---
 .../app/__pycache__/__init__.cpython-312.pyc  | Bin 198 -> 173 bytes
 .../__pycache__/__init__.cpython-312.pyc      | Bin 210 -> 185 bytes
 .../__pycache__/__init__.cpython-312.pyc      | Bin 243 -> 218 bytes
 .../entities/__pycache__/user.cpython-312.pyc | Bin 850 -> 825 bytes
 .../__pycache__/__init__.cpython-312.pyc      | Bin 213 -> 188 bytes
 .../db_connection_manager.cpython-312.pyc     | Bin 1592 -> 1567 bytes
 .../__pycache__/__init__.cpython-312.pyc      | Bin 360 -> 335 bytes
 .../__pycache__/csv_file_repo.cpython-312.pyc | Bin 12162 -> 12137 bytes
 .../sqlite_db_repo.cpython-312.pyc            | Bin 12014 -> 11989 bytes
 .../__pycache__/__init__.cpython-312.pyc      | Bin 726 -> 701 bytes
 .../__pycache__/generate.cpython-312.pyc      | Bin 2998 -> 3063 bytes
 .../__pycache__/get_headers.cpython-312.pyc   | Bin 2119 -> 2094 bytes
 .../get_last_login_data.cpython-312.pyc       | Bin 1854 -> 1829 bytes
 .../get_values_under_header.cpython-312.pyc   | Bin 3753 -> 3728 bytes
 .../__pycache__/upload_data.cpython-312.pyc   | Bin 1657 -> 1632 bytes
 backend/app/use_cases/generate.py             |   5 +-
 .../datapoint_entity.cpython-312.pyc          | Bin 2248 -> 2223 bytes
 backend/ml_model/model_with_score.pkl         | Bin 2314 -> 2314 bytes
 .../data_preprocessing.cpython-312.pyc        | Bin 3510 -> 3485 bytes
 .../__pycache__/file_reader.cpython-312.pyc   | Bin 2869 -> 2844 bytes
 .../__pycache__/model_saver.cpython-312.pyc   | Bin 1191 -> 3567 bytes
 backend/ml_model/repository/model_saver.py    |  72 ++++-
 .../ml_model/repository/multiple_models.py    | 197 +++++++-----
 .../ml_model/repository/safe_grid_search.py   |  59 ++++
 backend/ml_model/repository/safe_split.py     |  28 +-
 .../__pycache__/model.cpython-312.pyc         | Bin 3389 -> 10257 bytes
 backend/ml_model/use_cases/model.py           | 288 ++++++++++++++----
 .../ml_model/use_cases/multiple_model_use.py  |   5 +-
 .../tests/repositories/test_model_saver.py    |   5 +-
 .../repositories/test_safe_train_grid.py      |  15 +-
 backend/tests/use_cases/test_model.py         |  21 +-
 .../use_cases/test_multiple_model_use.py      |   4 +-
 32 files changed, 515 insertions(+), 184 deletions(-)

diff --git a/backend/app/__pycache__/__init__.cpython-312.pyc b/backend/app/__pycache__/__init__.cpython-312.pyc
index 35ccb444efa3e08bd0ce7d2b4a53e1712dd64478..f60fb9536d81df9378d50a22e4b1b8b0dcab3d15 100644
GIT binary patch
delta 47
zcmX@cxR#OoG%qg~0}y2T8%^XkmhjOJElw>e)=w<TO-xVB(+{Xj&H%ClCgz6&058Q3
AegFUf

delta 72
zcmZ3>c#M(zG%qg~0}z}_HJr$8Y?!JaTAW%`te=&bnU!Chk*V*JTAW>yU!d>hrQljo
aQk1CRTv}9=nOvHaSfrm^9A7XoEF1tUSr{|`

diff --git a/backend/app/controllers/__pycache__/__init__.cpython-312.pyc b/backend/app/controllers/__pycache__/__init__.cpython-312.pyc
index e5f62b9d7f1767733d6d9eeabcf47c91d6643c19..50a67483fece5134d383b277f55fc0df0c460198 100644
GIT binary patch
delta 47
zcmcb_xRa6lG%qg~0}y2T8%^XkmWa>~Elw>e)=w<TO-xVB(+{Xj&H%ClCgvvt05xR}
At^fc4

delta 72
zcmdnVc!`nwG%qg~0}yOaHJr$8Y*?rtTAW%`te=&bnU!Chk*V*JTAW>yU!d>hrQljo
aQk1CRTv}9=nOvHaSfrm^9A7XoEExbW92ijm

diff --git a/backend/app/entities/__pycache__/__init__.cpython-312.pyc b/backend/app/entities/__pycache__/__init__.cpython-312.pyc
index 6db9f48abd968586e854c56f843ea3293fb8d9ae..5190fee9d61fbaed74fd036f1db2e671a5d293b0 100644
GIT binary patch
delta 47
zcmey&c#DzyG%qg~0}y2T8%^X6kqFffElw>e)=w<TO-xVB(+{Xj&H%ClCQe8O07UN(
AF8}}l

delta 72
zcmcb`_?eOWG%qg~0}#yBF`UR9Vwk5NTAW%`te=&bnU!Chk*V*JTAW>yU!d>hrQljo
aQk1CRTv}9=nOvHaSfrm^9A7Z8JQ)Bs9vFWB

diff --git a/backend/app/entities/__pycache__/user.cpython-312.pyc b/backend/app/entities/__pycache__/user.cpython-312.pyc
index f98caf19b238fa48a7989ce472c1a4fd4e0ad681..267ab79a0bb5d769eeb906a2ad1bb28210ee1799 100644
GIT binary patch
delta 50
zcmcb_wv&zfG%qg~0}!+=cH7APnNcE8KeRZts8~O-C^s=ZF;73BGC2dt4%n>Eq|68a
Dh5-+}

delta 75
zcmdnVc8QJqG%qg~0}$xV_Sne%nb9yyKeRZts8~NMF*7T_I3rWvCAB!aB)>r4%S*wv
dqNFHM!MU`kC^NY<C$UIBxj4RHvlx>yBLIl}7@hzC

diff --git a/backend/app/infrastructure/__pycache__/__init__.cpython-312.pyc b/backend/app/infrastructure/__pycache__/__init__.cpython-312.pyc
index dfc1c4d8dbeb3350877e71c7520b971d2db06516..7fe7f1d0e0085ca863e54fa5c8b435cd4ee075ed 100644
GIT binary patch
delta 47
zcmcc0xQCJZG%qg~0}y2T8%^XkmWb95Elw>e)=w<TO-xVB(+{Xj&H%ClCg!IB05;7I
Ax&QzG

delta 72
zcmdnPc$Ja+G%qg~0}zNA8cyUkHZ0K(Elw>e*3U}J%*rp$$kca9EzT~<FVOe$QgE#(
aDN0muE-fm`OfJnyEYeRdjxU%PmIeR;f)|JY

diff --git a/backend/app/infrastructure/__pycache__/db_connection_manager.cpython-312.pyc b/backend/app/infrastructure/__pycache__/db_connection_manager.cpython-312.pyc
index dc08bf8ca04bf953ae4262847a2c0f0faac24cb5..ec3d8ee6a2088294618fc7d9780cc0374c7b0ea5 100644
GIT binary patch
delta 50
zcmdnNGoOe1G%qg~0}!lQ>9di0Ewe<1erR!OQL%nvQEp;-VxE3LWpW0P9kBT&vp*96
Df`|}*

delta 75
zcmbQwvxA5GG%qg~0}$vg^4iF~mf5gTKeRZts8~NMF*7T_I3rWvCAB!aB)>r4%S*wv
dqNFHM!MU`kC^NY<C$UIBxj4RH^95#qCIEOn894v|

diff --git a/backend/app/repositories/__pycache__/__init__.cpython-312.pyc b/backend/app/repositories/__pycache__/__init__.cpython-312.pyc
index 2d3c4cd8b6b1e47f50ce79638977d4e29ccd522b..897f9534636367670516d4fcf4c5d58faee089cc 100644
GIT binary patch
delta 47
zcmaFCbe@U(G%qg~0}!lQ=`)dguSBGNXmM&$v3_DvZen_3o_;`Oat4qcF!5(T0A>IX
AvH$=8

delta 72
zcmX@l^n!`|G%qg~0}$vg@|wuK*RV)Gv^ce>SU)Q<Gb_J1BU9fcwK%&Zzd+y1OTo3G
aq$p9rxwNP#Gr2S;u}D9;IKE)wgM0u^;TdcI

diff --git a/backend/app/repositories/__pycache__/csv_file_repo.cpython-312.pyc b/backend/app/repositories/__pycache__/csv_file_repo.cpython-312.pyc
index 002193f771f555ee842d3dfcc65b359a99a907fc..8e8dfb1212c2cd19542863203b5aec6eb01f0e0c 100644
GIT binary patch
delta 57
zcmZpQe;LPpnwOW00SH#D^x4QQ$srM^A6lGRRIHy^l$)5In5Q35nVbP+2W$@Im?O{l
KYx5`d3G4t8XA{@}

delta 82
zcmaDE*A&lvnwOW00SI&#d2QsD<S;DP4=qkDD%Q_R%*@I!&dAhvNiEJU$uH3N@=|cE
kC@D%*a4sz>%1kcJNi5P&E{-qQY{M}}p7GY^o9YwT0Z1$ySpWb4

diff --git a/backend/app/repositories/__pycache__/sqlite_db_repo.cpython-312.pyc b/backend/app/repositories/__pycache__/sqlite_db_repo.cpython-312.pyc
index 145f3bef433321741bcd3a7202acb82718fe9a9f..21f21b23c57c8545c0d36e2caed3a31b853808af 100644
GIT binary patch
delta 50
zcmaDCdo`B(G%qg~0}!lQ>9di0F1tj$erR!OQL%nvQEp;-VxE3LWpW0P9kBT(yQn$<
DvWO8^

delta 75
zcmcZ_`!1IIG%qg~0}$vg^4iEfm))>JKeRZts8~NMF*7T_I3rWvCAB!aB)>r4%S*wv
dqNFHM!MU`kC^NY<C$UIBxj4RH^8t2IbpXJQ8W8{h

diff --git a/backend/app/use_cases/__pycache__/__init__.cpython-312.pyc b/backend/app/use_cases/__pycache__/__init__.cpython-312.pyc
index 10c6893159c8b58537516a1838b773558b35659e..6aa3dc1668cfe378d561d6f55bef81ff7e2f8ff6 100644
GIT binary patch
delta 49
zcmcb{x|fyvG%qg~0}!lQ>9dhrj!7a+KeRZts8~O-C^s=ZF;73BGC2dt4wxLpR09BI
CP7j6v

delta 74
zcmdnXdX1I)G%qg~0}$vg^4iEP$7GnVA6lGRRIHzsn3<JdoRO*Tl3JWyl3$?j<)z?S
cQBsts;9Oc%l$l(blUSsmTpV98*^#LR07mr~KmY&$

diff --git a/backend/app/use_cases/__pycache__/generate.cpython-312.pyc b/backend/app/use_cases/__pycache__/generate.cpython-312.pyc
index e4c8f6512eb24754d0a698dbdb4cc7905f75397e..624fa65d3d1edc405d10912eeb340a0467fbe443 100644
GIT binary patch
delta 421
zcmdlc{#~5!G%qg~0}xd0@=2HH*vOa0$jjrKpOTsrQk0mPms+&Bit!(lM3{bPacWVq
zeqvE>VtQhpen4e%29O;vc_qsZ#v7B9SXVP;@lLj8lQODhtzm6oN@u8L1!A@uRu_iY
zLI#Ff_8PV<evmz=poTq55U5R>nLSGwq@68=2`D5AVscag-38=`L**r*v@}R^@<%pV
zUe?u&5YreLYFH;rvllb+P3~uR5*8`}IXylxFC{*;EHS4vu_Sf!1@;<Mjv{WL`XZ1s
ziUdG}AdtAlmkaW3d}>8%a%o9w(d0x9304lEgu>)n4jsmulUH##2}!EXmh0fVAt--c
z(CDI|(PcrC$saiGGHOje$LU}s#VU3~Mqz>QOwSL@Ahv<YhTt74JBoK|Ziu^R-~ti!
z@dwinIC;OYN=<g)YGRb1e3&bP(P**`w*;fzWLNGOQOmC^OpHw5x%3#tJ~04^B0iuq
E07Lw6Y5)KL

delta 383
zcmew^zD=C(G%qg~0}!|@_Da9PzL77Dk&QJsKP5G1b0gzFCc}LF(BjmhV*RYd%&h$4
zj7)u()Z*-t`~rP1F9p|%lA=Tf=hC90%;eIX#3KFV;`oBe(^+;f?wB0Fx>~D&DV?E~
z1&CQ|SX>xl3mF({*=ks`ctO^og30=9Vw3sVI9O`fvIHmpWtCz}VFEIRK}?P+p!<Lv
zQ4j~DKpe)91TiN6XOrb+S<MJBkddK=WwIuFF(dEfx$I7pKeJaevQN(E5S3=jFD)r3
zExE;&ms%bVWiw_LvjeqF-oT;5czW_(4ks2tvB~0-4LR>JYE0(maxju)6}us$ut0dG
z=LcpG+rVT)@D7z7#XB`O#9cISfe8BegXssHykA%)CpU66G0IJ5;m%+*n4HTk!DutN
bjXOrv=qn2oBhz;-T}H7_3_zlY4`?p{xS?#c

diff --git a/backend/app/use_cases/__pycache__/get_headers.cpython-312.pyc b/backend/app/use_cases/__pycache__/get_headers.cpython-312.pyc
index 037e861beb960633881b56140509eaf0bb7e1044..7d20b539e97970370f908b6ccc616e54846fa607 100644
GIT binary patch
delta 50
zcmX>uuug#cG%qg~0}!lQ>9djh6thI6erR!OQL%nvQEp;-VxE3LWpW0P9k7{=#gPR7
Dh!79O

delta 75
zcmZ1{a9n`<G%qg~0}$vg^4iFKirKJ8KeRZts8~NMF*7T_I3rWvCAB!aB)>r4%S*wv
dqNFHM!MU`kC^NY<C$UIBxj4RH^IK*|7669U8GZl&

diff --git a/backend/app/use_cases/__pycache__/get_last_login_data.cpython-312.pyc b/backend/app/use_cases/__pycache__/get_last_login_data.cpython-312.pyc
index 0672f031e14169d1afa43730a70775922ded4ccd..0deaed17d79bf713a733e2bbcfc4898ae6e600ee 100644
GIT binary patch
delta 50
zcmdnTx0H|jG%qg~0}!lQ>9djBjYT3+KeRZts8~O-C^s=ZF;73BGC2dt4%pnpvWE!(
DcS#T_

delta 75
zcmZ3=w~vqeG%qg~0}$vg^4iGl#$s5dA6lGRRIHzsn3<JdoRO*Tl3JWyl3$?j<)z?S
dQBsts;9Oc%l$l(blUSsmTpVApIg@1%698lB7~=o{

diff --git a/backend/app/use_cases/__pycache__/get_values_under_header.cpython-312.pyc b/backend/app/use_cases/__pycache__/get_values_under_header.cpython-312.pyc
index 14abd7b77cdcd19e0993057740ec76afbce4a9b2..3b52d44b3a12d67daf6ceab7371232bf6f00cfab 100644
GIT binary patch
delta 50
zcmZ1}J3*HFG%qg~0}!lQ>9di04YNe5erR!OQL%nvQEp;-VxE3LWpW0P9kBTY^Fb~E
DgPRce

delta 75
zcmbOryHb|>G%qg~0}$vg^4iF~hS{)AKeRZts8~NMF*7T_I3rWvCAB!aB)>r4%S*wv
dqNFHM!MU`kC^NY<C$UIBxj4RH^LgfjTmX4c8L|KX

diff --git a/backend/app/use_cases/__pycache__/upload_data.cpython-312.pyc b/backend/app/use_cases/__pycache__/upload_data.cpython-312.pyc
index 393a383ad1baa5963995df22456f7c201a905ce3..6f14d4e2d2648dd2bfaef47fa18444159d6bf82c 100644
GIT binary patch
delta 50
zcmey#^MHr@G%qg~0}!lQ>9di03$sL|erR!OQL%nvQEp;-VxE3LWpW0P9kBTWb0-r3
Dn<o)E

delta 75
zcmaFB^OJ}BG%qg~0}$vg^4iF~h1sx3KeRZts8~NMF*7T_I3rWvCAB!aB)>r4%S*wv
dqNFHM!MU`kC^NY<C$UIBxj4RH^L6G<CIFnq8T0@E

diff --git a/backend/app/use_cases/generate.py b/backend/app/use_cases/generate.py
index 279b70fd..9fa9bfed 100644
--- a/backend/app/use_cases/generate.py
+++ b/backend/app/use_cases/generate.py
@@ -6,7 +6,7 @@
 project_root = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
 sys.path.append(project_root)
 
-from backend.ml_model.use_cases.model import model
+from backend.ml_model.use_cases.model import ModelTrainer
 
 from backend.app.use_cases.DatabaseRepositoryInterface import (
     DatabaseRepositoryInterface,
@@ -39,7 +39,8 @@ def execute(
         self.file_repo.update_comparison_csv(demographics, choices, time)
         self.db_repo.update_db_for_user(demographics, choices, time)
         print("GENERATE:", demographics, choices, time)
-        output = model()
+        model_executer = ModelTrainer()
+        output = model_executer.train_and_evaluate()
 
         if output is None:
             output = []
diff --git a/backend/ml_model/entities/__pycache__/datapoint_entity.cpython-312.pyc b/backend/ml_model/entities/__pycache__/datapoint_entity.cpython-312.pyc
index bcf1184c9e631c0683e15ec50013b7daec072f9f..990bf01b019b7ca107d0305dc9a383eda75848ab 100644
GIT binary patch
delta 57
zcmX>hxL%O^G%qg~0}!lQ>9dhrmq{W?KeRZts8~O-C^s=ZF;73BGC2dt4%nQ@G?9hz
K*XG}BXBh$Zd=p{-

delta 97
zcmZ24ctVi-G%qg~0}$vg^4iF)%Vb!sA6lGRRIHzsn3<JdoRO*Tl3JWyl3$?j<)z?S
zQBsts;9Oc%l$l(blUSsmTpVApIe=**3(qY^1x=<R7N9{ztdj-VL^d<BuVVxNvc??d

diff --git a/backend/ml_model/model_with_score.pkl b/backend/ml_model/model_with_score.pkl
index 1758e1504adc5f420ab370584b3afcd1a39f568a..244c1d99afb51fe6c76e73a0b8664643faf51021 100644
GIT binary patch
delta 31
ncmeAY>Jr-UnM2%YN@-FLYjJXZQR)<T`+HAYGT%kGm+Aok$qfxZ

delta 31
ncmeAY>Jr-UnM2%gN@-FLYjJXZQR)<T`+HAYGT%kGm+Aok$o36B

diff --git a/backend/ml_model/repository/__pycache__/data_preprocessing.cpython-312.pyc b/backend/ml_model/repository/__pycache__/data_preprocessing.cpython-312.pyc
index 9e6f80bc1d3fefe1aaac2a29821f7e2f285cfb95..a5f34b24663ddb1185d45d497354e22b79c7593d 100644
GIT binary patch
delta 50
zcmdlcJy)9hG%qg~0}!lQ>9djBpG6`~KeRZts8~O-C^s=ZF;73BGC2dt4%pnyqRj~a
DdD9QT

delta 75
zcmbO$y-k|?G%qg~0}$vg^4iGl&th1wA6lGRRIHzsn3<JdoRO*Tl3JWyl3$?j<)z?S
dQBsts;9Oc%l$l(blUSsmTpVApxrjxZ698z-7<vEz

diff --git a/backend/ml_model/repository/__pycache__/file_reader.cpython-312.pyc b/backend/ml_model/repository/__pycache__/file_reader.cpython-312.pyc
index e56b309f5dc71e9fdfa0007c3019cdbcaa29d7c9..93850868b515c3ef74261172748029981e2478b1 100644
GIT binary patch
delta 50
zcmdlgHb;#6G%qg~0}!lQ>9dhrm{lTPKeRZts8~O-C^s=ZF;73BGC2dt4%qC^`ivC-
DZ|V>3

delta 75
zcmbOuwpEP#G%qg~0}$vg^4iEP%xYMnA6lGRRIHzsn3<JdoRO*Tl3JWyl3$?j<)z?S
dQBsts;9Oc%l$l(blUSsmTpVAp*^KoWD*#tS7^naM

diff --git a/backend/ml_model/repository/__pycache__/model_saver.cpython-312.pyc b/backend/ml_model/repository/__pycache__/model_saver.cpython-312.pyc
index b5d0a571f6cceef8d6878ad635fe98d45cac6af8..448301e4fa1f3b2b8c395b123d5f94aac04f5d4c 100644
GIT binary patch
literal 3567
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
H%j5q5p<k=#

literal 1191
zcmah|J#5=X6u#r1Xvvb}rh$sWKnN#5tpFCAA<mGXK;$G1Ja~xF2G&BHdFPTeB@%a(
zB?UC%p+h|xnXDm0(5XR&bj;Xv>Ch#CJDuGrS+WUm00W+KM~Sh~41EW__r3RyAK$&l
z`@38&0wMFiF8yRH0KAn>F6I~<c>?SK3@{8qb7Wx?X1>x?g;heWr8jj5uu62S5jB|1
zNlq=+MZ9wA=Lj1ZuA8{<v(_~Gux7rOiRBvPliyPxuMk9CZ}CTNt`U|vZn(~ko|6d7
zjsDnDl5}X>RdYsR4e?0-Xco%aQxFLIUrAxAJQt^yvZW?t1VEsTVrO+wIO~mYl6MF^
zAG2?1|HD%HoF&yT{8WXWl=B^_jz3j*4Qv_7RGtaW<>=I=AXTyYL`jXDOH4zP>(uXS
zm%vrPU{`@)6+p52T2EaCU0Bl}ep9rBte{Q8ti&T$E5anS5VMdKZ-mymAChdx!)m>5
zXGy2)C!WLHh?2V4!j<k?P2qZ$<9Zffu1!#RWUfSvYcWbZUcf$WqZZ+&<497+;aU*+
zZLUQzX>%j?-HniN4R=~`tw7}{s4kTp>4?m9JCr(thZjeMWW;ct$r;I02s!E5KQKa>
z9Uwo5nCIKK3EN1b*j`$)?(`ChtVO}%yPXhG+htBnqky;xvlkKb=5NLEe8Wd<zR_Wc
zq*+7m25Dov6*}2BZA#*Z`AJ0k<8Cm~I$DqWyeQFV7yU|9B>xh&DbzL?7D4&K?()v^
zVBzV){^XVIJMX5Zce^{?-A6l*p7i#o=C<!0PM_baKCbS~Jf0bNujg*<PdB!gJ{X`_
z`6U=!-k-QQ1W>>E^y;Bm*)8pq2Hx)%-h6re<@7)1jbl}0h6d0}$Aui7FnJeW&3@g`
z)jxH;Q7MR-$PoQPDA8}!#)xqx#=Ocz=Min!M_pwk6b<pCHkCJtPuxZcx=ZEgj1@wC
z!m`sn14kkYXjP~a^QL&U6O!+!C0uza*bSkEDunO=OdNpnTX6ng@a@p3z|vr52!#2K
czDS>?8T{k^U#qWHGx&Pt!3UY87sdM@0R;INe*gdg

diff --git a/backend/ml_model/repository/model_saver.py b/backend/ml_model/repository/model_saver.py
index 1b02e75e..5f324dff 100644
--- a/backend/ml_model/repository/model_saver.py
+++ b/backend/ml_model/repository/model_saver.py
@@ -1,22 +1,72 @@
 import os
 import pickle
-
 import pandas as pd
 from sklearn.model_selection import GridSearchCV
 
 
-def save_model(best_clf: GridSearchCV, x_test: pd.DataFrame, y_test: pd.Series) -> None:
+class ModelSaver:
     """
-    Saves the model as a pkl file
+            Saves the trained model and its evaluation score as a pickle (.pkl) file.
+
+            Parameters:
+            -----------
+            best_clf : GridSearchCV
+                The trained model object, which is an instance of GridSearchCV containing the best estimator after hyperparameter tuning.
+
+            x_test : pd.DataFrame
+                The test dataset features used for evaluating the model.
+
+            y_test : pd.Series
+                The actual labels corresponding to the test dataset.
+
+            Returns:
+            --------
+            None
+                The function saves the model and its score to a file named `model_with_score.pkl` in the parent directory of the current script location.
     """
-    # Overall model score
-    score = best_clf.score(x_test, y_test)
+    def __init__(self, best_clf: GridSearchCV, x_test: pd.DataFrame, y_test: pd.Series):
+        """
+        Initializes the ModelSaver class with model, test features, and test labels.
+
+        Parameters:
+        -----------
+        best_clf : GridSearchCV
+            The trained model object, which is an instance of GridSearchCV containing the best estimator after hyperparameter tuning.
+
+        x_test : pd.DataFrame
+            The test dataset features used for evaluating the model.
+
+        y_test : pd.Series
+            The actual labels corresponding to the test dataset.
+        """
+        self.best_clf = best_clf
+        self.x_test = x_test
+        self.y_test = y_test
+
+    def save_model(self) -> None:
+        """
+        Saves the trained model and its evaluation score as a pickle (.pkl) file.
+
+        Returns:
+        --------
+        None
+            The function saves the model and its score to a file named `model_with_score.pkl` in the parent directory of the current script location.
+
+        Notes:
+        ------
+        - The `score` is calculated using the `score` method of the `best_clf` object, which typically represents accuracy for classification models.
+        - The resulting pickle file contains a dictionary with two keys:
+            - "model": the `best_clf` object.
+            - "score": the evaluation score of the model on the test data.
+        """
+        # Overall model score
+        score = self.best_clf.score(self.x_test, self.y_test)
 
-    curr_dir = os.path.dirname(__file__)
-    model_path = os.path.join(curr_dir, "../model_with_score.pkl")
+        curr_dir = os.path.dirname(__file__)
+        model_path = os.path.join(curr_dir, "../model_with_score.pkl")
 
-    # Save the model and its score
-    with open(model_path, "wb") as f:
-        pickle.dump({"model": best_clf, "score": score}, f)
+        # Save the model and its score
+        with open(model_path, "wb") as f:
+            pickle.dump({"model": self.best_clf, "score": score}, f)
 
-    return
+        return
diff --git a/backend/ml_model/repository/multiple_models.py b/backend/ml_model/repository/multiple_models.py
index cb4fa8e7..722815b9 100644
--- a/backend/ml_model/repository/multiple_models.py
+++ b/backend/ml_model/repository/multiple_models.py
@@ -12,95 +12,124 @@
 from backend.ml_model.repository.data_preprocessing_multiple_models import DataProcessorMultiple
 from backend.ml_model.repository.fairness import FairnessEvaluator
 from backend.ml_model.repository.file_reader_multiple_models import FileReaderMultiple
-from backend.ml_model.repository.safe_train_grid import safe_train_test_split
+from backend.ml_model.repository.safe_split import SafeSplitter
 
 current_dir = os.path.dirname(os.path.abspath(__file__))
 csv_file_path = os.path.join(current_dir, "../../../database/output.csv")
 
 
-def evaluate_multiple_models(model_files):
-    file_reader = FileReaderMultiple(csv_file_path)
-    df_dropped, inputs, target = file_reader.read_file()
-
-    data_processor = DataProcessorMultiple(inputs)
-    inputs_encoded = data_processor.encode_categorical_columns()
-    inputs_n = data_processor.drop_categorical_columns()
-
-    split_data = safe_train_test_split(inputs_n, target)
-    if split_data is None:
-        return {}
-
-    x_train, x_test, y_train, y_test = split_data
-
-    # Debug: Print columns of x_test
-    print(f"Columns in x_test: {x_test.columns}")
-
-    # Update sensitive features list to match the actual column names in x_test
-    sensitive_features_list = ["gender_N", "age_groups_N", "race_N", "state_N"]
-
-    # Dictionary to store results
-    results = {}
-
-    for model_file in model_files:
-        try:
-            # Load the model
-            with open(model_file, "rb") as f:
-                model_dict = pickle.load(f)
-                model = model_dict["model"]
-                print(f"Loaded object type: {type(model)}")
-                print(f"Loaded object: {model}")
-
-            # Make predictions
-            y_pred = model.predict(x_test)
-
-            # Debug: Check predictions
-            print(f"True Labels (y_test): {y_test.head()}")
-            print(f"Predicted Labels (y_pred): {y_pred[:10]}")
-
-            # Dictionary and list to store fairness results for the model
-            model_results = {}
-            fairness_values = []
-
-            for sensitive_feature in sensitive_features_list:
-                # Select the sensitive feature column for the evaluation
-                if sensitive_feature in x_test.columns:
-                    sensitive_col = x_test[sensitive_feature]
-                    print(
-                        f"Sensitive Feature: {sensitive_feature}, "
-                        f"Column Data: {sensitive_col.head()}"
-                    )
-
-                    # Evaluate fairness for this specific sensitive feature
-                    fairness_evaluator = FairnessEvaluator(
-                        y_test, y_pred, sensitive_col
-                    )
-                    metric_frame = fairness_evaluator.evaluate_fairness()
-
-                    average = sum(metric_frame.by_group["accuracy"]) / len(
-                        metric_frame.by_group["accuracy"]
+class MultiModelEvaluator:
+    """
+    A class for evaluating multiple machine learning models on a dataset.
+
+    This class handles data preprocessing, model loading, and fairness evaluation
+    based on specified sensitive features, producing metrics for each model.
+    """
+    def __init__(self, model_files: list):
+        """
+        Initializes the ModelEvaluator with the file path to the CSV and model files.
+
+        Parameters:
+        -----------
+
+        model_files : list
+            List of file paths to the model pickle files to evaluate.
+        """
+        self.model_files = model_files
+
+    def evaluate_models(self) -> dict:
+        """
+        Evaluates multiple models for fairness and performance metrics.
+
+        Returns:
+        --------
+        dict
+            A dictionary containing evaluation results for each model file.
+        """
+        # Read and preprocess the data
+        file_reader = FileReaderMultiple(csv_file_path)
+        df_dropped, inputs, target = file_reader.read_file()
+
+        data_processor = DataProcessorMultiple(inputs)
+        inputs_encoded = data_processor.encode_categorical_columns()
+        inputs_n = data_processor.drop_categorical_columns()
+
+        data_splitter = SafeSplitter()
+        split_data = data_splitter.train_test_split(inputs_n, target)
+        if split_data is None:
+            return {}
+
+        x_train, x_test, y_train, y_test = split_data
+
+        # Debug: Print columns of x_test
+        print(f"Columns in x_test: {x_test.columns}")
+
+        # Update sensitive features list to match the actual column names in x_test
+        sensitive_features_list = ["gender_N", "age_groups_N", "race_N", "state_N"]
+
+        # Dictionary to store results
+        results = {}
+
+        for model_file in self.model_files:
+            try:
+                # Load the model
+                with open(model_file, "rb") as f:
+                    model_dict = pickle.load(f)
+                    model = model_dict["model"]
+                    print(f"Loaded object type: {type(model)}")
+                    print(f"Loaded object: {model}")
+
+                # Make predictions
+                y_pred = model.predict(x_test)
+
+                # Debug: Check predictions
+                print(f"True Labels (y_test): {y_test.head()}")
+                print(f"Predicted Labels (y_pred): {y_pred[:10]}")
+
+                # Dictionary and list to store fairness results for the model
+                model_results = {}
+                fairness_values = []
+
+                for sensitive_feature in sensitive_features_list:
+                    # Select the sensitive feature column for the evaluation
+                    if sensitive_feature in x_test.columns:
+                        sensitive_col = x_test[sensitive_feature]
+                        print(
+                            f"Sensitive Feature: {sensitive_feature}, "
+                            f"Column Data: {sensitive_col.head()}"
+                        )
+
+                        # Evaluate fairness for this specific sensitive feature
+                        fairness_evaluator = FairnessEvaluator(
+                            y_test, y_pred, sensitive_col
+                        )
+                        metric_frame = fairness_evaluator.evaluate_fairness()
+
+                        average = sum(metric_frame.by_group["accuracy"]) / len(
+                            metric_frame.by_group["accuracy"]
+                        )
+                        rounded = round(average, 3)
+
+                        fairness_values.append(average)
+
+                        # Store the metrics for this demographic
+                        demo_name = sensitive_feature.replace("_N", "")
+                        model_results[demo_name] = rounded
+                    else:
+                        print(
+                            f"Sensitive feature '{sensitive_feature}' "
+                            f"not found in x_test."
+                        )
+
+                if fairness_values:
+                    model_results["variance"] = round(pd.Series(fairness_values).var(), 7)
+                    model_results["mean"] = round(
+                        sum(fairness_values) / len(fairness_values), 3
                     )
-                    rounded = round(average, 3)
-
-                    fairness_values.append(average)
-
-                    # Store the metrics for this demographic
-                    demo_name = sensitive_feature.replace("_N", "")
-                    model_results[demo_name] = rounded
-                else:
-                    print(
-                        f"Sensitive feature '{sensitive_feature}' "
-                        f"not found in x_test."
-                    )
-
-            if fairness_values:
-                model_results["variance"] = round(pd.Series(fairness_values).var(), 7)
-                model_results["mean"] = round(
-                    sum(fairness_values) / len(fairness_values), 3
-                )
-            # Store results for the model
-            results[model_file] = model_results
+                # Store results for the model
+                results[model_file] = model_results
 
-        except Exception as e:
-            results[model_file] = f"Error: {e}"
+            except Exception as e:
+                results[model_file] = f"Error: {e}"
 
-    return results
+        return results
diff --git a/backend/ml_model/repository/safe_grid_search.py b/backend/ml_model/repository/safe_grid_search.py
index e69de29b..a3156f8d 100644
--- a/backend/ml_model/repository/safe_grid_search.py
+++ b/backend/ml_model/repository/safe_grid_search.py
@@ -0,0 +1,59 @@
+from sklearn.model_selection import GridSearchCV
+from sklearn.tree import DecisionTreeClassifier
+import pandas as pd
+
+
+class SafeGridSearch:
+    """
+    A utility class for safely performing grid search for hyperparameter tuning.
+
+    This class ensures that grid search is executed while handling cases
+    where there are insufficient samples for cross-validation.
+    """
+
+    def __init__(self, classifier=DecisionTreeClassifier(), param_grid=None):
+        """
+        Initializes the SafeGridSearch with a classifier and a parameter grid.
+
+        Parameters:
+        -----------
+        classifier : estimator object, optional (default=DecisionTreeClassifier())
+            The base classifier to use for grid search.
+
+        param_grid : dict, optional
+            The parameter grid to use for tuning hyperparameters. If None,
+            a default parameter grid for DecisionTreeClassifier is used.
+        """
+        self.classifier = classifier
+        self.param_grid = param_grid or {
+            "criterion": ["gini", "entropy"],
+            "max_depth": [None] + list(range(1, 11)),
+            "min_samples_split": [2, 5, 10],
+        }
+
+    def perform_search(self, x_train: pd.DataFrame, y_train: pd.Series):
+        """
+        Performs a safe grid search for hyperparameter tuning.
+
+        Parameters:
+        -----------
+        x_train : pd.DataFrame
+            The training feature set.
+
+        y_train : pd.Series
+            The training labels.
+
+        Returns:
+        --------
+        estimator or None
+            Returns the best estimator if grid search is successful.
+            Returns None if there are insufficient samples for cross-validation.
+        """
+        try:
+            grid_search = GridSearchCV(self.classifier, self.param_grid, cv=5, scoring="accuracy")
+            grid_search.fit(x_train, y_train)
+            return grid_search.best_estimator_
+        except ValueError as e:
+            if "Cannot have number of splits n_splits" in str(e):
+                print("Not enough samples for cross-validation. Returning None.")
+                return None
diff --git a/backend/ml_model/repository/safe_split.py b/backend/ml_model/repository/safe_split.py
index 4849877a..b22bbd76 100644
--- a/backend/ml_model/repository/safe_split.py
+++ b/backend/ml_model/repository/safe_split.py
@@ -4,14 +4,28 @@
 
 class SafeSplitter:
     """
-    A class for safely splitting datasets into training and testing subsets.
+    A utility class for safely splitting datasets into training and testing subsets.
 
     This class ensures that a dataset is properly split while handling cases
     where the sample size is too small to perform the split.
     """
 
-    @staticmethod
-    def train_test_split(inputs: pd.DataFrame, target: pd.Series, test_size=0.2, random_state=48):
+    def __init__(self, test_size=0.2, random_state=48):
+        """
+        Initializes the SafeSplitter with parameters for splitting.
+
+        Parameters:
+        -----------
+        test_size : float, optional (default=0.2)
+            Proportion of the dataset to include in the test split.
+
+        random_state : int, optional (default=48)
+            Controls the shuffling applied to the data before splitting.
+        """
+        self.test_size = test_size
+        self.random_state = random_state
+
+    def train_test_split(self, inputs: pd.DataFrame, target: pd.Series):
         """
         Splits the dataset into training and testing subsets safely.
 
@@ -23,12 +37,6 @@ def train_test_split(inputs: pd.DataFrame, target: pd.Series, test_size=0.2, ran
         target : pd.Series
             Target labels of the dataset.
 
-        test_size : float, optional (default=0.2)
-            Proportion of the dataset to include in the test split.
-
-        random_state : int, optional (default=48)
-            Controls the shuffling applied to the data before splitting.
-
         Returns:
         --------
         tuple or None
@@ -37,7 +45,7 @@ def train_test_split(inputs: pd.DataFrame, target: pd.Series, test_size=0.2, ran
         """
         try:
             x_train, x_test, y_train, y_test = train_test_split(
-                inputs, target, test_size=test_size, random_state=random_state
+                inputs, target, test_size=self.test_size, random_state=self.random_state
             )
             return x_train, x_test, y_train, y_test
         except ValueError as e:
diff --git a/backend/ml_model/use_cases/__pycache__/model.cpython-312.pyc b/backend/ml_model/use_cases/__pycache__/model.cpython-312.pyc
index 56f8660faa9b43c5786ad85f4e651bb0c808e13c..c7279b418d30e50c97852e3c841f14e8251dde3a 100644
GIT binary patch
literal 10257
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

delta 1661
zcmY*ZO>7%Q6rQymuVZ_?an?VHon+SyNt&e8qz!H=s;Z(tlmKm|(o#i5%i>+z>pJW0
z?6^v*wc<(~jNp*6hvtCPNL&iJ1aaww12+(tY!}Ja3W*+iL0lrG5>gL{nN8!ulXmva
zo9}&Z-kW)I|H_Y<*slx|23XF0vsi9N?#G6F|4`o_zCgv7hnI#aAOks4%PeP?vef<C
zL)Js;3N>QwQnTq1IlAQ|jsPr;%FJhAX>666j#+1XU%Y8ZcNB5CE-STZpF3bkB}FVl
zRTd3Jg2jrP^ehNUswN`EK%$}7RAl|_J2@A`bbkEpeTTUp07MafBIso-0JdJ*n!p6r
zKI?WSbLb{^X;MvJ(~szVH~^-v2Mm}2>mHx5jt+%_%|0_wjbN{AUl3~y)<!S0Jtx}q
zA7s@GnW2`i46Xt*bTfbh^f$xJNHdD!J#@br>7f~uX;G_`$y7P(9?QKR?uCz;bTx6{
z^Xf1AhVi7y;w(~DF2f~*X4quQ6tQX?(TSh+7tiwph!{OFqh`z;*djH;(u|w&YL;Zf
z52De18%~|U-q8aLMe5{5;KvZ(!?0%196Z1@Ig_jA2+w#z8$;v&N15~%&Y#FD9Fss3
z`!)colO*FcU?zIiNSKMMU^;O3tFVCOtW>KR0v-fZQ3OfXVO@u+gcPCF(27W{YleX8
zLP<q}BzX5mkThA4>w+#pX<0!E6!!1VQIGG#ilPZnK@CV8F=a{BWWTDFt$VrTDPkx?
zNv|0D=u42?oj=L7nNGkE{<%!ixFeR-nj-2Fs<{17kz{XfMPl!+!3f4c(iJYPLq%4L
z$fb+*T4Px=T+YC8u;cz*ELN1_El6&i8&~c~wFb^gEJ-TV6vKf1gs6`!va*CEQLn2S
z5^Jh~AgL&flBI!SO_4N_0KD}h#&pt+c)KI}QlJ}_OQMWxrYo`=R5iVU3^#}*SXPi#
zjLk2)VXuQc3YT6Hz1DJrSi#-p(yIpstPn%!Q_^(BTFDKriX=fdR8k~dO=ZrymOeb`
zMsdlZS`<s9_-<6zF{)m~3DqGS!do_yc(8st#LWxBi`)5Yh60UzRZ^>UqoU@|DaI{S
z*Yk^u!ub`v72#|HVzx$2g88B$>J}e*d#%qqW|+rBDZ<#q$I}AOqktRz`eSEsw)I{&
zccham*tvp}Td)ITt;O}=M(}wMq{cT3PI9Joshb?{Bv0GP(@ydXp0T4HcE)CB9QH`-
zqBkqpY{6j{S{Jd`;MC^IcFKt_v=+N`d}oaw?y~WA|I?{CJMdcTo%Z$hk2XpeHy~`%
zkJ1i1hdF3=hfa4{ZZ`;GsSY!0Gou?NhnZ+yz?Olb4$Iptze(Bbq1HugiKaV|nJ1B%
zT|ek&*F){QPePfe47Yw`W2M9AZ9czE+5EAc#BrOMU)!ZYU;23rWM&@~whKFNec%jV
z+6kn(+(d^vVRI)O?quuzXMtFIWh1qj`Ymu62MBQ;dh!W9`FnbP`^MvypGTbZ^>(zI
zne1c=cBbHD7CvX6rH^-`iS^26^igHc?;8rYqu4V$)q}LzXDOkRP0iV<x$W7<YfkEN
z>+;h`W+#x@!v_JT`5&?qUsBYpm75$%{O6@6FSyqf7BzKjhCG?x>3s{}8$>^fhZmt!
k_*fe?<up8xr=;VIht?-kMgJc_w0@a75#9?fP+8C6U*%%fa{vGU

diff --git a/backend/ml_model/use_cases/model.py b/backend/ml_model/use_cases/model.py
index 1f7815f0..b38fb920 100644
--- a/backend/ml_model/use_cases/model.py
+++ b/backend/ml_model/use_cases/model.py
@@ -11,68 +11,248 @@
 from backend.ml_model.repository.data_preprocessing import DataProcessor
 from backend.ml_model.repository.fairness import FairnessEvaluator
 from backend.ml_model.repository.file_reader import FileReader
-from backend.ml_model.repository.model_saver import save_model
-from backend.ml_model.repository.safe_train_grid import safe_grid_search, safe_train_test_split
+from backend.ml_model.repository.model_saver import ModelSaver
+from backend.ml_model.repository.safe_split import SafeSplitter
+from backend.ml_model.repository.safe_grid_search import SafeGridSearch
 from backend.ml_model.utility import model_util
 
 current_dir = os.path.dirname(os.path.abspath(__file__))
-csv_file_path = os.path.join(current_dir, "../../../database/output.csv")
+file_path_csv = os.path.join(current_dir, "../../../database/output.csv")
 
 
-def model():
+class ModelTrainer:
     """
-    Calls all the appropriate functions to fit a model and do parameter search.
-    Then returns the findings to be displayed by the graphs.
+    A class that encapsulates the process of training a machine learning model,
+    performing hyperparameter tuning, evaluating fairness, and saving the trained model.
+
+    This class performs the following steps:
+    1. Loads and preprocesses the data.
+    2. Splits the data into training and testing sets.
+    3. Performs grid search for hyperparameter tuning.
+    4. Makes predictions.
+    5. Evaluates fairness across sensitive features.
+    6. Saves the model and prepares data for visualization.
     """
-    # Load and preprocess data
-    file_reader = FileReader(csv_file_path)
-    df_dropped, inputs, target = file_reader.read_file()
-
-    # Encode categorical columns using DataProcessor
-    data_processor = DataProcessor(inputs)
-    inputs_encoded = data_processor.encode_categorical_columns()
-    mappings = data_processor.get_mappings()
-    inputs_n = data_processor.drop_categorical_columns()
-
-    # Split data
-    split_data = safe_train_test_split(inputs_n, target)
-    if split_data is None:
-        return []  # Early exit if there aren't enough samples
-
-    x_train, x_test, y_train, y_test = split_data
-
-    # Perform grid search for hyperparameter tuning
-    best_clf = safe_grid_search(x_train, y_train)
-    if best_clf is None:
-        return None  # Early exit if grid search fails due to insufficient samples
-
-    # Make predictions
-    y_pred = best_clf.predict(x_test)
-
-    # Handle sensitive features for fairness evaluation
-    feature1 = inputs_n.columns[0]
-    sensitive_features = (
-        x_test[[feature1]]
-        if file_reader.single_column_check
-        else x_test[[feature1, inputs_n.columns[1]]]
-    )
-
-    # Evaluate fairness
-    fairness_evaluator = FairnessEvaluator(y_test, y_pred, sensitive_features)
-    metric_frame = fairness_evaluator.evaluate_fairness()
-    # Save the model
-    save_model(best_clf, x_test, y_test)
-
-    # Create, clean, and sort bias dictionary
-    if file_reader.single_column_check:
-        dp_processor = SingleFeatureDataPointCreator(feature1, mappings, metric_frame)
+
+    def __init__(self, csv_file_path=file_path_csv, test_size=0.2, random_state=48):
+        """
+        Initializes the ModelTrainer with necessary parameters.
+
+        Parameters:
+        -----------
+        csv_file_path : str
+            The path to the CSV file containing the dataset.
+
+        test_size : float, optional (default=0.2)
+            The proportion of the dataset to be used for testing.
+
+        random_state : int, optional (default=48)
+            The random seed used for reproducibility in train-test splitting.
+        """
+        self.csv_file_path = csv_file_path
+        self.test_size = test_size
+        self.random_state = random_state
+
+    def load_and_preprocess_data(self):
+        """
+        Loads the data from a CSV file, processes it by dropping irrelevant columns,
+        and encodes categorical variables.
+
+        Returns:
+        --------
+        tuple : (df_dropped, inputs, target)
+            - df_dropped : DataFrame with dropped columns
+            - inputs : DataFrame with the feature columns
+            - target : Series with the target variable
+            - file_reader: FileReader object
+        """
+        file_reader = FileReader(self.csv_file_path)
+        return (file_reader.read_file(), file_reader)
+
+    def encode_data(self, inputs):
+        """
+        Encodes categorical columns and returns the encoded inputs.
+
+        Parameters:
+        -----------
+        inputs : pd.DataFrame
+            The input feature set to be encoded.
+
+        Returns:
+        --------
+        tuple : (inputs_encoded, mappings, inputs_n)
+            - inputs_encoded : The inputs with categorical columns encoded
+            - mappings : A dictionary of mappings for encoding
+            - inputs_n : The inputs with categorical columns dropped
+        """
+        data_processor = DataProcessor(inputs)
+        inputs_encoded = data_processor.encode_categorical_columns()
+        mappings = data_processor.get_mappings()
+        inputs_n = data_processor.drop_categorical_columns()
+        return inputs_encoded, mappings, inputs_n
+
+    def split_data(self, inputs_n, target):
+        """
+        Splits the dataset into training and testing subsets.
+
+        Parameters:
+        -----------
+        inputs_n : pd.DataFrame
+            The feature set after dropping categorical columns.
+
+        target : pd.Series
+            The target variable.
+
+        Returns:
+        --------
+        tuple or None : (x_train, x_test, y_train, y_test) or None
+            Returns a tuple of the training and testing sets, or None if splitting fails.
+        """
+        data_splitter = SafeSplitter(self.test_size, self.random_state)
+        return data_splitter.train_test_split(inputs_n, target)
+
+    def perform_grid_search(self, x_train, y_train):
+        """
+        Performs a grid search to find the best model based on hyperparameter tuning.
+
+        Parameters:
+        -----------
+        x_train : pd.DataFrame
+            The training feature set.
+
+        y_train : pd.Series
+            The training target variable.
+
+        Returns:
+        --------
+        model or None : The best model after grid search or None if search fails.
+        """
+        grid_searcher = SafeGridSearch()
+        return grid_searcher.perform_search(x_train, y_train)
+
+    def evaluate_fairness(self, y_test, y_pred, sensitive_features):
+        """
+        Evaluates the fairness of the model predictions with respect to sensitive features.
+
+        Parameters:
+        -----------
+        y_test : pd.Series
+            The true labels for the test set.
+
+        y_pred : np.array
+            The predicted labels for the test set.
+
+        sensitive_features : pd.DataFrame
+            The sensitive feature columns to evaluate fairness.
+
+        Returns:
+        --------
+        metric_frame : DataFrame
+            A DataFrame containing fairness metrics.
+        """
+        fairness_evaluator = FairnessEvaluator(y_test, y_pred, sensitive_features)
+        return fairness_evaluator.evaluate_fairness()
+
+    def save_model(self, best_clf, x_test, y_test):
+        """
+        Saves the trained model and its accuracy score.
+
+        Parameters:
+        -----------
+        best_clf : estimator
+            The trained model.
+
+        x_test : pd.DataFrame
+            The test feature set.
+
+        y_test : pd.Series
+            The test target variable.
+        """
+        modelsaver = ModelSaver(best_clf, x_test, y_test)
+        modelsaver.save_model()
+
+    def create_data_points(self, feature1, mappings, metric_frame, inputs_n, file_reader):
+        """
+        Creates a list of data points for visualization based on the fairness evaluation.
+
+        Parameters:
+        -----------
+        feature1 : str
+            The first sensitive feature.
+
+        mappings : dict
+            A dictionary of mappings for encoding.
+
+        metric_frame : DataFrame
+            A DataFrame containing fairness metrics.
+
+        inputs_n : pd.DataFrame
+            The feature set after dropping categorical columns.
+
+        file_reader : FileReader
+            The file reader used to check for single-column data.
+
+        Returns:
+        --------
+        data_point_list : list
+            A list of data points to be displayed by the graphs.
+        """
+        if file_reader.single_column_check:
+            dp_processor = SingleFeatureDataPointCreator(feature1, mappings, metric_frame)
+        else:
+            dp_processor = MultiFeatureDataPointCreator(feature1, mappings, metric_frame, inputs_n)
+
         data_point_list = dp_processor.data_point_list()
-    else:
-        dp_processor = MultiFeatureDataPointCreator(
-            feature1, mappings, metric_frame, inputs_n
+        return model_util.clean_datapoints(file_reader, data_point_list)
+
+    def train_and_evaluate(self):
+        """
+        The main function that calls all other methods to train a model, evaluate fairness,
+        and return results for visualization.
+
+        Returns:
+        --------
+        data_point_list : list
+            A list of cleaned data points to be displayed by graphs.
+            Returns an empty list if there aren't enough samples or if grid search fails.
+        """
+        # Load and preprocess data
+        data_tuple, file_reader = self.load_and_preprocess_data()
+        df_dropped, inputs, target = data_tuple
+
+        # Encode data
+        inputs_encoded, mappings, inputs_n = self.encode_data(inputs)
+
+        # Split data
+        split_data = self.split_data(inputs_n, target)
+        if split_data is None:
+            return []  # Early exit if there aren't enough samples
+
+        x_train, x_test, y_train, y_test = split_data
+
+        # Perform grid search for hyperparameter tuning
+        best_clf = self.perform_grid_search(x_train, y_train)
+        if best_clf is None:
+            return None  # Early exit if grid search fails
+
+        # Make predictions
+        y_pred = best_clf.predict(x_test)
+
+        # Handle sensitive features for fairness evaluation
+        feature1 = inputs_n.columns[0]
+        sensitive_features = (
+            x_test[[feature1]]
+            if file_reader.single_column_check
+            else x_test[[feature1, inputs_n.columns[1]]]
         )
-        data_point_list = dp_processor.data_point_list()
 
-    data_point_list = model_util.clean_datapoints(file_reader, data_point_list)
+        # Evaluate fairness
+        metric_frame = self.evaluate_fairness(y_test, y_pred, sensitive_features)
+
+        # Save the model
+        self.save_model(best_clf, x_test, y_test)
+
+        # Create, clean, and sort bias dictionary
+        data_point_list = self.create_data_points(feature1, mappings, metric_frame, inputs_n, file_reader)
 
-    return data_point_list
+        return data_point_list
diff --git a/backend/ml_model/use_cases/multiple_model_use.py b/backend/ml_model/use_cases/multiple_model_use.py
index 64128b64..6f508966 100644
--- a/backend/ml_model/use_cases/multiple_model_use.py
+++ b/backend/ml_model/use_cases/multiple_model_use.py
@@ -6,7 +6,7 @@
 project_root = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
 sys.path.append(project_root)
 
-from backend.ml_model.repository.multiple_models import evaluate_multiple_models
+from backend.ml_model.repository.multiple_models import MultiModelEvaluator
 
 
 class EvaluateModelsUseCase:
@@ -35,7 +35,8 @@ def execute(self):
         # self.file_repo.import_csv_to_db()
         print("working till here")
         self.file_repo.save_data_to_csv()
-        output = evaluate_multiple_models(self.model_files)
+        model_evaluator = MultiModelEvaluator(self.model_files)
+        output = model_evaluator.evaluate_multiple_models()
         self.file_repo.delete_csv_data()
 
         return output
diff --git a/backend/tests/repositories/test_model_saver.py b/backend/tests/repositories/test_model_saver.py
index 65df75c3..7b31c132 100644
--- a/backend/tests/repositories/test_model_saver.py
+++ b/backend/tests/repositories/test_model_saver.py
@@ -3,7 +3,7 @@
 
 import pandas as pd
 import pytest
-from backend.ml_model.repository.model_saver import save_model
+from backend.ml_model.repository.model_saver import ModelSaver
 from sklearn.model_selection import GridSearchCV
 
 
@@ -32,7 +32,8 @@ def test_save_model(mock_pickle_dump, mock_open, mock_model_and_data):
     mock_clf, x_test, y_test = mock_model_and_data
 
     # Call the save_model function
-    result = save_model(mock_clf, x_test, y_test)
+    model_saver = ModelSaver(mock_clf, x_test, y_test)
+    result = model_saver.save_model()
 
     # Check that the function returns None
     assert (
diff --git a/backend/tests/repositories/test_safe_train_grid.py b/backend/tests/repositories/test_safe_train_grid.py
index 380aeb6f..9fa33a00 100644
--- a/backend/tests/repositories/test_safe_train_grid.py
+++ b/backend/tests/repositories/test_safe_train_grid.py
@@ -3,10 +3,8 @@
 import numpy as np
 import pandas as pd
 import pytest
-from backend.ml_model.repository.safe_train_grid import (
-    safe_grid_search,
-)  # Adjust import based on your project structure
-from backend.ml_model.repository.safe_train_grid import safe_train_test_split
+from backend.ml_model.repository.safe_grid_search import SafeGridSearch
+from backend.ml_model.repository.safe_split import SafeSplitter
 from sklearn.model_selection import GridSearchCV, train_test_split
 from sklearn.tree import DecisionTreeClassifier
 
@@ -18,7 +16,8 @@ def test_safe_train_test_split_insufficient_samples():
     inputs = pd.DataFrame({"feature1": [1]})
     target = pd.Series([0])
 
-    result = safe_train_test_split(inputs, target)
+    splitter = SafeSplitter()
+    result = splitter.train_test_split(inputs, target)
     assert result is None, "Expected None when there aren't enough samples to split."
 
 
@@ -28,7 +27,8 @@ def test_safe_train_test_split_valid_case():
     inputs = pd.DataFrame({"feature1": [1, 2, 3, 4, 5]})
     target = pd.Series([0, 1, 0, 1, 0])
 
-    result = safe_train_test_split(inputs, target)
+    splitter = SafeSplitter()
+    result = splitter.train_test_split(inputs, target)
     assert result is not None, "Expected valid result with enough samples."
     assert (
         len(result) == 4
@@ -42,7 +42,8 @@ def test_safe_grid_search_insufficient_samples():
     x_train = pd.DataFrame({"feature1": [1, 2]})
     y_train = pd.Series([0, 1])
 
-    result = safe_grid_search(x_train, y_train)
+    grid_searcher = SafeGridSearch()
+    result = grid_searcher.perform_search(x_train, y_train)
     assert (
         result is None
     ), "Expected None when there aren't enough samples for cross-validation."
diff --git a/backend/tests/use_cases/test_model.py b/backend/tests/use_cases/test_model.py
index 46adf21a..ded8d41a 100644
--- a/backend/tests/use_cases/test_model.py
+++ b/backend/tests/use_cases/test_model.py
@@ -8,7 +8,7 @@
 from backend.ml_model.repository import data_point_creator_multiple, data_point_creator_single
 from backend.ml_model.repository.data_point_creator_multiple import MultiFeatureDataPointCreator
 from backend.ml_model.repository.data_point_creator_single import SingleFeatureDataPointCreator
-from backend.ml_model.use_cases.model import model
+from backend.ml_model.use_cases.model import ModelTrainer
 from backend.ml_model.utility import model_util
 from sklearn.model_selection import GridSearchCV
 from sklearn.tree import DecisionTreeClassifier
@@ -127,8 +127,8 @@ def mock_data_processor(mock_data):
 def mock_safe_train_test_split():
     # Mock the train-test split behavior
     with patch(
-        "ml_model.repository.safe_train_grid.safe_train_test_split"
-    ) as mock_split:
+        "ml_model.repository.safe_split.SafeSplitter"
+    ) as mock_split.train_test_split:
         mock_split.return_value = (
             pd.DataFrame(),
             pd.DataFrame(),
@@ -141,7 +141,7 @@ def mock_safe_train_test_split():
 @pytest.fixture
 def mock_safe_grid_search():
     # Mock the grid search behavior
-    with patch("ml_model.repository.safe_train_grid.safe_grid_search") as mock_search:
+    with patch("ml_model.repository.safe_gird_search.SafeGridSearch") as mock_search.perform_search:
         clf = MagicMock(spec=DecisionTreeClassifier)
         mock_search.return_value = clf
         yield mock_search
@@ -160,8 +160,8 @@ def mock_fairness_evaluator():
 @pytest.fixture
 def mock_save_model():
     # Mock the save_model behavior
-    with patch("ml_model.repository.model_saver.save_model") as mock_save:
-        yield mock_save
+    with patch("ml_model.repository.model_saver.ModelSaver") as mock_save:
+        yield mock_save.save_model
 
 
 @pytest.fixture
@@ -178,10 +178,10 @@ def mock_data_point_creator():
 
 @patch("ml_model.repository.file_reader.FileReader", new_callable=MagicMock)
 @patch("ml_model.repository.data_preprocessing.DataProcessor", new_callable=MagicMock)
-@patch("ml_model.repository.safe_train_grid.safe_train_test_split")
-@patch("ml_model.repository.safe_train_grid.safe_grid_search")
+@patch("ml_model.repository.safe_split.SafeSplitter.train_test_split")
+@patch("ml_model.repository.safe_grid_search.SafeGridSearch.perform_search")
 @patch("ml_model.repository.fairness.FairnessEvaluator", new_callable=MagicMock)
-@patch("ml_model.repository.model_saver.save_model", new_callable=MagicMock)
+@patch("ml_model.repository.model_saver.ModelSaver.save_model", new_callable=MagicMock)
 @patch(
     "ml_model.repository.data_point_creator_multiple.MultiFeatureDataPointCreator",
     new_callable=MagicMock,
@@ -234,7 +234,8 @@ def test_model(
     ]
 
     # Act: Call the model function
-    result = model()
+    model = ModelTrainer()
+    result = model.train_and_evaluate()
 
     # Assert: Ensure the result is as expected
     assert isinstance(result, list)  # We expect a list of data points
diff --git a/backend/tests/use_cases/test_multiple_model_use.py b/backend/tests/use_cases/test_multiple_model_use.py
index 5ce8ab31..57c08bd8 100644
--- a/backend/tests/use_cases/test_multiple_model_use.py
+++ b/backend/tests/use_cases/test_multiple_model_use.py
@@ -1,7 +1,7 @@
 from unittest.mock import MagicMock, patch
 
 import pytest
-from backend.ml_model.repository.multiple_models import evaluate_multiple_models
+from backend.ml_model.repository.multiple_models import MultiModelEvaluator
 from backend.ml_model.use_cases.multiple_model_use import EvaluateModelsUseCase
 
 
@@ -18,7 +18,7 @@ def mock_model_files():
     return ["model1.pkl", "model2.pkl"]
 
 
-@patch("ml_model.repository.multiple_models.evaluate_multiple_models")
+@patch("ml_model.repository.multiple_models.MultiModelEvaluator.evaluate_models")
 def test_execute_with_failure(
     mock_evaluate_multiple_models, mock_file_repo, mock_model_files
 ):