diff --git a/.idea/.gitignore b/.idea/.gitignore new file mode 100644 index 0000000..26d3352 --- /dev/null +++ b/.idea/.gitignore @@ -0,0 +1,3 @@ +# Default ignored files +/shelf/ +/workspace.xml diff --git a/.idea/cs229-2018-autumn.iml b/.idea/cs229-2018-autumn.iml new file mode 100644 index 0000000..b5ad51a --- /dev/null +++ b/.idea/cs229-2018-autumn.iml @@ -0,0 +1,12 @@ + + + + + + + + + + \ No newline at end of file diff --git a/.idea/inspectionProfiles/profiles_settings.xml b/.idea/inspectionProfiles/profiles_settings.xml new file mode 100644 index 0000000..105ce2d --- /dev/null +++ b/.idea/inspectionProfiles/profiles_settings.xml @@ -0,0 +1,6 @@ + + + + \ No newline at end of file diff --git a/.idea/misc.xml b/.idea/misc.xml new file mode 100644 index 0000000..a971a2c --- /dev/null +++ b/.idea/misc.xml @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/.idea/modules.xml b/.idea/modules.xml new file mode 100644 index 0000000..5a3a3f2 --- /dev/null +++ b/.idea/modules.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/.idea/vcs.xml b/.idea/vcs.xml new file mode 100644 index 0000000..35eb1dd --- /dev/null +++ b/.idea/vcs.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/Pipfile b/Pipfile new file mode 100644 index 0000000..58877f8 --- /dev/null +++ b/Pipfile @@ -0,0 +1,12 @@ +[[source]] +url = "https://pypi.org/simple" +verify_ssl = true +name = "pypi" + +[packages] + +[dev-packages] + +[requires] +python_version = "3.11" +python_full_version = "3.11.5" diff --git a/Pipfile.lock b/Pipfile.lock new file mode 100644 index 0000000..a552889 --- /dev/null +++ b/Pipfile.lock @@ -0,0 +1,21 @@ +{ + "_meta": { + "hash": { + "sha256": "ace7e9784a57c9841694abb0b34b2c60c71c5820bbe44603aad915ceb02cba3b" + }, + "pipfile-spec": 6, + "requires": { + "python_full_version": "3.11.5", + "python_version": "3.11" + }, + "sources": [ + { + "name": "pypi", + "url": "https://pypi.org/simple", + "verify_ssl": true + } + ] + }, + "default": {}, + "develop": {} +} diff --git a/andrew-ng-machine-learning-yearning-1.pdf b/andrew-ng-machine-learning-yearning-1.pdf new file mode 100644 index 0000000..7ce771e Binary files /dev/null and b/andrew-ng-machine-learning-yearning-1.pdf differ diff --git a/cs229_main_notes.pdf b/cs229_main_notes.pdf new file mode 100644 index 0000000..cbffe0e Binary files /dev/null and b/cs229_main_notes.pdf differ diff --git a/problem-sets/PS1/src/__pycache__/linear_model.cpython-311.pyc b/problem-sets/PS1/src/__pycache__/linear_model.cpython-311.pyc new file mode 100644 index 0000000..3ce4954 Binary files /dev/null and b/problem-sets/PS1/src/__pycache__/linear_model.cpython-311.pyc differ diff --git a/problem-sets/PS1/src/__pycache__/p01b_logreg.cpython-311.pyc b/problem-sets/PS1/src/__pycache__/p01b_logreg.cpython-311.pyc new file mode 100644 index 0000000..59d6d55 Binary files /dev/null and b/problem-sets/PS1/src/__pycache__/p01b_logreg.cpython-311.pyc differ diff --git a/problem-sets/PS1/src/__pycache__/p01e_gda.cpython-311.pyc b/problem-sets/PS1/src/__pycache__/p01e_gda.cpython-311.pyc new file mode 100644 index 0000000..a251106 Binary files /dev/null and b/problem-sets/PS1/src/__pycache__/p01e_gda.cpython-311.pyc differ diff --git a/problem-sets/PS1/src/__pycache__/p02cde_posonly.cpython-311.pyc b/problem-sets/PS1/src/__pycache__/p02cde_posonly.cpython-311.pyc new file mode 100644 index 0000000..5f31b43 Binary files /dev/null and b/problem-sets/PS1/src/__pycache__/p02cde_posonly.cpython-311.pyc differ diff --git a/problem-sets/PS1/src/__pycache__/p03d_poisson.cpython-311.pyc b/problem-sets/PS1/src/__pycache__/p03d_poisson.cpython-311.pyc new file mode 100644 index 0000000..9090506 Binary files /dev/null and b/problem-sets/PS1/src/__pycache__/p03d_poisson.cpython-311.pyc differ diff --git a/problem-sets/PS1/src/__pycache__/p05b_lwr.cpython-311.pyc b/problem-sets/PS1/src/__pycache__/p05b_lwr.cpython-311.pyc new file mode 100644 index 0000000..5859921 Binary files /dev/null and b/problem-sets/PS1/src/__pycache__/p05b_lwr.cpython-311.pyc differ diff --git a/problem-sets/PS1/src/__pycache__/p05c_tau.cpython-311.pyc b/problem-sets/PS1/src/__pycache__/p05c_tau.cpython-311.pyc new file mode 100644 index 0000000..ebe512d Binary files /dev/null and b/problem-sets/PS1/src/__pycache__/p05c_tau.cpython-311.pyc differ diff --git a/problem-sets/PS1/src/__pycache__/util.cpython-311.pyc b/problem-sets/PS1/src/__pycache__/util.cpython-311.pyc new file mode 100644 index 0000000..52c5ded Binary files /dev/null and b/problem-sets/PS1/src/__pycache__/util.cpython-311.pyc differ diff --git a/problem-sets/PS1/src/output/p01b_pred_1.txt b/problem-sets/PS1/src/output/p01b_pred_1.txt new file mode 100644 index 0000000..2ae9e9f --- /dev/null +++ b/problem-sets/PS1/src/output/p01b_pred_1.txt @@ -0,0 +1,100 @@ +0 +0 +1 +0 +0 +0 +0 +1 +0 +0 +0 +0 +0 +0 +0 +0 +0 +1 +0 +0 +0 +0 +1 +1 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +1 +0 +0 +0 +1 +0 +0 +0 +0 +0 +0 +0 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +0 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +0 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 diff --git a/problem-sets/PS1/src/output/p01b_pred_1_fig.png b/problem-sets/PS1/src/output/p01b_pred_1_fig.png new file mode 100644 index 0000000..0efaf6c Binary files /dev/null and b/problem-sets/PS1/src/output/p01b_pred_1_fig.png differ diff --git a/problem-sets/PS1/src/output/p01b_pred_2.txt b/problem-sets/PS1/src/output/p01b_pred_2.txt new file mode 100644 index 0000000..3d909de --- /dev/null +++ b/problem-sets/PS1/src/output/p01b_pred_2.txt @@ -0,0 +1,100 @@ +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +1 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +1 +1 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +1 +1 +1 +1 +1 +0 +0 +1 +1 +1 +1 +1 +1 +1 +0 +1 +1 +1 +1 +0 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +0 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +0 +1 +1 +1 +1 +1 +1 +1 diff --git a/problem-sets/PS1/src/output/p01b_pred_2_fig.png b/problem-sets/PS1/src/output/p01b_pred_2_fig.png new file mode 100644 index 0000000..e03be85 Binary files /dev/null and b/problem-sets/PS1/src/output/p01b_pred_2_fig.png differ diff --git a/problem-sets/PS1/src/output/p01e_pred_1.txt b/problem-sets/PS1/src/output/p01e_pred_1.txt new file mode 100644 index 0000000..b52b6a4 --- /dev/null +++ b/problem-sets/PS1/src/output/p01e_pred_1.txt @@ -0,0 +1,100 @@ +0 +1 +1 +0 +0 +0 +0 +1 +0 +0 +0 +0 +0 +0 +0 +0 +0 +1 +1 +0 +0 +0 +1 +1 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +1 +0 +1 +0 +0 +0 +1 +0 +0 +0 +0 +0 +0 +0 +1 +1 +0 +1 +1 +1 +1 +1 +0 +1 +1 +1 +1 +0 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +0 +0 +1 +1 +1 +1 +1 +1 +1 +1 +1 +0 +1 +1 +1 +1 +1 +1 +1 +1 +1 diff --git a/problem-sets/PS1/src/output/p01e_pred_1_fig.png b/problem-sets/PS1/src/output/p01e_pred_1_fig.png new file mode 100644 index 0000000..384c615 Binary files /dev/null and b/problem-sets/PS1/src/output/p01e_pred_1_fig.png differ diff --git a/problem-sets/PS1/src/output/p01e_pred_2.txt b/problem-sets/PS1/src/output/p01e_pred_2.txt new file mode 100644 index 0000000..3474959 --- /dev/null +++ b/problem-sets/PS1/src/output/p01e_pred_2.txt @@ -0,0 +1,100 @@ +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +1 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +1 +0 +0 +0 +1 +1 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +1 +1 +1 +1 +1 +1 +0 +1 +1 +1 +1 +1 +1 +1 +0 +1 +1 +1 +1 +0 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +0 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +0 +1 +1 +1 +1 +1 +1 +1 diff --git a/problem-sets/PS1/src/output/p01e_pred_2_fig.png b/problem-sets/PS1/src/output/p01e_pred_2_fig.png new file mode 100644 index 0000000..d6525a9 Binary files /dev/null and b/problem-sets/PS1/src/output/p01e_pred_2_fig.png differ diff --git a/problem-sets/PS1/src/output/p02c_pred.txt b/problem-sets/PS1/src/output/p02c_pred.txt new file mode 100644 index 0000000..c09c26f --- /dev/null +++ b/problem-sets/PS1/src/output/p02c_pred.txt @@ -0,0 +1,124 @@ +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +1 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +1 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 diff --git a/problem-sets/PS1/src/output/p02c_pred_fig.png b/problem-sets/PS1/src/output/p02c_pred_fig.png new file mode 100644 index 0000000..a28b1ab Binary files /dev/null and b/problem-sets/PS1/src/output/p02c_pred_fig.png differ diff --git a/problem-sets/PS1/src/output/p02d_pred.txt b/problem-sets/PS1/src/output/p02d_pred.txt new file mode 100644 index 0000000..1b5ac46 --- /dev/null +++ b/problem-sets/PS1/src/output/p02d_pred.txt @@ -0,0 +1,124 @@ +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 diff --git a/problem-sets/PS1/src/output/p02d_pred_fig.png b/problem-sets/PS1/src/output/p02d_pred_fig.png new file mode 100644 index 0000000..fd151e8 Binary files /dev/null and b/problem-sets/PS1/src/output/p02d_pred_fig.png differ diff --git a/problem-sets/PS1/src/output/p02e_pred.txt b/problem-sets/PS1/src/output/p02e_pred.txt new file mode 100644 index 0000000..eac636a --- /dev/null +++ b/problem-sets/PS1/src/output/p02e_pred.txt @@ -0,0 +1,124 @@ +1 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +1 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +1 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +1 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 diff --git a/problem-sets/PS1/src/output/p02e_pred_fig.png b/problem-sets/PS1/src/output/p02e_pred_fig.png new file mode 100644 index 0000000..ae89396 Binary files /dev/null and b/problem-sets/PS1/src/output/p02e_pred_fig.png differ diff --git a/problem-sets/PS1/src/output/p02e_pred_fig_1.png b/problem-sets/PS1/src/output/p02e_pred_fig_1.png new file mode 100644 index 0000000..ae89396 Binary files /dev/null and b/problem-sets/PS1/src/output/p02e_pred_fig_1.png differ diff --git a/problem-sets/PS1/src/output/p03d_pred.png b/problem-sets/PS1/src/output/p03d_pred.png new file mode 100644 index 0000000..402b9b9 Binary files /dev/null and b/problem-sets/PS1/src/output/p03d_pred.png differ diff --git a/problem-sets/PS1/src/output/p03d_pred.txt b/problem-sets/PS1/src/output/p03d_pred.txt new file mode 100644 index 0000000..194c7b3 --- /dev/null +++ b/problem-sets/PS1/src/output/p03d_pred.txt @@ -0,0 +1,250 @@ +12003264 +2829789 +20529119 +1606054 +478442 +5703695 +688683 +482172 +1907501 +113300 +4191018 +496303 +4189573 +1847337 +146316 +1167915 +1589608 +3150062 +407711 +123071 +2117534 +118168 +1183351 +4786955 +578619 +9574643 +409468 +1099053 +1744190 +1470158 +494960 +3468353 +5675723 +24963785 +464990 +14629232 +777239 +1288541 +454136 +10173933 +2684415 +7234900 +459949 +203637 +3452766 +10846761 +6562307 +344402 +994860 +1477492 +1527524 +227820 +4056056 +218431 +2127383 +352285 +5846722 +4573591 +2959514 +696310 +10982719 +4079530 +3984765 +318705 +345636 +2807543 +382816 +13826792 +656840 +905002 +267465 +252442 +344744 +1606482 +799479 +1959872 +854184 +10703286 +1947334 +3753486 +2219174 +7459049 +4391794 +8098473 +3009169 +310023 +432320 +931799 +443265 +1482065 +878622 +2237126 +2913022 +215672 +296807 +196924 +4726978 +1979417 +1152382 +543210 +1659342 +315410 +347054 +5755635 +6788972 +1079980 +2614364 +2729788 +260023 +645603 +6697996 +338730 +8307945 +3906913 +1555440 +760415 +532293 +2419347 +3746725 +1438441 +8532285 +1467622 +3824587 +169928 +723547 +3114875 +261614 +7605320 +1573478 +1603858 +757689 +9450517 +11602140 +181602 +152951 +722889 +11078841 +140525 +208343 +475531 +4299319 +2673348 +265198 +363323 +5172854 +133668 +241212 +3473602 +190455 +156264 +370055 +134228 +239950 +1259402 +8207263 +741507 +9060386 +5472262 +3091917 +10358322 +1973971 +14609190 +5368024 +557239 +1030994 +18353106 +65941 +2302542 +1118548 +4044411 +1156728 +1376943 +3981421 +1278112 +5427722 +5489504 +15065047 +415744 +550852 +2270041 +2108438 +190145 +3336367 +1027416 +8820788 +370236 +33134844 +536961 +27697262 +1132961 +2084020 +3286021 +382745 +1150338 +697008 +510519 +9407013 +305378 +4348929 +313811 +613087 +20712034 +4361454 +73645 +15665937 +442725 +19686345 +5696536 +1225223 +15583928 +1820469 +1797114 +1043652 +472055 +178658 +815098 +15191469 +3139159 +195781 +1226129 +8751685 +8845960 +568142 +334653 +9108577 +180519 +4497334 +271914 +2252843 +1806147 +111596 +132212 +2599369 +6820905 +5020782 +16359535 +360256 +1367486 +257844 +562211 +317155 +958043 +2180602 +654621 +13312049 +5724903 +11601637 +142535 +401299 +3277210 diff --git a/problem-sets/PS1/src/output/p05b_pred_1.png b/problem-sets/PS1/src/output/p05b_pred_1.png new file mode 100644 index 0000000..5435740 Binary files /dev/null and b/problem-sets/PS1/src/output/p05b_pred_1.png differ diff --git a/problem-sets/PS1/src/output/p05c_pred_tau_0_03.png b/problem-sets/PS1/src/output/p05c_pred_tau_0_03.png new file mode 100644 index 0000000..1f887f5 Binary files /dev/null and b/problem-sets/PS1/src/output/p05c_pred_tau_0_03.png differ diff --git a/problem-sets/PS1/src/output/p05c_pred_tau_0_05.png b/problem-sets/PS1/src/output/p05c_pred_tau_0_05.png new file mode 100644 index 0000000..79bc946 Binary files /dev/null and b/problem-sets/PS1/src/output/p05c_pred_tau_0_05.png differ diff --git a/problem-sets/PS1/src/output/p05c_pred_tau_0_1.png b/problem-sets/PS1/src/output/p05c_pred_tau_0_1.png new file mode 100644 index 0000000..d755da6 Binary files /dev/null and b/problem-sets/PS1/src/output/p05c_pred_tau_0_1.png differ diff --git a/problem-sets/PS1/src/output/p05c_pred_tau_0_5.png b/problem-sets/PS1/src/output/p05c_pred_tau_0_5.png new file mode 100644 index 0000000..5435740 Binary files /dev/null and b/problem-sets/PS1/src/output/p05c_pred_tau_0_5.png differ diff --git a/problem-sets/PS1/src/output/p05c_pred_tau_10_0.png b/problem-sets/PS1/src/output/p05c_pred_tau_10_0.png new file mode 100644 index 0000000..93963c0 Binary files /dev/null and b/problem-sets/PS1/src/output/p05c_pred_tau_10_0.png differ diff --git a/problem-sets/PS1/src/output/p05c_pred_tau_1_0.png b/problem-sets/PS1/src/output/p05c_pred_tau_1_0.png new file mode 100644 index 0000000..a712d68 Binary files /dev/null and b/problem-sets/PS1/src/output/p05c_pred_tau_1_0.png differ diff --git a/problem-sets/PS1/src/p01b_logreg.py b/problem-sets/PS1/src/p01b_logreg.py index c79f9bb..1fa03bb 100644 --- a/problem-sets/PS1/src/p01b_logreg.py +++ b/problem-sets/PS1/src/p01b_logreg.py @@ -1,5 +1,6 @@ import numpy as np import util +import os from linear_model import LinearModel @@ -15,6 +16,15 @@ def main(train_path, eval_path, pred_path): x_train, y_train = util.load_dataset(train_path, add_intercept=True) # *** START CODE HERE *** + model = LogisticRegression() + theta = model.fit(x_train, y_train) + + x_test, y_test = util.load_dataset(eval_path, add_intercept=True) + fcsts, _ = model.predict(x_test) + + model.write(fcsts, pred_path) + fig_path_prefix = pred_path.split(".")[0] + util.plot(x_train, y_train, theta, save_path=f"{fig_path_prefix}_fig") # *** END CODE HERE *** @@ -35,16 +45,78 @@ def fit(self, x, y): y: Training example labels. Shape (m,). """ # *** START CODE HERE *** + tolerance = 10 ** -5 + change = np.inf + max_iters = 15 + self.theta = np.zeros(np.shape(x)[1]) + i = 0 + while change > tolerance and i < max_iters: + grad = self.loss_gradient(self.theta, x, y) + hess = self.loss_hessian(self.theta, x) + h_inv = np.linalg.inv(hess) + self.theta = self.theta - h_inv @ grad + i += 1 + + return self.theta # *** END CODE HERE *** def predict(self, x): """Make a prediction given new inputs x. Args: - x: Inputs of shape (m, n). + x: Inputs of shape ((m, n), m). Returns: Outputs of shape (m,). """ # *** START CODE HERE *** + S = self.sigmoid(self.theta, x) + fcsts = (S >= 0.5) * 1 + return fcsts, S # *** END CODE HERE *** + + def sigmoid(self, theta, X): + """Evaluate sigmoid based on the given params and X matrix + + Args: + theta: Input of shape (n, 1) + X: Input of shape (m, n) + + Returns: + Outputs of shape (m, 1) + """ + return 1/(1 + np.exp(-theta @ X.T)) + + def loss_gradient(self, theta, X, Y): + """Evaluate the logistic loss diff + + Args: + theta: Input of shape (n, 1) + X: Input of shape (m, n) + Y: Input of shape (m, 1) + Returns: + Outputs of shape (n, 1) + """ + S = self.sigmoid(theta, X) + m = len(X[0]) + grad = (1/m)*(np.sum((S - Y) * X.T, axis=1)) + return grad + + def loss_hessian(self, theta, X): + """Evaluate the logistic loss diff + + Args: + theta: Input of shape (n, 1) + X: Input of shape (m, n) + Y: Input of shape (m, 1) + Returns: + Outputs of shape (n, 1) + """ + S = self.sigmoid(theta, X) + m = len(X[0]) + return (1/m)*((S*(1 - S) * X.T) @ X) + + def write(self, data, path): + dir = os.path.dirname(path) + os.makedirs(dir, exist_ok=True) + np.savetxt(path, data, fmt="%d", delimiter=",") \ No newline at end of file diff --git a/problem-sets/PS1/src/p01e_gda.py b/problem-sets/PS1/src/p01e_gda.py index 33837ed..fb9a514 100644 --- a/problem-sets/PS1/src/p01e_gda.py +++ b/problem-sets/PS1/src/p01e_gda.py @@ -1,5 +1,6 @@ import numpy as np import util +import os from linear_model import LinearModel @@ -16,6 +17,15 @@ def main(train_path, eval_path, pred_path): x_train, y_train = util.load_dataset(train_path, add_intercept=False) # *** START CODE HERE *** + model = GDA() + theta = model.fit(x_train, y_train) + + x_test, y_test = util.load_dataset(eval_path, add_intercept=True) + fcst = model.predict(x_test) + + util.write(fcst, pred_path) + fig_path_prefix = pred_path.split(".")[0] + util.plot(x_train, y_train, theta, save_path=f"{fig_path_prefix}_fig") # *** END CODE HERE *** @@ -39,6 +49,31 @@ def fit(self, x, y): theta: GDA model parameters. """ # *** START CODE HERE *** + # get m and n + m, n = x.shape[0], x.shape[1] + + # calculate phi + phi = np.sum(y) / m + + # calculate mu0 and mu1 + y0, y1 = y == 0, y == 1 + num_0, num_1 = np.sum(y0), np.sum(y1) + y0, y1 = y0.reshape(len(y0), 1), y1.reshape(len(y1), 1) + mu0, mu1 = np.sum(x * y0, axis=0) / num_0, np.sum(x * y1, + axis=0) / num_1 + + # calculate sigma + x_diff = x - (y0 * mu0) - (y1 * mu1) + sigma = (1 / m) * x_diff.T @ x_diff + + # calculate thetas + sigma_inv = np.linalg.inv(sigma) + theta = (mu1 - mu0) @ sigma_inv + theta0 = (1 / 2) * (mu0 + mu1) @ sigma_inv @ ( + mu0 - mu1).T - np.log((1 - phi) / phi) + + self.theta = np.insert(theta, 0, theta0) + return self.theta # *** END CODE HERE *** def predict(self, x): @@ -51,4 +86,7 @@ def predict(self, x): Outputs of shape (m,). """ # *** START CODE HERE *** + # calculate sigmoid + S = 1 / (1 + np.exp(-(x @ self.theta))) + return S >= 0.5 # *** END CODE HERE diff --git a/problem-sets/PS1/src/p02cde_posonly.py b/problem-sets/PS1/src/p02cde_posonly.py index 87a5a94..4578be0 100644 --- a/problem-sets/PS1/src/p02cde_posonly.py +++ b/problem-sets/PS1/src/p02cde_posonly.py @@ -26,10 +26,52 @@ def main(train_path, valid_path, test_path, pred_path): pred_path_e = pred_path.replace(WILDCARD, 'e') # *** START CODE HERE *** + x_train, t_train = util.load_dataset(train_path, label_col="t", add_intercept=True) + x_test, t_test = util.load_dataset(test_path, label_col="t", add_intercept=True) + + x_train, y_train = util.load_dataset(train_path, label_col="y", add_intercept=True) + x_test, y_test = util.load_dataset(test_path, label_col="y", add_intercept=True) + + x_valid, y_valid = util.load_dataset(train_path, label_col="y", add_intercept=True) + # Part (c): Train and test on true labels # Make sure to save outputs to pred_path_c + logreg_model = LogisticRegression() + theta = logreg_model.fit(x_train, t_train) + t_fcsts_c, _ = logreg_model.predict(x_test) + util.evaluate_classification(t_fcsts_c, t_test, "PS1 p02 (c)") + util.write(t_fcsts_c, pred_path_c) + + fig_path_prefix = pred_path_c.split(".")[0] + util.plot(x_test, t_test, theta, save_path=f"{fig_path_prefix}_fig") + # Part (d): Train on y-labels and test on true labels # Make sure to save outputs to pred_path_d + logreg_model = LogisticRegression() + theta = logreg_model.fit(x_train, y_train) + t_fcsts_d, _ = logreg_model.predict(x_test) + util.evaluate_classification(t_fcsts_d, t_test, "PS1 p02 (d)") + util.write(t_fcsts_d, pred_path_d) + + fig_path_prefix = pred_path_d.split(".")[0] + util.plot(x_test, t_test, theta, save_path=f"{fig_path_prefix}_fig") + # Part (e): Apply correction factor using validation set and test on true labels # Plot and use np.savetxt to save outputs to pred_path_e + pos_examples = np.asarray(y_valid, dtype="int") + v_pos_x = x_valid[pos_examples] + _, raw_probs = logreg_model.predict(x_valid) + a = np.sum(raw_probs)/len(raw_probs) + print(f"\n\nalpha = {a}") + _, raw_probs = logreg_model.predict(x_test) + adjusted_probs = raw_probs/a + fcsts = adjusted_probs >= 0.5 + util.evaluate_classification(fcsts, t_test, "PS1 p02 (e)") + util.write(fcsts, pred_path_e) + + fig_path_prefix = pred_path_e.split(".")[0] + util.plot(x_test, t_test, theta, save_path=f"{fig_path_prefix}_fig", + correction=-np.log((2/a) - 1)/theta[2]) + # util.plot(x_test, t_test, theta, save_path=f"{fig_path_prefix}_fig", + # correction=a) # *** END CODER HERE diff --git a/problem-sets/PS1/src/p03d_poisson.py b/problem-sets/PS1/src/p03d_poisson.py index 3c58214..33c6ce6 100644 --- a/problem-sets/PS1/src/p03d_poisson.py +++ b/problem-sets/PS1/src/p03d_poisson.py @@ -1,5 +1,6 @@ import numpy as np import util +import matplotlib.pyplot as plt from linear_model import LinearModel @@ -19,6 +20,17 @@ def main(lr, train_path, eval_path, pred_path): # *** START CODE HERE *** # Fit a Poisson Regression model # Run on the validation set, and use np.savetxt to save outputs to pred_path + model = PoissonRegression() + model.fit(x_train, y_train) + + x_valid, y_valid = util.load_dataset(eval_path, add_intercept=False) + fcsts = model.predict(x_valid) + util.evaluate_regression(y_valid, fcsts, "PS1 p03(d)") + fcsts = np.asarray(fcsts, dtype="int") + util.write(fcsts, pred_path) + fig_path_prefix = pred_path.split(".")[0] + util.plot_regression(fcsts, y_valid, "forecast", + "true", fig_path_prefix) # *** END CODE HERE *** @@ -31,7 +43,11 @@ class PoissonRegression(LinearModel): > clf.predict(x_eval) """ - def fit(self, x, y): + def __init__(self, lr=0.003): + super().__init__() + self.lr = lr + + def fit(self, x, y, scale_y = "True"): """Run gradient ascent to maximize likelihood for Poisson regression. Args: @@ -39,6 +55,19 @@ def fit(self, x, y): y: Training example labels. Shape (m,). """ # *** START CODE HERE *** + # calculate the early stopping criteria as 0.01 * prev_loss + # if the change in loss is less than this value for 3 times in a row, + # then stop. However, since we may encounter anomalies which can result + # in a really high loss for a single value. We evaluate this over a + # batch. + x = util.add_intercept(x) + self.scale_param = np.min(y) + y = y/self.scale_param + m, n = x.shape + theta = np.zeros(n) + for x_i, y_i in zip(x, y): + theta += self.lr * (y_i - np.exp(theta @ x_i.T)) * x_i + self.theta = theta # *** END CODE HERE *** def predict(self, x): @@ -51,4 +80,7 @@ def predict(self, x): Floating-point prediction for each input, shape (m,). """ # *** START CODE HERE *** + x = util.add_intercept(x) + unscaled_y_hat = np.exp(self.theta @ x.T) + return unscaled_y_hat * self.scale_param # *** END CODE HERE *** diff --git a/problem-sets/PS1/src/p05b_lwr.py b/problem-sets/PS1/src/p05b_lwr.py index af9ae51..dd85601 100644 --- a/problem-sets/PS1/src/p05b_lwr.py +++ b/problem-sets/PS1/src/p05b_lwr.py @@ -18,8 +18,19 @@ def main(tau, train_path, eval_path): # *** START CODE HERE *** # Fit a LWR model + model = LocallyWeightedLinearRegression(tau) + model.fit(x_train, y_train) + # Get MSE value on the validation set - # Plot validation predictions on top of training set + x_valid, y_valid = util.load_dataset(eval_path, add_intercept=True) + fcsts = model.predict(x_valid) + util.evaluate_regression(y_valid, fcsts, "PS1 p05(b)") + + # Plot validation predictions on top of validation set + fig_path_prefix = "output/p05b_pred_1" + util.plot_regression_train_and_fcst(x_valid, y_valid, x_valid, fcsts, + save_path=fig_path_prefix) + # No need to save predictions # Plot data # *** END CODE HERE *** @@ -35,16 +46,32 @@ class LocallyWeightedLinearRegression(LinearModel): """ def __init__(self, tau): - super(LocallyWeightedLinearRegression, self).__init__() + super().__init__() self.tau = tau self.x = None self.y = None + self.theta = None + + def get_weights(self, x_hat): + j, n = x_hat.shape + # 'n' can be overwritten because it's same for both + m, n = self.x.shape + + # read https://numpy.org/doc/stable/user/basics.broadcasting.html + x_hat = x_hat.reshape(j, 1, n) + + diffs = self.x - x_hat + l2_norm = np.linalg.norm(diffs, ord=2, axis=2) + l2_norm_squared = l2_norm ** 2 + return np.exp(-l2_norm_squared/(2 * self.tau**2)) def fit(self, x, y): """Fit LWR by saving the training set. """ # *** START CODE HERE *** + self.x = x + self.y = y # *** END CODE HERE *** def predict(self, x): @@ -57,4 +84,15 @@ def predict(self, x): Outputs of shape (m,). """ # *** START CODE HERE *** + W = self.get_weights(x) + j, k = W.shape + W = W.reshape(j, k, 1) + weighted_X = self.x * W + weighted_X = np.transpose(weighted_X, axes=(0, 2, 1)) + + X = np.copy(self.x) + Thetas = np.linalg.inv(weighted_X @ X) @ weighted_X @ self.y + + y_hats = np.sum(Thetas * x, 1) + return y_hats # *** END CODE HERE *** diff --git a/problem-sets/PS1/src/p05c_tau.py b/problem-sets/PS1/src/p05c_tau.py index 9585fd5..18f5712 100644 --- a/problem-sets/PS1/src/p05c_tau.py +++ b/problem-sets/PS1/src/p05c_tau.py @@ -24,4 +24,33 @@ def main(tau_values, train_path, valid_path, test_path, pred_path): # Run on the test set to get the MSE value # Save predictions to pred_path # Plot data + + fig_path_prefix = util.get_fig_prefix(pred_path) + x_valid, y_valid = util.load_dataset(valid_path, add_intercept=True) + mse_vals = [] + + for tau in tau_values: + model = LocallyWeightedLinearRegression(tau) + model.fit(x_train, y_train) + + # Get MSE value on the validation set + fcsts = model.predict(x_valid) + mse = util.evaluate_regression(y_valid, fcsts, + f"PS1 p05(c) tau: {tau} valid_set") + tau_str = str(tau).split(".") + tau_str = "_".join(tau_str) + plot_path = f"{fig_path_prefix}_tau_{tau_str}" + util.plot_regression_train_and_fcst(x_valid, y_valid, x_valid, fcsts, + save_path=plot_path) + mse_vals.append(mse) + + # Plot validation predictions on top of test set + best_tau = tau_values[np.argmin(mse_vals)] + model = LocallyWeightedLinearRegression(best_tau) + model.fit(x_train, y_train) + + x_test, y_test = util.load_dataset(test_path, add_intercept=True) + fcsts = model.predict(x_test) + mse = util.evaluate_regression(y_test, fcsts, + f"PS1 p05(c) tau: {best_tau}, test_set") # *** END CODE HERE *** diff --git a/problem-sets/PS1/src/util.py b/problem-sets/PS1/src/util.py index baa0336..45d1459 100644 --- a/problem-sets/PS1/src/util.py +++ b/problem-sets/PS1/src/util.py @@ -1,5 +1,6 @@ import matplotlib.pyplot as plt import numpy as np +import os def add_intercept(x): @@ -60,7 +61,8 @@ def add_intercept_fn(x): return inputs, labels -def plot(x, y, theta, save_path=None, correction=1.0): +def plot(x, y, theta, save_path=None, correction=0.0): +# def plot(x, y, theta, save_path=None, correction=1.0): """Plot dataset and fitted logistic regression parameters. Args: x: Matrix of training examples, one per row. @@ -75,16 +77,90 @@ def plot(x, y, theta, save_path=None, correction=1.0): plt.plot(x[y == 0, -2], x[y == 0, -1], 'go', linewidth=2) # Plot decision boundary (found by solving for theta^T x = 0) - margin1 = (max(x[:, -2]) - min(x[:, -2]))*0.2 - margin2 = (max(x[:, -1]) - min(x[:, -1]))*0.2 - x1 = np.arange(min(x[:, -2])-margin1, max(x[:, -2])+margin1, 0.01) - x2 = -(theta[0] / theta[2] * correction + theta[1] / theta[2] * x1) + margin1 = (max(x[:, -2]) - min(x[:, -2])) * 0.2 + margin2 = (max(x[:, -1]) - min(x[:, -1])) * 0.2 + x1 = np.arange(min(x[:, -2]) - margin1, max(x[:, -2]) + margin1, 0.01) + x2 = correction - (theta[0] / theta[2] + theta[1] / theta[2] * x1) + # x2 = -(theta[0] / theta[2]*correction + theta[1] / theta[2] * x1) plt.plot(x1, x2, c='red', linewidth=2) - plt.xlim(x[:, -2].min()-margin1, x[:, -2].max()+margin1) - plt.ylim(x[:, -1].min()-margin2, x[:, -1].max()+margin2) + plt.xlim(x[:, -2].min() - margin1, x[:, -2].max() + margin1) + plt.ylim(x[:, -1].min() - margin2, x[:, -1].max() + margin2) # Add labels and save to disk plt.xlabel('x1') plt.ylabel('x2') if save_path is not None: plt.savefig(save_path) + +def plot_regression(x, y, label_x="x", label_y="y", save_path=""): + plt.figure() + plt.scatter(x, y) + # Add labels and save to disk + plt.xlabel(label_x) + plt.ylabel(label_y) + if save_path is not None: + plt.savefig(save_path) + +def plot_regression_train_and_fcst(x_train, y_train, x_test, y_test, label_x="x", label_y="y", save_path=""): + plt.figure() + plt.plot(x_train, y_train, 'bx', linewidth=2) + plt.plot(x_test, y_test, 'ro', linewidth=2) + # Add labels and save to disk + plt.xlabel(label_x) + plt.ylabel(label_y) + if save_path is not None: + plt.savefig(save_path) + + +def evaluate_classification(fcst, y_test, heading=""): + print(f"\n\n{heading}") + # evaluate + y_test_vec = y_test.reshape(len(y_test), 1) + fcst_vec = fcst.reshape(len(fcst), 1) + + correct = (y_test_vec == fcst_vec) + wrong = 1 - correct + + accuracy = np.sum(correct) / len(fcst_vec) + true_pos = np.sum(correct * fcst_vec) + true_neg = np.sum(correct * (1 - fcst_vec)) + false_pos = np.sum(wrong * fcst_vec) + false_neg = np.sum(wrong * (1 - fcst_vec)) + + if (true_pos + false_pos) == 0: + precision = 0 + else: + precision = true_pos / (true_pos + false_pos) + + if (true_pos + false_neg) == 0: + recall = 0 + else: + recall = true_pos / (true_pos + false_neg) + + print(f"y_test_vec, shape: {y_test_vec.shape}, num: {np.sum(y_test_vec)}") + print(f"fcst_vec, shape: {fcst_vec.shape}, num: {np.sum(fcst_vec)}") + print(f"correct vec, shape: {correct.shape}, num: {np.sum(correct)}") + print(f"wrong vec, shape: {wrong.shape}, num: {np.sum(wrong)}") + print(f"accuracy: {np.round(accuracy, 2)}, " + f"precision: {np.round(precision, 2)}, " + f"recall: {np.round(recall, 2)}") + + +def evaluate_regression(y, y_hat, heading=""): + print(f"\n\n{heading}") + m = len(y) + # evaluate + y_vec = y.reshape(m, 1) + y_hat_vec = y_hat.reshape(m, 1) + mse = (1/m) * np.sum((y_hat_vec - y_vec)**2) + mse = np.round(mse, 2) + print(f"MSE = {mse}") + return mse + +def write(data, path): + dir_name = os.path.dirname(path) + os.makedirs(dir_name, exist_ok=True) + np.savetxt(path, data, fmt="%d", delimiter=",") + +def get_fig_prefix(pred_path): + return pred_path.split(".")[0] diff --git a/problem-sets/PS2/MHA's notebooks/.ipynb_checkpoints/PS2_P1-checkpoint.ipynb b/problem-sets/PS2/MHA's notebooks/.ipynb_checkpoints/PS2_P1-checkpoint.ipynb new file mode 100644 index 0000000..993243b --- /dev/null +++ b/problem-sets/PS2/MHA's notebooks/.ipynb_checkpoints/PS2_P1-checkpoint.ipynb @@ -0,0 +1,1274 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "434b7bba-ab2c-4595-b3d6-5aa7152e3dfb", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import sys\n", + "SCRIPT_DIR = os.path.dirname(os.path.abspath(\"__file__\"))\n", + "SCRIPT_DIR_PARENT = os.path.dirname(SCRIPT_DIR)\n", + "sys.path.append(os.path.dirname(SCRIPT_DIR_PARENT))\n", + "\n", + "from PS2.src import util\n", + "from PS2.src.p01_lr import logistic_regression_modified\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "7ad972a6-a11f-4f75-b6d0-76f8c8b0038d", + "metadata": {}, + "outputs": [], + "source": [ + "Xa, Ya = util.load_csv('../data/ds1_a.csv', add_intercept=False)\n", + "Xb, Yb = util.load_csv('../data/ds1_b.csv', add_intercept=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "4562fa2a-ef15-4f52-8293-4b8263e3cc26", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "util.plot_points(Xa, Ya)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "0ce74347-0803-4b4b-8527-fb1622306e2e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "util.plot_points(Xb, Yb)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "6723bdd6-6ddc-4f60-a9bb-938e4940bbce", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Converged in 30395 iterations\n", + "Could not converge in 400000 epochs\n" + ] + } + ], + "source": [ + "Xa, Ya = util.load_csv('../data/ds1_a.csv', add_intercept=True)\n", + "Xb, Yb = util.load_csv('../data/ds1_b.csv', add_intercept=True)\n", + "\n", + "grads_a, thetas_a, _ = logistic_regression_modified(Xa, Ya)\n", + "grads_b, thetas_b, _ = logistic_regression_modified(Xb, Yb)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "de505346-48ce-4595-8f21-4ff5ba9924b3", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "util.plot_line(grads_a[:, 0], grads_a[:, 1], grads_a[:, 2])" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "d948fd70-4dcd-40e5-9fb5-98df5703c71a", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "util.plot_line(grads_b[:, 0], grads_b[:, 1], grads_b[:, 2])" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "e144a55e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "util.plot_line(thetas_a[:, 0], thetas_a[:, 1], thetas_a[:, 2])" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "be9ab7f9", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "util.plot_line(thetas_b[:, 0], thetas_b[:, 1], thetas_b[:, 2])" + ] + }, + { + "cell_type": "markdown", + "id": "a118e8f4", + "metadata": {}, + "source": [ + "# Ans 1(a)" + ] + }, + { + "cell_type": "markdown", + "id": "72fa27b0", + "metadata": {}, + "source": [ + "Most notable difference between the two datasets is dataset B being linearly separable and dataset A not being linearly separable." + ] + }, + { + "cell_type": "markdown", + "id": "b1ecbb46", + "metadata": {}, + "source": [ + "# Ans 1(b)" + ] + }, + { + "cell_type": "markdown", + "id": "e171fcf2", + "metadata": {}, + "source": [ + "Init step:\n", + "$$\\theta = zeros(X.shape[1:])$$\n", + "\n", + "Update step:\n", + "\n", + "$$\\theta = \\theta - \\alpha \\cdot grad$$\n", + "\n", + "where:\n", + "\n", + "$$grad = -\\frac{1}{m} X^T \\left(\\frac{Y}{1 + e^{Y (X \\cdot \\theta)}}\\right)$$\n", + "$$m = num \\space of \\space examples$$" + ] + }, + { + "cell_type": "markdown", + "id": "b43f4e4c", + "metadata": {}, + "source": [ + "Let's start by looking at each feature of X individually. The constant of integration will represent the integral values for the other features.\n", + "\n", + "$$Loss(\\theta) = -\\int{\\left(\\frac{xy}{1 + e^{yx\\theta}}\\right)}d\\theta$$\n", + "Let u = $xy\\theta$. Then,\n", + "$$\\frac{du}{d\\theta} = xy$$\n", + "$$ du = xyd\\theta$$\n", + "\n", + "So, the integral becomes:\n", + "$$ Loss(\\theta) = -\\int{\\left(\\frac{1}{1 + e^u}\\right)}du $$\n", + "for a single example this is:\n", + "$$ Loss(\\theta) = ln(e^u + 1) - u $$\n", + "$$ Loss(\\theta) = ln(e^{xy\\theta} + 1) - xy\\theta $$" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "e4a7f6e4", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "step = 3\n", + "max_theta = 30\n", + "min_theta = 1\n", + "n_correct = 9\n", + "n_incorrect = 1\n", + "\n", + "def loss(theta, correct=True):\n", + " xy = 1\n", + " if not correct:\n", + " xy = -1\n", + " return np.log(np.exp(xy*theta) + 1) - (xy*theta)\n", + " \n", + " \n", + "losses = []\n", + "for theta in range(1, 30, 3):\n", + " losses.append([theta, loss(theta, True)*n_correct, loss(theta, False)*n_incorrect])\n", + "\n", + "losses = np.array(losses)\n", + "# print(losses)\n", + "util.plot_line(losses[:, 0], losses[:, 1], losses[:, 2])" + ] + }, + { + "cell_type": "markdown", + "id": "f093cb8f", + "metadata": {}, + "source": [ + "$xy\\theta$ is positive for a correctly classified point and negative for an incorrectly classified one.\n", + "1. For the linearly inseparable case (i.e. the case with some incorrectly classified points): \n", + " As an example, let's assume that there are 10 examples, 9 forecast correctly and 1 incorrectly. \n", + " - As $\\theta$ increases, initially the decrease in loss caused by 9 correctly labeled examples is enough to encourage increasing its value, but at some point the total loss caused by the single wrong example overcomes this drop. Therefore the incorrect example acts as a regularizer. \n", + " - As $\\theta$ increases, given that $xy\\theta$ is negative for wrong labels, $e^{xy\\theta}$ becomes close to 0. This means that $ln(e^{xy\\theta} + 1) \\rightarrow 0$, so $- xy\\theta $ becomes the dominant contributor to the loss, and the $Loss$ increases quickly. \n", + " \n", + "2. For the linearly separable case (i.e. with all examples correctly labeled): \n", + " - As $\\theta$ increases, the loss goes down and continues to decrease, therefore the algorithm tries to continue to increase theta in magnitude.\n", + " - As $\\theta$ increases, given that $xy\\theta$ is positive for correct labels, $e^{xy\\theta}$ becomes large. This means that $ln(e^{xy\\theta} + 1) \\rightarrow xy\\theta$, so $- xy\\theta $ and the $Loss \\rightarrow 0$. \n", + "\n", + "However, we also observe that the gradient for the linearly separable case continues to drop over time, so if the threshold was large enough, we should see early stopping." + ] + }, + { + "cell_type": "markdown", + "id": "8836ed3a", + "metadata": {}, + "source": [ + "(c) [5 points] For each of these possible modifications, state whether or not it would lead to\n", + "the provided training algorithm converging on datasets such as B. Justify your answers.\n", + "\n", + " 1. Using a different constant learning rate. \n", + " 1. Decreasing the learning rate over time (e.g. scaling the initial learning rate by $\\frac{1}{t^2}$, where t is the number of gradient descent iterations thus far). \n", + " 1. Linear scaling of the input features. \n", + " 1. Adding a regularization term $||\\theta||^2_2$ to the loss function. \n", + " 1. Adding zero-mean Gaussian noise to the training data or labels." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "28ffee3d", + "metadata": {}, + "outputs": [], + "source": [ + "# Experiments\n", + "import os\n", + "import sys\n", + "SCRIPT_DIR = os.path.dirname(os.path.abspath(\"__file__\"))\n", + "SCRIPT_DIR_PARENT = os.path.dirname(SCRIPT_DIR)\n", + "sys.path.append(os.path.dirname(SCRIPT_DIR_PARENT))\n", + "from PS2.src import util\n", + "from PS2.src.p01_lr import logistic_regression_modified\n", + "import numpy as np\n", + "\n", + "Xa, Ya = util.load_csv('../data/ds1_a.csv', add_intercept=True)\n", + "Xb, Yb = util.load_csv('../data/ds1_b.csv', add_intercept=True)\n", + "\n", + "log_step = 10000\n", + "max_iters = 400000\n", + "iters = range(log_step, max_iters+1, log_step)" + ] + }, + { + "cell_type": "markdown", + "id": "102b0ac5", + "metadata": {}, + "source": [ + "# 1" + ] + }, + { + "cell_type": "markdown", + "id": "7f358158", + "metadata": {}, + "source": [ + " ### Using a different constant learning rate." + ] + }, + { + "cell_type": "markdown", + "id": "259e6a3c", + "metadata": {}, + "source": [ + " \n", + " 1. FOR DATASET B: If we increase the learning rate by 10 times (to 100), the delta of theta for each step would change by roughly 10 times. For the following step, the gradient should decrease by less than 10 times since it is flattening out, so the norm would actually be bigger for each iteration, and the linalg would take even longer (dataset B) to get within the threshold. Decreasing the learning rate to a small enough value could theoretically lead to convergence but the parameters learned would likely be unhelpful due to premature convergence. \n", + " FOR DATASET A: Increasing could lead to oscillating around the optimum leading to non-convergence, while decreasing would cause convergence to take longer." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "d6bb2e62", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "training for learning rate: 1\n", + "Converged in 278192 iterations\n", + "Could not converge in 400000 epochs\n", + "training for learning rate: 10\n", + "Converged in 30395 iterations\n", + "Could not converge in 400000 epochs\n", + "training for learning rate: 100\n", + "Could not converge in 400000 epochs\n", + "Could not converge in 400000 epochs\n" + ] + } + ], + "source": [ + "# (1)\n", + "def train(learning_rates):\n", + " labels = {\"A\": [], \"B\": []}\n", + " ys = {\"A\": [], \"B\": []}\n", + " for lr in learning_rates:\n", + " print(f\"training for learning rate: {lr}\")\n", + " _, _, norms_a, _ = logistic_regression_modified(Xa, Ya, learning_rate=lr)\n", + " _, _, norms_b, _ = logistic_regression_modified(Xb, Yb, learning_rate=lr)\n", + " ys[\"A\"].append(norms_a[:, 1])\n", + " ys[\"B\"].append(norms_b[:, 1])\n", + " labels[\"A\"].append(f\"A_lr_{lr}\")\n", + " labels[\"B\"].append(f\"B_lr_{lr}\")\n", + " return ys, labels\n", + " \n", + "ys, labels = train([1, 10, 100])" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "4b2ff2b3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "plotting A_lr_1\n", + "plotting A_lr_10\n", + "plotting A_lr_100\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "util.plot_lines(iters, ys = ys[\"A\"], x_label='iters', y_label='Norm', labels = labels[\"A\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "52c71713", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "plotting B_lr_1\n", + "plotting B_lr_10\n", + "plotting B_lr_100\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "util.plot_lines(iters, ys = ys[\"B\"], x_label='iters', y_label='Norm', labels = labels[\"B\"])" + ] + }, + { + "cell_type": "markdown", + "id": "9ea1db3a", + "metadata": {}, + "source": [ + "# 2" + ] + }, + { + "cell_type": "markdown", + "id": "377f4258", + "metadata": {}, + "source": [ + "### Decreasing the learning rate over time (e.g. scaling the initial learning rate by $\\frac{1}{t^2}$, where t is the number of gradient descent iterations thus far). " + ] + }, + { + "cell_type": "markdown", + "id": "b3d275b9", + "metadata": {}, + "source": [ + "Both datasets converge quickly because the early stopping criteria evaluates the change in the values of theta and if learning rate drops enough, this change can become lower than the min threshold, leading to convergence. Whether this value of theta is useful or not, is a different question." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "ea53cc1a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Converged in 11 iterations\n", + "Converged in 11 iterations\n" + ] + } + ], + "source": [ + "# (2)\n", + "decay=lambda t, lr: lr*(1/t**2)\n", + "\n", + "# original learning rate\n", + "_, _, norms_a, _ = logistic_regression_modified(Xa, Ya, learning_rate=10, decay=decay)\n", + "_, _, norms_b, _ = logistic_regression_modified(Xb, Yb, learning_rate=10, decay=decay)\n" + ] + }, + { + "cell_type": "markdown", + "id": "ad213c51", + "metadata": {}, + "source": [ + "# 3" + ] + }, + { + "cell_type": "markdown", + "id": "045ed3e4", + "metadata": {}, + "source": [ + "### Linear scaling of the input features. " + ] + }, + { + "cell_type": "markdown", + "id": "8d1982f4", + "metadata": {}, + "source": [ + "$$grad = -\\frac{1}{m} X^T \\left(\\frac{Y}{1 + e^{Y (X \\cdot \\theta)}}\\right)$$\n", + "$$m = num \\space of \\space examples$$" + ] + }, + { + "cell_type": "markdown", + "id": "1b2af3e6", + "metadata": {}, + "source": [ + "If $X$ is doubled, then the gradient would become:\n", + "$$grad = -\\frac{1}{m} 2X^T \\left(\\frac{Y}{1 + e^{Y (2X \\cdot \\theta)}}\\right)$$" + ] + }, + { + "cell_type": "markdown", + "id": "e1156963", + "metadata": {}, + "source": [ + "In the case of correct labels, $xy\\theta > 0$, which means that $-xy <= grad <= 0$. \n", + "In the case of incorrect labels, $xy\\theta < 0$, which means that $-2xy <= grad <= -xy$." + ] + }, + { + "cell_type": "markdown", + "id": "b3faa7f7", + "metadata": {}, + "source": [ + "If $X$ is scaled by 5 times: \n", + "For correct labels, the gradient approaches 0 even quicker than before. \n", + "For incorrect labels, the gradient approaches $-\\frac{5}{2}xy$. \n", + " \n", + "This basically means that for dataset A (linearly inseparable), this has an effect similar to that of increasing the learning rate for incorrect examples, and decreasing it for the correct examples. \n", + " \n", + "For dataset B (linearly separable), its effect is similar to that of reducing the overall learning rate, which we already showed above is unlikely to have a significant affect on convergence, unless the scale is large enough to force the early stopping criteria to be met." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "28e09be0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "training for scale: 0.1\n", + "Could not converge in 400000 epochs\n", + "Could not converge in 400000 epochs\n", + "training for scale: 1\n", + "Converged in 30395 iterations\n", + "Could not converge in 400000 epochs\n", + "training for scale: 5\n", + "Could not converge in 400000 epochs\n", + "Could not converge in 400000 epochs\n" + ] + } + ], + "source": [ + "# (3)\n", + "def train(scales):\n", + " labels = {\"A\": [], \"B\": []}\n", + " ys = {\"A\": [], \"B\": []}\n", + " for scale in scales:\n", + " print(f\"training for scale: {scale}\")\n", + " _, _, norms_a, _ = logistic_regression_modified(scale*Xa, Ya)\n", + " _, _, norms_b, _ = logistic_regression_modified(scale*Xb, Yb)\n", + " ys[\"A\"].append(norms_a[:, 1])\n", + " ys[\"B\"].append(norms_b[:, 1])\n", + " labels[\"A\"].append(f\"A_scale_{scale}\")\n", + " labels[\"B\"].append(f\"B_scale_{scale}\")\n", + " return ys, labels\n", + " \n", + "ys, labels = train([0.1, 1, 5])" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "97cb6962", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "plotting A_scale_0.1\n", + "plotting A_scale_1\n", + "plotting A_scale_5\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "util.plot_lines(iters, ys = ys[\"A\"], x_label='iters', y_label='Norm', labels = labels[\"A\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "4e50f27a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "plotting B_scale_0.1\n", + "plotting B_scale_1\n", + "plotting B_scale_5\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "util.plot_lines(iters, ys = ys[\"B\"], x_label='iters', y_label='Norm', labels = labels[\"B\"])" + ] + }, + { + "cell_type": "markdown", + "id": "158edceb", + "metadata": {}, + "source": [ + "# 4" + ] + }, + { + "cell_type": "markdown", + "id": "e147b8af", + "metadata": {}, + "source": [ + "### Adding a regularization term $||\\theta||^2_2$ to the loss function. " + ] + }, + { + "cell_type": "markdown", + "id": "802c5bc5", + "metadata": {}, + "source": [ + "$$ Loss(\\theta) = ln(e^{xy\\theta} + 1) - xy\\theta + \\gamma\\theta^2 \\space (\\leftarrow L2 \\space norm)$$" + ] + }, + { + "cell_type": "markdown", + "id": "b59c35c9", + "metadata": {}, + "source": [ + "$$grad = -\\frac{1}{m} X^T \\left(\\frac{Y}{1 + e^{Y (X \\cdot \\theta)}}\\right) + \\gamma\\frac{2\\theta}{m}$$\n", + "$$m = num \\space of \\space examples$$" + ] + }, + { + "cell_type": "markdown", + "id": "5db39df9", + "metadata": {}, + "source": [ + "Convergence is sped up by adding regularization by limiting the size of theta. However, if the value of $\\gamma$ is increased beyond a certain value, then the loss is dominated by the regularization term and the current value of learning rate might be too large leading to oscillation. So, the learning rate may have to be lowered." + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "97340a1d", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import sys\n", + "SCRIPT_DIR = os.path.dirname(os.path.abspath(\"__file__\"))\n", + "SCRIPT_DIR_PARENT = os.path.dirname(SCRIPT_DIR)\n", + "sys.path.append(os.path.dirname(SCRIPT_DIR_PARENT))\n", + "from PS2.src import util\n", + "from PS2.src.p01_lr import logistic_regression_modified\n", + "import numpy as np\n", + "from collections import defaultdict\n", + "\n", + "Xa, Ya = util.load_csv('../data/ds1_a.csv', add_intercept=True)\n", + "Xb, Yb = util.load_csv('../data/ds1_b.csv', add_intercept=True)\n", + "\n", + "max_iters = 20000\n", + "log_step = 499 # odd number so as to avoid missing oscillations in vals in alternating steps\n", + "iters = range(log_step, max_iters + 1, log_step)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "5c282e8d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "training for l2_coef: 0.1\n", + "Converged in 15154 iterations\n", + "Converged in 16611 iterations\n", + "training for l2_coef: 0.2\n", + "Converged in 8547 iterations\n", + "Converged in 8775 iterations\n", + "training for l2_coef: 0.5\n", + "Converged in 4115 iterations\n", + "Converged in 4009 iterations\n" + ] + } + ], + "source": [ + "# (4)\n", + "def train(l2_coefs):\n", + " labels = defaultdict(list)\n", + " ys = {\"norms\": defaultdict(list), \"grads\": defaultdict(list), \"thetas\": defaultdict(list), \"losses\": defaultdict(list)}\n", + " for c in l2_coefs:\n", + " print(f\"training for l2_coef: {c}\")\n", + " grads_a, thetas_a, norms_a, losses_a = logistic_regression_modified(Xa, Ya, max_iters=max_iters, learning_rate=1,\n", + " log_step=log_step, l2_reg_coef=c)\n", + " grads_b, thetas_b, norms_b, losses_b = logistic_regression_modified(Xb, Yb, max_iters=max_iters, learning_rate=1,\n", + " log_step=log_step, l2_reg_coef=c)\n", + " ys[\"norms\"][\"A\"].append(norms_a[:, 1])\n", + " ys[\"norms\"][\"B\"].append(norms_b[:, 1])\n", + " \n", + " ys[\"grads\"][\"A\"].append(grads_a[:, 1])\n", + " ys[\"grads\"][\"B\"].append(grads_b[:, 1])\n", + " \n", + " ys[\"thetas\"][\"A\"].append(thetas_a[:, 1])\n", + " ys[\"thetas\"][\"B\"].append(thetas_b[:, 1])\n", + " \n", + " ys[\"losses\"][\"A\"].append(losses_a[:, 1])\n", + " ys[\"losses\"][\"B\"].append(losses_b[:, 1])\n", + " \n", + " labels[\"A\"].append(f\"A_l2_coef_{c}\")\n", + " labels[\"B\"].append(f\"B_l2_coef_{c}\")\n", + " return ys, labels\n", + "\n", + "ys, labels = train([0.1, 0.2, 0.5])" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "f14a00be", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "plotting A_l2_coef_0.1\n", + "plotting A_l2_coef_0.2\n", + "plotting A_l2_coef_0.5\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "util.plot_lines(iters, ys = ys[\"thetas\"][\"A\"], x_label='iters', y_label='Theta', labels = labels[\"A\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "4878baca", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "plotting B_l2_coef_0.1\n", + "plotting B_l2_coef_0.2\n", + "plotting B_l2_coef_0.5\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "util.plot_lines(iters, ys = ys[\"thetas\"][\"B\"], x_label='iters', y_label='Theta', labels = labels[\"B\"])" + ] + }, + { + "cell_type": "markdown", + "id": "f2a90c31", + "metadata": {}, + "source": [ + "# 5" + ] + }, + { + "cell_type": "markdown", + "id": "ad65e7f7", + "metadata": {}, + "source": [ + "### Adding zero-mean Gaussian noise to the training data or labels." + ] + }, + { + "cell_type": "markdown", + "id": "db5b1edf", + "metadata": {}, + "source": [ + "Adding noise to the inputs can make the data linearly inseparable thereby making it possible to converge. If adding the noise still doesn't make the data linearly inseparable, the model will still not converge. \n", + "Adding noise to the labels doesn't make a significant difference unless the signs of the labels change. If the signs don't change, but the magnitude reduces, then there may be a chance of the change in theta getting to within the early stopping threshold." + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "id": "46d058d3", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import sys\n", + "SCRIPT_DIR = os.path.dirname(os.path.abspath(\"__file__\"))\n", + "SCRIPT_DIR_PARENT = os.path.dirname(SCRIPT_DIR)\n", + "sys.path.append(os.path.dirname(SCRIPT_DIR_PARENT))\n", + "from PS2.src import util\n", + "from PS2.src.p01_lr import logistic_regression_modified\n", + "import numpy as np\n", + "from collections import defaultdict\n", + "\n", + "Xa, Ya = util.load_csv('../data/ds1_a.csv', add_intercept=True)\n", + "Xb, Yb = util.load_csv('../data/ds1_b.csv', add_intercept=True)\n", + "\n", + "max_iters = 50000\n", + "log_step = 499 # odd number so as to avoid missing oscillations in vals in alternating steps\n", + "iters = range(log_step, max_iters + 1, log_step)\n", + "\n", + "\n", + "def add_gaussian_noise(data, mean=0, std=0.1):\n", + " noise = np.random.normal(mean, std, data.shape)\n", + " return data + noise" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "id": "c4404dd8", + "metadata": {}, + "outputs": [], + "source": [ + "# (5) applying gaussian noise to labels\n", + "def train(stds, mode):\n", + " labels = defaultdict(list)\n", + " ys = {\"norms\": defaultdict(list), \"grads\": defaultdict(list), \"thetas\": defaultdict(list), \"losses\": defaultdict(list)}\n", + " for std in stds:\n", + " print(f\"training for std: {std}\")\n", + "\n", + " if mode == \"labels\":\n", + " Ya_ = add_gaussian_noise(Ya, std=std)\n", + " Yb_ = add_gaussian_noise(Yb, std=std)\n", + " grads_a, thetas_a, norms_a, losses_a = logistic_regression_modified(Xa, Ya_, max_iters=max_iters, \n", + " log_step=log_step, learning_rate=10)\n", + " grads_b, thetas_b, norms_b, losses_b = logistic_regression_modified(Xb, Yb_, max_iters=max_iters,\n", + " log_step=log_step, learning_rate=10)\n", + " else:\n", + " Xa_ = add_gaussian_noise(Xa, std=std)\n", + " Xb_ = add_gaussian_noise(Xb, std=std)\n", + " grads_a, thetas_a, norms_a, losses_a = logistic_regression_modified(Xa_, Ya, max_iters=max_iters, \n", + " log_step=log_step, learning_rate=1)\n", + " grads_b, thetas_b, norms_b, losses_b = logistic_regression_modified(Xb_, Yb, max_iters=max_iters,\n", + " log_step=log_step, learning_rate=1)\n", + " \n", + " ys[\"norms\"][\"A\"].append(norms_a[:, 1])\n", + " ys[\"norms\"][\"B\"].append(norms_b[:, 1])\n", + " \n", + " ys[\"grads\"][\"A\"].append(grads_a[:, 1])\n", + " ys[\"grads\"][\"B\"].append(grads_b[:, 1])\n", + " \n", + " ys[\"thetas\"][\"A\"].append(thetas_a[:, 1])\n", + " ys[\"thetas\"][\"B\"].append(thetas_b[:, 1])\n", + " \n", + " ys[\"losses\"][\"A\"].append(losses_a[:, 1])\n", + " ys[\"losses\"][\"B\"].append(losses_b[:, 1])\n", + " \n", + " labels[\"A\"].append(f\"A_std_{std}\")\n", + " labels[\"B\"].append(f\"B_std_{std}\")\n", + " return ys, labels" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "id": "050da96b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "training for std: 0.2\n", + "Converged in 37384 iterations\n", + "Could not converge in 50000 epochs\n", + "training for std: 0.5\n", + "Converged in 21811 iterations\n", + "Could not converge in 50000 epochs\n", + "training for std: 1\n", + "Could not converge in 50000 epochs\n", + "Converged in 1374 iterations\n" + ] + } + ], + "source": [ + "ys, labels = train([.2, .5, 1], \"labels\")" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "id": "ce9da272", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "plotting A_std_0.2\n", + "plotting A_std_0.5\n", + "plotting A_std_1\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "util.plot_lines(iters, ys = ys[\"thetas\"][\"A\"], x_label='iters', y_label='Theta', labels = labels[\"A\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "id": "bb18a279", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "plotting B_std_0.2\n", + "plotting B_std_0.5\n", + "plotting B_std_1\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "util.plot_lines(iters, ys = ys[\"thetas\"][\"B\"], x_label='iters', y_label='Theta', labels = labels[\"B\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "id": "f9c9039d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "training for std: 0.1\n", + "Converged in 38490 iterations\n", + "Could not converge in 50000 epochs\n", + "training for std: 0.2\n", + "Converged in 5379 iterations\n", + "Converged in 8639 iterations\n", + "training for std: 0.3\n", + "Converged in 2761 iterations\n", + "Converged in 2361 iterations\n" + ] + } + ], + "source": [ + "ys, labels = train([.1, .2, .3], \"input\")" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "id": "b9d95c77", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "plotting A_std_0.1\n", + "plotting A_std_0.2\n", + "plotting A_std_0.3\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAj8AAAGwCAYAAABGogSnAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAA6PklEQVR4nO3de3hU1b3/8c9kkkkCSYZL7tzCEeSOxUQ0KopAEYoeUVRaRYnS/oQCQtGqqUUtpzV4Khg5VhEbUI5FqBWsh4sarICcQMEAiqIIGgiFYEBCbuRCJuv3R8gcIyQkMNfM+/U885DZl9nflY3Mx7XXXttijDECAAAIEEHeLgAAAMCTCD8AACCgEH4AAEBAIfwAAICAQvgBAAABhfADAAACCuEHAAAElGBvF+ButbW1OnLkiCIjI2WxWLxdDgAAaAZjjEpLS5WYmKigINf21bT68HPkyBF16dLF22UAAIALcOjQIXXu3Nmln9nqw09kZKSkul9eVFSUl6sBAADNUVJSoi5duji/x12p1Yef+ktdUVFRhB8AAPyMO4asMOAZAAAEFMIPAAAIKIQfAAAQUAg/AAAgoBB+AABAQCH8AACAgEL4AQAAAYXwAwAAAgrhBwAABBTCDwAACCiEHwAAEFAIPwAAIKC0+gebIrAZY2SMZCTVGqPa+vem7r2p30Z1y2Skundy7le/vn6Z9H/bOFc0/NG53Vn16OwVjW/rv0xjjQLQKkWGhsjeJsTbZTQb4QcuV1trVFZdo9LKGpVWnlZpZY1KKk6rrKpG5VUOVZx2qPK0Q6eqa1RRXauK0w5V1ThUXVNb93LU/XnaUavTDqOa2lrVOIxOO2pVU2tU4zBy1Bo5zJk/z7xqz7yvDzZ1L2//NgCg9fvl0Ev0yKje3i6j2Qg/aDZjjI6VVelfRRVnXqdUWFKl78qr9V1ZlU6UV+t4WbWKTlXLEQCpw2I586fzveUH7xvZT+dY0ci2jR67ZZsDgFsFB/nXv0qEH5zFUWt08LtyfVFQqi+PluiLghJ9c7xch4sqVFVT2+zPsVmDFBkWfOYVosiwYLWxBSvcZlWbEKvCbVaFhVgVFhKksBCrbNYg2YLrXqHBQbJZgxRsDVKw1aKQoDN/Wi2yBgUpOMiiIItFwda6P61BFlktFgUFSUGWumUNfrbUhQ5LUF1wsHx/2Zn/ZoMsdT9/P8x8P8hYGkszAAC/QviByqpqtC3vO23e951yD57Q3m9LVXn63CHHYpESosLUuX0bdWofrrioMEVH2BQdEaqOETZ1aGtTx7ahatcmRGEhVg+3BACA8yP8BCBHrdHO/CJt3n9c/7v/uHbmn1TNDy5ThYUEqVdcpPokRKl3fKR6xkWqS/s2ireHyRbMTYIAAP9F+Akgh06c0pu5/9LfPj6kI8WVDdZ17dBG1/SIVuolHdU/MUrdOraV1c+u4QIA0ByEn1auqsah7D3fasX2Q9q8/7jztuqosGANuTRG1/aI1jWXRKtrxzbeLRQAAA8h/LRSpx21WrrloP704X6dKK92Lr+mR0fdmdJFN/aLZ0wOACAgEX5aoQ+/LNR/rNmjb46VS5LiokJ1R3IX3ZnShR4eAEDAI/y0IvsLS/Ufq7/Qxq+OSZKiI2x6eGQv3Z7cWcFWBikDACARflqFimqH/vO9L7V0y0E5ao1CrBbdf013TRvWQ5Fh/jPdOAAAnkD48XOFpZX6xdJcfXLopCTpx33j9PhP+igpuq13CwMAwEcRfvzYV9+W6r4l23X4ZIXatQlR5vgfaWivWG+XBQCATyP8+KmP9h3TL1/fodKqGiV1bKMl9w1Wd3p7AAA4L8KPH1r2z3zN/vtnctQaDU7qoJfvSVb7tjZvlwUAgF8g/PgRY4zmvvulXt74jSTp1kGdNHfcAIUGM18PAADNRfjxI1mb85zB51cjLtWDw3vwpHEAAFqI8OMntuWdUMa6LyVJs2/qq0nXdvdyRQAA+CdmvvMDhaWVmrZshxy1Rv9+WaLuvybJ2yUBAOC3CD8+rsZRq2nLdqqwtEqXxkVo7rgBXOoCAOAiEH583H++t1fb8k6orc2qlyYkq42NK5UAAFwMwo8Pe/ezAi3aVDfA+Y93XKZLYiK8XBEAAP6P8OOjvj5Wpoff/FSS9Ish3fWTAQlerggAgNaB8OODahy1mvqXHSqrqtHgpA56ZFRvb5cEAECrQfjxQSt3HtaXR0vVvk2IXrhrkEKsnCYAAFyFb1Ufc9pRqxf+sV+SNPn6SxQbFebligAAaF0IPz5m1Y7Dyj9xStERNt2T2s3b5QAA0OoQfnzIaUet/uvDfZKkB667hNvaAQBwA8KPD3kr9186dKJC0RGhmnAVvT4AALgD4cdHVNfU6r+cY33+TeE2ntQOAIA7EH58xN9y/6XDJysUE0mvDwAA7kT48QHVNbX604d1vT5Trr9EYSH0+gAA4C6EHx/wZu4hHT5ZodjIUN11ZVdvlwMAQKtG+PGyqhqH/nRmrM+UofT6AADgboQfL/vrx//SkeJKxUWF6meD6fUBAMDdCD9eZIzRok1fS5J+ObQHvT4AAHiAV8PPpk2bdPPNNysxMVEWi0Vvv/12g/XGGD311FNKTExUeHi4hg4dqs8//9w7xbrBZ4dLdOhEhcJDrLozpYu3ywEAICB4NfyUl5frsssu0wsvvHDO9f/5n/+p+fPn64UXXtD27dsVHx+vH//4xyotLfVwpe7x3udHJUlDe8Uwrw8AAB7i1ecnjB49WqNHjz7nOmOMMjMz9fjjj+u2226TJL322muKi4vTsmXL9MADD5xzv6qqKlVVVTnfl5SUuL5wF3l/T134GdkvzsuVAAAQOHx2zE9eXp6OHj2qkSNHOpeFhobq+uuvV05OTqP7ZWRkyG63O19duvjm5aS84+X66tsyBQdZNKwX4QcAAE/x2fBz9Ghdr0hcXMNgEBcX51x3Lunp6SouLna+Dh065NY6L1T9Ja/USzrK3ibEy9UAABA4fP6x4RaLpcF7Y8xZy74vNDRUoaGh7i7rotWHn5H94r1cCQAAgcVne37i4+tCwQ97eQoLC8/qDfI335ZUamf+SUnSyL7+3RYAAPyNz4af7t27Kz4+XtnZ2c5l1dXV2rhxo66++movVnbxsvd8K0ka1LWd4qLCvFwNAACBxauXvcrKyrR//37n+7y8PO3atUsdOnRQ165dNXPmTD399NPq2bOnevbsqaefflpt2rTRXXfd5cWqL57zkldfLnkBAOBpXg0/H3/8sW644Qbn+1mzZkmSJk6cqFdffVWPPPKIKioq9Mtf/lJFRUW68sor9f777ysyMtJbJV+04orT2vL1d5KkG7nFHQAAj7MYY4y3i3CnkpIS2e12FRcXKyoqytvl6O2dhzVzxS71jI1Q9qzrvV0OAAA+yZ3f3z475qe1qr/kdSN3eQEA4BWEHw+qPO3Qhr3HJBF+AADwFsKPB23ed1wVpx1KtIepfyfvX4IDACAQEX486PsTGzY1USMAAHAfwo+H1Dhqtf6Luvl9eJApAADeQ/jxkO0HilR06rTatwnR4KQO3i4HAICARfjxkPpLXsP7xCnYyq8dAABv4VvYQ7Z+Uzex4Yg+sV6uBACAwEb48YCqGof2F5ZJkgZ2bufdYgAACHCEHw/Y922ZamqN7OEhSrDzIFMAALyJ8OMBXxSUSJL6JkRxizsAAF5G+PGAPWfCT58EJjYEAMDbCD8e4Oz5SST8AADgbYQfNzPGaM+R+p6fSC9XAwAACD9udqS4UiWVNQqxWtQzlvADAIC3EX7crL7Xp0dspGzB/LoBAPA2vo3djEteAAD4FsKPm33/NncAAOB9hB8320P4AQDApxB+3Ki08rTyT5ySxBw/AAD4CsKPG315tFSSlGAPU/u2Ni9XAwAAJMKPWzHeBwAA30P4caP6O72Y2RkAAN9B+HEjnukFAIDvIfy4SY2jVnvPjPnhshcAAL6D8OMmecfLVVVTq7Y2q7p2aOPtcgAAwBmEHzepv+TVOyFKQUEWL1cDAADqEX7chMkNAQDwTYQfN/mioG68D4OdAQDwLYQfN+E2dwAAfBPhxw0KSyt1vKxKQRapVxxPcwcAwJcQftyg/pJX9+i2CrdZvVwNAAD4PsKPG9Rf8mK8DwAAvofw4wbOZ3ox3gcAAJ9D+HEDbnMHAMB3EX5crPK0Q98cK5NE+AEAwBcRflxs79FS1RopOsKmmMhQb5cDAAB+gPDjYt9/krvFwmMtAADwNYQfF/uygDu9AADwZYQfFztSXClJPMkdAAAfRfhxscLSKklivA8AAD6K8ONix8+En1jCDwAAPonw40LGGB2j5wcAAJ9G+HGhkooaVTtqJUnREYQfAAB8EeHHhY6V1Q12jgoLVlgIDzQFAMAXEX5cqLDkzHifqDAvVwIAABpD+HGhY2VnxvtwyQsAAJ9F+HEhBjsDAOD7CD8uRPgBAMD3EX5cqJA5fgAA8HmEHxei5wcAAN9H+HEhwg8AAL6P8ONCzru9CD8AAPgswo+LVNfU6kR5tSRudQcAwJcRflzku/K6Xp/gIIvat7F5uRoAANAYwo+L1I/3iY4IVVCQxcvVAACAxhB+XITBzgAA+AfCj4sQfgAA8A+EHxdhgkMAAPwD4cdF6PkBAMA/EH5chPADAIB/IPy4iHOCQ+b4AQDApxF+XKSwtFKSFBtF+AEAwJcRflzAGPN/l70iwrxcDQAAaArhxwXKqmpUebpWkhQdyezOAAD4Mp8OPzU1Nfrtb3+r7t27Kzw8XP/2b/+mOXPmqLa21tulNVDf6xMRGqw2tmAvVwMAAJri09/UzzzzjBYuXKjXXntN/fr108cff6z77rtPdrtdM2bM8HZ5TtzpBQCA//Dp8LNlyxbdcsstGjNmjCQpKSlJb7zxhj7++ONG96mqqlJVVZXzfUlJidvrLCT8AADgN3z6ste1116rDz74QF999ZUk6ZNPPtHmzZv1k5/8pNF9MjIyZLfbna8uXbq4vU56fgAA8B8+3fPz6KOPqri4WL1795bVapXD4dAf/vAH/exnP2t0n/T0dM2aNcv5vqSkxO0BiDl+AADwHz4dflasWKHXX39dy5YtU79+/bRr1y7NnDlTiYmJmjhx4jn3CQ0NVWioZ0MIPT8AAPgPnw4/v/71r/XYY4/ppz/9qSRpwIABOnjwoDIyMhoNP97AQ00BAPAfPj3m59SpUwoKalii1Wr12Vvd6fkBAMD3+XTPz80336w//OEP6tq1q/r166edO3dq/vz5uv/++71dWgOEHwAA/IdPh5//+q//0uzZs/XLX/5ShYWFSkxM1AMPPKAnnnjC26U5OWqNTpQTfgAA8Bc+HX4iIyOVmZmpzMxMb5fSqO/KqlRrpCCL1LEt4QcAAF/n02N+/EH9YOeOEaGyBlm8XA0AADgfws9FYo4fAAD8C+HnIjHYGQAA/0L4uUiEHwAA/Avh5yIdY4JDAAD8CuHnItHzAwCAfyH8XCTCDwAA/oXwc5G42wsAAP9C+LlIhSWVkqTYqDAvVwIAAJqD8HMRyqtqVF7tkMRlLwAA/AXh5yIcP3PJKzzEqrY2q5erAQAAzUH4uQjfH+xssfBoCwAA/AHh5yIUMscPAAB+h/BzEbjNHQAA/0P4uQiEHwAA/A/h5yI4ww9z/AAA4DcIPxfBOcEhPT8AAPgNws9FKCytn+CQ8AMAgL8g/FyE/7vsxezOAAD4C8LPBaqtNTpeVi2Jy14AAPgTws8FKjpVLUetkcUidYywebscAADQTISfC1Q/wWGHNjaFWPk1AgDgL/jWvkDM8QMAgH8i/Fwgwg8AAP6J8HOBnHP8MMEhAAB+hfBzgbp2aKORfeP0o67tvF0KAABogWBvF+CvfjIgQT8ZkODtMgAAQAvR8wMAAAIK4QcAAASUC7rstX37dr355pvKz89XdXV1g3UrV650SWEAAADu0OKen+XLl+uaa67Rnj17tGrVKp0+fVp79uzRP/7xD9ntdnfUCAAA4DItDj9PP/20nnvuOa1evVo2m03PP/+8vvjiC915553q2rWrO2oEAABwmRaHn6+//lpjxoyRJIWGhqq8vFwWi0W/+tWvtGjRIpcXCAAA4EotDj8dOnRQaWmpJKlTp0767LPPJEknT57UqVOnXFsdAACAi7V4wPOQIUOUnZ2tAQMG6M4779SMGTP0j3/8Q9nZ2Ro+fLg7agQAAHCZFoefF154QZWVlZKk9PR0hYSEaPPmzbrttts0e/ZslxcIAADgShZjjPF2Ee5UUlIiu92u4uJiRUVFebscAADQDO78/m7xmB+r1arCwsKzln/33XeyWq0uKQoAAMBdWhx+Gusoqqqqks1mu+iCAAAA3KnZY34WLFggSbJYLPrzn/+siIgI5zqHw6FNmzapd+/erq8QAADAhZodfp577jlJdT0/CxcubHCJy2azKSkpSQsXLnR9hQAAAC7U7PCTl5cnSbrhhhu0cuVKtW/f3m1FAQAAuEuLx/x8+OGHat++vaqrq7V3717V1NS4oy4AAAC3aHH4qaio0KRJk9SmTRv169dP+fn5kqQHH3xQc+fOdXmBAAAArtTi8PPYY4/pk08+0YYNGxQWFuZcPmLECK1YscKlxQEAALhai2d4fvvtt7VixQpdddVVslgszuV9+/bV119/7dLiAAAAXK3FPT/Hjh1TbGzsWcvrn+4OAADgy1ocfq644gqtWbPG+b4+8LzyyitKTU11XWUAAABu0OLLXhkZGRo1apT27NmjmpoaPf/88/r888+1ZcsWbdy40R01AgAAuEyLe36uvvpq/e///q9OnTqlSy65RO+//77i4uK0ZcsWJScnu6NGAAAAl+Gp7gAAwOe48/u7xZe9JKm2tlb79+9XYWGhamtrG6y77rrrXFIYAACAO7Q4/GzdulV33XWXDh48eNYT3i0WixwOh8uKAwAAcLUWh5/JkycrJSVFa9asUUJCAre3AwAAv9Li8LNv3z797W9/U48ePdxRDwAAgFu1+G6vK6+8Uvv373dHLQAAAG7XrJ6fTz/91Pnz9OnT9dBDD+no0aMaMGCAQkJCGmw7cOBA11YIAADgQs261T0oKEgWi+WsAc7ODzmzzhcHPHOrOwAA/sfrt7rn5eW59KAAAADe0qzw061bN91///16/vnnFRkZ6e6aAAAA3KbZA55fe+01VVRUuLMWAAAAt2t2+GnlT8EAAAABokW3ujOhIQAA8HctmuTw0ksvPW8AOnHixEUVBAAA4E4tCj+/+93vZLfb3VULAACA27Uo/Pz0pz9VbGysu2o5p8OHD+vRRx/VunXrVFFRoUsvvVRZWVlKTk72aB0AAKB1aHb48cZ4n6KiIl1zzTW64YYbtG7dOsXGxurrr79Wu3btPF4LAABoHZodfrxxt9czzzyjLl26aMmSJc5lSUlJTe5TVVWlqqoq5/uSkhJ3lQcAAPxQs+/2qq2t9fglr3feeUcpKSm64447FBsbq0GDBumVV15pcp+MjAzZ7Xbnq0uXLh6qFgAA+INmPdvLW8LCwiRJs2bN0h133KFt27Zp5syZevnll3Xvvfeec59z9fx06dKFZ3sBAOBH3PlsL58OPzabTSkpKcrJyXEue/DBB7V9+3Zt2bKlWZ/Bg00BAPA/7vz+btEkh56WkJCgvn37NljWp08f5efne6kiAADg73w6/FxzzTXau3dvg2VfffWVunXr5qWKAACAv/Pp8POrX/1KW7du1dNPP639+/dr2bJlWrRokaZOnert0gAAgJ/y6fBzxRVXaNWqVXrjjTfUv39//cd//IcyMzN19913e7s0AADgp3x6wLMrMOAZAAD/E7ADngEAAFyN8AMAAAIK4QcAAAQUwg8AAAgohB8AABBQCD8AACCgEH4AAEBAIfwAAICAQvgBAAABhfADAAACCuEHAAAEFMIPAAAIKIQfAAAQUAg/AAAgoBB+AABAQCH8AACAgEL4AQAAAYXwAwAAAgrhBwAABBTCDwAACCiEHwAAEFAIPwAAIKAQfgAAQEAh/AAAgIBC+AEAAAGF8AMAAAIK4QcAAAQUwg8AAAgohB8AABBQCD8AACCgEH4AAEBAIfwAAICAQvgBAAABhfADAAACCuEHAAAEFMIPAAAIKIQfAAAQUAg/AAAgoBB+AABAQCH8AACAgEL4AQAAAYXwAwAAAgrhBwAABBTCDwAACCiEHwAAEFAIPwAAIKAQfgAAQEAh/AAAgIAS7O0CAoIxkqNaqqms+7lu4fd+9hOhUZKVvzIAAP/GN5krGSN9vFjKXSJVFkunK868Tkmm1tvVXbwpOVJcP29XAQDARSH8uErJEenv06SvP/B2JQAAoAmEn4tljPTZW9KaWXW9PcFh0rDfSl1TpZDwM682dX9aQyXLmWFWFsuZD7D84L0PszBEDADg/wg/F+PUibrQ8/mquveJg6RbF0kxl3q3LgAA0CjCz4X66n3pnWlS2bdSULB03SPSkFmSNcTblQEAgCYQfi7UoX/WBZ/oXtKtC6VOl3u7IgAA0AyEnwt1/aNSWJQ0+P/VjecBAAB+gfBzoYJt0jUzvF0FAABoIW7fAQAAAYXwAwAAAgrhBwAABBTCDwAACCiEHwAAEFAIPwAAIKAQfgAAQEAh/AAAgIDiV+EnIyNDFotFM2fO9HYpAADAT/lN+Nm+fbsWLVqkgQMHersUAADgx/wi/JSVlenuu+/WK6+8ovbt23u7HAAA4Mf8IvxMnTpVY8aM0YgRI867bVVVlUpKShq8AAAA6vn8g02XL1+uHTt2aPv27c3aPiMjQ7/73e/cXBUAAPBXPt3zc+jQIc2YMUOvv/66wsLCmrVPenq6iouLna9Dhw65uUoAAOBPLMYY4+0iGvP222/r1ltvldVqdS5zOByyWCwKCgpSVVVVg3XnUlJSIrvdruLiYkVFRbm7ZAAA4ALu/P726ctew4cP1+7duxssu++++9S7d289+uij5w0+AAAAP+TT4ScyMlL9+/dvsKxt27bq2LHjWcsBAACaw6fH/AAAALiaT/f8nMuGDRu8XQIAAPBj9PwAAICAQvgBAAABhfADAAACit+N+QEAwOFw6PTp094uAxchJCTEa1PWEH4AAH7DGKOjR4/q5MmT3i4FLtCuXTvFx8fLYrF49LiEHwCA36gPPrGxsWrTpo3HvzThGsYYnTp1SoWFhZKkhIQEjx6f8AMA8AsOh8MZfDp27OjtcnCRwsPDJUmFhYWKjY316CUwBjwDAPxC/RifNm3aeLkSuEr9ufT0+C3CDwDAr3Cpq/Xw1rkk/AAAgIBC+AEAAAGF8AMAQABIS0vT2LFjvV2GTyD8AADgITk5ObJarRo1apRLPu/AgQOyWCzatWuXSz7v+1588UV1795dYWFhSk5O1kcffdTk9gUFBbrrrrvUq1cvBQUFaebMmS6vyVUIPwAAeMjixYs1ffp0bd68Wfn5+d4up1ErVqzQzJkz9fjjj2vnzp0aMmSIRo8e3WTNVVVViomJ0eOPP67LLrvMg9W2HOEHAOC3jDE6VV3j8ZcxpsW1lpeX669//aumTJmim266Sa+++mqz9isqKtLdd9+tmJgYhYeHq2fPnlqyZIkkqXv37pKkQYMGyWKxaOjQoZLq5kSaNWuW2rVrp44dO+qRRx5pUc3z58/XpEmT9POf/1x9+vRRZmamunTpopdeeqnRfZKSkvT888/r3nvvld1ub/axvIFJDgEAfqvitEN9n3jP48fdM+dGtbG17Ct0xYoV6tWrl3r16qUJEyZo+vTpmj179nlv9549e7b27NmjdevWKTo6Wvv371dFRYUkadu2bRo8eLDWr1+vfv36yWazSZLmzZunxYsXKysrS3379tW8efO0atUqDRs27Lx1VldXKzc3V4899liD5SNHjlROTk6L2uyrCD8AAHhAVlaWJkyYIEkaNWqUysrK9MEHH2jEiBFN7pefn69BgwYpJSVFUl0PS72YmBhJUseOHRUfH+9cnpmZqfT0dI0bN06StHDhQr33XvNC4vHjx+VwOBQXF9dgeVxcnI4ePdqsz/B1hB8AgN8KD7Fqz5wbvXLclti7d6+2bdumlStXSpKCg4M1fvx4LV68+LzhZ8qUKRo3bpx27NihkSNHauzYsbr66qsb3b64uFgFBQVKTU11LgsODlZKSkqLLn39sEfKGNNqJpgk/AAA/JbFYmnx5SdvyMrKUk1NjTp16uRcZoxRSEiIioqK1L59+0b3HT16tA4ePKg1a9Zo/fr1Gj58uKZOnapnn33WLbVGR0fLarWe1ctTWFh4Vm+Qv2LAMwAAblRTU6OlS5dq3rx52rVrl/P1ySefqFu3bvrLX/5y3s+IiYlRWlqaXn/9dWVmZmrRokWS5Bzj43A4nNva7XYlJCRo69atDWrIzc1tVr02m03JycnKzs5usDw7O7vJHid/4vtxGQAAP7Z69WoVFRVp0qRJZ90FdfvttysrK0vTpk1rdP8nnnhCycnJ6tevn6qqqrR69Wr16dNHkhQbG6vw8HC9++676ty5s8LCwmS32zVjxgzNnTtXPXv2VJ8+fTR//nydPHmy2TXPmjVL99xzj1JSUpSamqpFixYpPz9fkydPdm6Tnp6uw4cPa+nSpc5l9fMNlZWV6dixY9q1a5dsNpv69u3b7GN7Aj0/AAC4UVZWlkaMGHHO27/HjRunXbt2aceOHY3ub7PZlJ6eroEDB+q6666T1WrV8uXLJdWN5VmwYIFefvllJSYm6pZbbpEkPfTQQ7r33nuVlpam1NRURUZG6tZbb212zePHj1dmZqbmzJmjH/3oR9q0aZPWrl2rbt26ObcpKCg4a96fQYMGadCgQcrNzdWyZcs0aNAg/eQnP2n2cT3FYi5ksgI/UlJSIrvdruLiYkVFRXm7HADABaqsrFReXp5z1mH4v6bOqTu/v+n5AQAAAYXwAwCAF02ePFkRERHnfH1/jI2r5OfnN3q8iIgIn37shqsw4BkAAC+aM2eOHn744XOuc8dwjcTExCYfhJqYmOjyY/oawg8AAF4UGxur2NhYjx0vODhYPXr08NjxfBGXvQAAQEAh/AAAgIBC+AEAAAGF8AMAAAIK4QcAAAQUwg8AAAEgLS1NY8eO9XYZPoHwAwCAh+Tk5MhqtWrUqFEu+bwDBw7IYrE0OW/PhXrxxRedj51ITk7WRx991OT2K1eu1I9//GPFxMQoKipKqampeu+991xelysQfgAA8JDFixdr+vTp2rx5s0/PpLxixQrNnDlTjz/+uHbu3KkhQ4Zo9OjRTda8adMm/fjHP9batWuVm5urG264QTfffLN27tzpwcqbh/ADAPBfxkjV5Z5/XcAzwcvLy/XXv/5VU6ZM0U033aRXX321WfsVFRXp7rvvVkxMjMLDw9WzZ08tWbJEktS9e3dJdU9Tt1gsGjp0qCTJ4XBo1qxZateunTp27KhHHnlELXmO+fz58zVp0iT9/Oc/V58+fZSZmakuXbropZdeanSfzMxMPfLII7riiivUs2dPPf300+rZs6f+53/+p9nH9RRmeAYA+K/Tp6SnvfA4ht8ckWxtW7TLihUr1KtXL/Xq1UsTJkzQ9OnTNXv2bFkslib3mz17tvbs2aN169YpOjpa+/fvV0VFhSRp27ZtGjx4sNavX69+/frJZrNJkubNm6fFixcrKytLffv21bx587Rq1SoNGzbsvHVWV1crNzdXjz32WIPlI0eOVE5OTrPbW1tbq9LSUnXo0KHZ+3gK4QcAAA/IysrShAkTJEmjRo1SWVmZPvjgA40YMaLJ/fLz8zVo0CClpKRIkpKSkpzrYmJiJEkdO3ZUfHy8c3lmZqbS09M1btw4SdLChQubPf7m+PHjcjgciouLa7A8Li5OR48ebdZnSHUBrLy8XHfeeWez9/EUwg8AwH+FtKnrhfHGcVtg79692rZtm1auXCmp7vla48eP1+LFi88bfqZMmaJx48Zpx44dGjlypMaOHaurr7660e2Li4tVUFCg1NRU57Lg4GClpKS06NLXD3ukjDHn7aWq98Ybb+ipp57S3//+d48+t6y5CD8AAP9lsbT48pM3ZGVlqaamRp06dXIuM8YoJCRERUVFat++faP7jh49WgcPHtSaNWu0fv16DR8+XFOnTtWzzz7rllqjo6NltVrP6uUpLCw8qzfoXFasWKFJkybpzTffPG+w8xYGPAMA4EY1NTVaunSp5s2bp127djlfn3zyibp166a//OUv5/2MmJgYpaWl6fXXX1dmZqYWLVokSc4xPg6Hw7mt3W5XQkKCtm7d2qCG3NzcZtVrs9mUnJys7OzsBsuzs7Ob7HGS6np80tLStGzZMo0ZM6ZZx/MGen4AAHCj1atXq6ioSJMmTZLdbm+w7vbbb1dWVpamTZvW6P5PPPGEkpOT1a9fP1VVVWn16tXq06ePJCk2Nlbh4eF699131blzZ4WFhclut2vGjBmaO3euevbsqT59+mj+/Pk6efJks2ueNWuW7rnnHqWkpCg1NVWLFi1Sfn6+Jk+e7NwmPT1dhw8f1tKlSyXVBZ97771Xzz//vK666ipnz1F4ePhZ7fY2en4AAHCjrKwsjRgx4pwBYNy4cdq1a5d27NjR6P42m03p6ekaOHCgrrvuOlmtVi1fvlxS3VieBQsW6OWXX1ZiYqJuueUWSdJDDz2ke++9V2lpaUpNTVVkZKRuvfXWZtc8fvx4ZWZmas6cOfrRj36kTZs2ae3aterWrZtzm4KCggbz/rz88suqqanR1KlTlZCQ4HzNmDGj2cf1FItpyegnP1RSUiK73a7i4mJFRUV5uxwAwAWqrKxUXl6ec9Zh+L+mzqk7v7/p+QEAAAGF8AMAgBdNnjxZERER53x9f4yNq+Tn5zd6vIiICJ9+7IarMOAZAAAvmjNnjh5++OFzrnPHcI3ExMQmH4SamOiFGbM9jPADAIAXxcbGenQiwODgYPXo0cNjx/NFXPYCAAABhfADAAACCuEHAAAEFMIPAAAIKIQfAAAQUAg/AAAEgLS0NI0dO9bbZfgEwg8AAB6Sk5Mjq9WqUaNGueTzDhw4IIvF0uS8PRfqxRdfdD52Ijk5WR999FGT22/evFnXXHONOnbsqPDwcPXu3VvPPfecy+tyBcIPAAAesnjxYk2fPl2bN2/26ZmUV6xYoZkzZ+rxxx/Xzp07NWTIEI0ePbrJmtu2batp06Zp06ZN+uKLL/Tb3/5Wv/3tb7Vo0SIPVt48PNgUAOAXzvUQTGOMKmoqPF5LeHC4LBZLi/YpLy9XQkKCtm/frieffFJ9+/bVE088cd79ioqKNG3aNL3//vsqKytT586d9Zvf/Eb33XffWTVcf/312rBhgxwOh379619r8eLFslqtmjRpkr799lsVFxfr7bffPu8xr7zySl1++eV66aWXnMv69OmjsWPHKiMjo9ltvu2229S2bVv993//9znXe+vBpszwDADwWxU1Fbpy2ZUeP+4/7/qn2oS0adE+K1asUK9evdSrVy9NmDBB06dP1+zZs88bombPnq09e/Zo3bp1io6O1v79+1VRURf4tm3bpsGDB2v9+vXq16+fbDabJGnevHlavHixsrKy1LdvX82bN0+rVq3SsGHDzltndXW1cnNz9dhjjzVYPnLkSOXk5DS7vTt37lROTo5+//vfN3sfTyH8AADgAVlZWZowYYIkadSoUSorK9MHH3ygESNGNLlffn6+Bg0apJSUFElSUlKSc11MTIwkqWPHjoqPj3cuz8zMVHp6usaNGydJWrhwod57771m1Xn8+HE5HA7FxcU1WB4XF6ejR4+ed//OnTvr2LFjqqmp0VNPPaWf//znzTquJxF+AAB+Kzw4XP+8659eOW5L7N27V9u2bdPKlSsl1T1fa/z48Vq8ePF5w8+UKVM0btw47dixQyNHjtTYsWN19dVXN7p9cXGxCgoKlJqa6lwWHByslJQUtWSkyw97pIwxzbrU99FHH6msrExbt27VY489ph49euhnP/tZs4/rCYSfC1RWXaaS6hI5ah06bU7LUeuQwzhUU1sjh3G49djBQcHq17GfW48BAP7AYrG0+PKTN2RlZammpkadOnVyLjPGKCQkREVFRWrfvn2j+44ePVoHDx7UmjVrtH79eg0fPlxTp07Vs88+65Zao6OjZbVaz+rlKSwsPKs36Fy6d+8uSRowYIC+/fZbPfXUU4Sf1uKNL9/Qgp0LvHLs2PBYfXDnB145NgCgZWpqarR06VLNmzdPI0eObLBu3Lhx+stf/qJp06Y1+RkxMTFKS0tTWlqahgwZol//+td69tlnnWN8HI7/+59uu92uhIQEbd26Vdddd52zhtzcXF1++eXnrddmsyk5OVnZ2dm69dZbncuzs7N1yy23NLvdUl3Aq6qqatE+nkD4uUA2q02h1lAFBwXLarEqOChYwZZgWYOsCrIEyaKW3QXQEh3DO7rtswEArrV69WoVFRVp0qRJstvtDdbdfvvtysrKajL8PPHEE0pOTla/fv1UVVWl1atXq0+fPpKk2NhYhYeH691331Xnzp0VFhYmu92uGTNmaO7cuerZs6f69Omj+fPn6+TJk82uedasWbrnnnuUkpKi1NRULVq0SPn5+Zo8ebJzm/T0dB0+fFhLly6VJP3pT39S165d1bt3b0l18/48++yzmj59erOP6ymEnws0sd9ETew30dtlAAB8XFZWlkaMGHFW8JHqen6efvpp7dixo9FeGZvNpvT0dB04cEDh4eEaMmSIli9fLqluLM+CBQs0Z84cPfHEExoyZIg2bNighx56SAUFBUpLS1NQUJDuv/9+3XrrrSouLm5WzePHj9d3332nOXPmqKCgQP3799fatWvVrVs35zYFBQUN5v2pra1Venq68vLyFBwcrEsuuURz587VAw880JJfl0cwzw8AwC80NScM/JO35vnx6RmeMzIydMUVVygyMlKxsbEaO3as9u7d6+2yAACAH/Pp8LNx40ZNnTpVW7duVXZ2tmpqajRy5EiVl5d7uzQAAFxi8uTJioiIOOfr+2NsXCU/P7/R40VERPj0Yzdcxa8uex07dkyxsbHauHGjcwT7+XDZCwBah9Z62auwsFAlJSXnXBcVFaXY2FiXHq+mpkYHDhxodH1SUpKCgz0zJJjHWzRD/UCtDh06NLpNVVVVg9vqGvsLBQCAL4iNjXV5wGlKcHCwevTo4bHj+SKfvuz1fcYYzZo1S9dee6369+/f6HYZGRmy2+3OV5cuXTxYJQDA3fzoggXOw1vn0m/Cz7Rp0/Tpp5/qjTfeaHK79PR0FRcXO1+HDh3yUIUAAHcKCQmRJJ06dcrLlcBV6s9l/bn1FL+47DV9+nS988472rRpkzp37tzktqGhoQoNDfVQZQAAT7FarWrXrp0KCwslSW3atGnWs6bge4wxOnXqlAoLC9WuXTtZrVaPHt+nw48xRtOnT9eqVau0YcMG5/NCAACBqf7J5fUBCP6tXbt2DZ5G7yk+HX6mTp2qZcuW6e9//7siIyOdD1mz2+0KD2/ZE3UBAP7PYrEoISFBsbGxOn36tLfLwUUICQnxeI9PPZ++1b2x7swlS5YoLS2tWZ/Bre4AAPifgL3V3YdzGQAA8FN+c7cXAACAKxB+AABAQPHpy16uUH/pjJmeAQDwH/Xf2+4YAtPqw09paakkMdMzAAB+qLS0VHa73aWf6dN3e7lCbW2tjhw5osjIyAueDKukpERdunTRoUOHWvUdY4HSTom2tkaB0k6JtrZGgdJOqfltNcaotLRUiYmJCgpy7SidVt/zExQUdN5ZoZsrKiqq1f+llAKnnRJtbY0CpZ0SbW2NAqWdUvPa6uoen3oMeAYAAAGF8AMAAAIK4acZQkND9eSTT7b6B6YGSjsl2toaBUo7JdraGgVKOyXfaGurH/AMAADwffT8AACAgEL4AQAAAYXwAwAAAgrhBwAABBTCz3m8+OKL6t69u8LCwpScnKyPPvrI2yU16amnnpLFYmnwio+Pd643xuipp55SYmKiwsPDNXToUH3++ecNPqOqqkrTp09XdHS02rZtq3//93/Xv/71rwbbFBUV6Z577pHdbpfdbtc999yjkydPuq1dmzZt0s0336zExERZLBa9/fbbDdZ7sl35+fm6+eab1bZtW0VHR+vBBx9UdXW1x9qalpZ21jm+6qqr/K6tGRkZuuKKKxQZGanY2FiNHTtWe/fubbBNazmvzWlrazmvL730kgYOHOicwC41NVXr1q1zrm8t5/R87Wwt5/NcMjIyZLFYNHPmTOcyvzuvBo1avny5CQkJMa+88orZs2ePmTFjhmnbtq05ePCgt0tr1JNPPmn69etnCgoKnK/CwkLn+rlz55rIyEjz1ltvmd27d5vx48ebhIQEU1JS4txm8uTJplOnTiY7O9vs2LHD3HDDDeayyy4zNTU1zm1GjRpl+vfvb3JyckxOTo7p37+/uemmm9zWrrVr15rHH3/cvPXWW0aSWbVqVYP1nmpXTU2N6d+/v7nhhhvMjh07THZ2tklMTDTTpk3zWFsnTpxoRo0a1eAcf/fddw228Ye23njjjWbJkiXms88+M7t27TJjxowxXbt2NWVlZc5tWst5bU5bW8t5feedd8yaNWvM3r17zd69e81vfvMbExISYj777DNjTOs5p+drZ2s5nz+0bds2k5SUZAYOHGhmzJjhXO5v55Xw04TBgwebyZMnN1jWu3dv89hjj3mpovN78sknzWWXXXbOdbW1tSY+Pt7MnTvXuayystLY7XazcOFCY4wxJ0+eNCEhIWb58uXObQ4fPmyCgoLMu+++a4wxZs+ePUaS2bp1q3ObLVu2GEnmyy+/dEOrGvphIPBku9auXWuCgoLM4cOHndu88cYbJjQ01BQXF7u9rcbU/aN6yy23NLqPv7a1sLDQSDIbN240xrTu8/rDthrTes+rMca0b9/e/PnPf27V5/T77TSmdZ7P0tJS07NnT5OdnW2uv/56Z/jxx/PKZa9GVFdXKzc3VyNHjmywfOTIkcrJyfFSVc2zb98+JSYmqnv37vrpT3+qb775RpKUl5eno0ePNmhTaGiorr/+emebcnNzdfr06QbbJCYmqn///s5ttmzZIrvdriuvvNK5zVVXXSW73e6V340n27Vlyxb1799fiYmJzm1uvPFGVVVVKTc3163t/L4NGzYoNjZWl156qX7xi1+osLDQuc5f21pcXCxJ6tChg6TWfV5/2NZ6re28OhwOLV++XOXl5UpNTW215/SH7azX2s7n1KlTNWbMGI0YMaLBcn88r63+waYX6vjx43I4HIqLi2uwPC4uTkePHvVSVed35ZVXaunSpbr00kv17bff6ve//72uvvpqff755866z9WmgwcPSpKOHj0qm82m9u3bn7VN/f5Hjx5VbGzsWceOjY31yu/Gk+06evToWcdp3769bDabx9o+evRo3XHHHerWrZvy8vI0e/ZsDRs2TLm5uQoNDfXLthpjNGvWLF177bXq37+/8/j1df+wHf58Xs/VVql1ndfdu3crNTVVlZWVioiI0KpVq9S3b1/nF1hrOaeNtVNqXedTkpYvX64dO3Zo+/btZ63zx/9WCT/nYbFYGrw3xpy1zJeMHj3a+fOAAQOUmpqqSy65RK+99ppzsN2FtOmH25xre2//bjzVLm+3ffz48c6f+/fvr5SUFHXr1k1r1qzRbbfd1uh+vtzWadOm6dNPP9XmzZvPWtfazmtjbW1N57VXr17atWuXTp48qbfeeksTJ07Uxo0bGz2+v57TxtrZt2/fVnU+Dx06pBkzZuj9999XWFhYo9v503nlslcjoqOjZbVaz0qShYWFZ6VOX9a2bVsNGDBA+/btc9711VSb4uPjVV1draKioia3+fbbb8861rFjx7zyu/Fku+Lj4886TlFRkU6fPu21vxcJCQnq1q2b9u3bJ8n/2jp9+nS98847+vDDD9W5c2fn8tZ4Xhtr67n483m12Wzq0aOHUlJSlJGRocsuu0zPP/98qzunjbXzXPz5fObm5qqwsFDJyckKDg5WcHCwNm7cqAULFig4ONh5HL86r80eHRSABg8ebKZMmdJgWZ8+fXx6wPMPVVZWmk6dOpnf/e53zkFpzzzzjHN9VVXVOQelrVixwrnNkSNHzjko7Z///Kdzm61bt3p9wLMn2lU/2O7IkSPObZYvX+7RAc8/dPz4cRMaGmpee+01Y4z/tLW2ttZMnTrVJCYmmq+++uqc61vLeT1fW8/FX8/ruQwbNsxMnDixVZ3Tptp5Lv58PktKSszu3bsbvFJSUsyECRPM7t27/fK8En6aUH+re1ZWltmzZ4+ZOXOmadu2rTlw4IC3S2vUQw89ZDZs2GC++eYbs3XrVnPTTTeZyMhIZ81z5841drvdrFy50uzevdv87Gc/O+ftiJ07dzbr1683O3bsMMOGDTvn7YgDBw40W7ZsMVu2bDEDBgxw663upaWlZufOnWbnzp1Gkpk/f77ZuXOnc9oBT7Wr/jbL4cOHmx07dpj169ebzp07u/S20qbaWlpaah566CGTk5Nj8vLyzIcffmhSU1NNp06d/K6tU6ZMMXa73WzYsKHB7cCnTp1ybtNazuv52tqazmt6errZtGmTycvLM59++qn5zW9+Y4KCgsz7779vjGk957Spdram89mY79/tZYz/nVfCz3n86U9/Mt26dTM2m81cfvnlDW5N9UX1cyuEhISYxMREc9ttt5nPP//cub62ttY8+eSTJj4+3oSGhprrrrvO7N69u8FnVFRUmGnTppkOHTqY8PBwc9NNN5n8/PwG23z33Xfm7rvvNpGRkSYyMtLcfffdpqioyG3t+vDDD42ks171/5flyXYdPHjQjBkzxoSHh5sOHTqYadOmmcrKSo+09dSpU2bkyJEmJibGhISEmK5du5qJEyee1Q5/aOu52ijJLFmyxLlNazmv52trazqv999/v/PfzJiYGDN8+HBn8DGm9ZzTptrZms5nY34YfvztvFqMMab5F8kAAAD8GwOeAQBAQCH8AACAgEL4AQAAAYXwAwAAAgrhBwAABBTCDwAACCiEHwAAEFAIPwAAIKAQfgD4hKFDh2rmzJneLgNAAGCGZwA+4cSJEwoJCVFkZKSSkpI0c+ZMwhAAtwj2dgEAIEkdOnRw+WdWV1fLZrO5/HMB+DcuewHwCfWXvYYOHaqDBw/qV7/6lSwWiywWi3ObnJwcXXfddQoPD1eXLl304IMPqry83Lk+KSlJv//975WWlia73a5f/OIXqq6u1rRp05SQkKCwsDAlJSUpIyPDG00E4CMIPwB8ysqVK9W5c2fNmTNHBQUFKigokCTt3r1bN954o2677TZ9+umnWrFihTZv3qxp06Y12P+Pf/yj+vfvr9zcXM2ePVsLFizQO++8o7/+9a/au3evXn/9dSUlJXmhZQB8BZe9APiUDh06yGq1KjIyUvHx8c7lf/zjH3XXXXc5xwH17NlTCxYs0PXXX6+XXnpJYWFhkqRhw4bp4Ycfdu6Xn5+vnj176tprr5XFYlG3bt082h4AvoeeHwB+ITc3V6+++qoiIiKcrxtvvFG1tbXKy8tzbpeSktJgv7S0NO3atUu9evXSgw8+qPfff9/TpQPwMfT8APALtbW1euCBB/Tggw+eta5r167On9u2bdtg3eWXX668vDytW7dO69ev15133qkRI0bob3/7m9trBuCbCD8AfI7NZpPD4Wiw7PLLL9fnn3+uHj16tPjzoqKiNH78eI0fP1633367Ro0apRMnTrjlDjMAvo/LXgB8TlJSkjZt2qTDhw/r+PHjkqRHH31UW7Zs0dSpU7Vr1y7t27dP77zzjqZPn97kZz333HNavny5vvzyS3311Vd68803FR8fr3bt2nmgJQB8EeEHgM+ZM2eODhw4oEsuuUQxMTGSpIEDB2rjxo3at2+fhgwZokGDBmn27NlKSEho8rMiIiL0zDPPKCUlRVdccYUOHDigtWvXKiiIf/6AQMUMzwAAIKDwvz4AACCgEH4AAEBAIfwAAICAQvgBAAABhfADAAACCuEHAAAEFMIPAAAIKIQfAAAQUAg/AAAgoBB+AABAQCH8AACAgPL/AY+RDBuF+Qz4AAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "util.plot_lines(iters, ys = ys[\"thetas\"][\"A\"], x_label='iters', y_label='Theta', labels = labels[\"A\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "id": "cc56cb6c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "plotting B_std_0.1\n", + "plotting B_std_0.2\n", + "plotting B_std_0.3\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "util.plot_lines(iters, ys = ys[\"thetas\"][\"B\"], x_label='iters', y_label='Theta', labels = labels[\"B\"])" + ] + }, + { + "cell_type": "markdown", + "id": "f0c184d8", + "metadata": {}, + "source": [ + "# (d)" + ] + }, + { + "cell_type": "markdown", + "id": "5c729b10", + "metadata": {}, + "source": [ + "### (d) [3 points] Are support vector machines, which use the hinge loss, vulnerable to datasets like B? Why or why not? Give an informal justification." + ] + }, + { + "cell_type": "markdown", + "id": "b878748e", + "metadata": {}, + "source": [ + "Ans:" + ] + }, + { + "cell_type": "markdown", + "id": "00e7ef1f", + "metadata": {}, + "source": [ + "$$ Loss(\\theta) = max(0, 1 - xy\\theta)$$" + ] + }, + { + "cell_type": "markdown", + "id": "3de40357", + "metadata": {}, + "source": [ + "$$grad(\\theta) = 0 \\, \\leftarrow \\,(for \\, correct \\, forecasts \\, with \\, xy\\theta \\, \\geq 1)$$" + ] + }, + { + "cell_type": "markdown", + "id": "428d2e15", + "metadata": {}, + "source": [ + "$$grad(\\theta) = -xy \\, \\leftarrow \\,(for \\, wrong \\, forecasts)$$" + ] + }, + { + "cell_type": "markdown", + "id": "315de6c0", + "metadata": {}, + "source": [ + "In the case of correct forecasts, the Loss=0. Only for wrong forecasts, the loss is $1 - xy\\theta$. For linearly separable case, the loss can quickly get to 0 and cannot be lowered further by increasing the magnitude of $\\theta$. Therefore, it is not vulnerable to datasets like B." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "95f89c51", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import sys\n", + "SCRIPT_DIR = os.path.dirname(os.path.abspath(\"__file__\"))\n", + "SCRIPT_DIR_PARENT = os.path.dirname(SCRIPT_DIR)\n", + "sys.path.append(os.path.dirname(SCRIPT_DIR_PARENT))\n", + "from PS2.src import util\n", + "from PS2.src.p01_lr import logistic_regression_modified\n", + "import numpy as np\n", + "from collections import defaultdict\n", + "\n", + "Xa, Ya = util.load_csv('../data/ds1_a.csv', add_intercept=True)\n", + "Xb, Yb = util.load_csv('../data/ds1_b.csv', add_intercept=True)\n", + "\n", + "max_iters = 50000\n", + "log_step = 499 # odd number so as to avoid missing oscillations in vals in alternating steps\n", + "iters = range(log_step, max_iters + 1, log_step)\n", + "\n", + "def hinge_loss(X, Y, theta, l2_reg_coef):\n", + " m, n = X.shape\n", + " loss = (1/m) * np.sum(np.maximum(0, 1 - Y * X.dot(theta)))\n", + " regularization = (l2_reg_coef / 2) * np.sum(theta[1:]**2)\n", + " return loss + regularization\n", + "\n", + "\n", + "def hinge_grad(X, Y, theta):\n", + " m, n = X.shape\n", + " margin = Y * X.dot(theta)\n", + " mask = margin < 1\n", + " dw = -(1/m) * X.T.dot(Y * mask)\n", + " return dw" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "23a6f1ef", + "metadata": {}, + "outputs": [], + "source": [ + "# (d) applying gaussian noise to labels\n", + "\n", + "grads_a, thetas_a, norms_a, losses_a = logistic_regression_modified(Xa, Ya, max_iters=max_iters, \n", + " log_step=log_step, learning_rate=10)\n", + "grads_b, thetas_b, norms_b, losses_b = logistic_regression_modified(Xb, Yb, max_iters=max_iters,\n", + " log_step=log_step, learning_rate=10)\n", + " \n", + "ys[\"norms\"][\"A\"].append(norms_a[:, 1])\n", + "ys[\"norms\"][\"B\"].append(norms_b[:, 1])\n", + "\n", + "ys[\"grads\"][\"A\"].append(grads_a[:, 1])\n", + "ys[\"grads\"][\"B\"].append(grads_b[:, 1])\n", + "\n", + "ys[\"thetas\"][\"A\"].append(thetas_a[:, 1])\n", + "ys[\"thetas\"][\"B\"].append(thetas_b[:, 1])\n", + "\n", + "ys[\"losses\"][\"A\"].append(losses_a[:, 1])\n", + "ys[\"losses\"][\"B\"].append(losses_b[:, 1])\n", + " \n", + "labels[\"A\"].append(f\"A\")\n", + "labels[\"B\"].append(f\"B\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/problem-sets/PS2/MHA's notebooks/.ipynb_checkpoints/PS2_P2-checkpoint.ipynb b/problem-sets/PS2/MHA's notebooks/.ipynb_checkpoints/PS2_P2-checkpoint.ipynb new file mode 100644 index 0000000..7a92562 --- /dev/null +++ b/problem-sets/PS2/MHA's notebooks/.ipynb_checkpoints/PS2_P2-checkpoint.ipynb @@ -0,0 +1,210 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "0c65cb0d", + "metadata": {}, + "source": [ + "# Question 2" + ] + }, + { + "cell_type": "markdown", + "id": "c92abfad", + "metadata": {}, + "source": [ + "### (a)\n", + "**[5 points] Show that the above property holds true for the described logistic regression model over the range (a, b) = (0, 1). \n", + "Hint: Use the fact that we include a bias term**" + ] + }, + { + "cell_type": "markdown", + "id": "37d3bd73", + "metadata": {}, + "source": [ + "$$P(y = 1|x; \\theta) = h_\\theta(x) = \\frac{1}{1 + e^{-\\theta^Tx}}, \\quad I_{a,b} = \\{i|i \\in \\{1, \\ldots, m\\}, h_\\theta(x^{(i)}) \\in (a, b)\\}$$" + ] + }, + { + "cell_type": "markdown", + "id": "1a62f2cb", + "metadata": {}, + "source": [ + "**Ans:** \n", + "We have to show that the mean of all probs forecast by the model is equal to the fraction of ones in the original dataset. " + ] + }, + { + "cell_type": "markdown", + "id": "894e477d", + "metadata": {}, + "source": [ + "We know that the probability range (0, 1) covers all datapoints." + ] + }, + { + "cell_type": "markdown", + "id": "954e5207", + "metadata": {}, + "source": [ + "The intercept term translates the sigmoid curve, which originally intersects the y(or probability) axis at 0.5. " + ] + }, + { + "cell_type": "markdown", + "id": "161f2a8b", + "metadata": {}, + "source": [ + "We want to show that:\n", + "\n", + "$$ \\frac{1}{m} \\sum_{i=1}^{m} \\frac{1}{1+e^{-\\theta^{T}x^{(i)}}} = \\frac{1}{m} \\sum_{i=1}^{m} \\mathbf{I} \\{ y^{(i)} = 1 \\} $$\n", + "\n", + "after the model using this function for predicting probabilities has converged to its optimal state.\n", + "\n", + "### Likelihood\n", + "\n", + "$$ \\prod_{i=1}^{m} P(y^{(i)} \\mid x^{(i)}) $$\n", + "\n", + "### Log Likelihood\n", + "\n", + "$$ \\sum_{i=1}^{m} \\log P(y^{(i)} \\mid x^{(i)}) $$\n", + "\n", + "Let $h(x^{(i)}) = \\frac{1}{1+e^{-\\theta^{T}x^{(i)}}}$\n", + "\n", + "$$ L = \\sum_{i=1}^{m} \\left( \\log (h(x^{(i)})) y^{(i)} + \\log (1 - h(x^{(i)})) (1 - y^{(i)}) \\right) $$\n", + "\n", + "After training, we want the gradient to be zero for maximum likelihood.\n", + "\n", + "### Sigmoid Function\n", + "\n", + "The sigmoid function is defined as:\n", + "\n", + "$$ \\sigma(z) = \\frac{1}{1 + e^{-z}} $$\n", + "\n", + "To derive its derivative, we start by differentiating $\\sigma(z)$ with respect to $z$:\n", + "\n", + "$$ \\frac{\\partial \\sigma}{\\partial z} = \\frac{\\partial}{\\partial z} \\left( \\frac{1}{1 + e^{-z}} \\right) $$\n", + "\n", + "Using the chain rule, we get:\n", + "\n", + "$$ \\frac{\\partial \\sigma}{\\partial z} = \\frac{1}{(1 + e^{-z})^2} \\cdot \\frac{\\partial}{\\partial z} (1 + e^{-z}) $$\n", + "\n", + "$$ \\frac{\\partial \\sigma}{\\partial z} = \\frac{1}{(1 + e^{-z})^2} \\cdot (-e^{-z}) $$\n", + "\n", + "Since $\\sigma(z) = \\frac{1}{1 + e^{-z}}$, we have $1 - \\sigma(z) = \\frac{e^{-z}}{1 + e^{-z}}$. Thus:\n", + "\n", + "$$ \\frac{\\partial \\sigma}{\\partial z} = \\sigma(z) (1 - \\sigma(z)) $$\n", + "\n", + "\n", + "### Gradient of Log\n", + "$$ \\frac{\\partial \\log(z)}{\\partial x} = \\frac{1}{z} \\frac{\\partial z}{\\partial x} $$\n", + "\n", + "Let $z = \\theta^T x$, then\n", + "\n", + "$$ \\frac{\\partial \\sigma}{\\partial z} = \\sigma (1 - \\sigma) $$\n", + "\n", + "### Gradient of the Log Likelihood\n", + "\n", + "$$ \\frac{\\partial L}{\\partial \\theta} = \\frac{\\partial L}{\\partial h} . \\frac{\\partial h}{\\partial \\theta}$$\n", + "\n", + "$$ \\frac{\\partial L}{\\partial h} = \\sum_{i=1}^{m} \\left( \\frac{y^{(i)}}{h(x^{(i)})} - \\frac{1 - y^{(i)}}{1 - h(x^{(i)})} \\right) $$\n", + "\n", + "$$ \\frac{\\partial L}{\\partial \\theta} = \\sum_{i=1}^{m} \\left( \\frac{y^{(i)}}{h(x^{(i)})} - \\frac{1 - y^{(i)}}{1 - h(x^{(i)})} \\right)\\left( h(x^{(i)}) (1 - h(x^{(i)})) \\right) x^{(i)} $$\n", + "\n", + "$$ = \\sum_{i=1}^{m} \\left( y^{(i)} - h(x^{(i)}) \\right) x^{(i)} $$\n", + "\n", + "Since $\\frac{\\partial L}{\\partial \\theta} = 0$:\n", + "\n", + "$$ \\sum_{i=1}^{m} \\left( y^{(i)} - h(x^{(i)}) \\right) x_j^{(i)} = 0 $$\n", + "\n", + "Let's set $x_j^{(i)} = 1$ because it will make evaluation easier. Since $x_j^{(i)} = 1$ for all $i$:\n", + "\n", + "$$ \\sum_{i=1}^{m} \\left( y^{(i)} - h(x^{(i)}) \\right) 1 = 0 $$\n", + "\n", + "$$ \\sum_{i=1}^{m} y^{(i)} = \\sum_{i=1}^{m} h(x^{(i)}) $$\n", + "\n", + "This is exactly what we set out to prove to begin with.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "f0d1f9e1", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "eab8672d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def sigmoid(z):\n", + " return 1 / (1 + np.exp(-z))\n", + "\n", + "def plot_sigmoid_with_bias(X, slope, bias_values):\n", + " plt.figure(figsize=(12, 8))\n", + " for bias in bias_values:\n", + " theta = np.array([bias, slope])\n", + " z = np.dot(X, theta)\n", + " y = sigmoid(z)\n", + " plt.plot(X[:, 1], y, label=f'Bias = {bias}')\n", + " \n", + " plt.title('Sigmoid Curve with Different Bias Values')\n", + " plt.xlabel('X')\n", + " plt.ylabel('y')\n", + " plt.legend()\n", + " plt.grid(True)\n", + " plt.show()\n", + "\n", + "# Generate input data\n", + "X = np.column_stack((np.ones(100), np.linspace(-10, 10, 100)))\n", + "\n", + "# Set slope and bias values to test\n", + "slope = 0.7\n", + "bias_values = [-5, -2, 0, 2, 5]\n", + "\n", + "# Plot sigmoid curves\n", + "plot_sigmoid_with_bias(X, slope, bias_values)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/problem-sets/PS2/MHA's notebooks/PS2_P1.ipynb b/problem-sets/PS2/MHA's notebooks/PS2_P1.ipynb new file mode 100644 index 0000000..985dd68 --- /dev/null +++ b/problem-sets/PS2/MHA's notebooks/PS2_P1.ipynb @@ -0,0 +1,1396 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "434b7bba-ab2c-4595-b3d6-5aa7152e3dfb", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import sys\n", + "SCRIPT_DIR = os.path.dirname(os.path.abspath(\"__file__\"))\n", + "SCRIPT_DIR_PARENT = os.path.dirname(SCRIPT_DIR)\n", + "sys.path.append(os.path.dirname(SCRIPT_DIR_PARENT))\n", + "\n", + "from PS2.src import util\n", + "from PS2.src.p01_lr import logistic_regression_modified\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "7ad972a6-a11f-4f75-b6d0-76f8c8b0038d", + "metadata": {}, + "outputs": [], + "source": [ + "Xa, Ya = util.load_csv('../data/ds1_a.csv', add_intercept=False)\n", + "Xb, Yb = util.load_csv('../data/ds1_b.csv', add_intercept=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "4562fa2a-ef15-4f52-8293-4b8263e3cc26", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "util.plot_points(Xa, Ya)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "0ce74347-0803-4b4b-8527-fb1622306e2e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "util.plot_points(Xb, Yb)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "6723bdd6-6ddc-4f60-a9bb-938e4940bbce", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Converged in 30395 iterations\n", + "Could not converge in 400000 epochs\n" + ] + } + ], + "source": [ + "Xa, Ya = util.load_csv('../data/ds1_a.csv', add_intercept=True)\n", + "Xb, Yb = util.load_csv('../data/ds1_b.csv', add_intercept=True)\n", + "\n", + "grads_a, thetas_a, _ = logistic_regression_modified(Xa, Ya)\n", + "grads_b, thetas_b, _ = logistic_regression_modified(Xb, Yb)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "de505346-48ce-4595-8f21-4ff5ba9924b3", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "util.plot_line(grads_a[:, 0], grads_a[:, 1], grads_a[:, 2])" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "d948fd70-4dcd-40e5-9fb5-98df5703c71a", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "util.plot_line(grads_b[:, 0], grads_b[:, 1], grads_b[:, 2])" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "e144a55e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "util.plot_line(thetas_a[:, 0], thetas_a[:, 1], thetas_a[:, 2])" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "be9ab7f9", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "util.plot_line(thetas_b[:, 0], thetas_b[:, 1], thetas_b[:, 2])" + ] + }, + { + "cell_type": "markdown", + "id": "a118e8f4", + "metadata": {}, + "source": [ + "# Ans 1(a)" + ] + }, + { + "cell_type": "markdown", + "id": "72fa27b0", + "metadata": {}, + "source": [ + "Most notable difference between the two datasets is dataset B being linearly separable and dataset A not being linearly separable." + ] + }, + { + "cell_type": "markdown", + "id": "b1ecbb46", + "metadata": {}, + "source": [ + "# Ans 1(b)" + ] + }, + { + "cell_type": "markdown", + "id": "e171fcf2", + "metadata": {}, + "source": [ + "Init step:\n", + "$$\\theta = zeros(X.shape[1:])$$\n", + "\n", + "Update step:\n", + "\n", + "$$\\theta = \\theta - \\alpha \\cdot grad$$\n", + "\n", + "where:\n", + "\n", + "$$grad = -\\frac{1}{m} X^T \\left(\\frac{Y}{1 + e^{Y (X \\cdot \\theta)}}\\right)$$\n", + "$$m = num \\space of \\space examples$$" + ] + }, + { + "cell_type": "markdown", + "id": "b43f4e4c", + "metadata": {}, + "source": [ + "Let's start by looking at each feature of X individually. The constant of integration will represent the integral values for the other features.\n", + "\n", + "$$Loss(\\theta) = -\\int{\\left(\\frac{xy}{1 + e^{yx\\theta}}\\right)}d\\theta$$\n", + "Let u = $xy\\theta$. Then,\n", + "$$\\frac{du}{d\\theta} = xy$$\n", + "$$ du = xyd\\theta$$\n", + "\n", + "So, the integral becomes:\n", + "$$ Loss(\\theta) = -\\int{\\left(\\frac{1}{1 + e^u}\\right)}du $$\n", + "for a single example this is:\n", + "$$ Loss(\\theta) = ln(e^u + 1) - u $$\n", + "$$ Loss(\\theta) = ln(e^{xy\\theta} + 1) - xy\\theta $$" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "e4a7f6e4", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "step = 3\n", + "max_theta = 30\n", + "min_theta = 1\n", + "n_correct = 9\n", + "n_incorrect = 1\n", + "\n", + "def loss(theta, correct=True):\n", + " xy = 1\n", + " if not correct:\n", + " xy = -1\n", + " return np.log(np.exp(xy*theta) + 1) - (xy*theta)\n", + " \n", + " \n", + "losses = []\n", + "for theta in range(1, 30, 3):\n", + " losses.append([theta, loss(theta, True)*n_correct, loss(theta, False)*n_incorrect])\n", + "\n", + "losses = np.array(losses)\n", + "# print(losses)\n", + "util.plot_line(losses[:, 0], losses[:, 1], losses[:, 2])" + ] + }, + { + "cell_type": "markdown", + "id": "f093cb8f", + "metadata": {}, + "source": [ + "$xy\\theta$ is positive for a correctly classified point and negative for an incorrectly classified one.\n", + "1. For the linearly inseparable case (i.e. the case with some incorrectly classified points): \n", + " As an example, let's assume that there are 10 examples, 9 forecast correctly and 1 incorrectly. \n", + " - As $\\theta$ increases, initially the decrease in loss caused by 9 correctly labeled examples is enough to encourage increasing its value, but at some point the total loss caused by the single wrong example overcomes this drop. Therefore the incorrect example acts as a regularizer. \n", + " - As $\\theta$ increases, given that $xy\\theta$ is negative for wrong labels, $e^{xy\\theta}$ becomes close to 0. This means that $ln(e^{xy\\theta} + 1) \\rightarrow 0$, so $- xy\\theta $ becomes the dominant contributor to the loss, and the $Loss$ increases quickly. \n", + " \n", + "2. For the linearly separable case (i.e. with all examples correctly labeled): \n", + " - As $\\theta$ increases, the loss goes down and continues to decrease, therefore the algorithm tries to continue to increase theta in magnitude.\n", + " - As $\\theta$ increases, given that $xy\\theta$ is positive for correct labels, $e^{xy\\theta}$ becomes large. This means that $ln(e^{xy\\theta} + 1) \\rightarrow xy\\theta$, so $- xy\\theta $ and the $Loss \\rightarrow 0$. \n", + "\n", + "However, we also observe that the gradient for the linearly separable case continues to drop over time, so if the threshold was large enough, we should see early stopping." + ] + }, + { + "cell_type": "markdown", + "id": "8836ed3a", + "metadata": {}, + "source": [ + "(c) [5 points] For each of these possible modifications, state whether or not it would lead to\n", + "the provided training algorithm converging on datasets such as B. Justify your answers.\n", + "\n", + " 1. Using a different constant learning rate. \n", + " 1. Decreasing the learning rate over time (e.g. scaling the initial learning rate by $\\frac{1}{t^2}$, where t is the number of gradient descent iterations thus far). \n", + " 1. Linear scaling of the input features. \n", + " 1. Adding a regularization term $||\\theta||^2_2$ to the loss function. \n", + " 1. Adding zero-mean Gaussian noise to the training data or labels." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "28ffee3d", + "metadata": {}, + "outputs": [], + "source": [ + "# Experiments\n", + "import os\n", + "import sys\n", + "SCRIPT_DIR = os.path.dirname(os.path.abspath(\"__file__\"))\n", + "SCRIPT_DIR_PARENT = os.path.dirname(SCRIPT_DIR)\n", + "sys.path.append(os.path.dirname(SCRIPT_DIR_PARENT))\n", + "from PS2.src import util\n", + "from PS2.src.p01_lr import logistic_regression_modified\n", + "import numpy as np\n", + "\n", + "Xa, Ya = util.load_csv('../data/ds1_a.csv', add_intercept=True)\n", + "Xb, Yb = util.load_csv('../data/ds1_b.csv', add_intercept=True)\n", + "\n", + "log_step = 10000\n", + "max_iters = 400000\n", + "iters = range(log_step, max_iters+1, log_step)" + ] + }, + { + "cell_type": "markdown", + "id": "102b0ac5", + "metadata": {}, + "source": [ + "# 1" + ] + }, + { + "cell_type": "markdown", + "id": "7f358158", + "metadata": {}, + "source": [ + " ### Using a different constant learning rate." + ] + }, + { + "cell_type": "markdown", + "id": "ffcbd33d", + "metadata": {}, + "source": [ + "### No" + ] + }, + { + "cell_type": "markdown", + "id": "259e6a3c", + "metadata": {}, + "source": [ + " \n", + " 1. FOR DATASET B: If we increase the learning rate by 10 times (to 100), the delta of theta for each step would change by roughly 10 times. For the following step, the gradient should decrease by less than 10 times since it is flattening out, so the norm would actually be bigger for each iteration, and the linalg would take even longer (dataset B) to get within the threshold. Decreasing the learning rate to a small enough value could theoretically lead to convergence but the parameters learned would likely be unhelpful due to premature convergence. \n", + " FOR DATASET A: Increasing could lead to oscillating around the optimum leading to non-convergence, while decreasing would cause convergence to take longer." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "d6bb2e62", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "training for learning rate: 1\n", + "Converged in 278192 iterations\n", + "Could not converge in 400000 epochs\n", + "training for learning rate: 10\n", + "Converged in 30395 iterations\n", + "Could not converge in 400000 epochs\n", + "training for learning rate: 100\n", + "Could not converge in 400000 epochs\n", + "Could not converge in 400000 epochs\n" + ] + } + ], + "source": [ + "# (1)\n", + "def train(learning_rates):\n", + " labels = {\"A\": [], \"B\": []}\n", + " ys = {\"A\": [], \"B\": []}\n", + " for lr in learning_rates:\n", + " print(f\"training for learning rate: {lr}\")\n", + " _, _, norms_a, _ = logistic_regression_modified(Xa, Ya, learning_rate=lr)\n", + " _, _, norms_b, _ = logistic_regression_modified(Xb, Yb, learning_rate=lr)\n", + " ys[\"A\"].append(norms_a[:, 1])\n", + " ys[\"B\"].append(norms_b[:, 1])\n", + " labels[\"A\"].append(f\"A_lr_{lr}\")\n", + " labels[\"B\"].append(f\"B_lr_{lr}\")\n", + " return ys, labels\n", + " \n", + "ys, labels = train([1, 10, 100])" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "4b2ff2b3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "plotting A_lr_1\n", + "plotting A_lr_10\n", + "plotting A_lr_100\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "util.plot_lines(iters, ys = ys[\"A\"], x_label='iters', y_label='Norm', labels = labels[\"A\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "52c71713", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "plotting B_lr_1\n", + "plotting B_lr_10\n", + "plotting B_lr_100\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "util.plot_lines(iters, ys = ys[\"B\"], x_label='iters', y_label='Norm', labels = labels[\"B\"])" + ] + }, + { + "cell_type": "markdown", + "id": "9ea1db3a", + "metadata": {}, + "source": [ + "# 2" + ] + }, + { + "cell_type": "markdown", + "id": "377f4258", + "metadata": {}, + "source": [ + "### Decreasing the learning rate over time (e.g. scaling the initial learning rate by $\\frac{1}{t^2}$, where t is the number of gradient descent iterations thus far). " + ] + }, + { + "cell_type": "markdown", + "id": "ff00600d", + "metadata": {}, + "source": [ + "### Yes" + ] + }, + { + "cell_type": "markdown", + "id": "b3d275b9", + "metadata": {}, + "source": [ + "Both datasets converge quickly because the early stopping criteria evaluates the change in the values of theta and if learning rate drops enough, this change can become lower than the min threshold, leading to convergence. Whether this value of theta is useful or not, is a different question." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "ea53cc1a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Converged in 11 iterations\n", + "Converged in 11 iterations\n" + ] + } + ], + "source": [ + "# (2)\n", + "decay=lambda t, lr: lr*(1/t**2)\n", + "\n", + "# original learning rate\n", + "_, _, norms_a, _ = logistic_regression_modified(Xa, Ya, learning_rate=10, decay=decay)\n", + "_, _, norms_b, _ = logistic_regression_modified(Xb, Yb, learning_rate=10, decay=decay)\n" + ] + }, + { + "cell_type": "markdown", + "id": "ad213c51", + "metadata": {}, + "source": [ + "# 3" + ] + }, + { + "cell_type": "markdown", + "id": "045ed3e4", + "metadata": {}, + "source": [ + "### Linear scaling of the input features. " + ] + }, + { + "cell_type": "markdown", + "id": "df8c6f79", + "metadata": {}, + "source": [ + "### No" + ] + }, + { + "cell_type": "markdown", + "id": "8d1982f4", + "metadata": {}, + "source": [ + "$$grad = -\\frac{1}{m} X^T \\left(\\frac{Y}{1 + e^{Y (X \\cdot \\theta)}}\\right)$$\n", + "$$m = num \\space of \\space examples$$" + ] + }, + { + "cell_type": "markdown", + "id": "1b2af3e6", + "metadata": {}, + "source": [ + "If $X$ is doubled, then the gradient would become:\n", + "$$grad = -\\frac{1}{m} 2X^T \\left(\\frac{Y}{1 + e^{Y (2X \\cdot \\theta)}}\\right)$$" + ] + }, + { + "cell_type": "markdown", + "id": "e1156963", + "metadata": {}, + "source": [ + "In the case of correct labels, $xy\\theta > 0$, which means that $-xy <= grad <= 0$. \n", + "In the case of incorrect labels, $xy\\theta < 0$, which means that $-2xy <= grad <= -xy$." + ] + }, + { + "cell_type": "markdown", + "id": "b3faa7f7", + "metadata": {}, + "source": [ + "If $X$ is scaled by 5 times: \n", + "For correct labels, the gradient approaches 0 even quicker than before. \n", + "For incorrect labels, the gradient approaches $-\\frac{5}{2}xy$. \n", + " \n", + "This basically means that for dataset A (linearly inseparable), this has an effect similar to that of increasing the learning rate for incorrect examples, and decreasing it for the correct examples. \n", + " \n", + "For dataset B (linearly separable), its effect is similar to that of reducing the overall learning rate, which we already showed above is unlikely to have a significant affect on convergence, unless the scale is large enough to force the early stopping criteria to be met." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "28e09be0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "training for scale: 0.1\n", + "Could not converge in 400000 epochs\n", + "Could not converge in 400000 epochs\n", + "training for scale: 1\n", + "Converged in 30395 iterations\n", + "Could not converge in 400000 epochs\n", + "training for scale: 5\n", + "Could not converge in 400000 epochs\n", + "Could not converge in 400000 epochs\n" + ] + } + ], + "source": [ + "# (3)\n", + "def train(scales):\n", + " labels = {\"A\": [], \"B\": []}\n", + " ys = {\"A\": [], \"B\": []}\n", + " for scale in scales:\n", + " print(f\"training for scale: {scale}\")\n", + " _, _, norms_a, _ = logistic_regression_modified(scale*Xa, Ya)\n", + " _, _, norms_b, _ = logistic_regression_modified(scale*Xb, Yb)\n", + " ys[\"A\"].append(norms_a[:, 1])\n", + " ys[\"B\"].append(norms_b[:, 1])\n", + " labels[\"A\"].append(f\"A_scale_{scale}\")\n", + " labels[\"B\"].append(f\"B_scale_{scale}\")\n", + " return ys, labels\n", + " \n", + "ys, labels = train([0.1, 1, 5])" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "97cb6962", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "plotting A_scale_0.1\n", + "plotting A_scale_1\n", + "plotting A_scale_5\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "util.plot_lines(iters, ys = ys[\"A\"], x_label='iters', y_label='Norm', labels = labels[\"A\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "4e50f27a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "plotting B_scale_0.1\n", + "plotting B_scale_1\n", + "plotting B_scale_5\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "util.plot_lines(iters, ys = ys[\"B\"], x_label='iters', y_label='Norm', labels = labels[\"B\"])" + ] + }, + { + "cell_type": "markdown", + "id": "158edceb", + "metadata": {}, + "source": [ + "# 4" + ] + }, + { + "cell_type": "markdown", + "id": "e147b8af", + "metadata": {}, + "source": [ + "### Adding a regularization term $||\\theta||^2_2$ to the loss function. " + ] + }, + { + "cell_type": "markdown", + "id": "f6933f9c", + "metadata": {}, + "source": [ + "### Yes" + ] + }, + { + "cell_type": "markdown", + "id": "ff7ccb5f", + "metadata": {}, + "source": [ + "$$ Loss(\\theta) = ln(e^{xy\\theta} + 1) - xy\\theta + \\gamma\\theta^2 \\space (\\leftarrow L2 \\space norm)$$" + ] + }, + { + "cell_type": "markdown", + "id": "95bd2f52", + "metadata": {}, + "source": [ + "$$grad = -\\frac{1}{m} X^T \\left(\\frac{Y}{1 + e^{Y (X \\cdot \\theta)}}\\right) + \\gamma\\frac{2\\theta}{m}$$\n", + "$$m = num \\space of \\space examples$$" + ] + }, + { + "cell_type": "markdown", + "id": "c96bc018", + "metadata": {}, + "source": [ + "Convergence is sped up by adding regularization by limiting the size of theta. However, if the value of $\\gamma$ is increased beyond a certain value, then the loss is dominated by the regularization term and the current value of learning rate might be too large leading to oscillation. So, the learning rate may have to be lowered." + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "745f2389", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import sys\n", + "SCRIPT_DIR = os.path.dirname(os.path.abspath(\"__file__\"))\n", + "SCRIPT_DIR_PARENT = os.path.dirname(SCRIPT_DIR)\n", + "sys.path.append(os.path.dirname(SCRIPT_DIR_PARENT))\n", + "from PS2.src import util\n", + "from PS2.src.p01_lr import logistic_regression_modified\n", + "import numpy as np\n", + "from collections import defaultdict\n", + "\n", + "Xa, Ya = util.load_csv('../data/ds1_a.csv', add_intercept=True)\n", + "Xb, Yb = util.load_csv('../data/ds1_b.csv', add_intercept=True)\n", + "\n", + "max_iters = 20000\n", + "log_step = 499 # odd number so as to avoid missing oscillations in vals in alternating steps\n", + "iters = range(log_step, max_iters + 1, log_step)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "5c282e8d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "training for l2_coef: 0.1\n", + "Converged in 15154 iterations\n", + "Converged in 16611 iterations\n", + "training for l2_coef: 0.2\n", + "Converged in 8547 iterations\n", + "Converged in 8775 iterations\n", + "training for l2_coef: 0.5\n", + "Converged in 4115 iterations\n", + "Converged in 4009 iterations\n" + ] + } + ], + "source": [ + "# (4)\n", + "def train(l2_coefs):\n", + " labels = defaultdict(list)\n", + " ys = {\"norms\": defaultdict(list), \"grads\": defaultdict(list), \"thetas\": defaultdict(list), \"losses\": defaultdict(list)}\n", + " for c in l2_coefs:\n", + " print(f\"training for l2_coef: {c}\")\n", + " grads_a, thetas_a, norms_a, losses_a = logistic_regression_modified(Xa, Ya, max_iters=max_iters, learning_rate=1,\n", + " log_step=log_step, l2_reg_coef=c)\n", + " grads_b, thetas_b, norms_b, losses_b = logistic_regression_modified(Xb, Yb, max_iters=max_iters, learning_rate=1,\n", + " log_step=log_step, l2_reg_coef=c)\n", + " ys[\"norms\"][\"A\"].append(norms_a[:, 1])\n", + " ys[\"norms\"][\"B\"].append(norms_b[:, 1])\n", + " \n", + " ys[\"grads\"][\"A\"].append(grads_a[:, 1])\n", + " ys[\"grads\"][\"B\"].append(grads_b[:, 1])\n", + " \n", + " ys[\"thetas\"][\"A\"].append(thetas_a[:, 1])\n", + " ys[\"thetas\"][\"B\"].append(thetas_b[:, 1])\n", + " \n", + " ys[\"losses\"][\"A\"].append(losses_a[:, 1])\n", + " ys[\"losses\"][\"B\"].append(losses_b[:, 1])\n", + " \n", + " labels[\"A\"].append(f\"A_l2_coef_{c}\")\n", + " labels[\"B\"].append(f\"B_l2_coef_{c}\")\n", + " return ys, labels\n", + "\n", + "ys, labels = train([0.1, 0.2, 0.5])" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "f14a00be", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "plotting A_l2_coef_0.1\n", + "plotting A_l2_coef_0.2\n", + "plotting A_l2_coef_0.5\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "util.plot_lines(iters, ys = ys[\"thetas\"][\"A\"], x_label='iters', y_label='Theta', labels = labels[\"A\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "4878baca", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "plotting B_l2_coef_0.1\n", + "plotting B_l2_coef_0.2\n", + "plotting B_l2_coef_0.5\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "util.plot_lines(iters, ys = ys[\"thetas\"][\"B\"], x_label='iters', y_label='Theta', labels = labels[\"B\"])" + ] + }, + { + "cell_type": "markdown", + "id": "9f06327a", + "metadata": {}, + "source": [ + "# 5" + ] + }, + { + "cell_type": "markdown", + "id": "3099d046", + "metadata": {}, + "source": [ + "### Adding zero-mean Gaussian noise to the training data or labels." + ] + }, + { + "cell_type": "markdown", + "id": "8ba6337e", + "metadata": {}, + "source": [ + "### Maybe (depends on whether adding noise will make the data inseparable or not)" + ] + }, + { + "cell_type": "markdown", + "id": "a098eeb8", + "metadata": {}, + "source": [ + "Adding noise to the inputs can make the data linearly inseparable thereby making it possible to converge. If adding the noise still doesn't make the data linearly inseparable, the model will still not converge. \n", + "Adding noise to the labels doesn't make a significant difference unless the signs of the labels change. If the signs don't change, but the magnitude reduces, then there may be a chance of the change in theta getting to within the early stopping threshold." + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "id": "6e1def3d", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import sys\n", + "SCRIPT_DIR = os.path.dirname(os.path.abspath(\"__file__\"))\n", + "SCRIPT_DIR_PARENT = os.path.dirname(SCRIPT_DIR)\n", + "sys.path.append(os.path.dirname(SCRIPT_DIR_PARENT))\n", + "from PS2.src import util\n", + "from PS2.src.p01_lr import logistic_regression_modified\n", + "import numpy as np\n", + "from collections import defaultdict\n", + "\n", + "Xa, Ya = util.load_csv('../data/ds1_a.csv', add_intercept=True)\n", + "Xb, Yb = util.load_csv('../data/ds1_b.csv', add_intercept=True)\n", + "\n", + "max_iters = 50000\n", + "log_step = 499 # odd number so as to avoid missing oscillations in vals in alternating steps\n", + "iters = range(log_step, max_iters + 1, log_step)\n", + "\n", + "\n", + "def add_gaussian_noise(data, mean=0, std=0.1):\n", + " noise = np.random.normal(mean, std, data.shape)\n", + " return data + noise" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "id": "bd391b2b", + "metadata": {}, + "outputs": [], + "source": [ + "# (5) applying gaussian noise to labels\n", + "def train(stds, mode):\n", + " labels = defaultdict(list)\n", + " ys = {\"norms\": defaultdict(list), \"grads\": defaultdict(list), \"thetas\": defaultdict(list), \"losses\": defaultdict(list)}\n", + " for std in stds:\n", + " print(f\"training for std: {std}\")\n", + "\n", + " if mode == \"labels\":\n", + " Ya_ = add_gaussian_noise(Ya, std=std)\n", + " Yb_ = add_gaussian_noise(Yb, std=std)\n", + " grads_a, thetas_a, norms_a, losses_a = logistic_regression_modified(Xa, Ya_, max_iters=max_iters, \n", + " log_step=log_step, learning_rate=10)\n", + " grads_b, thetas_b, norms_b, losses_b = logistic_regression_modified(Xb, Yb_, max_iters=max_iters,\n", + " log_step=log_step, learning_rate=10)\n", + " else:\n", + " Xa_ = add_gaussian_noise(Xa, std=std)\n", + " Xb_ = add_gaussian_noise(Xb, std=std)\n", + " grads_a, thetas_a, norms_a, losses_a = logistic_regression_modified(Xa_, Ya, max_iters=max_iters, \n", + " log_step=log_step, learning_rate=1)\n", + " grads_b, thetas_b, norms_b, losses_b = logistic_regression_modified(Xb_, Yb, max_iters=max_iters,\n", + " log_step=log_step, learning_rate=1)\n", + " \n", + " ys[\"norms\"][\"A\"].append(norms_a[:, 1])\n", + " ys[\"norms\"][\"B\"].append(norms_b[:, 1])\n", + " \n", + " ys[\"grads\"][\"A\"].append(grads_a[:, 1])\n", + " ys[\"grads\"][\"B\"].append(grads_b[:, 1])\n", + " \n", + " ys[\"thetas\"][\"A\"].append(thetas_a[:, 1])\n", + " ys[\"thetas\"][\"B\"].append(thetas_b[:, 1])\n", + " \n", + " ys[\"losses\"][\"A\"].append(losses_a[:, 1])\n", + " ys[\"losses\"][\"B\"].append(losses_b[:, 1])\n", + " \n", + " labels[\"A\"].append(f\"A_std_{std}\")\n", + " labels[\"B\"].append(f\"B_std_{std}\")\n", + " return ys, labels" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "id": "3ec10ff2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "training for std: 0.2\n", + "Converged in 37384 iterations\n", + "Could not converge in 50000 epochs\n", + "training for std: 0.5\n", + "Converged in 21811 iterations\n", + "Could not converge in 50000 epochs\n", + "training for std: 1\n", + "Could not converge in 50000 epochs\n", + "Converged in 1374 iterations\n" + ] + } + ], + "source": [ + "ys, labels = train([.2, .5, 1], \"labels\")" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "id": "0f56cfd1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "plotting A_std_0.2\n", + "plotting A_std_0.5\n", + "plotting A_std_1\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "util.plot_lines(iters, ys = ys[\"thetas\"][\"A\"], x_label='iters', y_label='Theta', labels = labels[\"A\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "id": "6a19816a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "plotting B_std_0.2\n", + "plotting B_std_0.5\n", + "plotting B_std_1\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "util.plot_lines(iters, ys = ys[\"thetas\"][\"B\"], x_label='iters', y_label='Theta', labels = labels[\"B\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "id": "d4e58067", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "training for std: 0.1\n", + "Converged in 38490 iterations\n", + "Could not converge in 50000 epochs\n", + "training for std: 0.2\n", + "Converged in 5379 iterations\n", + "Converged in 8639 iterations\n", + "training for std: 0.3\n", + "Converged in 2761 iterations\n", + "Converged in 2361 iterations\n" + ] + } + ], + "source": [ + "ys, labels = train([.1, .2, .3], \"input\")" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "id": "4d0c330f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "plotting A_std_0.1\n", + "plotting A_std_0.2\n", + "plotting A_std_0.3\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "util.plot_lines(iters, ys = ys[\"thetas\"][\"A\"], x_label='iters', y_label='Theta', labels = labels[\"A\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "id": "fff7da1c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "plotting B_std_0.1\n", + "plotting B_std_0.2\n", + "plotting B_std_0.3\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "util.plot_lines(iters, ys = ys[\"thetas\"][\"B\"], x_label='iters', y_label='Theta', labels = labels[\"B\"])" + ] + }, + { + "cell_type": "markdown", + "id": "86003a9a", + "metadata": {}, + "source": [ + "# (d)" + ] + }, + { + "cell_type": "markdown", + "id": "a52353ab", + "metadata": {}, + "source": [ + "### (d) [3 points] Are support vector machines, which use the hinge loss, vulnerable to datasets like B? Why or why not? Give an informal justification." + ] + }, + { + "cell_type": "markdown", + "id": "51f6c737", + "metadata": {}, + "source": [ + "Ans:" + ] + }, + { + "cell_type": "markdown", + "id": "16f899ab", + "metadata": {}, + "source": [ + "$$ Loss(\\theta) = max(0, 1 - xy\\theta)$$" + ] + }, + { + "cell_type": "markdown", + "id": "c037caab", + "metadata": {}, + "source": [ + "$$grad(\\theta) = 0 \\, \\leftarrow \\,(for \\, correct \\, forecasts \\, with \\, xy\\theta \\, \\geq 1)$$" + ] + }, + { + "cell_type": "markdown", + "id": "adb897f4", + "metadata": {}, + "source": [ + "$$grad(\\theta) = -xy \\, \\leftarrow \\,(for \\, wrong \\, forecasts)$$" + ] + }, + { + "cell_type": "markdown", + "id": "bde9e052", + "metadata": {}, + "source": [ + "In the case of correct forecasts, the Loss=0. Only for wrong forecasts, the loss is $1 - xy\\theta$. For linearly separable case, the loss can quickly get to 0 and cannot be lowered further by increasing the magnitude of $\\theta$. Therefore, it is not vulnerable to datasets like B." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "cd15a549", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import sys\n", + "SCRIPT_DIR = os.path.dirname(os.path.abspath(\"__file__\"))\n", + "SCRIPT_DIR_PARENT = os.path.dirname(SCRIPT_DIR)\n", + "sys.path.append(os.path.dirname(SCRIPT_DIR_PARENT))\n", + "from PS2.src import util\n", + "from PS2.src.p01_lr import logistic_regression_modified\n", + "import numpy as np\n", + "from collections import defaultdict\n", + "\n", + "Xa, Ya = util.load_csv('../data/ds1_a.csv', add_intercept=True)\n", + "Xb, Yb = util.load_csv('../data/ds1_b.csv', add_intercept=True)\n", + "\n", + "max_iters = 400000\n", + "log_step = 499 # odd number so as to avoid missing oscillations in vals in alternating steps\n", + "iters = range(log_step, max_iters + 1, log_step)\n", + "\n", + "def hinge_loss(X, Y, theta, l2_reg_coef):\n", + " m, n = X.shape\n", + " loss = (1/m) * np.sum(np.maximum(0, 1 - Y * X.dot(theta)))\n", + " regularization = (l2_reg_coef / 2) * np.sum(theta[1:]**2)\n", + " return loss + regularization\n", + "\n", + "\n", + "def hinge_grad(X, Y, theta):\n", + " m, n = X.shape\n", + " margin = Y * X.dot(theta)\n", + " mask = margin < 1\n", + " dw = -(1/m) * X.T.dot(Y * mask)\n", + " return dw" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "7152dc2d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training A\n", + "Could not converge in 400000 epochs\n", + "Training B\n", + "Converged in 93858 iterations\n" + ] + } + ], + "source": [ + "# (d) applying gaussian noise to labels\n", + "print(\"Training A\")\n", + "grads_a, thetas_a, norms_a, losses_a = logistic_regression_modified(Xa, Ya, max_iters=max_iters, loss_func=hinge_loss,\n", + " grad_func=hinge_grad,\n", + " log_step=log_step, learning_rate=0.2)\n", + "\n", + "print(\"Training B\")\n", + "grads_b, thetas_b, norms_b, losses_b = logistic_regression_modified(Xb, Yb, max_iters=max_iters, loss_func=hinge_loss,\n", + " grad_func=hinge_grad,\n", + " log_step=log_step, learning_rate=20)\n", + "\n", + "labels = defaultdict(list)\n", + "ys = {\"norms\": defaultdict(list), \"grads\": defaultdict(list), \"thetas\": defaultdict(list), \"losses\": defaultdict(list)}\n", + " \n", + "ys[\"norms\"][\"A\"].append(norms_a[:, 1])\n", + "ys[\"norms\"][\"B\"].append(norms_b[:, 1])\n", + "\n", + "ys[\"grads\"][\"A\"].append(grads_a[:, 1])\n", + "ys[\"grads\"][\"B\"].append(grads_b[:, 1])\n", + "\n", + "ys[\"thetas\"][\"A\"].append(thetas_a[:, 1])\n", + "ys[\"thetas\"][\"B\"].append(thetas_b[:, 1])\n", + "\n", + "ys[\"losses\"][\"A\"].append(losses_a[:, 1])\n", + "ys[\"losses\"][\"B\"].append(losses_b[:, 1])\n", + " \n", + "labels[\"A\"].append(f\"A\")\n", + "labels[\"B\"].append(f\"B\")" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "5a67fd70", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "plotting A\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "util.plot_lines(iters, ys = ys[\"thetas\"][\"A\"], x_label='iters', y_label='Theta', labels = labels[\"A\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "0fc2e62a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "plotting B\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "util.plot_lines(iters, ys = ys[\"thetas\"][\"B\"], x_label='iters', y_label='Theta', labels = labels[\"B\"])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "788ca8b1", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/problem-sets/PS2/MHA's notebooks/PS2_P2.ipynb b/problem-sets/PS2/MHA's notebooks/PS2_P2.ipynb new file mode 100644 index 0000000..7a92562 --- /dev/null +++ b/problem-sets/PS2/MHA's notebooks/PS2_P2.ipynb @@ -0,0 +1,210 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "0c65cb0d", + "metadata": {}, + "source": [ + "# Question 2" + ] + }, + { + "cell_type": "markdown", + "id": "c92abfad", + "metadata": {}, + "source": [ + "### (a)\n", + "**[5 points] Show that the above property holds true for the described logistic regression model over the range (a, b) = (0, 1). \n", + "Hint: Use the fact that we include a bias term**" + ] + }, + { + "cell_type": "markdown", + "id": "37d3bd73", + "metadata": {}, + "source": [ + "$$P(y = 1|x; \\theta) = h_\\theta(x) = \\frac{1}{1 + e^{-\\theta^Tx}}, \\quad I_{a,b} = \\{i|i \\in \\{1, \\ldots, m\\}, h_\\theta(x^{(i)}) \\in (a, b)\\}$$" + ] + }, + { + "cell_type": "markdown", + "id": "1a62f2cb", + "metadata": {}, + "source": [ + "**Ans:** \n", + "We have to show that the mean of all probs forecast by the model is equal to the fraction of ones in the original dataset. " + ] + }, + { + "cell_type": "markdown", + "id": "894e477d", + "metadata": {}, + "source": [ + "We know that the probability range (0, 1) covers all datapoints." + ] + }, + { + "cell_type": "markdown", + "id": "954e5207", + "metadata": {}, + "source": [ + "The intercept term translates the sigmoid curve, which originally intersects the y(or probability) axis at 0.5. " + ] + }, + { + "cell_type": "markdown", + "id": "161f2a8b", + "metadata": {}, + "source": [ + "We want to show that:\n", + "\n", + "$$ \\frac{1}{m} \\sum_{i=1}^{m} \\frac{1}{1+e^{-\\theta^{T}x^{(i)}}} = \\frac{1}{m} \\sum_{i=1}^{m} \\mathbf{I} \\{ y^{(i)} = 1 \\} $$\n", + "\n", + "after the model using this function for predicting probabilities has converged to its optimal state.\n", + "\n", + "### Likelihood\n", + "\n", + "$$ \\prod_{i=1}^{m} P(y^{(i)} \\mid x^{(i)}) $$\n", + "\n", + "### Log Likelihood\n", + "\n", + "$$ \\sum_{i=1}^{m} \\log P(y^{(i)} \\mid x^{(i)}) $$\n", + "\n", + "Let $h(x^{(i)}) = \\frac{1}{1+e^{-\\theta^{T}x^{(i)}}}$\n", + "\n", + "$$ L = \\sum_{i=1}^{m} \\left( \\log (h(x^{(i)})) y^{(i)} + \\log (1 - h(x^{(i)})) (1 - y^{(i)}) \\right) $$\n", + "\n", + "After training, we want the gradient to be zero for maximum likelihood.\n", + "\n", + "### Sigmoid Function\n", + "\n", + "The sigmoid function is defined as:\n", + "\n", + "$$ \\sigma(z) = \\frac{1}{1 + e^{-z}} $$\n", + "\n", + "To derive its derivative, we start by differentiating $\\sigma(z)$ with respect to $z$:\n", + "\n", + "$$ \\frac{\\partial \\sigma}{\\partial z} = \\frac{\\partial}{\\partial z} \\left( \\frac{1}{1 + e^{-z}} \\right) $$\n", + "\n", + "Using the chain rule, we get:\n", + "\n", + "$$ \\frac{\\partial \\sigma}{\\partial z} = \\frac{1}{(1 + e^{-z})^2} \\cdot \\frac{\\partial}{\\partial z} (1 + e^{-z}) $$\n", + "\n", + "$$ \\frac{\\partial \\sigma}{\\partial z} = \\frac{1}{(1 + e^{-z})^2} \\cdot (-e^{-z}) $$\n", + "\n", + "Since $\\sigma(z) = \\frac{1}{1 + e^{-z}}$, we have $1 - \\sigma(z) = \\frac{e^{-z}}{1 + e^{-z}}$. Thus:\n", + "\n", + "$$ \\frac{\\partial \\sigma}{\\partial z} = \\sigma(z) (1 - \\sigma(z)) $$\n", + "\n", + "\n", + "### Gradient of Log\n", + "$$ \\frac{\\partial \\log(z)}{\\partial x} = \\frac{1}{z} \\frac{\\partial z}{\\partial x} $$\n", + "\n", + "Let $z = \\theta^T x$, then\n", + "\n", + "$$ \\frac{\\partial \\sigma}{\\partial z} = \\sigma (1 - \\sigma) $$\n", + "\n", + "### Gradient of the Log Likelihood\n", + "\n", + "$$ \\frac{\\partial L}{\\partial \\theta} = \\frac{\\partial L}{\\partial h} . \\frac{\\partial h}{\\partial \\theta}$$\n", + "\n", + "$$ \\frac{\\partial L}{\\partial h} = \\sum_{i=1}^{m} \\left( \\frac{y^{(i)}}{h(x^{(i)})} - \\frac{1 - y^{(i)}}{1 - h(x^{(i)})} \\right) $$\n", + "\n", + "$$ \\frac{\\partial L}{\\partial \\theta} = \\sum_{i=1}^{m} \\left( \\frac{y^{(i)}}{h(x^{(i)})} - \\frac{1 - y^{(i)}}{1 - h(x^{(i)})} \\right)\\left( h(x^{(i)}) (1 - h(x^{(i)})) \\right) x^{(i)} $$\n", + "\n", + "$$ = \\sum_{i=1}^{m} \\left( y^{(i)} - h(x^{(i)}) \\right) x^{(i)} $$\n", + "\n", + "Since $\\frac{\\partial L}{\\partial \\theta} = 0$:\n", + "\n", + "$$ \\sum_{i=1}^{m} \\left( y^{(i)} - h(x^{(i)}) \\right) x_j^{(i)} = 0 $$\n", + "\n", + "Let's set $x_j^{(i)} = 1$ because it will make evaluation easier. Since $x_j^{(i)} = 1$ for all $i$:\n", + "\n", + "$$ \\sum_{i=1}^{m} \\left( y^{(i)} - h(x^{(i)}) \\right) 1 = 0 $$\n", + "\n", + "$$ \\sum_{i=1}^{m} y^{(i)} = \\sum_{i=1}^{m} h(x^{(i)}) $$\n", + "\n", + "This is exactly what we set out to prove to begin with.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "f0d1f9e1", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "eab8672d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def sigmoid(z):\n", + " return 1 / (1 + np.exp(-z))\n", + "\n", + "def plot_sigmoid_with_bias(X, slope, bias_values):\n", + " plt.figure(figsize=(12, 8))\n", + " for bias in bias_values:\n", + " theta = np.array([bias, slope])\n", + " z = np.dot(X, theta)\n", + " y = sigmoid(z)\n", + " plt.plot(X[:, 1], y, label=f'Bias = {bias}')\n", + " \n", + " plt.title('Sigmoid Curve with Different Bias Values')\n", + " plt.xlabel('X')\n", + " plt.ylabel('y')\n", + " plt.legend()\n", + " plt.grid(True)\n", + " plt.show()\n", + "\n", + "# Generate input data\n", + "X = np.column_stack((np.ones(100), np.linspace(-10, 10, 100)))\n", + "\n", + "# Set slope and bias values to test\n", + "slope = 0.7\n", + "bias_values = [-5, -2, 0, 2, 5]\n", + "\n", + "# Plot sigmoid curves\n", + "plot_sigmoid_with_bias(X, slope, bias_values)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/problem-sets/PS2/MHA's notebooks/__init__.py b/problem-sets/PS2/MHA's notebooks/__init__.py new file mode 100644 index 0000000..f012f1c --- /dev/null +++ b/problem-sets/PS2/MHA's notebooks/__init__.py @@ -0,0 +1,6 @@ +import os +import sys + +SCRIPT_DIR = os.path.dirname(os.path.abspath("__file__")) +SCRIPT_DIR_PARENT = os.path.dirname(SCRIPT_DIR) +sys.path.append(os.path.dirname(SCRIPT_DIR_PARENT)) \ No newline at end of file diff --git a/problem-sets/PS2/__init__.py b/problem-sets/PS2/__init__.py new file mode 100644 index 0000000..f012f1c --- /dev/null +++ b/problem-sets/PS2/__init__.py @@ -0,0 +1,6 @@ +import os +import sys + +SCRIPT_DIR = os.path.dirname(os.path.abspath("__file__")) +SCRIPT_DIR_PARENT = os.path.dirname(SCRIPT_DIR) +sys.path.append(os.path.dirname(SCRIPT_DIR_PARENT)) \ No newline at end of file diff --git a/problem-sets/PS2/__pycache__/__init__.cpython-311.pyc b/problem-sets/PS2/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000..09dc5a4 Binary files /dev/null and b/problem-sets/PS2/__pycache__/__init__.cpython-311.pyc differ diff --git a/problem-sets/PS2/__pycache__/__init__.cpython-312.pyc b/problem-sets/PS2/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000..9f93bd3 Binary files /dev/null and b/problem-sets/PS2/__pycache__/__init__.cpython-312.pyc differ diff --git a/problem-sets/PS2/data/.ipynb_checkpoints/ds1_a-checkpoint.csv b/problem-sets/PS2/data/.ipynb_checkpoints/ds1_a-checkpoint.csv new file mode 100644 index 0000000..a239df4 --- /dev/null +++ b/problem-sets/PS2/data/.ipynb_checkpoints/ds1_a-checkpoint.csv @@ -0,0 +1,101 @@ +y,x0,x1 +-1.000000000000000000e+00,6.012660321346644521e-01,1.650910586864833274e-01 +1.000000000000000000e+00,8.717253403947561319e-01,5.273606284195629934e-01 +-1.000000000000000000e+00,3.725479744663405812e-01,4.466090687037850282e-01 +-1.000000000000000000e+00,1.357664310444239852e-02,5.135778964393811208e-02 +1.000000000000000000e+00,5.830316375912952820e-01,7.106191307030319537e-01 +1.000000000000000000e+00,9.084797126970022285e-01,1.752718002509726647e-01 +-1.000000000000000000e+00,3.999644820298295933e-01,4.739952831980015491e-01 +1.000000000000000000e+00,8.325367962545292544e-01,5.980482975033334370e-01 +-1.000000000000000000e+00,4.816405545569502067e-03,9.844565337131838678e-01 +-1.000000000000000000e+00,7.499084384207852505e-01,4.542354333273501688e-02 +1.000000000000000000e+00,6.787728052832739944e-01,9.244621614802555065e-01 +-1.000000000000000000e+00,2.955893587048743498e-01,3.491424901113958645e-01 +-1.000000000000000000e+00,2.036023752010092114e-01,5.920026826758448824e-01 +-1.000000000000000000e+00,2.198870010022596633e-01,4.525792858555204301e-01 +-1.000000000000000000e+00,1.454150156442755026e-01,8.284065671346926285e-01 +-1.000000000000000000e+00,2.507999560886482460e-01,5.412252402844155430e-01 +-1.000000000000000000e+00,4.454069172249203179e-01,9.642287028245233316e-02 +1.000000000000000000e+00,2.533909449181281914e-02,9.541419533675528086e-01 +1.000000000000000000e+00,8.795209274605995109e-01,9.807605212599779243e-01 +1.000000000000000000e+00,7.941665553454693161e-01,4.595618235830615239e-01 +-1.000000000000000000e+00,2.692782581937129827e-01,3.045600108717329002e-01 +-1.000000000000000000e+00,5.269267778019376403e-01,1.446119313623852598e-01 +-1.000000000000000000e+00,6.425484830157719429e-01,1.444312811956353082e-01 +-1.000000000000000000e+00,2.762516897555838957e-01,2.210722138600362818e-02 +-1.000000000000000000e+00,5.583924564641318256e-01,3.164687286818336220e-01 +-1.000000000000000000e+00,2.075942837293226484e-01,5.810765156019325195e-01 +-1.000000000000000000e+00,5.865040077341432401e-01,1.730316178976930575e-01 +-1.000000000000000000e+00,3.805484638713033663e-01,6.717623204463272213e-01 +-1.000000000000000000e+00,3.813986396562527581e-01,3.077646651653764831e-02 +-1.000000000000000000e+00,4.899248660762223206e-01,4.167626968687931921e-02 +1.000000000000000000e+00,6.682081706177449565e-01,6.628198755504333128e-01 +-1.000000000000000000e+00,3.421034653103514067e-01,7.363192575332345724e-01 +1.000000000000000000e+00,8.337479918488441832e-01,1.573775395900884888e-01 +-1.000000000000000000e+00,4.923674631211191199e-01,3.888211557841462218e-01 +-1.000000000000000000e+00,2.746871724354470468e-01,2.194037119875775765e-01 +1.000000000000000000e+00,9.514244202703872055e-01,7.517850107244149482e-01 +1.000000000000000000e+00,7.222970233828414077e-01,6.293849395650549239e-01 +1.000000000000000000e+00,7.221358438649915223e-01,9.296141057040921973e-01 +-1.000000000000000000e+00,1.351819603026834793e-01,1.854270482295840017e-01 +1.000000000000000000e+00,6.847589110633647280e-01,3.005782511358631170e-01 +1.000000000000000000e+00,9.167839007195689449e-01,7.608979395120699651e-01 +-1.000000000000000000e+00,7.296113795807901425e-02,4.672119711166422551e-01 +1.000000000000000000e+00,8.453793119640681253e-01,7.107858693353201751e-01 +1.000000000000000000e+00,8.758550459041712921e-01,5.390947722932232233e-01 +-1.000000000000000000e+00,6.680240193628613765e-01,4.079056712401981644e-01 +-1.000000000000000000e+00,1.942797580183325268e-01,6.786361588339889783e-01 +-1.000000000000000000e+00,6.992478452176446035e-01,2.772214675572326481e-02 +1.000000000000000000e+00,4.856696344043648361e-01,6.878385389105863279e-01 +-1.000000000000000000e+00,1.532187070142976282e-01,7.760493991951687986e-01 +1.000000000000000000e+00,4.260091802091322544e-01,8.316101224643255296e-01 +1.000000000000000000e+00,7.730169346598478874e-01,8.167050106762755446e-01 +1.000000000000000000e+00,2.811591409918925422e-01,7.915812228496058589e-01 +-1.000000000000000000e+00,3.969712841861736674e-01,5.436956492094292548e-01 +-1.000000000000000000e+00,1.561845853065626510e-01,1.149413637944906030e-01 +-1.000000000000000000e+00,5.462254340670188446e-01,2.775432517674987221e-01 +1.000000000000000000e+00,9.147298002684245422e-01,8.771582557983079731e-01 +1.000000000000000000e+00,5.480483804952250848e-01,5.571056036752553009e-01 +1.000000000000000000e+00,8.750401697283192171e-01,9.688990899668680212e-01 +-1.000000000000000000e+00,8.693212797165661421e-02,4.463068285614146813e-01 +1.000000000000000000e+00,4.598375862902908118e-01,8.810994801265042975e-01 +-1.000000000000000000e+00,3.757937993395965570e-02,3.157852668502673099e-01 +-1.000000000000000000e+00,1.644957474326235181e-01,7.126782272435483456e-01 +-1.000000000000000000e+00,4.696837654443807297e-01,7.651211500270849175e-02 +-1.000000000000000000e+00,3.457483908016467655e-01,6.395094766845679235e-01 +1.000000000000000000e+00,8.106231383282292979e-01,4.007879765862863986e-01 +-1.000000000000000000e+00,2.198238787111499448e-01,3.812991804733401047e-01 +-1.000000000000000000e+00,7.804157051854651028e-01,1.695647137097033852e-01 +-1.000000000000000000e+00,1.332143858129445357e-01,6.990228277977402760e-01 +1.000000000000000000e+00,2.147236390512209381e-01,8.529417155381071591e-01 +1.000000000000000000e+00,8.302333072606401521e-01,4.886383657396295987e-01 +1.000000000000000000e+00,6.565655768761827771e-01,6.457323732473402300e-01 +1.000000000000000000e+00,7.214153912553155079e-01,2.401191402571628553e-01 +-1.000000000000000000e+00,1.323621993588250945e-01,3.770522982995052619e-01 +-1.000000000000000000e+00,4.977100693580231994e-01,6.548100620049546183e-02 +-1.000000000000000000e+00,2.540307903435575776e-01,6.519108537876683318e-01 +1.000000000000000000e+00,9.925329991819680231e-01,8.009199234853079385e-01 +1.000000000000000000e+00,9.871058868993810576e-01,8.958814489034055972e-01 +1.000000000000000000e+00,7.329421343906131758e-01,7.162614142817553819e-01 +1.000000000000000000e+00,9.944219413039141475e-01,7.052213028969684938e-01 +-1.000000000000000000e+00,2.072586215931685460e-01,7.856577766861695400e-01 +-1.000000000000000000e+00,6.419590805832910974e-01,3.274665648965369158e-01 +-1.000000000000000000e+00,3.809536714273964453e-02,7.312617957403662050e-01 +-1.000000000000000000e+00,7.506710432993660698e-01,1.265072249195027254e-01 +1.000000000000000000e+00,8.343988342644053091e-01,1.841024147367045227e-01 +-1.000000000000000000e+00,1.758563408675866135e-01,4.620185467796678047e-01 +1.000000000000000000e+00,9.017343818930201316e-01,6.451069718007419462e-01 +1.000000000000000000e+00,4.645860976665043829e-01,8.036931879984066107e-01 +-1.000000000000000000e+00,1.095113168514771917e-01,5.896622604055185013e-01 +1.000000000000000000e+00,2.595460748012538010e-01,6.656903665016161709e-01 +1.000000000000000000e+00,8.248707100076894116e-01,5.982805782011830775e-01 +1.000000000000000000e+00,6.066008767832432591e-01,7.002726085427883884e-01 +-1.000000000000000000e+00,4.960382430993948155e-03,9.641836628417100874e-01 +1.000000000000000000e+00,9.187704651055217386e-02,9.457729354805407551e-01 +1.000000000000000000e+00,2.146449197939926945e-01,9.362964528123883801e-01 +1.000000000000000000e+00,7.650517822114389910e-01,7.758744085669813106e-01 +1.000000000000000000e+00,7.910586028200941033e-01,7.463191757483961242e-01 +-1.000000000000000000e+00,3.116241907975170200e-01,3.477116968694634602e-01 +1.000000000000000000e+00,3.473903707850247713e-01,9.182780921232864824e-01 +1.000000000000000000e+00,9.469950080796307734e-01,8.927011126301536148e-01 +-1.000000000000000000e+00,1.636710794703860605e-01,8.530396603820045165e-02 diff --git a/problem-sets/PS2/src/__init__.py b/problem-sets/PS2/src/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/problem-sets/PS2/src/__pycache__/__init__.cpython-311.pyc b/problem-sets/PS2/src/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000..44bc2b7 Binary files /dev/null and b/problem-sets/PS2/src/__pycache__/__init__.cpython-311.pyc differ diff --git a/problem-sets/PS2/src/__pycache__/__init__.cpython-312.pyc b/problem-sets/PS2/src/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000..a7ebb83 Binary files /dev/null and b/problem-sets/PS2/src/__pycache__/__init__.cpython-312.pyc differ diff --git a/problem-sets/PS2/src/__pycache__/p01_lr.cpython-311.pyc b/problem-sets/PS2/src/__pycache__/p01_lr.cpython-311.pyc new file mode 100644 index 0000000..7165fce Binary files /dev/null and b/problem-sets/PS2/src/__pycache__/p01_lr.cpython-311.pyc differ diff --git a/problem-sets/PS2/src/__pycache__/p01_lr.cpython-312.pyc b/problem-sets/PS2/src/__pycache__/p01_lr.cpython-312.pyc new file mode 100644 index 0000000..b9f0410 Binary files /dev/null and b/problem-sets/PS2/src/__pycache__/p01_lr.cpython-312.pyc differ diff --git a/problem-sets/PS2/src/__pycache__/util.cpython-311.pyc b/problem-sets/PS2/src/__pycache__/util.cpython-311.pyc new file mode 100644 index 0000000..6e9e87d Binary files /dev/null and b/problem-sets/PS2/src/__pycache__/util.cpython-311.pyc differ diff --git a/problem-sets/PS2/src/__pycache__/util.cpython-312.pyc b/problem-sets/PS2/src/__pycache__/util.cpython-312.pyc new file mode 100644 index 0000000..d520a9e Binary files /dev/null and b/problem-sets/PS2/src/__pycache__/util.cpython-312.pyc differ diff --git a/problem-sets/PS2/src/p01_lr.py b/problem-sets/PS2/src/p01_lr.py index 8e735a9..84422e0 100644 --- a/problem-sets/PS2/src/p01_lr.py +++ b/problem-sets/PS2/src/p01_lr.py @@ -1,9 +1,10 @@ # Important note: you do not have to modify this file for your homework. -import util +# import util +from PS2.src import util import numpy as np - +MAX_EPOCHS = 400000 def calc_grad(X, Y, theta): """Compute the gradient of the loss with respect to theta.""" m, n = X.shape @@ -19,7 +20,8 @@ def logistic_regression(X, Y): """Train a logistic regression model.""" m, n = X.shape theta = np.zeros(n) - learning_rate = 10 + learning_rate = 100 + grads = [] i = 0 while True: @@ -28,11 +30,65 @@ def logistic_regression(X, Y): grad = calc_grad(X, Y, theta) theta = theta - learning_rate * grad if i % 10000 == 0: - print('Finished %d iterations' % i) + grads.append([i, grad[1], grad[2]]) + # print('Finished %d iterations' % i) + if i == MAX_EPOCHS: + print(f"Could not converge in {MAX_EPOCHS} epochs") + break if np.linalg.norm(prev_theta - theta) < 1e-15: print('Converged in %d iterations' % i) break - return + return np.array(grads) + + +def calc_loss(X, Y, theta, l2_reg_coef): + m, n = X.shape + xytheta = Y * X.dot(theta) + l2_norm = (1/m) * l2_reg_coef * np.sum(theta**2) + loss = (1/m)*np.sum(np.log(np.exp(xytheta) + 1) - xytheta) + l2_norm + return loss + +def logistic_regression_modified(X, Y, loss_func = calc_loss, grad_func = calc_grad, + l2_reg_coef=0, max_iters=10000, log_step=10000, learning_rate=10, decay=lambda i, lr: lr): + """Train a logistic regression model.""" + m, n = X.shape + theta = np.zeros(n) + grads = [] + thetas = [] + norms = [] + losses = [] + + i = 0 + while True: + i += 1 + prev_theta = theta + learning_rate = decay(i, learning_rate) + grad = grad_func(X, Y, theta) + grad[1:] = grad[1:] + (1/m)*l2_reg_coef * theta[1:] + theta = theta - learning_rate * grad + norm = np.linalg.norm(prev_theta - theta) + loss = loss_func(X, Y, theta, l2_reg_coef) + + if i % log_step == 0: + grads.append([i, grad[1], grad[2]]) + thetas.append([i, theta[1], theta[2]]) + norms.append([i, norm]) + losses.append([i, loss]) + # print(f"iterations: {i}, norm: {np.linalg.norm(prev_theta - theta)}") + # print('Finished %d iterations' % i) + + if i == max_iters: + print(f"Could not converge in {max_iters} epochs") + break + if norm < 1e-15: + print('Converged in %d iterations' % i) + grads.append([i, grad[1], grad[2]]) + thetas.append([i, theta[1], theta[2]]) + norms.append([i, norm]) + losses.append([i, loss]) + break + + return np.array(grads), np.array(thetas), np.array(norms), np.array(losses) def main(): @@ -46,4 +102,4 @@ def main(): if __name__ == '__main__': - main() + main() \ No newline at end of file diff --git a/problem-sets/PS2/src/util.py b/problem-sets/PS2/src/util.py index 9c5889f..2f09727 100644 --- a/problem-sets/PS2/src/util.py +++ b/problem-sets/PS2/src/util.py @@ -3,6 +3,7 @@ import matplotlib.pyplot as plt import numpy as np import json +import os def add_intercept_fn(x): @@ -74,7 +75,7 @@ def load_spam_dataset(tsv_path): return messages, np.array(labels) -def plot(x, y, theta, save_path, correction=1.0): +def plot(x, y, theta, save_path, correction=0.0): """Plot dataset and fitted logistic regression parameters. Args: @@ -91,7 +92,8 @@ def plot(x, y, theta, save_path, correction=1.0): # Plot decision boundary (found by solving for theta^T x = 0) x1 = np.arange(min(x[:, -2]), max(x[:, -2]), 0.01) - x2 = -(theta[0] / theta[2] * correction + theta[1] / theta[2] * x1) + x2 = correction - (theta[0] / theta[2] + theta[1] / theta[2] * x1) + # x2 = -(theta[0] / theta[2]*correction + theta[1] / theta[2] * x1) plt.plot(x1, x2, c='red', linewidth=2) # Add labels and save to disk @@ -113,13 +115,101 @@ def plot_contour(predict_fn): def plot_points(x, y): """Plot some points where x are the coordinates and y is the label""" - x_one = x[y == 0, :] - x_two = x[y == 1, :] - - plt.scatter(x_one[:,0], x_one[:,1], marker='x', color='red') - plt.scatter(x_two[:,0], x_two[:,1], marker='o', color='blue') + cmap = plt.cm.jet + cmaplist = [cmap(i) for i in range(cmap.N)] + cmap = cmap.from_list('Custom cmap', cmaplist, cmap.N) + plt.scatter(x[:, 0], x[:, 1], c=y, cmap=cmap, alpha=0.5) + + +def plot_line(x, y1, y2): + """Plot some points where x are the coordinates and y is the label""" + plt.plot(x, y1, x, y2) + +def plot_lines(x, ys, labels, x_label='X', y_label='Y'): + """Plot multiple lines where x is the coordinate and ys is a list of y values with corresponding labels""" + for y, label in zip(ys, labels): + print(f"plotting {label}") + plt.plot(x[:len(y)], y, label=label) + plt.xlabel(x_label) + plt.ylabel(y_label) + plt.legend() + plt.show() def write_json(filename, value): """Write the provided value as JSON to the given filename""" with open(filename, 'w') as f: json.dump(value, f) + + +def plot_regression(x, y, label_x="x", label_y="y", save_path=""): + plt.figure() + plt.scatter(x, y) + # Add labels and save to disk + plt.xlabel(label_x) + plt.ylabel(label_y) + if save_path is not None: + plt.savefig(save_path) + +def plot_regression_train_and_fcst(x_train, y_train, x_test, y_test, label_x="x", label_y="y", save_path=""): + plt.figure() + plt.plot(x_train, y_train, 'bx', linewidth=2) + plt.plot(x_test, y_test, 'ro', linewidth=2) + # Add labels and save to disk + plt.xlabel(label_x) + plt.ylabel(label_y) + if save_path is not None: + plt.savefig(save_path) + + +def evaluate_classification(fcst, y_test, heading=""): + print(f"\n\n{heading}") + # evaluate + y_test_vec = y_test.reshape(len(y_test), 1) + fcst_vec = fcst.reshape(len(fcst), 1) + + correct = (y_test_vec == fcst_vec) + wrong = 1 - correct + + accuracy = np.sum(correct) / len(fcst_vec) + true_pos = np.sum(correct * fcst_vec) + true_neg = np.sum(correct * (1 - fcst_vec)) + false_pos = np.sum(wrong * fcst_vec) + false_neg = np.sum(wrong * (1 - fcst_vec)) + + if (true_pos + false_pos) == 0: + precision = 0 + else: + precision = true_pos / (true_pos + false_pos) + + if (true_pos + false_neg) == 0: + recall = 0 + else: + recall = true_pos / (true_pos + false_neg) + + print(f"y_test_vec, shape: {y_test_vec.shape}, num: {np.sum(y_test_vec)}") + print(f"fcst_vec, shape: {fcst_vec.shape}, num: {np.sum(fcst_vec)}") + print(f"correct vec, shape: {correct.shape}, num: {np.sum(correct)}") + print(f"wrong vec, shape: {wrong.shape}, num: {np.sum(wrong)}") + print(f"accuracy: {np.round(accuracy, 2)}, " + f"precision: {np.round(precision, 2)}, " + f"recall: {np.round(recall, 2)}") + + +def evaluate_regression(y, y_hat, heading=""): + print(f"\n\n{heading}") + m = len(y) + # evaluate + y_vec = y.reshape(m, 1) + y_hat_vec = y_hat.reshape(m, 1) + mse = (1/m) * np.sum((y_hat_vec - y_vec)**2) + mse = np.round(mse, 2) + print(f"MSE = {mse}") + return mse + +def write(data, path): + dir_name = os.path.dirname(path) + os.makedirs(dir_name, exist_ok=True) + np.savetxt(path, data, fmt="%d", delimiter=",") + +def get_fig_prefix(pred_path): + return pred_path.split(".")[0]