diff --git a/.gitignore b/.gitignore
index a9783e2..7f3c84d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1 +1,2 @@
 concrete/*
+data/*
diff --git a/README.md b/README.md
index 1bee5de..bbf76f6 100644
--- a/README.md
+++ b/README.md
@@ -52,6 +52,11 @@ pip install src/requirements.txt
 ```
 3. Execute the notebooks in the specified order, ensuring that the dataset and necessary files are correctly referenced.
 
+
+## Dask as the Runtime Engine
+
+In the data processing step, we have incorporated **Dask**, a parallel computing library, to handle large-scale data efficiently. With Dask, we can process data in a distributed manner, allowing us to scale our computation to multiple cores and machines seamlessly. The use of Dask enables us to leverage the power of parallel processing, making our data processing pipelines faster and more scalable.
+
 Feel free to experiment with different regression algorithms and hyperparameter tuning to further enhance the model performance. Share your feedback and contribute to this project to help us improve and expand its capabilities.
 
 ## MLflow Integration
@@ -71,4 +76,4 @@ For inquiries or further information, please contact me at:
  - LinkedIn: https://www.linkedin.com/in/pedro-a-d-s/
 
 ## License
-This project is licensed under the MIT License.
\ No newline at end of file
+This project is licensed under the MIT License.
diff --git a/data/1-bronze/Concrete_Data_Cleaned.parquet b/data/1-bronze/Concrete_Data_Cleaned.parquet
index e50a3d7..b90636f 100644
Binary files a/data/1-bronze/Concrete_Data_Cleaned.parquet and b/data/1-bronze/Concrete_Data_Cleaned.parquet differ
diff --git a/notebooks/01-EDA/01_EDA_strength_prediction.ipynb b/notebooks/01-EDA/01_EDA_strength_prediction.ipynb
index 2cd7176..4606aed 100644
--- a/notebooks/01-EDA/01_EDA_strength_prediction.ipynb
+++ b/notebooks/01-EDA/01_EDA_strength_prediction.ipynb
@@ -81,11 +81,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "import numpy as np\n",
     "import pandas as pd\n",
     "import matplotlib.pyplot as plt\n",
     "import seaborn as sns\n",
-    "import itertools\n",
     "from scipy import stats\n",
     "%matplotlib inline\n",
     "sns.set_style(\"white\")"
@@ -184,7 +182,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "df = pd.read_csv('../../data/0. raw-data/Concrete_Data.csv')"
+    "df = pd.read_csv('../../data/0-raw-data/Concrete_Data.csv')"
    ]
   },
   {
@@ -2567,13 +2565,6 @@
    "source": [
     "df.to_parquet('../../data/2-silver/Concrete_Data_Cleaned.parquet', index = False)"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {
diff --git a/notebooks/02-ML Modelling/01_ml_experiments.ipynb b/notebooks/02-ML Modelling/01_ml_experiments.ipynb
index d77df77..9807c91 100644
--- a/notebooks/02-ML Modelling/01_ml_experiments.ipynb	
+++ b/notebooks/02-ML Modelling/01_ml_experiments.ipynb	
@@ -32,22 +32,16 @@
         "import pandas as pd\n",
         "import matplotlib.pyplot as plt\n",
         "import seaborn as sns\n",
-        "import xgboost as xgb\n",
         "import mlflow\n",
         "import mlflow.sklearn\n",
-        "%matplotlib inline\n",
-        "sns.set_style(\"white\")\n",
         "\n",
         "from sklearn.model_selection import train_test_split\n",
-        "from sklearn.linear_model import LinearRegression, Ridge, Lasso\n",
         "from sklearn.neighbors import KNeighborsRegressor\n",
         "from sklearn.tree import DecisionTreeRegressor\n",
         "from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor, AdaBoostRegressor, BaggingRegressor\n",
         "from sklearn.svm import SVR\n",
         "from sklearn import metrics\n",
-        "from scipy import stats\n",
         "from scipy.stats import zscore\n",
-        "from sklearn.metrics import mean_absolute_error, median_absolute_error, r2_score\n",
         "from sklearn.model_selection import KFold\n",
         "from sklearn.model_selection import cross_val_score\n",
         "from xgboost.sklearn import XGBRegressor\n",
@@ -64,7 +58,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 3,
+      "execution_count": 2,
       "metadata": {},
       "outputs": [],
       "source": [
@@ -73,13 +67,15 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 5,
+      "execution_count": 3,
       "metadata": {
         "id": "tp7uDcZaMqku"
       },
       "outputs": [],
       "source": [
-        "warnings.filterwarnings(\"ignore\")"
+        "warnings.filterwarnings(\"ignore\")\n",
+        "%matplotlib inline\n",
+        "sns.set_style(\"white\")"
       ]
     },
     {
@@ -93,13 +89,13 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 3,
+      "execution_count": 7,
       "metadata": {
         "id": "eBiHe1RdMqku"
       },
       "outputs": [],
       "source": [
-        "df = pd.read_parquet('../../data/2-silver/Concrete_Data_Cleaned.parquet')"
+        "df = pd.read_parquet('./data/1-bronze/Concrete_Data_Cleaned.parquet')"
       ]
     },
     {
@@ -113,7 +109,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 5,
+      "execution_count": 8,
       "metadata": {
         "colab": {
           "base_uri": "https://localhost:8080/",
@@ -165,8 +161,8 @@
               "      <td>2.5</td>\n",
               "      <td>1040.0</td>\n",
               "      <td>676.0</td>\n",
-              "      <td>28</td>\n",
-              "      <td>79.99</td>\n",
+              "      <td>28.0</td>\n",
+              "      <td>79,99</td>\n",
               "    </tr>\n",
               "    <tr>\n",
               "      <th>1</th>\n",
@@ -177,8 +173,8 @@
               "      <td>2.5</td>\n",
               "      <td>1055.0</td>\n",
               "      <td>676.0</td>\n",
-              "      <td>28</td>\n",
-              "      <td>61.89</td>\n",
+              "      <td>28.0</td>\n",
+              "      <td>61,89</td>\n",
               "    </tr>\n",
               "    <tr>\n",
               "      <th>2</th>\n",
@@ -189,8 +185,8 @@
               "      <td>0.0</td>\n",
               "      <td>932.0</td>\n",
               "      <td>594.0</td>\n",
-              "      <td>28</td>\n",
-              "      <td>40.27</td>\n",
+              "      <td>28.0</td>\n",
+              "      <td>40,27</td>\n",
               "    </tr>\n",
               "    <tr>\n",
               "      <th>3</th>\n",
@@ -201,8 +197,8 @@
               "      <td>0.0</td>\n",
               "      <td>932.0</td>\n",
               "      <td>594.0</td>\n",
-              "      <td>28</td>\n",
-              "      <td>41.05</td>\n",
+              "      <td>28.0</td>\n",
+              "      <td>41,05</td>\n",
               "    </tr>\n",
               "    <tr>\n",
               "      <th>4</th>\n",
@@ -213,23 +209,23 @@
               "      <td>0.0</td>\n",
               "      <td>978.4</td>\n",
               "      <td>825.5</td>\n",
-              "      <td>28</td>\n",
-              "      <td>44.30</td>\n",
+              "      <td>28.0</td>\n",
+              "      <td>44,30</td>\n",
               "    </tr>\n",
               "  </tbody>\n",
               "</table>\n",
               "</div>"
             ],
             "text/plain": [
-              "   cement   slag  ash  water  superplastic  coarseagg  fineagg  age  strength\n",
-              "0   272.9    0.0  0.0  162.0           2.5     1040.0    676.0   28     79.99\n",
-              "1   272.9    0.0  0.0  162.0           2.5     1055.0    676.0   28     61.89\n",
-              "2   332.5  142.5  0.0  185.0           0.0      932.0    594.0   28     40.27\n",
-              "3   332.5  142.5  0.0  185.0           0.0      932.0    594.0   28     41.05\n",
-              "4   198.6  132.4  0.0  192.0           0.0      978.4    825.5   28     44.30"
+              "   cement   slag  ash  water  superplastic  coarseagg  fineagg   age strength\n",
+              "0   272.9    0.0  0.0  162.0           2.5     1040.0    676.0  28.0   79,99 \n",
+              "1   272.9    0.0  0.0  162.0           2.5     1055.0    676.0  28.0   61,89 \n",
+              "2   332.5  142.5  0.0  185.0           0.0      932.0    594.0  28.0   40,27 \n",
+              "3   332.5  142.5  0.0  185.0           0.0      932.0    594.0  28.0   41,05 \n",
+              "4   198.6  132.4  0.0  192.0           0.0      978.4    825.5  28.0   44,30 "
             ]
           },
-          "execution_count": 5,
+          "execution_count": 8,
           "metadata": {},
           "output_type": "execute_result"
         }
@@ -262,7 +258,7 @@
           "data": {
             "text/plain": [
               "Index(['cement', 'slag', 'ash', 'water', 'superplastic', 'coarseagg',\n",
-              "       'fineagg', 'age', 'strength'],\n",
+              "       'fineagg', 'age', 'Concrete compressive strength(MPa, megapascals) '],\n",
               "      dtype='object')"
             ]
           },
@@ -277,7 +273,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 7,
+      "execution_count": null,
       "metadata": {
         "id": "7rkJekAZMqkv"
       },
@@ -292,7 +288,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 8,
+      "execution_count": null,
       "metadata": {},
       "outputs": [],
       "source": [
@@ -311,7 +307,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 9,
+      "execution_count": null,
       "metadata": {
         "id": "WFW8u_C8Mqkw"
       },
@@ -323,7 +319,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 10,
+      "execution_count": null,
       "metadata": {
         "id": "MmXTIBBdMqkw"
       },
@@ -334,7 +330,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 11,
+      "execution_count": null,
       "metadata": {
         "colab": {
           "base_uri": "https://localhost:8080/",
@@ -343,200 +339,7 @@
         "id": "Y0xZGBALMqkw",
         "outputId": "f6f38de1-59b9-439d-e499-dedcf46041ec"
       },
-      "outputs": [
-        {
-          "data": {
-            "text/html": [
-              "<div>\n",
-              "<style scoped>\n",
-              "    .dataframe tbody tr th:only-of-type {\n",
-              "        vertical-align: middle;\n",
-              "    }\n",
-              "\n",
-              "    .dataframe tbody tr th {\n",
-              "        vertical-align: top;\n",
-              "    }\n",
-              "\n",
-              "    .dataframe thead th {\n",
-              "        text-align: right;\n",
-              "    }\n",
-              "</style>\n",
-              "<table border=\"1\" class=\"dataframe\">\n",
-              "  <thead>\n",
-              "    <tr style=\"text-align: right;\">\n",
-              "      <th></th>\n",
-              "      <th>cement</th>\n",
-              "      <th>slag</th>\n",
-              "      <th>ash</th>\n",
-              "      <th>water</th>\n",
-              "      <th>superplastic</th>\n",
-              "      <th>coarseagg</th>\n",
-              "      <th>fineagg</th>\n",
-              "      <th>age</th>\n",
-              "    </tr>\n",
-              "  </thead>\n",
-              "  <tbody>\n",
-              "    <tr>\n",
-              "      <th>0</th>\n",
-              "      <td>0.147951</td>\n",
-              "      <td>-0.830600</td>\n",
-              "      <td>-0.822730</td>\n",
-              "      <td>-1.004275</td>\n",
-              "      <td>-0.618977</td>\n",
-              "      <td>1.262346</td>\n",
-              "      <td>-1.282281</td>\n",
-              "      <td>0.300203</td>\n",
-              "    </tr>\n",
-              "    <tr>\n",
-              "      <th>1</th>\n",
-              "      <td>0.147951</td>\n",
-              "      <td>-0.830600</td>\n",
-              "      <td>-0.822730</td>\n",
-              "      <td>-1.004275</td>\n",
-              "      <td>-0.618977</td>\n",
-              "      <td>1.496911</td>\n",
-              "      <td>-1.282281</td>\n",
-              "      <td>0.300203</td>\n",
-              "    </tr>\n",
-              "    <tr>\n",
-              "      <th>2</th>\n",
-              "      <td>0.892690</td>\n",
-              "      <td>1.130849</td>\n",
-              "      <td>-0.822730</td>\n",
-              "      <td>0.396167</td>\n",
-              "      <td>-1.156464</td>\n",
-              "      <td>-0.426523</td>\n",
-              "      <td>-2.543096</td>\n",
-              "      <td>0.300203</td>\n",
-              "    </tr>\n",
-              "    <tr>\n",
-              "      <th>3</th>\n",
-              "      <td>0.892690</td>\n",
-              "      <td>1.130849</td>\n",
-              "      <td>-0.822730</td>\n",
-              "      <td>0.396167</td>\n",
-              "      <td>-1.156464</td>\n",
-              "      <td>-0.426523</td>\n",
-              "      <td>-2.543096</td>\n",
-              "      <td>0.300203</td>\n",
-              "    </tr>\n",
-              "    <tr>\n",
-              "      <th>4</th>\n",
-              "      <td>-0.780475</td>\n",
-              "      <td>0.991827</td>\n",
-              "      <td>-0.822730</td>\n",
-              "      <td>0.822389</td>\n",
-              "      <td>-1.156464</td>\n",
-              "      <td>0.299065</td>\n",
-              "      <td>1.016402</td>\n",
-              "      <td>0.300203</td>\n",
-              "    </tr>\n",
-              "    <tr>\n",
-              "      <th>...</th>\n",
-              "      <td>...</td>\n",
-              "      <td>...</td>\n",
-              "      <td>...</td>\n",
-              "      <td>...</td>\n",
-              "      <td>...</td>\n",
-              "      <td>...</td>\n",
-              "      <td>...</td>\n",
-              "      <td>...</td>\n",
-              "    </tr>\n",
-              "    <tr>\n",
-              "      <th>1025</th>\n",
-              "      <td>0.191685</td>\n",
-              "      <td>0.766088</td>\n",
-              "      <td>0.642499</td>\n",
-              "      <td>0.067368</td>\n",
-              "      <td>0.756991</td>\n",
-              "      <td>-1.394495</td>\n",
-              "      <td>0.136906</td>\n",
-              "      <td>0.300203</td>\n",
-              "    </tr>\n",
-              "    <tr>\n",
-              "      <th>1026</th>\n",
-              "      <td>0.763985</td>\n",
-              "      <td>-0.830600</td>\n",
-              "      <td>1.053023</td>\n",
-              "      <td>1.065944</td>\n",
-              "      <td>1.079483</td>\n",
-              "      <td>-2.210781</td>\n",
-              "      <td>0.830354</td>\n",
-              "      <td>0.300203</td>\n",
-              "    </tr>\n",
-              "    <tr>\n",
-              "      <th>1027</th>\n",
-              "      <td>-1.406506</td>\n",
-              "      <td>1.088179</td>\n",
-              "      <td>0.939440</td>\n",
-              "      <td>0.865011</td>\n",
-              "      <td>0.155005</td>\n",
-              "      <td>-1.045775</td>\n",
-              "      <td>0.316803</td>\n",
-              "      <td>0.300203</td>\n",
-              "    </tr>\n",
-              "    <tr>\n",
-              "      <th>1028</th>\n",
-              "      <td>-1.274052</td>\n",
-              "      <td>1.739242</td>\n",
-              "      <td>-0.822730</td>\n",
-              "      <td>-0.176187</td>\n",
-              "      <td>1.272979</td>\n",
-              "      <td>0.474207</td>\n",
-              "      <td>0.453647</td>\n",
-              "      <td>0.300203</td>\n",
-              "    </tr>\n",
-              "    <tr>\n",
-              "      <th>1029</th>\n",
-              "      <td>-0.001997</td>\n",
-              "      <td>0.552738</td>\n",
-              "      <td>0.447784</td>\n",
-              "      <td>1.346033</td>\n",
-              "      <td>0.692492</td>\n",
-              "      <td>-1.482066</td>\n",
-              "      <td>0.032350</td>\n",
-              "      <td>0.300203</td>\n",
-              "    </tr>\n",
-              "  </tbody>\n",
-              "</table>\n",
-              "<p>1030 rows × 8 columns</p>\n",
-              "</div>"
-            ],
-            "text/plain": [
-              "        cement      slag       ash     water  superplastic  coarseagg  \\\n",
-              "0     0.147951 -0.830600 -0.822730 -1.004275     -0.618977   1.262346   \n",
-              "1     0.147951 -0.830600 -0.822730 -1.004275     -0.618977   1.496911   \n",
-              "2     0.892690  1.130849 -0.822730  0.396167     -1.156464  -0.426523   \n",
-              "3     0.892690  1.130849 -0.822730  0.396167     -1.156464  -0.426523   \n",
-              "4    -0.780475  0.991827 -0.822730  0.822389     -1.156464   0.299065   \n",
-              "...        ...       ...       ...       ...           ...        ...   \n",
-              "1025  0.191685  0.766088  0.642499  0.067368      0.756991  -1.394495   \n",
-              "1026  0.763985 -0.830600  1.053023  1.065944      1.079483  -2.210781   \n",
-              "1027 -1.406506  1.088179  0.939440  0.865011      0.155005  -1.045775   \n",
-              "1028 -1.274052  1.739242 -0.822730 -0.176187      1.272979   0.474207   \n",
-              "1029 -0.001997  0.552738  0.447784  1.346033      0.692492  -1.482066   \n",
-              "\n",
-              "       fineagg       age  \n",
-              "0    -1.282281  0.300203  \n",
-              "1    -1.282281  0.300203  \n",
-              "2    -2.543096  0.300203  \n",
-              "3    -2.543096  0.300203  \n",
-              "4     1.016402  0.300203  \n",
-              "...        ...       ...  \n",
-              "1025  0.136906  0.300203  \n",
-              "1026  0.830354  0.300203  \n",
-              "1027  0.316803  0.300203  \n",
-              "1028  0.453647  0.300203  \n",
-              "1029  0.032350  0.300203  \n",
-              "\n",
-              "[1030 rows x 8 columns]"
-            ]
-          },
-          "execution_count": 11,
-          "metadata": {},
-          "output_type": "execute_result"
-        }
-      ],
+      "outputs": [],
       "source": [
         "X_scaled_df"
       ]
@@ -552,7 +355,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 12,
+      "execution_count": null,
       "metadata": {
         "id": "gObLM3QlMqkw"
       },
@@ -586,7 +389,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 14,
+      "execution_count": null,
       "metadata": {
         "id": "XQ2br8k9NHfu"
       },
@@ -609,7 +412,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 15,
+      "execution_count": null,
       "metadata": {
         "id": "c2W5AhKUOCgy"
       },
@@ -649,7 +452,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 17,
+      "execution_count": null,
       "metadata": {
         "id": "CMAv3vTGOn6y"
       },
@@ -660,7 +463,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 18,
+      "execution_count": null,
       "metadata": {
         "colab": {
           "base_uri": "https://localhost:8080/"
@@ -668,29 +471,7 @@
         "id": "O4E4RHz_Oe2_",
         "outputId": "4c509277-cc89-4f86-93d9-fb902715f2eb"
       },
-      "outputs": [
-        {
-          "name": "stderr",
-          "output_type": "stream",
-          "text": [
-            "2023/07/16 18:02:12 INFO mlflow.tracking.fluent: Experiment with name 'Concrete-Strength-Experiments' does not exist. Creating a new experiment.\n"
-          ]
-        },
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "Train Accuracy:  96.509%\n",
-            "R2 Score: 0.847\n",
-            "------------------------------\n",
-            "MSE: 40.217\n",
-            "------------------------------\n",
-            "Metrics and artifacts logged!\n",
-            "cv accuracy:  0.865300222145633\n",
-            "Model run:  8977191a0af847ce892e666056fdfe66\n"
-          ]
-        }
-      ],
+      "outputs": [],
       "source": [
         "mlflow.set_experiment('Concrete-Strength-Experiments')\n",
         "\n",
@@ -750,7 +531,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 22,
+      "execution_count": null,
       "metadata": {
         "id": "-qM94fgVVAPg"
       },
@@ -762,7 +543,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 23,
+      "execution_count": null,
       "metadata": {
         "colab": {
           "base_uri": "https://localhost:8080/"
@@ -770,22 +551,7 @@
         "id": "S9TPTjfyU8Hu",
         "outputId": "af055a69-0df1-49a2-e8b4-600058e912ca"
       },
-      "outputs": [
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "Train Accuracy:  91.291%\n",
-            "R2 Score: 0.830\n",
-            "------------------------------\n",
-            "MSE: 44.584\n",
-            "------------------------------\n",
-            "Metrics and artifacts logged!\n",
-            "cv accuracy:  0.8554210267441394\n",
-            "Model run:  9b1561393cb74b33b5b8e7ba5194e815\n"
-          ]
-        }
-      ],
+      "outputs": [],
       "source": [
         "# Start a new MLflow run\n",
         "with mlflow.start_run():\n",
@@ -833,7 +599,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 24,
+      "execution_count": null,
       "metadata": {
         "id": "yHKzg4qWWb-m"
       },
@@ -845,7 +611,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 25,
+      "execution_count": null,
       "metadata": {
         "colab": {
           "base_uri": "https://localhost:8080/"
@@ -853,22 +619,7 @@
         "id": "kCmiu1XkWQav",
         "outputId": "0f721df4-1dfd-4b9e-8073-5dcaf365243a"
       },
-      "outputs": [
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "Train Accuracy:  76.634%\n",
-            "R2 Score: 0.711\n",
-            "------------------------------\n",
-            "MSE: 75.675\n",
-            "------------------------------\n",
-            "Metrics and artifacts logged!\n",
-            "cv accuracy:  0.7301976290471304\n",
-            "Model run:  5fcdcf5c1f2a4c5e9ba717b187a02734\n"
-          ]
-        }
-      ],
+      "outputs": [],
       "source": [
         "# Start a new MLflow run\n",
         "with mlflow.start_run():\n",
@@ -917,7 +668,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 26,
+      "execution_count": null,
       "metadata": {
         "id": "-QieEmgDMqlA"
       },
@@ -944,7 +695,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 27,
+      "execution_count": null,
       "metadata": {
         "colab": {
           "base_uri": "https://localhost:8080/",
@@ -953,18 +704,7 @@
         "id": "PHt_x_hDMqlA",
         "outputId": "8588acb4-48fe-4705-e1b8-255886f83416"
       },
-      "outputs": [
-        {
-          "data": {
-            "image/png": "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",
-            "text/plain": [
-              "<Figure size 1200x600 with 1 Axes>"
-            ]
-          },
-          "metadata": {},
-          "output_type": "display_data"
-        }
-      ],
+      "outputs": [],
       "source": [
         "plt.figure(figsize = (12, 6))\n",
         "plt.plot(range(1, 45), diff_k, color = 'blue', linestyle = 'dashed', marker = 'o', markerfacecolor = 'red', markersize = 10)\n",
@@ -975,7 +715,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 28,
+      "execution_count": null,
       "metadata": {
         "id": "7ZQrM1JrXwI0"
       },
@@ -987,7 +727,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 29,
+      "execution_count": null,
       "metadata": {
         "colab": {
           "base_uri": "https://localhost:8080/"
@@ -995,22 +735,7 @@
         "id": "KZiZDhvmXw7I",
         "outputId": "a1c484e9-7e73-40fb-b0c8-3482c8162584"
       },
-      "outputs": [
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "Train Accuracy:  89.268%\n",
-            "R2 Score: 0.733\n",
-            "------------------------------\n",
-            "MSE: 70.035\n",
-            "------------------------------\n",
-            "Metrics and artifacts logged!\n",
-            "cv accuracy:  0.5648537541937363\n",
-            "Model run:  355930aab0bb4150b78f6287ea78ab42\n"
-          ]
-        }
-      ],
+      "outputs": [],
       "source": [
         "# Start a new MLflow run\n",
         "with mlflow.start_run():\n",
@@ -1059,7 +784,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 30,
+      "execution_count": null,
       "metadata": {
         "id": "cHj1u0PaYsdU"
       },
@@ -1071,7 +796,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 31,
+      "execution_count": null,
       "metadata": {
         "colab": {
           "base_uri": "https://localhost:8080/"
@@ -1079,22 +804,7 @@
         "id": "-4Egu-dNY-s1",
         "outputId": "309d1f06-8e22-4bbb-bbae-5b998acad056"
       },
-      "outputs": [
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "Train Accuracy:  95.763%\n",
-            "R2 Score: 0.812\n",
-            "------------------------------\n",
-            "MSE: 49.370\n",
-            "------------------------------\n",
-            "Metrics and artifacts logged!\n",
-            "cv accuracy: 0.717\n",
-            "Model run:  9932d0ac56c242b58b2de46960bab005\n"
-          ]
-        }
-      ],
+      "outputs": [],
       "source": [
         "# Start a new MLflow run\n",
         "with mlflow.start_run():\n",
@@ -1142,7 +852,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 32,
+      "execution_count": null,
       "metadata": {
         "id": "xMj6UVCwZfU0"
       },
@@ -1154,7 +864,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 33,
+      "execution_count": null,
       "metadata": {
         "colab": {
           "base_uri": "https://localhost:8080/"
@@ -1162,22 +872,7 @@
         "id": "6FYMCyx1Zhwd",
         "outputId": "e8eb3752-6e35-4de4-ea95-dc1bdfed32f1"
       },
-      "outputs": [
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "Train Accuracy:  66.721%\n",
-            "R2 Score: 0.569\n",
-            "------------------------------\n",
-            "MSE: 112.921\n",
-            "------------------------------\n",
-            "Metrics and artifacts logged!\n",
-            "cv accuracy: 0.728\n",
-            "Model run:  663fc1927b364acda888e43c638153f1\n"
-          ]
-        }
-      ],
+      "outputs": [],
       "source": [
         "# Start a new MLflow run\n",
         "with mlflow.start_run():\n",
@@ -1229,7 +924,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 34,
+      "execution_count": null,
       "metadata": {
         "id": "LbUPeJwjajYO"
       },
@@ -1241,7 +936,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 35,
+      "execution_count": null,
       "metadata": {
         "colab": {
           "base_uri": "https://localhost:8080/"
@@ -1249,22 +944,7 @@
         "id": "nZTW4B5iauJz",
         "outputId": "a6215850-5994-49cf-c0cd-453244647495"
       },
-      "outputs": [
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "Train Accuracy:  97.753%\n",
-            "R2 Score: 0.832\n",
-            "------------------------------\n",
-            "MSE: 44.158\n",
-            "------------------------------\n",
-            "Metrics and artifacts logged!\n",
-            "cv accuracy: 0.869\n",
-            "Model run:  2f650498d25a482cb9f66c9f9bee6b96\n"
-          ]
-        }
-      ],
+      "outputs": [],
       "source": [
         "# Start a new MLflow run\n",
         "with mlflow.start_run():\n",
@@ -1310,7 +990,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 36,
+      "execution_count": null,
       "metadata": {
         "id": "OSrT6YBwbBi6"
       },
@@ -1322,7 +1002,7 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 37,
+      "execution_count": null,
       "metadata": {
         "colab": {
           "base_uri": "https://localhost:8080/"
@@ -1330,22 +1010,7 @@
         "id": "f8MwYZ3ubNt-",
         "outputId": "8a7b7201-f126-46bd-b80d-4041a69d5a33"
       },
-      "outputs": [
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "Train Accuracy:  97.812%\n",
-            "R2 Score: 0.765\n",
-            "------------------------------\n",
-            "MSE: 61.654\n",
-            "------------------------------\n",
-            "Metrics and artifacts logged!\n",
-            "cv accuracy:  0.7909050881453388\n",
-            "Model run:  17ab311e3f534c12a688242d96080e03\n"
-          ]
-        }
-      ],
+      "outputs": [],
       "source": [
         "# Start a new MLflow run\n",
         "with mlflow.start_run():\n",
@@ -1401,21 +1066,9 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 39,
+      "execution_count": null,
       "metadata": {},
-      "outputs": [
-        {
-          "data": {
-            "image/jpeg": "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",
-            "text/plain": [
-              "<IPython.core.display.Image object>"
-            ]
-          },
-          "execution_count": 39,
-          "metadata": {},
-          "output_type": "execute_result"
-        }
-      ],
+      "outputs": [],
       "source": [
         "Image(filename = './images/MLFlow-image-1.jpeg')"
       ]
@@ -1429,19 +1082,9 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 40,
+      "execution_count": null,
       "metadata": {},
-      "outputs": [
-        {
-          "name": "stderr",
-          "output_type": "stream",
-          "text": [
-            "Successfully registered model 'XGBoost Model'.\n",
-            "2023/07/16 18:22:52 INFO mlflow.tracking._model_registry.client: Waiting up to 300 seconds for model version to finish creation. Model name: XGBoost Model, version 1\n",
-            "Created version '1' of model 'XGBoost Model'.\n"
-          ]
-        }
-      ],
+      "outputs": [],
       "source": [
         "xgboost_run_id = '2f650498d25a482cb9f66c9f9bee6b96'\n",
         "\n",
@@ -1451,17 +1094,9 @@
     },
     {
       "cell_type": "code",
-      "execution_count": 45,
+      "execution_count": null,
       "metadata": {},
-      "outputs": [
-        {
-          "name": "stderr",
-          "output_type": "stream",
-          "text": [
-            "2023/07/16 18:35:44 WARNING mlflow.sklearn: Model was missing function: predict. Not logging python_function flavor!\n"
-          ]
-        }
-      ],
+      "outputs": [],
       "source": [
         "mlflow.sklearn.save_model(model_details, 'model')"
       ]
diff --git a/src/model_experiments/SVR.py b/src/model_experiments/SVR.py
new file mode 100644
index 0000000..cdd9335
--- /dev/null
+++ b/src/model_experiments/SVR.py
@@ -0,0 +1,63 @@
+import os
+import numpy as np
+import pandas as pd
+import argparse
+
+from modelevaluator import ModelEvaluator
+from logging import info
+from mlflow import log_metric, set_tag, log_param, start_run, active_run, end_run
+from mlflow.sklearn import log_model
+from sklearn.svm import SVR
+from sklearn.model_selection import KFold
+from sklearn.model_selection import cross_val_score
+
+# system
+os.chdir('../')
+
+# Get Data
+X = pd.read_csv('../data/2-silver/X.csv')
+X_train = pd.read_csv('../data/3-gold/X_train.csv')
+X_test = pd.read_csv('../data/3-gold/X_test.csv')
+
+y = pd.read_csv('../data/2-silver/y.csv')
+y_train = pd.read_csv('../data/3-gold/y_train.csv')
+y_test = pd.read_csv('../data/3-gold/y_test.csv')
+
+# Parse command-line arguments
+parser = argparse.ArgumentParser()
+parser.add_argument('--kernel', type = str, default = 'linear')
+args = parser.parse_args()
+
+# Instances
+SVR = SVR(kernel = args.kernel)
+evaluator = ModelEvaluator()
+
+# Experiment
+with start_run():
+    run_name = 'Random Forest'
+    set_tag('mlflow.runName', run_name)
+    
+    # Train the model
+    evaluator.train(X_train, y_train)
+    
+    # Lot hyperparameters
+    log_param('kernel', args.kernel)
+    
+    # Perform cross-validation
+    k = 20
+    kfold = KFold(n_splits = k, random_state = 70, shuffle = True)
+    K_results = cross_val_score(SVR, X, y, cv = kfold)
+    accuracy = np.mean(abs(K_results))
+    
+    # Log cross-validation-metrics
+    log_metric('cv_accuracy', accuracy)
+    info('cv accuracy loaded successfully.')
+    
+    # Log the model
+    log_model(SVR, 'SVR')
+    
+    # Print the run UUID
+    print('Model run: ', active_run().info.run_uuid)
+
+# End run
+end_run()
\ No newline at end of file
diff --git a/src/model_experiments/__init__.py b/src/model_experiments/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/src/model_experiments/adaboost.py b/src/model_experiments/adaboost.py
new file mode 100644
index 0000000..495ea93
--- /dev/null
+++ b/src/model_experiments/adaboost.py
@@ -0,0 +1,64 @@
+import os
+import numpy as np
+import pandas as pd
+import argparse
+
+from modelevaluator import ModelEvaluator
+from logging import info
+from mlflow import log_metric, set_tag, log_param, start_run, active_run, end_run
+from mlflow.sklearn import log_model
+from sklearn.ensemble import AdaBoostRegressor
+from sklearn.model_selection import KFold
+from sklearn.model_selection import cross_val_score
+
+# system
+os.chdir('../')
+
+# Get Data
+X = pd.read_csv('../data/2-silver/X.csv')
+X_train = pd.read_csv('../data/3-gold/X_train.csv')
+X_test = pd.read_csv('../data/3-gold/X_test.csv')
+
+y = pd.read_csv('../data/2-silver/y.csv')
+y_train = pd.read_csv('../data/3-gold/y_train.csv')
+y_test = pd.read_csv('../data/3-gold/y_test.csv')
+
+# Parse command-line arguments
+parser = argparse.ArgumentParser()
+parser.add_argument('--n_estimators', type = int, default = 50)
+args = parser.parse_args()
+
+# Instances
+ada_boost = AdaBoostRegressor(n_estimators = args.n_estimators)
+evaluator = ModelEvaluator()
+
+# Experiment
+with start_run():
+    # Set a custom run name
+    run_name = 'Ada Boost'
+    set_tag('mlflow.runName', run_name)
+    
+    # Train the model
+    evaluator.train(X_train, y_train)
+    
+    # Log hyperparameter
+    log_param('n_estimators', args.n_estimators)
+    
+    # Perform cross-validation
+    k = 20
+    kfold = KFold(n_splits = k, random_state = 70, shuffle = True)
+    K_results = cross_val_score(ada_boost(X, y, cv = kfold))
+    accuracy = np.mean(abs(K_results))
+    
+    # Log cross-validation-metrics
+    log_metric('cv_accuracy', accuracy)
+    info('cv_accuracy loaded successfully.')
+    
+    # Lod the model
+    log_model(ada_boost,  'random-forest')
+    
+    # Print the run UUID
+    print('Model run: ', active_run().info.run_uuid)
+
+# End run
+end_run()
\ No newline at end of file
diff --git a/src/model_experiments/bagging.py b/src/model_experiments/bagging.py
new file mode 100644
index 0000000..02727f8
--- /dev/null
+++ b/src/model_experiments/bagging.py
@@ -0,0 +1,63 @@
+import os
+import numpy as np
+import pandas as pd
+import argparse
+
+from modelevaluator import ModelEvaluator
+from logging import info
+from mlflow import log_metric, set_tag, log_param, start_run, active_run, end_run
+from mlflow.sklearn import log_model
+from sklearn.ensemble import BaggingRegressor
+from sklearn.model_selection import KFold
+from sklearn.model_selection import cross_val_score
+
+# system
+os.chdir('../')
+
+# Get Data
+X = pd.read_csv('../data/2-silver/X.csv')
+X_train = pd.read_csv('../data/3-gold/X_train.csv')
+X_test = pd.read_csv('../data/3-gold/X_test.csv')
+
+y = pd.read_csv('../data/2-silver/y.csv')
+y_train = pd.read_csv('../data/3-gold/y_train.csv')
+y_test = pd.read_csv('../data/3-gold/y_test.csv')
+
+# Parse command-line arguments
+parser = argparse.ArgumentParser()
+parser.add_argument('--n_estimators', type = int, default = 10)
+args = parser.parse_args()
+
+# Instances
+bagging = BaggingRegressor(n_estimators = args.n_estimators)
+evaluator = ModelEvaluator()
+
+# Experiment
+with start_run():
+    run_name = 'Bagging'
+    set_tag('mlflow.runName', run_name)
+    
+    # Train the model
+    evaluator.train(X_train, y_train)
+    
+    # Lot hyperparameters
+    log_param('n_estimators', args.n_estimators)
+    
+    # Perform cross-validation
+    k = 20
+    kfold = KFold(n_splits = k, random_state = 70, shuffle = True)
+    K_results = cross_val_score(bagging, X, y, cv = kfold)
+    accuracy = np.mean(abs(K_results))
+    
+    # Log cross-validation-metrics
+    log_metric('cv_accuracy', accuracy)
+    info('cv accuracy loaded successfully.')
+    
+    # Log the model
+    log_model(bagging, 'bagging')
+    
+    # Print the run UUID
+    print('Model run: ', active_run().info.run_uuid)
+
+# End run
+end_run()
\ No newline at end of file
diff --git a/src/model_experiments/decisiontree.py b/src/model_experiments/decisiontree.py
new file mode 100644
index 0000000..c8c9c67
--- /dev/null
+++ b/src/model_experiments/decisiontree.py
@@ -0,0 +1,72 @@
+import os
+import numpy as np
+import pandas as pd
+import argparse
+
+from modelevaluator import ModelEvaluator
+from logging import info
+from mlflow import log_metric, set_tag, log_param, start_run, active_run, end_run
+from mlflow.sklearn import log_model
+from sklearn.tree import DecisionTreeRegressor
+from sklearn.model_selection import KFold
+from sklearn.model_selection import cross_val_score
+
+# system
+os.chdir('../')
+
+# Get Data
+X = pd.read_csv('../data/2-silver/X.csv')
+X_train = pd.read_csv('../data/3-gold/X_train.csv')
+X_test = pd.read_csv('../data/3-gold/X_test.csv')
+
+y = pd.read_csv('../data/2-silver/y.csv')
+y_train = pd.read_csv('../data/3-gold/y_train.csv')
+y_test = pd.read_csv('../data/3-gold/y_test.csv')
+
+# Parse command-line arguments
+parser = argparse.ArgumentParser()
+parser.add_argument('--min_samples_leaf', type = int, default = 1)
+parser.add_argument('--min_samples_split', type = int, default = 2)
+parser.add_argument('--max_features', type = int, default = None)
+parser.add_argument('--max_depth', type = int, default = None)
+args = parser.parse_args()
+
+# Instances
+dt_model = DecisionTreeRegressor(min_samples_leaf = args.min_samples_leaf,
+                                 min_samples_split = args.min_samples_split,
+                                 max_depth = args.max_depth,
+                                 max_features = args.max_features)
+evaluator = ModelEvaluator()
+
+# Experiment
+with start_run():
+    run_name = 'Random Forest'
+    set_tag('mlflow.runName', run_name)
+    
+    # Train the model
+    evaluator.train(X_train, y_train)
+    
+    # Log hyperparameters
+    log_param("max_depth", args.max_depth)
+    log_param("min_samples_split", args.min_samples_split)
+    log_param("min_samples_leaf", args.min_samples_leaf)
+    log_param("max_features", args.max_features)
+    
+    # Perform cross-validation
+    k = 20
+    kfold = KFold(n_splits = k, random_state = 70, shuffle = True)
+    K_results = cross_val_score(dt_model, X, y, cv = kfold)
+    accuracy = np.mean(abs(K_results))
+    
+    # Log cross-validation-metrics
+    log_metric('cv_accuracy', accuracy)
+    info('cv accuracy loaded successfully.')
+    
+    # Log the model
+    log_model(dt_model, 'random-forest')
+    
+    # Print the run UUID
+    print('Model run: ', active_run().info.run_uuid)
+
+# End run
+end_run()
\ No newline at end of file
diff --git a/src/model_experiments/gradientboost.py b/src/model_experiments/gradientboost.py
new file mode 100644
index 0000000..36c7886
--- /dev/null
+++ b/src/model_experiments/gradientboost.py
@@ -0,0 +1,64 @@
+import os
+import numpy as np
+import pandas as pd
+import argparse
+
+from modelevaluator import ModelEvaluator
+from logging import info
+from mlflow import log_metric, set_tag, log_param, start_run, active_run, end_run
+from mlflow.sklearn import log_model
+from sklearn.ensemble import GradientBoostRegressor
+from sklearn.model_selection import KFold
+from sklearn.model_selection import cross_val_score
+
+# system
+os.chdir('../')
+
+# Get Data
+X = pd.read_csv('../data/2-silver/X.csv')
+X_train = pd.read_csv('../data/3-gold/X_train.csv')
+X_test = pd.read_csv('../data/3-gold/X_test.csv')
+
+y = pd.read_csv('../data/2-silver/y.csv')
+y_train = pd.read_csv('../data/3-gold/y_train.csv')
+y_test = pd.read_csv('../data/3-gold/y_test.csv')
+
+# Parse command-line arguments
+parser = argparse.ArgumentParser()
+parser.add_argument('--n_estimators', type = int, default = 10)
+args = parser.parse_args()
+
+# Instances
+gradient_boost = GradientBoostRegressor(n_estimators = args.n_estimators)
+evaluator = ModelEvaluator()
+
+# Experiment
+with start_run():
+    # Set a custom run name
+    run_name = 'Gradient Boost'
+    set_tag('mlflow.runName', run_name)
+    
+    # Train the model
+    evaluator.train(X_train, y_train)
+    
+    # Log hyperparameter
+    log_param('n_estimators', args.n_estimators)
+    
+    # Perform cross-validation
+    k = 20
+    kfold = KFold(n_splits = k, random_state = 70, shuffle = True)
+    K_results = cross_val_score(gradient_boost(X, y, cv = kfold))
+    accuracy = np.mean(abs(K_results))
+    
+    # Log cross-validation-metrics
+    log_metric('cv_accuracy', accuracy)
+    info('cv_accuracy loaded successfully.')
+    
+    # Lod the model
+    log_model(gradient_boost,  'gradient-boost')
+    
+    # Print the run UUID
+    print('Model run: ', active_run().info.run_uuid)
+
+# End run
+end_run()
\ No newline at end of file
diff --git a/src/model_experiments/knn.py b/src/model_experiments/knn.py
new file mode 100644
index 0000000..536a6c0
--- /dev/null
+++ b/src/model_experiments/knn.py
@@ -0,0 +1,64 @@
+import os
+import numpy as np
+import pandas as pd
+import argparse
+
+from modelevaluator import ModelEvaluator
+from logging import info
+from mlflow import log_metric, set_tag, log_param, start_run, active_run, end_run
+from mlflow.sklearn import log_model
+from sklearn.neighbors import KNeighborsRegressor
+from sklearn.model_selection import KFold
+from sklearn.model_selection import cross_val_score
+
+# system
+os.chdir('../')
+
+# Get Data
+X = pd.read_csv('../data/2-silver/X.csv')
+X_train = pd.read_csv('../data/3-gold/X_train.csv')
+X_test = pd.read_csv('../data/3-gold/X_test.csv')
+
+y = pd.read_csv('../data/2-silver/y.csv')
+y_train = pd.read_csv('../data/3-gold/y_train.csv')
+y_test = pd.read_csv('../data/3-gold/y_test.csv')
+
+# Parse command-line arguments
+parser = argparse.ArgumentParser()
+parser.add_argument('--n_neighbors', type = int, default = 3)
+args = parser.parse_args()
+
+# Instances
+KNN = KNeighborsRegressor(n_neighbors = args.n_neighbors)
+evaluator = ModelEvaluator()
+
+# Experiment
+with start_run():
+    # Set a custom run name
+    run_name = 'Gradient Boost'
+    set_tag('mlflow.runName', run_name)
+    
+    # Train the model
+    evaluator.train(X_train, y_train)
+    
+    # Log hyperparameter
+    log_param('n_estimators', args.n_neighbors)
+    
+    # Perform cross-validation
+    k = 20
+    kfold = KFold(n_splits = k, random_state = 70, shuffle = True)
+    K_results = cross_val_score(KNN(X, y, cv = kfold))
+    accuracy = np.mean(abs(K_results))
+    
+    # Log cross-validation-metrics
+    log_metric('cv_accuracy', accuracy)
+    info('cv_accuracy loaded successfully.')
+    
+    # Lod the model
+    log_model(KNN,  'KNN')
+    
+    # Print the run UUID
+    print('Model run: ', active_run().info.run_uuid)
+
+# End run
+end_run()
\ No newline at end of file
diff --git a/src/MlfExpetiments.py b/src/model_experiments/modelevaluator.py
similarity index 59%
rename from src/MlfExpetiments.py
rename to src/model_experiments/modelevaluator.py
index b32f0c1..6524b90 100644
--- a/src/MlfExpetiments.py
+++ b/src/model_experiments/modelevaluator.py
@@ -1,18 +1,24 @@
-import logging
-from dataclasses import dataclass
-import mlflow
+from logging import info
+from mlflow import log_metric
+import numpy as np
 import pandas as pd
-from sklearn import metrics
+from sklearn.metrics import mean_squared_error
+from mlflow import log_metric, set_tag, log_param, start_run, active_run, end_run
+from mlflow.sklearn import log_model
+from sklearn.metrics import r2_score
 from sklearn.base import BaseEstimator
+from sklearn.model_selection import KFold, cross_val_score
 
 
-@dataclass
 class ModelEvaluator:
     '''
     Utility class for training and evaluating scikit-learn models.
     '''
+    def __init__(self):
+        pass
 
-    def train(self, model: BaseEstimator, X_train: pd.DataFrame, y_train: pd.DataFrame) -> None:
+    def train(self, model: BaseEstimator, X_train: pd.DataFrame,
+              y_train: pd.DataFrame) -> None:
         '''
         Fits a scikit-learn model.
 
@@ -27,14 +33,15 @@ def train(self, model: BaseEstimator, X_train: pd.DataFrame, y_train: pd.DataFra
         try:
             model = model.fit(X_train, y_train)
             train_accuracy = model.score(X_train, y_train)
-            mlflow.log_metric('train-accuracy', train_accuracy)
-            logging.info(f'Train Accuracy: {train_accuracy:.3%}')
+            log_metric('train-accuracy', train_accuracy)
+            info(f'Train Accuracy: {train_accuracy:.2%}')
         except Exception as e:
             raise e
 
         return None
 
-    def evaluate(self, model: BaseEstimator, X_test: pd.DataFrame, y_test: pd.DataFrame) -> None:
+    def evaluate(self, model: BaseEstimator, X_test: pd.DataFrame,
+                 y_test: pd.DataFrame) -> None:
         '''
         Evaluates a scikit-learn model.
 
@@ -51,21 +58,21 @@ def evaluate(self, model: BaseEstimator, X_test: pd.DataFrame, y_test: pd.DataFr
             y_pred = model.predict(X_test)
 
             # Model performance metrics
-            r2_score = metrics.r2_score(y_test, y_pred)
-            mse_score = metrics.mean_squared_error(y_test, y_pred)
+            r2_score = r2_score(y_test, y_pred)
+            mse_score = mean_squared_error(y_test, y_pred)
 
             # Log metrics
-            mlflow.log_metric('r2-score', r2_score)
-            mlflow.log_metric('mse', mse_score)
+            log_metric('r2-score', r2_score)
+            log_metric('mse', mse_score)
 
             # Print and log metrics
-            logging.info('R2 Score: {:.3f}'.format(r2_score))
-            logging.info('-' * 30)
-            logging.info('MSE: {:.3f}'.format(mse_score))
+            info('R2 Score: {:.2f}'.format(r2_score))
+            info('MSE: {:.2f}'.format(mse_score))
 
-            logging.info('-' * 30)
-            logging.info('Metrics and artifacts logged!')
+            info('Metrics and artifacts logged!')
         except Exception as e:
             raise e
 
         return None
+            
+            
diff --git a/src/model_experiments/randomforest.py b/src/model_experiments/randomforest.py
new file mode 100644
index 0000000..efaecfa
--- /dev/null
+++ b/src/model_experiments/randomforest.py
@@ -0,0 +1,66 @@
+import os
+import numpy as np
+import pandas as pd
+import argparse
+
+from modelevaluator import ModelEvaluator
+from logging import info
+from mlflow import log_metric, set_tag, log_param, start_run, active_run, end_run
+from mlflow.sklearn import log_model
+from sklearn.ensemble import RandomForestRegressor
+from sklearn.model_selection import KFold
+from sklearn.model_selection import cross_val_score
+
+# system
+os.chdir('../')
+
+# Get Data
+X = pd.read_csv('../data/2-silver/X.csv')
+X_train = pd.read_csv('../data/3-gold/X_train.csv')
+X_test = pd.read_csv('../data/3-gold/X_test.csv')
+
+y = pd.read_csv('../data/2-silver/y.csv')
+y_train = pd.read_csv('../data/3-gold/y_train.csv')
+y_test = pd.read_csv('../data/3-gold/y_test.csv')
+
+# Parse command-line arguments
+parser = argparse.ArgumentParser()
+parser.add_argument('--n_estimators', type = int, default = 100)
+parser.add_argument('--max_depth', type = int, default = None)
+args = parser.parse_args()
+
+# Instances
+random_forest = RandomForestRegressor(n_estimators = args.n_estimators,
+                                      max_depth = args.max_depth)
+evaluator = ModelEvaluator()
+
+# Experiment
+with start_run():
+    run_name = 'Random Forest'
+    set_tag('mlflow.runName', run_name)
+    
+    # Train the model
+    evaluator.train(X_train, y_train)
+    
+    # Lot hyperparameters
+    log_param('n_estimators', args.n_estimators)
+    log_param('max_depth', args.max_depth)
+    
+    # Perform cross-validation
+    k = 20
+    kfold = KFold(n_splits = k, random_state = 70, shuffle = True)
+    K_results = cross_val_score(random_forest, X, y, cv = kfold)
+    accuracy = np.mean(abs(K_results))
+    
+    # Log cross-validation-metrics
+    log_metric('cv_accuracy', accuracy)
+    info('cv accuracy loaded successfully.')
+    
+    # Log the model
+    log_model(random_forest, 'random-forest')
+    
+    # Print the run UUID
+    print('Model run: ', active_run().info.run_uuid)
+
+# End run
+end_run()
\ No newline at end of file
diff --git a/src/model_experiments/xgr.py b/src/model_experiments/xgr.py
new file mode 100644
index 0000000..cd465f3
--- /dev/null
+++ b/src/model_experiments/xgr.py
@@ -0,0 +1,55 @@
+import os
+import numpy as np
+import pandas as pd
+
+from modelevaluator import ModelEvaluator
+from logging import info
+from mlflow import log_metric, set_tag, start_run, active_run, end_run
+from mlflow.sklearn import log_model
+from xgboost.sklearn import XGBRegressor
+from sklearn.model_selection import KFold
+from sklearn.model_selection import cross_val_score
+
+# system
+os.chdir('../')
+
+# Get Data
+X = pd.read_csv('../data/2-silver/X.csv')
+X_train = pd.read_csv('../data/3-gold/X_train.csv')
+X_test = pd.read_csv('../data/3-gold/X_test.csv')
+
+y = pd.read_csv('../data/2-silver/y.csv')
+y_train = pd.read_csv('../data/3-gold/y_train.csv')
+y_test = pd.read_csv('../data/3-gold/y_test.csv')
+
+
+# Instances
+xgr = XGBRegressor()
+evaluator = ModelEvaluator()
+
+# Experiment
+with start_run():
+    run_name = 'XGBoost'
+    set_tag('mlflow.runName', run_name)
+    
+    # Train the model
+    evaluator.train(X_train, y_train)
+    
+    # Perform cross-validation
+    k = 20
+    kfold = KFold(n_splits = k, random_state = 70, shuffle = True)
+    K_results = cross_val_score(xgr, X, y, cv = kfold)
+    accuracy = np.mean(abs(K_results))
+    
+    # Log cross-validation-metrics
+    log_metric('cv_accuracy', accuracy)
+    info('cv accuracy loaded successfully.')
+    
+    # Log the model
+    log_model(xgr, 'xgboost')
+    
+    # Print the run UUID
+    print('Model run: ', active_run().info.run_uuid)
+
+# End run
+end_run()
\ No newline at end of file
diff --git a/src/preprocessing/bronze_to_silver.py b/src/preprocessing/bronze_to_silver.py
new file mode 100644
index 0000000..e4764e4
--- /dev/null
+++ b/src/preprocessing/bronze_to_silver.py
@@ -0,0 +1,72 @@
+import dask.dataframe as dd
+import logging
+import os
+from dask.distributed import Client
+from typing import Tuple
+
+# Set up logging
+logs_dir = os.path.abspath('../../logs/')
+os.makedirs(logs_dir, exist_ok=True)
+logging.basicConfig(filename=os.path.join(logs_dir, 'dask_data_processing.log'),
+                    level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+# Set up logging to display logs in the CLI
+console = logging.StreamHandler()
+console.setLevel(logging.INFO)
+formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
+console.setFormatter(formatter)
+logging.getLogger('').addHandler(console)
+
+def process_data(file_path: str) -> Tuple[dd.DataFrame, dd.DataFrame]:
+    '''
+    Process data from a Dask DataFrame stored in a Parquet file.
+
+    Parameters:
+        file_path (str): Path to the Parquet file containing the data.
+
+    Returns:
+        tuple: A tuple containing the Dask DataFrame for independent variables (X) and 
+               the Dask DataFrame for the dependent variable (y).
+    '''
+    # Log the start of data processing
+    logging.info(f'Processing data from file: {file_path}')
+    
+    try: 
+        # Read the Parquet file into a Dask DataFrame
+        df = dd.read_parquet(file_path)
+        
+        # Split data into dependent (y) and independent (X) variables
+        X = df[['cement', 'slag', 'ash', 'water', 'superplastic', 'coarseagg', 'fineagg', 'age']]
+        y = df[['strength']] 
+        
+        return X, y
+    except Exception as e:
+        logging.error(f'It was not possible to process data: {file_path}. Error: {e}')
+
+if __name__ == '__main__':
+    # Provide the path to the Parquet file containing the data
+    data_file_path = os.path.abspath('data/1-bronze/Concrete_Data_Cleaned.parquet')
+    
+    # Connect to the Dask cluster
+    client = Client(n_workers = 4)
+    
+    # Process data using the function
+    X, y = process_data(data_file_path)
+    
+    # File paths to be saved
+    x_file_path = os.path.abspath('data/2-silver/X.parquet')
+    y_file_path = os.path.abspath('data/2-silver/Y.parquet')
+    
+    # Convert Dask DataFrames to Pandas DataFrames
+    X_pandas = X.compute()
+    y_pandas = y.compute()
+    
+    # Save the Pandas DataFrames X and y to Parquet files
+    X_pandas.to_parquet(x_file_path, index = False)
+    y_pandas.to_parquet(y_file_path, index = False)
+    
+    # Log the completion of data processing
+    logging.info('Data split completed.')
+
+    # Shutdown the Dask client
+    client.shutdown()
diff --git a/src/preprocessing/raw_to_bronze.py b/src/preprocessing/raw_to_bronze.py
new file mode 100644
index 0000000..4fa555d
--- /dev/null
+++ b/src/preprocessing/raw_to_bronze.py
@@ -0,0 +1,79 @@
+import dask.dataframe as dd
+import pandas as pd
+import logging
+import os
+
+from dask.distributed import Client
+
+# Set up logging
+logs_dir = os.path.abspath('../../logs/')
+os.makedirs(logs_dir, exist_ok=True)
+logging.basicConfig(filename=os.path.join(logs_dir, 'dask_data_processing.log'),
+                    level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+# Set up logging to display logs in the CLI
+console = logging.StreamHandler()
+console.setLevel(logging.INFO)
+formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
+console.setFormatter(formatter)
+logging.getLogger('').addHandler(console)
+
+
+def process_data(file_path: str) -> dd.DataFrame:
+    '''
+    Process raw data from a CSV file.
+
+    Parameters:
+        file_path (str): Path to the CSV file.
+
+    Returns:
+        dd.DataFrame: Processed DataFrame.
+    '''
+    logging.info(f"Processing data from file: {file_path}")
+    df = dd.read_csv(file_path)
+
+    df = df.rename(columns={'Cement (component 1)(kg in a m^3 mixture)': 'cement',
+                            'Blast Furnace Slag (component 2)(kg in a m^3 mixture)': 'slag',
+                            'Fly Ash (component 3)(kg in a m^3 mixture)': 'ash',
+                            'Water  (component 4)(kg in a m^3 mixture)': 'water',
+                            'Superplasticizer (component 5)(kg in a m^3 mixture)': 'superplastic',
+                            'Coarse Aggregate  (component 6)(kg in a m^3 mixture)': 'coarseagg',
+                            'Fine Aggregate (component 7)(kg in a m^3 mixture)': 'fineagg',
+                            'Age (day)': 'age',
+                            'Concrete compressive strength(MPa, megapascals) ': 'strength'})
+
+    # Perform replacement of ',' with '.' and convert numeric columns to float64
+    for column in df.columns:
+        if column != 'strength':  # We skip the 'strength' column in this conversion
+            df[column] = df[column].replace({',': '.'}, regex = True).astype('float64')
+    
+    for cols in df.columns[:-1]:
+        # calculating quartiles
+        Q1 = df[cols].quantile(0.25)
+        Q3 = df[cols].quantile(0.75)
+        # iqr range
+        iqr = Q3 - Q1
+
+        # calculating the low and high limits
+        low = Q1 - 1.5 * iqr
+        high = Q1 + 1.5 * iqr
+
+        # replacing outliers with the median value
+        df[cols] = df[cols].where((df[cols] >= low) & (df[cols] <= high), df[cols].median())
+
+    return df
+
+if __name__ == '__main__':
+    data_file_path = os.path.abspath('data/0-raw-data/Concrete_Data.csv')
+    client = Client(n_workers=4)
+
+    processed_data = process_data(data_file_path)
+    data_processed = processed_data.compute()
+
+    # Create an absolute path for the Parquet file
+    parquet_file_path = os.path.abspath('data/1-bronze/Concrete_Data_Cleaned.parquet')
+
+    # Save the processed data as Parquet
+    data_processed.to_parquet(parquet_file_path, index=False)
+
+    logging.info("Data processing completed and saved to Parquet.")
diff --git a/src/preprocessing/silver_to_gold.py b/src/preprocessing/silver_to_gold.py
new file mode 100644
index 0000000..13ea092
--- /dev/null
+++ b/src/preprocessing/silver_to_gold.py
@@ -0,0 +1,86 @@
+import dask.dataframe as dd
+import logging
+import os
+from dask.distributed import Client
+from typing import Tuple
+from sklearn.model_selection import train_test_split as sk_train_test_split
+
+# Set up logging
+logs_dir = os.path.abspath('../../logs/')
+os.makedirs(logs_dir, exist_ok=True)
+logging.basicConfig(filename=os.path.join(logs_dir, 'dask_data_processing.log'),
+                    level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+# Set up logging to display logs in the CLI
+console = logging.StreamHandler()
+console.setLevel(logging.INFO)
+formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
+console.setFormatter(formatter)
+logging.getLogger('').addHandler(console)
+
+def process_data(file_path_x: str,
+                 file_path_y: str) -> Tuple[dd.DataFrame, dd.DataFrame,
+                                          dd.DataFrame, dd.DataFrame]:
+    '''
+    Process data
+
+    Parameters:
+        file_path_x (str): Path to the Parquet file containing the independent variables (X).
+        file_path_y (str): Path to the Parquet file containing the dependent variable (y).
+
+    Returns:
+        Tuple[dd.DataFrame, dd.DataFrame, dd.DataFrame, dd.DataFrame]: A tuple containing the Dask DataFrame
+        for X_train, X_test, y_train, and y_test.
+    '''
+    # Log the start of data processing
+    logging.info(f'Processing data from files: {file_path_x}, {file_path_y}')
+    
+    X = dd.read_parquet(file_path_x)
+    y = dd.read_parquet(file_path_y)
+    
+    # Apply the z-score to X
+    X_scaled = (X - X.mean()) / X.std()
+    
+    # Convert Dask DataFrames to Pandas DataFrames
+    logging.info('Converting Dask DataFrames to Pandas DataFrames...')
+    X_scaled = X_scaled.compute()
+    y = y.compute()
+
+    # Train and test split
+    logging.info("Splitting data into train and test sets...")
+    X_train, X_test, y_train, y_test = sk_train_test_split(X_scaled, y, random_state=1, test_size=0.3)
+    
+    # Log the completion of data processing
+    logging.info('Data processing completed.')
+    
+    return X_train, X_test, y_train, y_test
+
+if __name__ == '__main__':
+    # Provide the paths to the Parquet files containing the data
+    file_path_x = os.path.abspath('data/2-silver/X.parquet')
+    file_path_y = os.path.abspath('data/2-silver/Y.parquet')
+    
+    # File paths to be saved
+    file_path_X_train = os.path.abspath('data/3-gold/X_train.parquet')
+    file_path_X_test = os.path.abspath('data/3-gold/X_test.parquet')
+    file_path_y_train = os.path.abspath('data/3-gold/y_train.parquet')
+    file_path_y_test = os.path.abspath('data/3-gold/y_test.parquet')
+    
+    # Connect to Dask Cluster
+    logging.info('Connecting to the Dask cluster...')
+    client = Client(n_workers=4)
+    
+    X_train, X_test, y_train, y_test = process_data(file_path_x, file_path_y)
+    
+    # Save the Pandas DataFrames to Parquet files
+    logging.info('Saving DataFrames to Parquet files...')
+    X_train.to_parquet(file_path_X_train, index=False)
+    X_test.to_parquet(file_path_X_test, index=False)
+    y_train.to_parquet(file_path_y_train, index=False)
+    y_test.to_parquet(file_path_y_test, index=False)
+    
+    # Log the completion of data processing
+    logging.info('Data split completed.')
+
+    # Shut down the Dask Client
+    client.shutdown()
diff --git a/src/requirements.txt b/src/requirements.txt
index f35e505..fc14e56 100644
--- a/src/requirements.txt
+++ b/src/requirements.txt
@@ -2,6 +2,7 @@ alembic==1.11.1
 asttokens==2.2.1
 backcall==0.2.0
 blinker==1.6.2
+bokeh==3.2.1
 certifi==2023.5.7
 charset-normalizer==3.2.0
 click==8.1.5
@@ -10,14 +11,19 @@ colorama==0.4.6
 comm==0.1.3
 contourpy==1.1.0
 cycler==0.11.0
+dask==2023.7.1
+dask-glm==0.2.0
+dask-ml==2023.3.24
 databricks-cli==0.17.7
 debugpy==1.6.7
 decorator==5.1.1
+distributed==2023.7.1
 docker==6.1.3
 entrypoints==0.4
 executing==1.2.0
 Flask==2.3.2
 fonttools==4.40.0
+fsspec==2023.6.0
 gitdb==4.0.10
 GitPython==3.1.32
 greenlet==2.0.2
@@ -32,18 +38,25 @@ joblib==1.2.0
 jupyter_client==8.2.0
 jupyter_core==5.3.1
 kiwisolver==1.4.4
+llvmlite==0.40.1
+locket==1.0.0
+lz4==4.3.2
 Mako==1.2.4
 Markdown==3.4.3
 MarkupSafe==2.1.3
 matplotlib==3.7.1
 matplotlib-inline==0.1.6
 mlflow==2.4.2
+msgpack==1.0.5
+multipledispatch==1.0.0
 nest-asyncio==1.5.6
-numpy==1.25.0
+numba==0.57.1
+numpy==1.24.4
 oauthlib==3.2.2
 packaging==23.1
-pandas==2.0.2
+pandas==2.0.3
 parso==0.8.3
+partd==1.4.0
 pickleshare==0.7.5
 Pillow==9.5.0
 platformdirs==3.6.0
@@ -67,11 +80,14 @@ scipy==1.10.1
 seaborn==0.12.2
 six==1.16.0
 smmap==5.0.0
+sortedcontainers==2.4.0
 SQLAlchemy==2.0.19
 sqlparse==0.4.4
 stack-data==0.6.2
 tabulate==0.9.0
+tblib==2.0.0
 threadpoolctl==3.1.0
+toolz==0.12.0
 tornado==6.3.2
 traitlets==5.9.0
 typing_extensions==4.7.1
@@ -82,4 +98,6 @@ wcwidth==0.2.6
 websocket-client==1.6.1
 Werkzeug==2.3.6
 xgboost==1.7.6
+xyzservices==2023.7.0
+zict==3.0.0
 zipp==3.16.2