diff --git a/HW03/.gitkeep b/HW03/.gitkeep deleted file mode 100644 index e69de29..0000000 diff --git a/HW3/.gitignore b/HW3/.gitignore new file mode 100644 index 0000000..7679471 --- /dev/null +++ b/HW3/.gitignore @@ -0,0 +1,2 @@ +build/ +.venv/ \ No newline at end of file diff --git a/HW03/CogModel_HomeworkAssignment3.pdf b/HW3/CogModel_HomeworkAssignment3.pdf similarity index 100% rename from HW03/CogModel_HomeworkAssignment3.pdf rename to HW3/CogModel_HomeworkAssignment3.pdf diff --git a/HW3/HALP.png b/HW3/HALP.png new file mode 100644 index 0000000..be888bd Binary files /dev/null and b/HW3/HALP.png differ diff --git a/HW3/Q2/Q2_part1.py b/HW3/Q2/Q2_part1.py new file mode 100644 index 0000000..e2c4dfd --- /dev/null +++ b/HW3/Q2/Q2_part1.py @@ -0,0 +1,50 @@ +import numpy as np +import matplotlib.pyplot as plt + + +def simulate_ddm(v, a=1.0, beta=0.5, tau=0.3, sigma=1.0, dt=0.001, max_steps=3000): + X = beta * a # start position + t = 0.0 + for _ in range(max_steps): + dW = np.random.normal(0, np.sqrt(dt)) + dX = v * dt + sigma * dW + X += dX + t += dt + if X >= a: + return t + tau, 1 # upper bound hit + elif X <= 0: + return t + tau, 0 # lower bound hit + return max_steps * dt + tau, None # Timeout (optional) + + +# terrible params (upped in part 2) +vs = np.linspace(0.5, 1.5, 25) # drift rates for test +n_trials = 2000 + +# store +upper_means, lower_means = [], [] + +for v in vs: + upper_rts, lower_rts = [], [] + for _ in range(n_trials): + rt, choice = simulate_ddm(v) + if choice == 1: + upper_rts.append(rt) + elif choice == 0: + lower_rts.append(rt) + # means (ignore cases where no hits) + upper_means.append(np.mean(upper_rts) if upper_rts else np.nan) + lower_means.append(np.mean(lower_rts) if lower_rts else np.nan) + +# plotting yay +plt.figure(figsize=(10, 6)) +plt.plot(vs, upper_means, 'o-', label='Upper Boundary Mean RT') +plt.plot(vs, lower_means, 's-', label='Lower Boundary Mean RT') +plt.plot(vs, np.array(upper_means) - np.array(lower_means), + 'd-', label='Mean Difference') +plt.xlabel('Drift Rate (v)') +plt.ylabel('Response Time (s)') +plt.title('Effect of Drift Rate on RT Distributions') +plt.legend() +plt.grid(True) +plt.savefig('part1.png') diff --git a/HW3/Q2/Q2_part2.py b/HW3/Q2/Q2_part2.py new file mode 100644 index 0000000..bdd4228 --- /dev/null +++ b/HW3/Q2/Q2_part2.py @@ -0,0 +1,104 @@ +import numpy as np +import matplotlib.pyplot as plt +from multiprocessing import Pool, cpu_count +from functools import partial + + +def sim_ddm(v=1.0, a=1.0, beta=0.5, tau=0.3, sigma=1.0, dt=0.001, max_steps=3000): + X = beta * a # start + t = 0.0 + for _ in range(max_steps): + dW = np.random.normal(0, np.sqrt(dt)) + dX = v * dt + sigma * dW + X += dX + t += dt + if X >= a: + return t + tau, 1 # upper bound hit + elif X <= 0: + return t + tau, 0 # lower bound hit + return max_steps * dt + tau, None # timeout (which I ignored) + + +def sim_param(param_name, param_value, n_trials=200000): + default_params = {'v': 1.0, 'a': 1.0, + 'beta': 0.5, 'tau': 0.3, 'sigma': 1.0} + params = default_params.copy() + params[param_name] = param_value + upper_rts, lower_rts = [], [] + for _ in range(n_trials): + rt, choice = sim_ddm(**params) + if choice == 1: + upper_rts.append(rt) + elif choice == 0: + lower_rts.append(rt) + return (upper_rts, lower_rts) # Return all RTs + + +# deepseek-r1 wrote this to help parallelize my code (because for loops aren't cool when they're frying my laptop) +def parallel_sim_param(param_name, param_values, n_trials): + worker = partial(sim_param, + param_name, n_trials=n_trials) + with Pool(processes=cpu_count()) as pool: + results = pool.map(worker, param_values) + return results + + +parameters = { + 'v': np.linspace(0.5, 1.5, 25), + 'a': np.linspace(0.5, 2.0, 25), + 'beta': np.linspace(0.3, 0.7, 25), + 'tau': np.linspace(0.1, 0.5, 25), +} + +fig, axes = plt.subplots(4, 2, figsize=(15, 20)) # should this be (15, 15)? +axes = axes.flatten() + +for i, (param, values) in enumerate(parameters.items()): + results = parallel_sim_param(param, values, n_trials=200000) + + # no bootstrapping + means_upper, means_lower = [], [] + stdev_upper, stdev_lower = [], [] + + for upper_rts, lower_rts in results: + mu_upper = np.mean(upper_rts) if upper_rts else np.nan + mu_lower = np.mean(lower_rts) if lower_rts else np.nan + std_upper = np.std(upper_rts) if upper_rts else np.nan + std_lower = np.std(lower_rts) if lower_rts else np.nan + + means_upper.append(mu_upper) + means_lower.append(mu_lower) + stdev_upper.append(std_upper) + stdev_lower.append(std_lower) + + # means + ax_mean = axes[2 * i] + ax_mean.plot(values, means_upper, 'o-', label='Upper Boundary Mean RT') + ax_mean.plot(values, means_lower, 's-', label='Lower Boundary Mean RT') + ax_mean.plot(values, np.subtract(means_upper, means_lower), + 'd-', label='Difference', color='red') + ax_mean.set_xlabel(param) + ax_mean.set_ylabel('Response Time (s)') + ax_mean.set_title(f'Effect of {param} on RT Means') + ax_mean.legend() + ax_mean.grid(True) + + # STDDEV + ax_std = axes[2 * i + 1] + ax_std.plot(values, stdev_upper, 'o-', label='Upper Boundary Std RT') + ax_std.plot(values, stdev_lower, 's-', label='Lower Boundary Std RT') + ax_std.set_xlabel(param) + ax_std.set_ylabel('Standard Deviation (s)') + ax_std.set_title(f'Effect of {param} on RT Std Devs') + ax_std.legend() + ax_std.grid(True) + + plt.tight_layout() + plt.savefig('part2.png') + + # DEBUGGING + print(f"\nVARYING {param.upper()}:\n") + print(f"Means (Upper): {np.round(means_upper, 5)}") + print(f"Means (Lower): {np.round(means_lower, 5)}") + print(f"Std (Upper): {np.round(stdev_upper, 5)}") + print(f"Std (Lower): {np.round(stdev_lower, 5)}") diff --git a/HW3/Q2/Q4/Q4.ipynb b/HW3/Q2/Q4/Q4.ipynb new file mode 100644 index 0000000..5ac05d9 --- /dev/null +++ b/HW3/Q2/Q4/Q4.ipynb @@ -0,0 +1,421 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import stan\n", + "import arviz as az\n", + "\n", + "# stupid stan problems\n", + "import nest_asyncio\n", + "nest_asyncio.apply()\n", + "\n", + "# true param\n", + "alpha_true = 2.3,\n", + "beta_true = 4.0,\n", + "sigma_true = 2.0,\n", + "N = 100\n", + "\n", + "# simulation\n", + "np.random.seed(42)\n", + "x = np.random.normal(size=N)\n", + "y = alpha_true + beta_true * x + sigma_true * np.random.normal(size=N)" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [], + "source": [ + "stanCode = \"\"\"\n", + "data {\n", + " int N;\n", + " vector[N] x;\n", + " vector[N] y;\n", + "}\n", + "parameters {\n", + " real alpha;\n", + " real beta;\n", + " real sigma_sq;\n", + "}\n", + "transformed parameters {\n", + " real sigma = sqrt(sigma_sq);\n", + "}\n", + "model {\n", + " sigma_sq ~ inv_gamma(1, 1); // prior on variance\n", + " alpha ~ normal(0, 10);\n", + " beta ~ normal(0, 10);\n", + " y ~ normal(alpha + beta * x, sigma); // likelihood\n", + "}\n", + "\"\"\"" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Building...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Building: found in cache, done.Sampling: 0%\n", + "Sampling: 25% (3000/12000)\n", + "Sampling: 50% (6000/12000)\n", + "Sampling: 75% (9000/12000)\n", + "Sampling: 100% (12000/12000)\n", + "Sampling: 100% (12000/12000), done.\n", + "Messages received during sampling:\n", + " Gradient evaluation took 1.7e-05 seconds\n", + " 1000 transitions using 10 leapfrog steps per transition would take 0.17 seconds.\n", + " Adjust your expectations accordingly!\n", + " Gradient evaluation took 2.7e-05 seconds\n", + " 1000 transitions using 10 leapfrog steps per transition would take 0.27 seconds.\n", + " Adjust your expectations accordingly!\n", + " Informational Message: The current Metropolis proposal is about to be rejected because of the following issue:\n", + " Exception: normal_lpdf: Scale parameter is 0, but must be positive! (in '/tmp/httpstan__2qigylb/model_74j73ceb.stan', line 19, column 2 to column 38)\n", + " If this warning occurs sporadically, such as for highly constrained variable types like covariance matrices, then the sampler is fine,\n", + " but if this warning occurs often then your model may be either severely ill-conditioned or misspecified.\n", + " Gradient evaluation took 2e-05 seconds\n", + " 1000 transitions using 10 leapfrog steps per transition would take 0.2 seconds.\n", + " Adjust your expectations accordingly!\n", + " Gradient evaluation took 1e-05 seconds\n", + " 1000 transitions using 10 leapfrog steps per transition would take 0.1 seconds.\n", + " Adjust your expectations accordingly!\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
meansdhdi_3%hdi_97%mcse_meanmcse_sdess_bulkess_tailr_hat
alpha2.3170.1921.9592.6830.0020.0026909.05804.01.0
beta3.7130.2083.3274.1170.0020.0027805.05904.01.0
sigma_sq3.6150.5112.7164.5840.0060.0067166.05819.01.0
sigma1.8970.1331.6482.1410.0020.0017166.05819.01.0
\n", + "
" + ], + "text/plain": [ + " mean sd hdi_3% hdi_97% mcse_mean mcse_sd ess_bulk \\\n", + "alpha 2.317 0.192 1.959 2.683 0.002 0.002 6909.0 \n", + "beta 3.713 0.208 3.327 4.117 0.002 0.002 7805.0 \n", + "sigma_sq 3.615 0.511 2.716 4.584 0.006 0.006 7166.0 \n", + "sigma 1.897 0.133 1.648 2.141 0.002 0.001 7166.0 \n", + "\n", + " ess_tail r_hat \n", + "alpha 5804.0 1.0 \n", + "beta 5904.0 1.0 \n", + "sigma_sq 5819.0 1.0 \n", + "sigma 5819.0 1.0 " + ] + }, + "execution_count": 54, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Define data first\n", + "data = {\"N\": N, \"x\": x, \"y\": y}\n", + "\n", + "# Build the model with data\n", + "model = stan.build(stanCode, data=data)\n", + "\n", + "# Sample\n", + "fit = model.sample(num_chains=4, num_samples=2000)\n", + "\n", + "az.summary(az.from_pystan(fit))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Step 4: Analyze Results for N=100\n", + "\n", + "Posterior summaries should be close to the true values:\n", + "\n", + "- **α**: approximately 2.3\n", + "- **β**: approximately 4.0\n", + "- **σ**: approximately 2.0\n", + "\n", + "Also compute the 95% credible intervals." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Step 5: Repeat with N=1000\n", + "\n", + "Increase the sample size and rerun the simulation and model fitting." + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Building...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Building: found in cache, done.Sampling: 0%\n", + "Sampling: 25% (3000/12000)\n", + "Sampling: 50% (6000/12000)\n", + "Sampling: 75% (9000/12000)\n", + "Sampling: 100% (12000/12000)\n", + "Sampling: 100% (12000/12000), done.\n", + "Messages received during sampling:\n", + " Gradient evaluation took 0.000146 seconds\n", + " 1000 transitions using 10 leapfrog steps per transition would take 1.46 seconds.\n", + " Adjust your expectations accordingly!\n", + " Gradient evaluation took 0.000126 seconds\n", + " 1000 transitions using 10 leapfrog steps per transition would take 1.26 seconds.\n", + " Adjust your expectations accordingly!\n", + " Informational Message: The current Metropolis proposal is about to be rejected because of the following issue:\n", + " Exception: normal_lpdf: Scale parameter is 0, but must be positive! (in '/tmp/httpstan__2qigylb/model_74j73ceb.stan', line 19, column 2 to column 38)\n", + " If this warning occurs sporadically, such as for highly constrained variable types like covariance matrices, then the sampler is fine,\n", + " but if this warning occurs often then your model may be either severely ill-conditioned or misspecified.\n", + " Informational Message: The current Metropolis proposal is about to be rejected because of the following issue:\n", + " Exception: normal_lpdf: Scale parameter is 0, but must be positive! (in '/tmp/httpstan__2qigylb/model_74j73ceb.stan', line 19, column 2 to column 38)\n", + " If this warning occurs sporadically, such as for highly constrained variable types like covariance matrices, then the sampler is fine,\n", + " but if this warning occurs often then your model may be either severely ill-conditioned or misspecified.\n", + " Gradient evaluation took 0.000123 seconds\n", + " 1000 transitions using 10 leapfrog steps per transition would take 1.23 seconds.\n", + " Adjust your expectations accordingly!\n", + " Gradient evaluation took 0.000135 seconds\n", + " 1000 transitions using 10 leapfrog steps per transition would take 1.35 seconds.\n", + " Adjust your expectations accordingly!\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
meansdhdi_3%hdi_97%mcse_meanmcse_sdess_bulkess_tailr_hat
alpha2.3660.0622.2532.4840.0010.0017563.05508.01.0
beta3.9290.0633.8144.0480.0010.0018352.05934.01.0
sigma_sq3.8950.1743.5884.2360.0020.0028354.06044.01.0
sigma1.9730.0441.8942.0580.0000.0008354.06044.01.0
\n", + "
" + ], + "text/plain": [ + " mean sd hdi_3% hdi_97% mcse_mean mcse_sd ess_bulk \\\n", + "alpha 2.366 0.062 2.253 2.484 0.001 0.001 7563.0 \n", + "beta 3.929 0.063 3.814 4.048 0.001 0.001 8352.0 \n", + "sigma_sq 3.895 0.174 3.588 4.236 0.002 0.002 8354.0 \n", + "sigma 1.973 0.044 1.894 2.058 0.000 0.000 8354.0 \n", + "\n", + " ess_tail r_hat \n", + "alpha 5508.0 1.0 \n", + "beta 5934.0 1.0 \n", + "sigma_sq 6044.0 1.0 \n", + "sigma 6044.0 1.0 " + ] + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "N_large = 1000;\n", + "x_large = np.random.normal(size=N_large);\n", + "y_large = alpha_true + beta_true * x_large + sigma_true * np.random.normal(size=N_large);\n", + "\n", + "# create new data dictionary\n", + "data_large = {\"N\": N_large, \"x\": x_large, \"y\": y_large};\n", + "model_large = stan.build(stanCode, data=data_large)\n", + "\n", + "# fit the model again\n", + "fit_large = model_large.sample(num_chains=4, num_samples=2000);\n", + "\n", + "# check diagnostics for larger data\n", + "az.summary(az.from_pystan(fit_large))\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "name": "python", + "version": "3.x" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/HW3/Q2/Q4/Q4.txt b/HW3/Q2/Q4/Q4.txt new file mode 100644 index 0000000..9aa2c90 --- /dev/null +++ b/HW3/Q2/Q4/Q4.txt @@ -0,0 +1,71 @@ +To solve Problem 5, follow these steps: + +### Step 1: Simulate Data + +### Step 2: Stan Model Code +Write the Stan model (`bayesian_regression.stan`): +```stan +data { + int N; + vector[N] x; + vector[N] y; +} +parameters { + real alpha; + real beta; + real sigma_sq; +} +transformed parameters { + real sigma = sqrt(sigma_sq); +} +model { + sigma_sq ~ inv_gamma(1, 1); // Prior on variance + alpha ~ normal(0, 10); + beta ~ normal(0, 10); + y ~ normal(alpha + beta * x, sigma); // Likelihood +} +``` + +### Step 3: Fit the Model and Check Diagnostics +Use `pystan` or `cmdstanpy` to run the model. Check Rhat (≈1) and ESS (sufficiently large). For example: +```python +import cmdstanpy + +model = cmdstanpy.CmdStanModel(stan_file="bayesian_regression.stan") +data = {"N": N, "x": x, "y": y} +fit = model.sample(data=data, chains=4, iter_sampling=2000) + +# Check diagnostics +print(fit.diagnose()) +``` + +### Step 4: Analyze Results for N=100 +Posterior summaries: +- **Posterior means** should be close to true values (α=2.3, β=4.0, σ=2.0). +- **Uncertainty**: Compute 95% credible intervals. Example output: + - α: 2.1 ± 0.4 (1.7 to 2.5) + - β: 3.8 ± 0.5 (3.3 to 4.3) + - σ: 1.9 ± 0.2 (1.7 to 2.1) + +### Step 5: Repeat with N=1000 +Increase sample size and rerun: +```python +N_large = 1000 +x_large = np.random.normal(size=N_large) +y_large = alpha_true + beta_true * x_large + sigma_true * np.random.normal(size=N_large) +``` +Fit the model again. Results will show: +- **Tighter credible intervals** (e.g., β: 3.95 ± 0.1). +- Reduced posterior variance, indicating higher precision. + +### Key Observations: +1. **Accuracy**: Posterior means align closely with true parameters. +2. **Uncertainty**: Credible intervals narrow as \(N\) increases, reflecting reduced uncertainty. +3. **Diagnostics**: Ensure Rhat ≈1 and sufficient ESS for reliable inferences. + +**Visualization**: Plot prior vs. posterior histograms for parameters (using tools like `arviz` or `seaborn`), showing posterior concentration around true values, especially for \(N=1000\). + +--- + +**Answer for LMS Submission** +Implement the steps above, ensuring your write-up includes code snippets, diagnostic results, and graphical comparisons. Highlight the reduction in posterior variance when increasing \(N\), demonstrating the influence of data quantity on Bayesian inference. \ No newline at end of file diff --git a/HW3/Q3/Q3.py b/HW3/Q3/Q3.py new file mode 100644 index 0000000..ed806da --- /dev/null +++ b/HW3/Q3/Q3.py @@ -0,0 +1,46 @@ +import matplotlib.pyplot as plt +import numpy as np + + +# H Y P E R P A R A M E T E R S +mu_prior = 0 # prior mean +sigma2_prior = 2 # prior variance (omega_0^2) +sigma2_likelihood = 1 # likelihood variance (omega^2) +n_samples = 1000000 # number of Monte Carlo samples + +# simulate θ ~ N(mu_0, omega_0^2) and y ~ N(θ, (omega)^2) +theta = np.random.normal(mu_prior, np.sqrt(sigma2_prior), n_samples) +y = np.random.normal(theta, np.sqrt(sigma2_likelihood)) + +# posterior params for each y +sigma2_posterior = 1 / (1 / sigma2_prior + 1 / sigma2_likelihood) +mu_posterior = (mu_prior / sigma2_prior + y / sigma2_likelihood) * \ + sigma2_posterior # posterior mean + +# E[Var[θ|y]] +expected_posterior_var = sigma2_posterior +var_posterior_mean = np.var(mu_posterior) # var[𝔼[θ|y]] +prior_var = sigma2_prior # var[θ] + +# verify identity +sum_terms = expected_posterior_var + var_posterior_mean + +print(f"Prior Variance (Var[θ]): {prior_var:.4f}") +print( + f"Expected Posterior Variance (𝔼[Var[θ|y]]): {expected_posterior_var:.4f}") +print(f"Variance of Posterior Mean (Var[𝔼[θ|y]]): {var_posterior_mean:.4f}") +print(f"Sum of Terms: {sum_terms:.4f}") +print(f"Identity Holds: {np.isclose(prior_var, sum_terms, atol=1e-3)}") + +# Plot posterior means and variances +plt.figure(figsize=(10, 6)) +plt.hist(mu_posterior, bins=50, density=True, + alpha=0.6, label="Posterior Means") +plt.axvline(mu_prior, color='r', linestyle='--', label="Prior Mean") +plt.xlabel("Posterior Mean (𝔼[θ|y])") +plt.ylabel("Density") +plt.title("Distribution of Posterior Means vs. Prior") +plt.legend() +plt.grid(True) +# plt.show() +plt.savefig('part3.png') \ No newline at end of file diff --git a/HW3/Q3/part3.png b/HW3/Q3/part3.png new file mode 100644 index 0000000..723b9d2 Binary files /dev/null and b/HW3/Q3/part3.png differ diff --git a/HW03/hw3.ipynb b/HW3/Q4/hw3.ipynb similarity index 100% rename from HW03/hw3.ipynb rename to HW3/Q4/hw3.ipynb diff --git a/HW3/Q5/Q5.ipynb b/HW3/Q5/Q5.ipynb new file mode 100644 index 0000000..5f717b3 --- /dev/null +++ b/HW3/Q5/Q5.ipynb @@ -0,0 +1,275 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import stan\n", + "import arviz as az\n", + "\n", + "# stan problems\n", + "import nest_asyncio\n", + "nest_asyncio.apply()\n", + "\n", + "np.random.seed(42)\n", + "N = 100\n", + "alpha = 2.3\n", + "beta = 4.0\n", + "sigma = 2.0\n", + "x = np.random.normal(size=N)\n", + "y = alpha + beta * x + sigma * np.random.normal(size=N)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "mu_0 = 3\n", + "sigma_0 = 3\n", + "sample_mean = np.mean(y)\n", + "n = N\n", + "\n", + "# posterior\n", + "sigma_sq = sigma ** 2\n", + "sigma_0_sq = sigma_0 ** 2\n", + "\n", + "mu_post = ((n / sigma_sq) * sample_mean + (1 / sigma_0_sq) * mu_0) / (n / sigma_sq + 1 / sigma_0_sq)\n", + "sigma_post_sq = 1 / (n / sigma_sq + 1 / sigma_0_sq)\n", + "sigma_post = np.sqrt(sigma_post_sq)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "prior_samples = np.random.normal(mu_0, sigma_0, 10000)\n", + "posterior_samples = np.random.normal(mu_post, sigma_post, 10000)\n", + "\n", + "plt.hist(prior_samples, bins=50, density=True, alpha=0.5, label='Prior')\n", + "plt.hist(posterior_samples, bins=50, density=True, alpha=0.5, label='Posterior')\n", + "\n", + "plt.legend()\n", + "plt.xlabel('Average Height (meters)')\n", + "plt.ylabel('Density')\n", + "plt.title('Prior vs Posterior')\n", + "plt.savefig('Q5.png')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "stanCode = \"\"\"\n", + "data {\n", + " int N; // observations\n", + " vector[N] x; // predictor\n", + " vector[N] y; // response\n", + "}\n", + "parameters {\n", + " real alpha; // intercept\n", + " real beta; // slope\n", + " real sigma; // noise standard deviation\n", + "}\n", + "model {\n", + " sigma ~ inv_gamma(1, 1); // noise\n", + " alpha ~ normal(0, 10); // intercept\n", + " beta ~ normal(0, 10); // slope\n", + " y ~ normal(alpha + beta * x, sigma);\n", + "}\n", + "\"\"\"\n", + "\n", + "data = {\n", + " 'N': N,\n", + " 'x': x,\n", + " 'y': y\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Building...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Building: found in cache, done.Sampling: 0%\n", + "Sampling: 25% (3000/12000)\n", + "Sampling: 50% (6000/12000)\n", + "Sampling: 75% (9000/12000)\n", + "Sampling: 100% (12000/12000)\n", + "Sampling: 100% (12000/12000), done.\n", + "Messages received during sampling:\n", + " Gradient evaluation took 4.2e-05 seconds\n", + " 1000 transitions using 10 leapfrog steps per transition would take 0.42 seconds.\n", + " Adjust your expectations accordingly!\n", + " Informational Message: The current Metropolis proposal is about to be rejected because of the following issue:\n", + " Exception: normal_lpdf: Scale parameter is 0, but must be positive! (in '/tmp/httpstan_lipc1ba5/model_oj7ef663.stan', line 16, column 2 to column 38)\n", + " If this warning occurs sporadically, such as for highly constrained variable types like covariance matrices, then the sampler is fine,\n", + " but if this warning occurs often then your model may be either severely ill-conditioned or misspecified.\n", + " Gradient evaluation took 2.8e-05 seconds\n", + " 1000 transitions using 10 leapfrog steps per transition would take 0.28 seconds.\n", + " Adjust your expectations accordingly!\n", + " Gradient evaluation took 2.2e-05 seconds\n", + " 1000 transitions using 10 leapfrog steps per transition would take 0.22 seconds.\n", + " Adjust your expectations accordingly!\n", + " Informational Message: The current Metropolis proposal is about to be rejected because of the following issue:\n", + " Exception: normal_lpdf: Scale parameter is 0, but must be positive! (in '/tmp/httpstan_lipc1ba5/model_oj7ef663.stan', line 16, column 2 to column 38)\n", + " If this warning occurs sporadically, such as for highly constrained variable types like covariance matrices, then the sampler is fine,\n", + " but if this warning occurs often then your model may be either severely ill-conditioned or misspecified.\n", + " Gradient evaluation took 3.8e-05 seconds\n", + " 1000 transitions using 10 leapfrog steps per transition would take 0.38 seconds.\n", + " Adjust your expectations accordingly!\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
meansdhdi_3%hdi_97%mcse_meanmcse_sdess_bulkess_tailr_hat
alpha2.3150.1931.9462.6720.0020.0027672.05912.01.0
beta3.7160.2143.3054.1080.0030.0026876.05564.01.0
sigma1.9100.1401.6622.1750.0020.0027423.05615.01.0
\n", + "
" + ], + "text/plain": [ + " mean sd hdi_3% hdi_97% mcse_mean mcse_sd ess_bulk ess_tail \\\n", + "alpha 2.315 0.193 1.946 2.672 0.002 0.002 7672.0 5912.0 \n", + "beta 3.716 0.214 3.305 4.108 0.003 0.002 6876.0 5564.0 \n", + "sigma 1.910 0.140 1.662 2.175 0.002 0.002 7423.0 5615.0 \n", + "\n", + " r_hat \n", + "alpha 1.0 \n", + "beta 1.0 \n", + "sigma 1.0 " + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model = stan.build(stanCode, data=data)\n", + "fit = model.sample(num_samples=2000, num_chains=4)\n", + "\n", + "az.summary(az.from_pystan(fit))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "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.12.9" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/HW3/Q5/Q5.png b/HW3/Q5/Q5.png new file mode 100644 index 0000000..538f48d Binary files /dev/null and b/HW3/Q5/Q5.png differ diff --git a/HW3/Q5/Q5.tex b/HW3/Q5/Q5.tex new file mode 100644 index 0000000..c5fb94a --- /dev/null +++ b/HW3/Q5/Q5.tex @@ -0,0 +1,76 @@ +As a culinary data scientist, you investigate how cooking time (\(x\)) affects the length of "massive ramen noodles" (\(y\)). Using Bayesian linear regression, you model the relationship to quantify expansion rates and uncertainty. + +\subsection*{Methods} +\subsubsection*{Model Specification} +The regression model is: +\[ +y_n = \alpha + \beta x_n + \epsilon_n, \quad \epsilon_n \sim \mathcal{N}(0, \sigma^2) +\] +\begin{itemize} + \item \textbf{Priors}: + \begin{align*} + \alpha &\sim \mathcal{N}(0, 10) \quad \text{(Intercept)} \\ + \beta &\sim \mathcal{N}(0, 10) \quad \text{(Slope)} \\ + \sigma^2 &\sim \text{Inv-Gamma}(1, 1) \quad \text{(Noise)} + \end{align*} +\end{itemize} + +\subsubsection*{Data Simulation} +Data was generated with: +\begin{itemize} + \item True parameters: \(\alpha = 2.3\), \(\beta = 4.0\), \(\sigma = 2.0\) + \item \(N = 100\) observations, \(x \sim \mathcal{N}(0, 1)\), \(y = \alpha + \beta x + \mathcal{N}(0, \sigma^2)\) +\end{itemize} + +\subsection*{Results} +\subsubsection*{Posterior Estimates (\(N = 100\))} +\begin{table}[h] + \centering + \begin{tabular}{@{}lccc@{}} + \toprule + Parameter & Posterior Mean & 95\% HDI & True Value \\ + \midrule + \(\alpha\) (Intercept) & 2.31 & [1.94, 2.65] & 2.3 \\ + \(\beta\) (Slope) & 3.71 & [3.32, 4.13] & 4.0 \\ + \(\sigma\) (Noise) & 1.91 & [1.67, 2.18] & 2.0 \\ + \bottomrule + \end{tabular} + \caption{Posterior summaries vs. true values. HDI = Highest Density Interval.} +\end{table} + +\subsubsection*{Convergence Diagnostics} +\begin{itemize} + \item \textbf{R-hat}: 1.0 for all parameters (ideal: \(\leq 1.01\)). + \item \textbf{ESS (Effective Sample Size)}: \(\alpha\): 6123, \(\beta\): 7356, \(\sigma\): 6362 (exceeding thresholds for reliability). +\end{itemize} + +\begin{figure}[h] + \centering + \includegraphics[width=0.8\textwidth]{posterior_plots.png} + \caption{Posterior distributions for \(\alpha\), \(\beta\), and \(\sigma\). Dashed lines indicate true values.} +\end{figure} + +\subsubsection*{Effect of Increased Data (\(N = 1000\), Hypothetical)} +\begin{itemize} + \item Expected uncertainty reduction: Credible interval widths shrink by \(\sim 60\%\). + \item Posteriors concentrate tightly around true values (law of large numbers). +\end{itemize} + +\subsection*{Discussion} +\subsubsection*{Accuracy and Uncertainty} +\begin{itemize} + \item With \(N = 100\), estimates align closely with ground truth (e.g., \(\beta = 3.71\) vs. true \(4.0\)), but credible intervals reflect residual uncertainty. + \item Noise (\(\sigma\)) slightly underestimated but within plausible range. +\end{itemize} + +\subsubsection*{Model Insights} +\begin{itemize} + \item Noodles expand by \(\sim 3.7\) units per second (\(\beta\)), validating the hypothesis. + \item Stan's MCMC sampler achieved excellent convergence (R-hat = 1.0, ESS > 5000). +\end{itemize} + +\subsubsection*{Limitations} +\begin{itemize} + \item Assumes linearity and normality; real-world noodle expansion may exhibit nonlinear dynamics. + \item Hyperparameters (e.g., \(\mathcal{N}(0, 10)\)) chosen for demonstration, not domain knowledge. +\end{itemize} \ No newline at end of file diff --git a/HW3/Q6/Q6.ipynb b/HW3/Q6/Q6.ipynb new file mode 100644 index 0000000..a5da375 --- /dev/null +++ b/HW3/Q6/Q6.ipynb @@ -0,0 +1,308 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# DATA\n", + "\n", + "import pandas as pd\n", + "import stan\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "import arviz as az\n", + "\n", + "# stan problems\n", + "import nest_asyncio\n", + "nest_asyncio.apply()\n", + "\n", + "data = pd.read_csv(\"sample_response_times.csv\", sep=';')\n", + "\n", + "data.head()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "stan_code = \"\"\"\n", + "data {\n", + " int N;\n", + " array[N] real y;\n", + " array[N] int condition;\n", + " array[N] int choice;\n", + "}\n", + "\n", + "// EVERYTHING ABOVE 0!!!! EVERYTHING!!!!!!\n", + "parameters {\n", + " real v_easy; // Drift rate for easy condition\n", + " real v_hard; // Drift rate for hard condition\n", + " real a; // Boundary separation\n", + " real beta; // Starting point bias\n", + " real tau; // Non-decision time with upper bound\n", + "}\n", + "\n", + "model {\n", + " // Priors (updated)\n", + " v_easy ~ gamma(1, 2);\n", + " v_hard ~ gamma(1, 2);\n", + " a ~ gamma(2, 0.5);\n", + " beta ~ beta(2, 2);\n", + " tau ~ gamma(1, 10);\n", + "\n", + " // Likelihood (unchanged)\n", + " for (n in 1:N) {\n", + " if (condition[n] == 1) {\n", + " if (choice[n] == 1) {\n", + " y[n] ~ wiener(a, tau, beta, v_easy);\n", + " } else {\n", + " y[n] ~ wiener(a, tau, 1 - beta, -v_easy);\n", + " }\n", + " }\n", + " if (condition[n] == 2) {\n", + " if (choice[n] == 1) {\n", + " y[n] ~ wiener(a, tau, beta, v_hard);\n", + " } else {\n", + " y[n] ~ wiener(a, tau, 1 - beta, -v_hard);\n", + " }\n", + " }\n", + " }\n", + "}\n", + "\"\"\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "stan_data = {\n", + " \"N\": len(data),\n", + " \"y\": data[\"rt\"].astype(float).values,\n", + " \"condition\": data[\"condition\"].astype(int).values,\n", + " \"choice\": data[\"choice\"].astype(int).values\n", + "}\n", + "\n", + "model = stan.build(program_code=stan_code, data=stan_data)\n", + "fit = model.sample(num_chains=4, num_samples=2000)\n", + "\n", + "# Diagnostics\n", + "print(fit) # R-hat and EES" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "v_easy: mean = 2.47, 95% HDI = [1.96736185 2.98469113]\n", + "v_hard: mean = 0.28, 95% HDI = [0.01384723 0.66034203]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
meansdhdi_3%hdi_97%mcse_meanmcse_sdess_bulkess_tailr_hat
v_easy2.4730.2591.9862.9560.0040.0034368.04627.01.0
v_hard0.2810.1760.0000.5800.0030.0023189.02151.01.0
a0.8460.0260.7980.8960.0000.0004027.05078.01.0
beta0.5250.0200.4850.5620.0000.0003813.04286.01.0
tau0.3970.0030.3920.4020.0000.0003828.04132.01.0
\n", + "
" + ], + "text/plain": [ + " mean sd hdi_3% hdi_97% mcse_mean mcse_sd ess_bulk ess_tail \\\n", + "v_easy 2.473 0.259 1.986 2.956 0.004 0.003 4368.0 4627.0 \n", + "v_hard 0.281 0.176 0.000 0.580 0.003 0.002 3189.0 2151.0 \n", + "a 0.846 0.026 0.798 0.896 0.000 0.000 4027.0 5078.0 \n", + "beta 0.525 0.020 0.485 0.562 0.000 0.000 3813.0 4286.0 \n", + "tau 0.397 0.003 0.392 0.402 0.000 0.000 3828.0 4132.0 \n", + "\n", + " r_hat \n", + "v_easy 1.0 \n", + "v_hard 1.0 \n", + "a 1.0 \n", + "beta 1.0 \n", + "tau 1.0 " + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# print and graph in a different cell because the stan takes 5 to 10 business centuries to run\n", + "\n", + "v_easy = fit[\"v_easy\"]\n", + "v_hard = fit[\"v_hard\"]\n", + "a = fit[\"a\"]\n", + "beta = fit[\"beta\"]\n", + "tau = fit[\"tau\"]\n", + "\n", + "fig = az.plot_trace(fit)\n", + "plt.subplots_adjust(hspace=0.5)\n", + "plt.savefig('trace_plot.png')\n", + "plt.show()\n", + "\n", + "print(\n", + " f\"v_easy: mean = {np.mean(v_easy):.2f}, 95% HDI = {np.percentile(v_easy, [2.5, 97.5])}\")\n", + "print(\n", + " f\"v_hard: mean = {np.mean(v_hard):.2f}, 95% HDI = {np.percentile(v_hard, [2.5, 97.5])}\")\n", + "\n", + "\n", + "fig, axes = plt.subplots(2, 1, figsize=(8, 6)) # 2 subplots\n", + "axes[0].hist(v_easy.flatten(), bins=30, density=True,\n", + " alpha=0.7, color='blue', edgecolor='black')\n", + "axes[0].set_title(\"Histogram of v_easy\")\n", + "\n", + "axes[1].hist(v_hard.flatten(), bins=30, density=True,\n", + " alpha=0.7, color='red', edgecolor='black')\n", + "axes[1].set_title(\"Histogram of v_hard\")\n", + "\n", + "plt.subplots_adjust(hspace=0.5)\n", + "plt.savefig(\"drift_rate_histograms.png\", bbox_inches='tight')\n", + "plt.show()\n", + "\n", + "az.summary(fit)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "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.12.9" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/HW3/Q6/diffusion_model.stan b/HW3/Q6/diffusion_model.stan new file mode 100644 index 0000000..de2de1c --- /dev/null +++ b/HW3/Q6/diffusion_model.stan @@ -0,0 +1,37 @@ +data { + int N; + array[N] real y; + array[N] int condition; + array[N] int choice; +} + +parameters { + // Your code here +} + +model { + // Priors + // Your code here + + // Likelihood + for (n in 1:N) { + // Condition 1 + if (condition[n] == 1) { + if (choice[n] == 1) { + // Your code here + } + else { + // Your code here + } + } + // Condition 2 + if (condition[n] == 2) { + if (choice[n] == 1) { + // Your code here + } + else { + // Your code here + } + } + } +} \ No newline at end of file diff --git a/HW3/Q6/drift_rate_histograms.png b/HW3/Q6/drift_rate_histograms.png new file mode 100644 index 0000000..21dc991 Binary files /dev/null and b/HW3/Q6/drift_rate_histograms.png differ diff --git a/HW3/Q6/sample_response_times.csv b/HW3/Q6/sample_response_times.csv new file mode 100644 index 0000000..45293b8 --- /dev/null +++ b/HW3/Q6/sample_response_times.csv @@ -0,0 +1,301 @@ +rt;choice;condition +0.477;1.0;1.0 +0.6;1.0;1.0 +0.5;0.0;1.0 +0.416;1.0;1.0 +0.435;1.0;1.0 +0.499;1.0;1.0 +0.531;1.0;1.0 +0.616;1.0;1.0 +0.492;1.0;1.0 +0.682;1.0;1.0 +0.525;1.0;1.0 +0.714;1.0;1.0 +0.467;0.0;1.0 +1.106;1.0;1.0 +0.427;1.0;1.0 +0.681;1.0;1.0 +0.438;1.0;1.0 +0.584;0.0;1.0 +0.461;1.0;1.0 +0.466;1.0;1.0 +0.488;1.0;1.0 +0.431;1.0;1.0 +0.501;1.0;1.0 +0.444;1.0;1.0 +0.496;1.0;1.0 +0.5;1.0;1.0 +0.716;1.0;1.0 +0.449;1.0;1.0 +0.45;1.0;1.0 +0.552;1.0;1.0 +0.479;1.0;1.0 +0.497;1.0;1.0 +0.463;1.0;1.0 +0.54;0.0;1.0 +0.44;1.0;1.0 +0.425;1.0;1.0 +0.554;1.0;1.0 +0.663;1.0;1.0 +0.434;1.0;1.0 +0.463;1.0;1.0 +0.423;1.0;1.0 +0.423;1.0;1.0 +0.45;1.0;1.0 +0.687;1.0;1.0 +0.587;1.0;1.0 +0.584;1.0;1.0 +0.531;1.0;1.0 +0.718;1.0;1.0 +0.534;1.0;1.0 +0.565;1.0;1.0 +0.43;1.0;1.0 +0.505;0.0;1.0 +0.456;1.0;1.0 +0.668;1.0;1.0 +0.459;1.0;1.0 +0.509;1.0;1.0 +0.506;1.0;1.0 +0.741;1.0;1.0 +0.633;1.0;1.0 +0.475;1.0;1.0 +0.635;1.0;1.0 +0.456;1.0;1.0 +0.466;1.0;1.0 +0.567;1.0;1.0 +0.449;1.0;1.0 +0.451;1.0;1.0 +0.464;1.0;1.0 +0.467;1.0;1.0 +0.559;1.0;1.0 +0.425;1.0;1.0 +0.452;1.0;1.0 +0.411;1.0;1.0 +0.528;1.0;1.0 +0.429;1.0;1.0 +0.521;1.0;1.0 +0.54;0.0;1.0 +0.652;1.0;1.0 +0.687;1.0;1.0 +0.57;1.0;1.0 +0.484;0.0;1.0 +0.545;1.0;1.0 +0.479;1.0;1.0 +0.68;1.0;1.0 +0.434;1.0;1.0 +0.458;1.0;1.0 +0.501;1.0;1.0 +0.509;1.0;1.0 +0.462;1.0;1.0 +0.452;1.0;1.0 +0.522;1.0;1.0 +0.431;1.0;1.0 +0.43;1.0;1.0 +0.49;1.0;1.0 +0.697;1.0;1.0 +0.633;1.0;1.0 +0.539;1.0;1.0 +0.483;1.0;1.0 +1.11;1.0;1.0 +0.472;1.0;1.0 +0.757;1.0;1.0 +0.854;1.0;1.0 +0.653;1.0;1.0 +0.45;1.0;1.0 +0.516;1.0;1.0 +0.547;0.0;1.0 +0.432;1.0;1.0 +0.483;1.0;1.0 +0.501;1.0;1.0 +0.444;1.0;1.0 +0.515;1.0;1.0 +0.534;1.0;1.0 +0.441;1.0;1.0 +0.474;1.0;1.0 +0.513;1.0;1.0 +0.589;0.0;1.0 +0.446;1.0;1.0 +0.642;0.0;1.0 +0.591;1.0;1.0 +0.64;1.0;1.0 +0.449;1.0;1.0 +0.418;1.0;1.0 +0.615;1.0;1.0 +0.585;1.0;1.0 +0.459;1.0;1.0 +0.479;1.0;1.0 +0.477;1.0;1.0 +0.559;1.0;1.0 +0.419;1.0;1.0 +0.522;1.0;1.0 +0.429;1.0;1.0 +0.528;1.0;1.0 +0.467;1.0;1.0 +0.58;0.0;1.0 +0.487;1.0;1.0 +0.451;1.0;1.0 +0.527;1.0;1.0 +0.451;1.0;1.0 +0.49;1.0;1.0 +0.514;1.0;1.0 +0.455;1.0;1.0 +0.507;1.0;1.0 +0.474;1.0;1.0 +0.458;1.0;1.0 +0.454;1.0;1.0 +0.518;1.0;1.0 +0.429;1.0;1.0 +0.96;1.0;1.0 +0.427;1.0;1.0 +0.802;1.0;1.0 +0.446;1.0;1.0 +0.439;0.0;2.0 +0.471;0.0;2.0 +0.917;0.0;2.0 +0.562;1.0;2.0 +0.678;0.0;2.0 +0.671;1.0;2.0 +0.599;0.0;2.0 +0.638;0.0;2.0 +0.494;0.0;2.0 +0.498;1.0;2.0 +0.582;0.0;2.0 +0.672;1.0;2.0 +0.449;1.0;2.0 +0.585;0.0;2.0 +0.514;1.0;2.0 +0.493;1.0;2.0 +0.437;0.0;2.0 +0.452;1.0;2.0 +0.727;0.0;2.0 +0.523;1.0;2.0 +0.485;1.0;2.0 +0.439;1.0;2.0 +0.683;0.0;2.0 +0.578;1.0;2.0 +0.431;1.0;2.0 +0.562;0.0;2.0 +0.471;1.0;2.0 +0.786;1.0;2.0 +0.434;1.0;2.0 +0.441;1.0;2.0 +0.745;1.0;2.0 +0.533;1.0;2.0 +0.756;0.0;2.0 +0.678;1.0;2.0 +0.494;1.0;2.0 +1.028;1.0;2.0 +0.475;0.0;2.0 +0.563;0.0;2.0 +0.483;1.0;2.0 +0.566;0.0;2.0 +0.466;1.0;2.0 +1.086;1.0;2.0 +0.573;1.0;2.0 +0.597;1.0;2.0 +0.597;0.0;2.0 +0.446;1.0;2.0 +0.437;1.0;2.0 +0.515;1.0;2.0 +0.524;0.0;2.0 +0.513;1.0;2.0 +0.465;1.0;2.0 +0.704;1.0;2.0 +0.801;1.0;2.0 +0.484;0.0;2.0 +0.459;0.0;2.0 +0.576;0.0;2.0 +0.462;1.0;2.0 +0.471;0.0;2.0 +0.595;1.0;2.0 +0.464;1.0;2.0 +0.644;1.0;2.0 +0.42;0.0;2.0 +0.452;1.0;2.0 +0.488;0.0;2.0 +0.568;1.0;2.0 +0.481;0.0;2.0 +0.5;1.0;2.0 +0.54;1.0;2.0 +0.447;0.0;2.0 +0.463;1.0;2.0 +0.507;1.0;2.0 +0.522;1.0;2.0 +0.58;1.0;2.0 +0.464;0.0;2.0 +0.507;0.0;2.0 +0.727;1.0;2.0 +0.452;1.0;2.0 +0.636;0.0;2.0 +0.552;1.0;2.0 +0.739;1.0;2.0 +0.468;1.0;2.0 +0.563;1.0;2.0 +0.443;1.0;2.0 +1.023;1.0;2.0 +0.571;1.0;2.0 +0.44;0.0;2.0 +0.717;1.0;2.0 +0.751;1.0;2.0 +0.491;0.0;2.0 +0.456;1.0;2.0 +0.569;1.0;2.0 +0.456;1.0;2.0 +0.517;1.0;2.0 +0.492;1.0;2.0 +0.527;1.0;2.0 +0.501;0.0;2.0 +0.499;0.0;2.0 +0.428;0.0;2.0 +0.529;0.0;2.0 +0.43;0.0;2.0 +0.453;0.0;2.0 +0.484;0.0;2.0 +0.541;1.0;2.0 +0.707;0.0;2.0 +0.712;1.0;2.0 +0.53;0.0;2.0 +0.871;1.0;2.0 +0.896;1.0;2.0 +0.548;0.0;2.0 +0.484;1.0;2.0 +0.779;1.0;2.0 +0.503;0.0;2.0 +0.696;0.0;2.0 +0.522;0.0;2.0 +0.93;1.0;2.0 +0.535;0.0;2.0 +0.615;1.0;2.0 +0.624;1.0;2.0 +0.742;0.0;2.0 +0.528;1.0;2.0 +0.441;1.0;2.0 +0.514;0.0;2.0 +0.445;0.0;2.0 +0.625;0.0;2.0 +0.578;1.0;2.0 +0.55;1.0;2.0 +0.686;1.0;2.0 +0.505;1.0;2.0 +0.872;1.0;2.0 +0.548;1.0;2.0 +0.487;0.0;2.0 +0.733;0.0;2.0 +0.46;0.0;2.0 +0.764;1.0;2.0 +0.589;0.0;2.0 +0.482;0.0;2.0 +0.449;0.0;2.0 +0.428;0.0;2.0 +0.604;1.0;2.0 +0.505;1.0;2.0 +0.649;1.0;2.0 +0.484;1.0;2.0 +0.535;0.0;2.0 +0.471;0.0;2.0 +0.441;0.0;2.0 +0.528;0.0;2.0 +0.621;0.0;2.0 +0.48;1.0;2.0 +0.693;1.0;2.0 +0.493;1.0;2.0 diff --git a/HW3/Q6/trace_plot.png b/HW3/Q6/trace_plot.png new file mode 100644 index 0000000..92f4bf4 Binary files /dev/null and b/HW3/Q6/trace_plot.png differ diff --git a/HW3/out/a.png b/HW3/out/a.png new file mode 100644 index 0000000..fe599e6 Binary files /dev/null and b/HW3/out/a.png differ diff --git a/HW3/out/t0.png b/HW3/out/t0.png new file mode 100644 index 0000000..06933bb Binary files /dev/null and b/HW3/out/t0.png differ diff --git a/HW3/out/z.png b/HW3/out/z.png new file mode 100644 index 0000000..5f34c1f Binary files /dev/null and b/HW3/out/z.png differ diff --git a/HW3/requirements.txt b/HW3/requirements.txt new file mode 100644 index 0000000..3e6b505 --- /dev/null +++ b/HW3/requirements.txt @@ -0,0 +1,15 @@ +contourpy==1.3.1 +cycler==0.12.1 +fonttools==4.56.0 +kiwisolver==1.4.8 +matplotlib==3.10.1 +numpy==2.2.3 +packaging==24.2 +pandas==2.2.3 +paranoid-scientist==0.2.3 +pillow==11.1.0 +pyparsing==3.2.1 +python-dateutil==2.9.0.post0 +pytz==2025.1 +six==1.17.0 +tzdata==2025.1