Created
May 28, 2025 17:21
-
-
Save ardzz/cf6ba7a15be935001e3d02b25a044db4 to your computer and use it in GitHub Desktop.
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
{ | |
"cells" : [ { | |
"cell_type" : "code", | |
"id" : "initial_id", | |
"metadata" : { | |
"collapsed" : true, | |
"ExecuteTime" : { | |
"end_time" : "2025-05-28T17:20:16.693555Z", | |
"start_time" : "2025-05-28T17:20:16.650955Z" | |
} | |
}, | |
"source" : [ "\"\"\"\n", "Sensor Calibration Model Comparison Tool\n", "Author: reky\n", "Date: 2025-05-29\n", "Description: Compare Linear Regression vs Interpolation methods for sensor calibration\n", "\"\"\"\n", "\n", "import pandas as pd\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "from sklearn.linear_model import LinearRegression\n", "from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score\n", "from scipy.interpolate import interp1d\n", "from scipy import stats\n", "from typing import Dict, Tuple, List, Any\n", "import warnings\n", "warnings.filterwarnings('ignore')\n", "\n", "class SensorCalibrationComparator:\n", " \"\"\"\n", " A class to compare different calibration methods for sensor data\n", " \"\"\"\n", "\n", " def __init__(self, instrument_readings: np.ndarray, actual_values: np.ndarray,\n", " sensor_name: str, unit: str):\n", " \"\"\"\n", " Initialize the comparator with sensor data\n", "\n", " Args:\n", " instrument_readings: Array of instrument readings\n", " actual_values: Array of actual/reference values\n", " sensor_name: Name of the sensor (e.g., 'Temperature', 'Humidity')\n", " unit: Unit of measurement (e.g., '°C', '%RH')\n", " \"\"\"\n", " self.X = instrument_readings\n", " self.Y = actual_values\n", " self.sensor_name = sensor_name\n", " self.unit = unit\n", " self.n_points = len(instrument_readings)\n", " self.results = {}\n", "\n", " def _linear_regression_loo(self) -> List[float]:\n", " \"\"\"Perform Leave-One-Out cross-validation for Linear Regression\"\"\"\n", " predictions = []\n", "\n", " for i in range(self.n_points):\n", " X_train = np.delete(self.X, i)\n", " Y_train = np.delete(self.Y, i)\n", " X_test = self.X[i]\n", "\n", " if len(X_train) > 1:\n", " model = LinearRegression()\n", " model.fit(X_train.reshape(-1, 1), Y_train)\n", " pred = model.predict([[X_test]])[0]\n", " else:\n", " pred = Y_train[0]\n", "\n", " predictions.append(pred)\n", "\n", " return predictions\n", "\n", " def _numpy_interpolation_loo(self) -> List[float]:\n", " \"\"\"Perform Leave-One-Out cross-validation for NumPy interpolation\"\"\"\n", " predictions = []\n", "\n", " for i in range(self.n_points):\n", " X_train = np.delete(self.X, i)\n", " Y_train = np.delete(self.Y, i)\n", " X_test = self.X[i]\n", "\n", " if len(X_train) > 1:\n", " pred = np.interp(X_test, X_train, Y_train)\n", " else:\n", " pred = Y_train[0]\n", "\n", " predictions.append(pred)\n", "\n", " return predictions\n", "\n", " def _scipy_interpolation_loo(self) -> List[float]:\n", " \"\"\"Perform Leave-One-Out cross-validation for SciPy interpolation\"\"\"\n", " predictions = []\n", "\n", " for i in range(self.n_points):\n", " X_train = np.delete(self.X, i)\n", " Y_train = np.delete(self.Y, i)\n", " X_test = self.X[i]\n", "\n", " if len(X_train) > 1:\n", " interp_func = interp1d(X_train, Y_train, kind='linear',\n", " bounds_error=False, fill_value='extrapolate')\n", " pred = float(interp_func(X_test))\n", " else:\n", " pred = Y_train[0]\n", "\n", " predictions.append(pred)\n", "\n", " return predictions\n", "\n", " def _calculate_metrics(self, predictions: List[float]) -> Any:\n", " \"\"\"Calculate evaluation metrics\"\"\"\n", " actuals = self.Y.tolist()\n", "\n", " mae = mean_absolute_error(actuals, predictions)\n", " rmse = np.sqrt(mean_squared_error(actuals, predictions))\n", " r2 = r2_score(actuals, predictions)\n", " max_error = np.max(np.abs(np.array(actuals) - np.array(predictions)))\n", "\n", " return {\n", " 'MAE': mae,\n", " 'RMSE': rmse,\n", " 'R²': r2,\n", " 'Max Error': max_error,\n", " 'Predictions': predictions\n", " }\n", "\n", " def compare_methods(self) -> Dict[str, Dict]:\n", " \"\"\"Compare all calibration methods\"\"\"\n", " print(f\"\\n{'='*60}\")\n", " print(f\"SENSOR CALIBRATION COMPARISON: {self.sensor_name}\")\n", " print(f\"{'='*60}\")\n", "\n", " methods = {\n", " 'Linear Regression': self._linear_regression_loo(),\n", " 'NumPy Interpolation': self._numpy_interpolation_loo(),\n", " 'SciPy Interpolation': self._scipy_interpolation_loo()\n", " }\n", "\n", " for method_name, predictions in methods.items():\n", " self.results[method_name] = self._calculate_metrics(predictions)\n", "\n", " self._display_results_table()\n", " self._display_detailed_predictions()\n", "\n", " return self.results\n", "\n", " def _display_results_table(self):\n", " \"\"\"Display comparison results in a formatted table\"\"\"\n", " best_mae = min(self.results.keys(), key=lambda x: self.results[x]['MAE'])\n", " best_rmse = min(self.results.keys(), key=lambda x: self.results[x]['RMSE'])\n", " best_r2 = max(self.results.keys(), key=lambda x: self.results[x]['R²'])\n", "\n", " print(f\"\\n{'Method':<20} {'MAE':<10} {'RMSE':<10} {'R²':<10} {'Max Error':<12}\")\n", " print(\"-\" * 70)\n", "\n", " for method, metrics in self.results.items():\n", " mae_star = \" ⭐\" if method == best_mae else \"\"\n", " rmse_star = \" ⭐\" if method == best_rmse else \"\"\n", " r2_star = \" ⭐\" if method == best_r2 else \"\"\n", "\n", " print(f\"{method:<20} {metrics['MAE']:<9.4f}{mae_star:<1} \"\n", " f\"{metrics['RMSE']:<9.4f}{rmse_star:<1} \"\n", " f\"{metrics['R²']:<9.4f}{r2_star:<1} \"\n", " f\"{metrics['Max Error']:<9.4f} {self.unit}\")\n", "\n", " def _display_detailed_predictions(self):\n", " \"\"\"Display detailed prediction vs actual comparison\"\"\"\n", " print(f\"\\nDetailed Predictions vs Actual Values:\")\n", " print(f\"{'Actual':<8} {'LR':<8} {'NumPy':<8} {'SciPy':<8} {'LR Err':<8} {'NP Err':<8} {'SP Err':<8}\")\n", " print(\"-\" * 65)\n", "\n", " lr_pred = self.results['Linear Regression']['Predictions']\n", " np_pred = self.results['NumPy Interpolation']['Predictions']\n", " sp_pred = self.results['SciPy Interpolation']['Predictions']\n", "\n", " for i in range(self.n_points):\n", " actual = self.Y[i]\n", " lr_err = abs(actual - lr_pred[i])\n", " np_err = abs(actual - np_pred[i])\n", " sp_err = abs(actual - sp_pred[i])\n", "\n", " print(f\"{actual:<8.2f} {lr_pred[i]:<8.2f} {np_pred[i]:<8.2f} \"\n", " f\"{sp_pred[i]:<8.2f} {lr_err:<8.4f} {np_err:<8.4f} {sp_err:<8.4f}\")\n", "\n", " def visualize_comparison(self):\n", " \"\"\"Create comprehensive visualization\"\"\"\n", " fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(15, 10))\n", "\n", " self._plot_model_curves(ax1)\n", " self._plot_residuals(ax2)\n", " self._plot_metrics_comparison(ax3)\n", " self._plot_actual_vs_predicted(ax4)\n", "\n", " plt.suptitle(f'{self.sensor_name} Calibration Methods Comparison', fontsize=16)\n", " plt.tight_layout()\n", " plt.show()\n", "\n", " def _plot_model_curves(self, ax):\n", " \"\"\"Plot model curves\"\"\"\n", " X_fine = np.linspace(self.X.min(), self.X.max(), 100)\n", "\n", " # Linear Regression line\n", " lr_model = LinearRegression()\n", " lr_model.fit(self.X.reshape(-1, 1), self.Y)\n", " lr_line = lr_model.predict(X_fine.reshape(-1, 1))\n", "\n", " # Interpolation lines\n", " np_line = np.interp(X_fine, self.X, self.Y)\n", " sp_interp = interp1d(self.X, self.Y, kind='linear', fill_value=\"extrapolate\")\n", " sp_line = sp_interp(X_fine)\n", "\n", " ax.scatter(self.X, self.Y, color='red', s=100, label='Calibration Data', zorder=5)\n", " ax.plot(X_fine, lr_line, 'b-', label='Linear Regression', linewidth=2)\n", " ax.plot(X_fine, np_line, 'g--', label='NumPy Interpolation', linewidth=2)\n", " ax.plot(X_fine, sp_line, 'm:', label='SciPy Interpolation', linewidth=2)\n", "\n", " ax.set_xlabel(f'Instrument Reading ({self.unit})')\n", " ax.set_ylabel(f'Actual {self.sensor_name} ({self.unit})')\n", " ax.set_title('Model Comparison')\n", " ax.legend()\n", " ax.grid(True, alpha=0.3)\n", "\n", " def _plot_residuals(self, ax):\n", " \"\"\"Plot residuals for each method\"\"\"\n", " methods = ['Linear Regression', 'NumPy Interpolation', 'SciPy Interpolation']\n", " colors = ['blue', 'green', 'magenta']\n", "\n", " for i, (method, color) in enumerate(zip(methods, colors)):\n", " residuals = np.array(self.Y) - np.array(self.results[method]['Predictions'])\n", " ax.scatter([i] * len(residuals), residuals, color=color, alpha=0.7, s=60)\n", "\n", " ax.axhline(y=0, color='black', linestyle='-', alpha=0.5)\n", " ax.set_xticks(range(len(methods)))\n", " ax.set_xticklabels([m.replace(' ', '\\n') for m in methods])\n", " ax.set_ylabel(f'Residuals ({self.unit})')\n", " ax.set_title('Residuals Distribution')\n", " ax.grid(True, alpha=0.3)\n", "\n", " def _plot_metrics_comparison(self, ax):\n", " \"\"\"Plot metrics comparison bar chart\"\"\"\n", " metrics_names = ['MAE', 'RMSE', 'Max Error']\n", " methods = list(self.results.keys())\n", "\n", " x = np.arange(len(metrics_names))\n", " width = 0.25\n", " colors = ['blue', 'green', 'magenta']\n", "\n", " for i, (method, color) in enumerate(zip(methods, colors)):\n", " values = [\n", " self.results[method]['MAE'],\n", " self.results[method]['RMSE'],\n", " self.results[method]['Max Error']\n", " ]\n", " ax.bar(x + i*width, values, width, label=method, color=color, alpha=0.7)\n", "\n", " ax.set_xlabel('Metrics')\n", " ax.set_ylabel(f'Error ({self.unit})')\n", " ax.set_title('Error Metrics Comparison')\n", " ax.set_xticks(x + width)\n", " ax.set_xticklabels(metrics_names)\n", " ax.legend()\n", " ax.grid(True, alpha=0.3)\n", "\n", " def _plot_actual_vs_predicted(self, ax):\n", " \"\"\"Plot actual vs predicted values\"\"\"\n", " methods = list(self.results.keys())\n", " colors = ['blue', 'green', 'magenta']\n", "\n", " for method, color in zip(methods, colors):\n", " predictions = self.results[method]['Predictions']\n", " ax.scatter(self.Y, predictions, color=color, alpha=0.7, s=60, label=method)\n", "\n", " # Perfect prediction line\n", " min_val = min(self.Y.min(), min([min(self.results[m]['Predictions']) for m in methods]))\n", " max_val = max(self.Y.max(), max([max(self.results[m]['Predictions']) for m in methods]))\n", " ax.plot([min_val, max_val], [min_val, max_val], 'k--', alpha=0.5, label='Perfect Prediction')\n", "\n", " ax.set_xlabel(f'Actual {self.sensor_name} ({self.unit})')\n", " ax.set_ylabel(f'Predicted {self.sensor_name} ({self.unit})')\n", " ax.set_title('Actual vs Predicted')\n", " ax.legend()\n", " ax.grid(True, alpha=0.3)\n", "\n", " def statistical_significance_test(self):\n", " \"\"\"Perform statistical significance tests\"\"\"\n", " print(f\"\\n{'='*50}\")\n", " print(\"STATISTICAL SIGNIFICANCE TESTS\")\n", " print(f\"{'='*50}\")\n", "\n", " methods = list(self.results.keys())\n", "\n", " for i in range(len(methods)):\n", " for j in range(i+1, len(methods)):\n", " method1, method2 = methods[i], methods[j]\n", "\n", " errors1 = np.abs(self.Y - np.array(self.results[method1]['Predictions']))\n", " errors2 = np.abs(self.Y - np.array(self.results[method2]['Predictions']))\n", "\n", " t_stat, p_value = stats.ttest_rel(errors1, errors2)\n", "\n", " print(f\"\\n{method1} vs {method2}:\")\n", " print(f\" t-statistic: {t_stat:.4f}\")\n", " print(f\" p-value: {p_value:.4f}\")\n", "\n", " if p_value < 0.05:\n", " better_method = method1 if np.mean(errors1) < np.mean(errors2) else method2\n", " print(f\" Result: {better_method} is significantly better (p < 0.05)\")\n", " else:\n", " print(f\" Result: No significant difference (p ≥ 0.05)\")\n", "\n", " def get_recommendation(self) -> Any:\n", " \"\"\"Get method recommendation based on results\"\"\"\n", " best_mae_method = min(self.results.keys(), key=lambda x: self.results[x]['MAE'])\n", " best_rmse_method = min(self.results.keys(), key=lambda x: self.results[x]['RMSE'])\n", "\n", " return {\n", " 'best_mae': best_mae_method,\n", " 'best_rmse': best_rmse_method,\n", " 'mae_value': self.results[best_mae_method]['MAE'],\n", " 'rmse_value': self.results[best_rmse_method]['RMSE']\n", " }" ], | |
"outputs" : [ ], | |
"execution_count" : 6 | |
}, { | |
"metadata" : { | |
"ExecuteTime" : { | |
"end_time" : "2025-05-28T17:20:16.723497Z", | |
"start_time" : "2025-05-28T17:20:16.711587Z" | |
} | |
}, | |
"cell_type" : "code", | |
"source" : [ "def compare_model():\n", " data_suhu = {\n", " 'Penunjukan Alat (°C)': [15.3, 20.3, 25.3, 30.2],\n", " 'Suhu Aktual (°C)': [15.09, 20.14, 25.12, 30.13],\n", " }\n", "\n", " data_kelembapan = {\n", " 'Penunjukan Alat (%RH)': [42, 51, 60, 67],\n", " 'Kelembapan Aktual (%RH)': [40.11, 50.71, 59.99, 69.03],\n", " }\n", "\n", " df_suhu = pd.DataFrame(data_suhu)\n", " df_kelembapan = pd.DataFrame(data_kelembapan)\n", "\n", " temp_comparator = SensorCalibrationComparator(\n", " instrument_readings=df_suhu['Penunjukan Alat (°C)'].values,\n", " actual_values=df_suhu['Suhu Aktual (°C)'].values,\n", " sensor_name='Temperature',\n", " unit='°C'\n", " )\n", "\n", " humidity_comparator = SensorCalibrationComparator(\n", " instrument_readings=df_kelembapan['Penunjukan Alat (%RH)'].values,\n", " actual_values=df_kelembapan['Kelembapan Aktual (%RH)'].values,\n", " sensor_name='Humidity',\n", " unit='%RH'\n", " )\n", "\n", " print(\"🔬 SENSOR CALIBRATION MODEL COMPARISON\")\n", " print(\"=\" * 60)\n", "\n", " temp_results = temp_comparator.compare_methods()\n", " temp_comparator.statistical_significance_test()\n", " temp_comparator.visualize_comparison()\n", "\n", " humidity_results = humidity_comparator.compare_methods()\n", " humidity_comparator.statistical_significance_test()\n", " humidity_comparator.visualize_comparison()\n", "\n", " print(f\"\\n{'='*60}\")\n", " print(\"🎯 FINAL RECOMMENDATIONS\")\n", " print(f\"{'='*60}\")\n", "\n", " temp_rec = temp_comparator.get_recommendation()\n", " humidity_rec = humidity_comparator.get_recommendation()\n", "\n", " print(f\"\\n🌡️ Temperature Sensor:\")\n", " print(f\" Best Method (MAE): {temp_rec['best_mae']} (MAE: {temp_rec['mae_value']:.4f}°C)\")\n", " print(f\" Best Method (RMSE): {temp_rec['best_rmse']} (RMSE: {temp_rec['rmse_value']:.4f}°C)\")\n", "\n", " print(f\"\\n💧 Humidity Sensor:\")\n", " print(f\" Best Method (MAE): {humidity_rec['best_mae']} (MAE: {humidity_rec['mae_value']:.4f}%RH)\")\n", " print(f\" Best Method (RMSE): {humidity_rec['best_rmse']} (RMSE: {humidity_rec['rmse_value']:.4f}%RH)\")" ], | |
"id" : "c8e000a8f1a7c89b", | |
"outputs" : [ ], | |
"execution_count" : 7 | |
}, { | |
"metadata" : { | |
"ExecuteTime" : { | |
"end_time" : "2025-05-28T17:20:20.185450Z", | |
"start_time" : "2025-05-28T17:20:16.740517Z" | |
} | |
}, | |
"cell_type" : "code", | |
"source" : "compare_model()", | |
"id" : "eae61ac1f706e599", | |
"outputs" : [ { | |
"name" : "stdout", | |
"output_type" : "stream", | |
"text" : [ "🔬 SENSOR CALIBRATION MODEL COMPARISON\n", "============================================================\n", "\n", "============================================================\n", "SENSOR CALIBRATION COMPARISON: Temperature\n", "============================================================\n", "\n", "Method MAE RMSE R² Max Error \n", "----------------------------------------------------------------------\n", "Linear Regression 0.0466 ⭐ 0.0546 ⭐ 0.9999 ⭐ 0.0836 °C\n", "NumPy Interpolation 2.5401 3.5570 0.5968 5.0500 °C\n", "SciPy Interpolation 0.0750 0.0825 0.9998 0.1296 °C\n", "\n", "Detailed Predictions vs Actual Values:\n", "Actual LR NumPy SciPy LR Err NP Err SP Err \n", "-----------------------------------------------------------------\n", "15.09 15.07 20.14 15.16 0.0168 5.0500 0.0700 \n", "20.14 20.12 20.11 20.11 0.0212 0.0350 0.0350 \n", "25.12 25.18 25.19 25.19 0.0648 0.0655 0.0655 \n", "30.13 30.05 25.12 30.00 0.0836 5.0100 0.1296 \n", "\n", "==================================================\n", "STATISTICAL SIGNIFICANCE TESTS\n", "==================================================\n", "\n", "Linear Regression vs NumPy Interpolation:\n", " t-statistic: -1.7369\n", " p-value: 0.1808\n", " Result: No significant difference (p ≥ 0.05)\n", "\n", "Linear Regression vs SciPy Interpolation:\n", " t-statistic: -2.2515\n", " p-value: 0.1098\n", " Result: No significant difference (p ≥ 0.05)\n", "\n", "NumPy Interpolation vs SciPy Interpolation:\n", " t-statistic: 1.7319\n", " p-value: 0.1817\n", " Result: No significant difference (p ≥ 0.05)\n" ] | |
}, { | |
"data" : { | |
"text/plain" : [ "<Figure size 1500x1000 with 4 Axes>" ], | |
"image/png" : "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" | |
}, | |
"metadata" : { }, | |
"output_type" : "display_data" | |
}, { | |
"name" : "stdout", | |
"output_type" : "stream", | |
"text" : [ "\n", "============================================================\n", "SENSOR CALIBRATION COMPARISON: Humidity\n", "============================================================\n", "\n", "Method MAE RMSE R² Max Error \n", "----------------------------------------------------------------------\n", "Linear Regression 0.6445 ⭐ 0.7714 ⭐ 0.9948 ⭐ 1.0889 %RH\n", "NumPy Interpolation 5.3313 6.9923 0.5766 10.6000 %RH\n", "SciPy Interpolation 1.2068 1.2796 0.9858 1.8222 %RH\n", "\n", "Detailed Predictions vs Actual Values:\n", "Actual LR NumPy SciPy LR Err NP Err SP Err \n", "-----------------------------------------------------------------\n", "40.11 40.16 50.71 41.43 0.0454 10.6000 1.3200 \n", "50.71 50.26 50.05 50.05 0.4475 0.6600 0.6600 \n", "59.99 60.99 61.02 61.02 0.9962 1.0250 1.0250 \n", "69.03 67.94 59.99 67.21 1.0889 9.0400 1.8222 \n", "\n", "==================================================\n", "STATISTICAL SIGNIFICANCE TESTS\n", "==================================================\n", "\n", "Linear Regression vs NumPy Interpolation:\n", " t-statistic: -1.7426\n", " p-value: 0.1798\n", " Result: No significant difference (p ≥ 0.05)\n", "\n", "Linear Regression vs SciPy Interpolation:\n", " t-statistic: -2.0052\n", " p-value: 0.1386\n", " Result: No significant difference (p ≥ 0.05)\n", "\n", "NumPy Interpolation vs SciPy Interpolation:\n", " t-statistic: 1.7056\n", " p-value: 0.1866\n", " Result: No significant difference (p ≥ 0.05)\n" ] | |
}, { | |
"data" : { | |
"text/plain" : [ "<Figure size 1500x1000 with 4 Axes>" ], | |
"image/png" : "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" | |
}, | |
"metadata" : { }, | |
"output_type" : "display_data" | |
}, { | |
"name" : "stdout", | |
"output_type" : "stream", | |
"text" : [ "\n", "============================================================\n", "🎯 FINAL RECOMMENDATIONS\n", "============================================================\n", "\n", "🌡️ Temperature Sensor:\n", " Best Method (MAE): Linear Regression (MAE: 0.0466°C)\n", " Best Method (RMSE): Linear Regression (RMSE: 0.0546°C)\n", "\n", "💧 Humidity Sensor:\n", " Best Method (MAE): Linear Regression (MAE: 0.6445%RH)\n", " Best Method (RMSE): Linear Regression (RMSE: 0.7714%RH)\n" ] | |
} ], | |
"execution_count" : 8 | |
} ], | |
"metadata" : { | |
"kernelspec" : { | |
"display_name" : "Python 3", | |
"language" : "python", | |
"name" : "python3" | |
}, | |
"language_info" : { | |
"codemirror_mode" : { | |
"name" : "ipython", | |
"version" : 2 | |
}, | |
"file_extension" : ".py", | |
"mimetype" : "text/x-python", | |
"name" : "python", | |
"nbconvert_exporter" : "python", | |
"pygments_lexer" : "ipython2", | |
"version" : "2.7.6" | |
} | |
}, | |
"nbformat" : 4, | |
"nbformat_minor" : 5 | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment