Datasets:

casey-martin

/

math_notebooks

like 0

# Gaussian Process Distribution of Relaxation Times ## In this tutorial we will reproduce Figure 7 of the article https://doi.org/10.1016/j.electacta.2019.135316 GP-DRT is our newly developed approach that can be used to obtain both the mean and covariance of the DRT from EIS data by assuming that the DRT is a Gaussian process (GP). The GP-DRP can predict the DRT and the imaginary part of the impedance at frequencies that were not previously measured. To obtain the DRT from the impedance we take that $\gamma(\xi)$ is a GP where $f$ is the frequency and $\xi=\log f$. Under the DRT model and considering that GPs are closed linear transformations, it follows that $Z^{\rm DRT}_{\rm im}\left(\xi\right)$ is also a GP. In other words, we can write $$\begin{pmatrix} \gamma(\xi) \\ Z^{\rm DRT}_{\rm im}\left(\xi\right) \end{pmatrix}\sim \mathcal{GP}\left(\mathbf 0, \begin{pmatrix} k(\xi, \xi^\prime) & \mathcal L^{\rm im}_{\xi^\prime} \left(k(\xi, \xi^\prime)\right)\\ \mathcal L^{\rm im}_{\xi} k(\xi, \xi^\prime) & \mathcal L^{\rm im}_{\xi^\prime}\left(\mathcal L^{\rm im}_{\xi} \left(k(\xi, \xi^\prime)\right)\right) \end{pmatrix}\right)$$ where $$\mathcal L^{\rm im}_\xi \left(\cdot\right) = -\displaystyle \int_{-\infty}^\infty \frac{2\pi \displaystyle e^{\xi-\hat \xi}}{1+\left(2\pi \displaystyle e^{\xi-\hat \xi}\right)^2} \left(\cdot\right) d \hat \xi$$ is a linear functional. The latter functional, maps the DRT to the imaginary part of the impedance. Assuming $N$ observations, we can set $\left(\mathbf Z^{\rm exp}_{\rm im}\right)_n = Z^{\rm exp}_{\rm im}(\xi_n)$ with $\xi_n =\log f_n$ and $n =1, 2, \ldots N $. The corresponding multivariate Gaussian random variable can be written as $$\begin{pmatrix} \boldsymbol{\gamma} \\ \mathbf Z^{\rm exp}_{\rm im} \end{pmatrix}\sim \mathcal{N}\left(\mathbf 0, \begin{pmatrix} \mathbf K & \mathcal L_{\rm im} \mathbf K\\ \mathcal L_{\rm im}^\sharp \mathbf K & \mathcal L^2_{\rm im} \mathbf K + \sigma_n^2 \mathbf I \end{pmatrix}\right)$$ where $$\begin{align} (\mathbf K)_{nm} &= k(\xi_n, \xi_m)\\ (\mathcal L_{\rm im} \mathbf K)_{nm} &= \left. \mathcal L^{\rm im}_{\xi^\prime} \left(k(\xi, \xi^\prime)\right) \right |_{\xi_n, \xi_m}\\ (\mathcal L_{\rm im}^\sharp \mathbf K)_{nm} &= \left.\mathcal L^{\rm im}_{\xi} \left(k(\xi, \xi^\prime)\right) \right|_{\xi_n, \xi_m}\\ (\mathcal L^2_{\rm im} \mathbf K)_{nm} &= \left.\mathcal L^{\rm im}_{\xi^\prime}\left(\mathcal L^{\rm im}_{\xi} \left(k(\xi, \xi^\prime)\right)\right) \right|_{\xi_n, \xi_m} \end{align}$$ and $\mathcal L_{\rm im} \mathbf K^\top = \mathcal L_{\rm im}^\sharp \mathbf K$. To obtain the DRT from impedance, the distribution of $\mathbf{\gamma}$ conditioned on $\mathbf Z^{\rm exp}_{\rm im}$ can be written as $$\boldsymbol{\gamma}|\mathbf Z^{\rm exp}_{\rm im}\sim \mathcal N\left( \mathbf \mu_{\gamma|Z^{\rm exp}_{\rm im}}, \mathbf\Sigma_{\gamma| Z^{\rm exp}_{\rm im}}\right)$$ with $$\begin{align} \mathbf \mu_{\gamma|Z^{\rm exp}_{\rm im}} &= \mathcal L_{\rm im} \mathbf K \left(\mathcal L^2_{\rm im} \mathbf K + \sigma_n^2 \mathbf I \right)^{-1} \mathbf Z^{\rm exp}_{\rm im} \\ \mathbf \Sigma_{\gamma| Z^{\rm exp}_{\rm im}} &= \mathbf K- \mathcal L_{\rm im} \mathbf K \left(\mathcal L^2_{\rm im} \mathbf K + \sigma_n^2 \mathbf I \right)^{-1}\mathcal L_{\rm im} \mathbf K^\top \end{align}$$ The above formulas depend on 1) the kernel, $k(\xi, \xi^\prime)$; 2) the noise level, $\sigma_n$; and 3) the experimental data, $\mathbf Z^{\rm exp}_{\rm im}$ (at the log-frequencies $\mathbf \xi$). ```python import numpy as np import matplotlib.pyplot as plt from math import sin, cos, pi import GP_DRT from scipy.optimize import minimize %matplotlib inline ``` ## 1) Define parameters of the ZARC circuit which will be used for the synthetic experiment generation The impedance of a ZARC can be written as $$ Z^{\rm exact}(f) = R_\infty + \displaystyle \frac{1}{\displaystyle \frac{1}{R_{\rm ct}}+C \left(i 2\pi f\right)^\phi} $$ where $\displaystyle C = \frac{\tau_0^\phi}{R_{\rm ct}}$. The corresponding DRT is given by $$ \gamma(\log \tau) = \displaystyle \frac{\displaystyle R_{\rm ct}}{\displaystyle 2\pi} \displaystyle \frac{\displaystyle \sin\left((1-\phi)\pi\right)}{\displaystyle \cosh(\phi \log(\tau/\tau_0))-\cos(\pi(1-\phi))} $$ ```python # define the frequency range N_freqs = 81 freq_vec = np.logspace(-4., 4., num=N_freqs, endpoint=True) xi_vec = np.log(freq_vec) tau = 1/freq_vec # define the frequency range used for prediction # note: we could have used other values freq_vec_star = np.logspace(-4., 4., num=81, endpoint=True) xi_vec_star = np.log(freq_vec_star) # parameters for ZARC model, the impedance and analytical DRT are calculated as the above equations R_inf = 10 R_ct = 50 phi = 0.8 tau_0 = 1. C = tau_0**phi/R_ct Z_exact = R_inf+1./(1./R_ct+C*(1j*2.*pi*freq_vec)**phi) gamma_fct = (R_ct)/(2.*pi)*sin((1.-phi)*pi)/(np.cosh(phi*np.log(tau/tau_0))-cos((1.-phi)*pi)) # we will use a finer mesh for plotting the results freq_vec_plot = np.logspace(-4., 4., num=10*(N_freqs-1), endpoint=True) tau_plot = 1/freq_vec_plot # for plotting only gamma_fct_plot = (R_ct)/(2.*pi)*sin((1.-phi)*pi)/(np.cosh(phi*np.log(tau_plot/tau_0))-cos((1.-phi)*pi)) # we will add noise to the impedance computed analytically rng = np.random.seed(214975) sigma_n_exp = 1. Z_exp = Z_exact + sigma_n_exp*(np.random.normal(0, 1, N_freqs)+1j*np.random.normal(0, 1, N_freqs)) ``` ## 2) Show the synthetic impedance in the Nyquist plot - this is similar to Figure 7 (a) ```python plt.rc('text', usetex=True) plt.rc('font', family='serif', size=15) plt.rc('xtick', labelsize=15) plt.rc('ytick', labelsize=15) # Nyquist plot of the impedance plt.plot(np.real(Z_exact), -np.imag(Z_exact), linewidth=4, color="black", label="exact") plt.plot(np.real(Z_exp), -np.imag(Z_exp), "o", markersize=10, color="red", label="synth exp") plt.plot(np.real(Z_exp[20:60:10]), -np.imag(Z_exp[20:60:10]), 's', markersize=10, color="black") plt.legend(frameon=False, fontsize = 15) plt.axis('scaled') plt.xticks(range(10, 70, 10)) plt.yticks(range(0, 60, 10)) plt.gca().set_aspect('equal', adjustable='box') plt.xlabel(r'$Z_{\rm re}/\Omega$', fontsize = 20) plt.ylabel(r'$-Z_{\rm im}/\Omega$', fontsize = 20) # label the frequency points plt.annotate(r'$10^{-2}$', xy=(np.real(Z_exp[20]), -np.imag(Z_exp[20])), xytext=(np.real(Z_exp[20])-2, 10-np.imag(Z_exp[20])), arrowprops=dict(arrowstyle="-",connectionstyle="arc")) plt.annotate(r'$10^{-1}$', xy=(np.real(Z_exp[30]), -np.imag(Z_exp[30])), xytext=(np.real(Z_exp[30])-2, 6-np.imag(Z_exp[30])), arrowprops=dict(arrowstyle="-",connectionstyle="arc")) plt.annotate(r'$1$', xy=(np.real(Z_exp[40]), -np.imag(Z_exp[40])), xytext=(np.real(Z_exp[40]), 10-np.imag(Z_exp[40])), arrowprops=dict(arrowstyle="-",connectionstyle="arc")) plt.annotate(r'$10$', xy=(np.real(Z_exp[50]), -np.imag(Z_exp[50])), xytext=(np.real(Z_exp[50])-1, 10-np.imag(Z_exp[50])), arrowprops=dict(arrowstyle="-",connectionstyle="arc")) plt.show() ``` ## 3) Obtain the optimal hyperparameters of the GP-DRT model by minimizing the negative marginal log-likelihood (NMLL) We constrain the kernel to be a squared exponential, _i.e._, $$ k(\xi, \xi^\prime) = \sigma_f^2 \exp\left(-\frac{1}{2 \ell^2}\left(\xi-\xi^\prime\right)^2 \right) $$ and optimize its two parameters, $\sigma_f$ and $\ell$ as well as the noise level $\sigma_n$. Therefore, the vector of GP-DRT hyperparameters is $\boldsymbol \theta = \begin{pmatrix} \sigma_n, \sigma_f, \ell \end{pmatrix}^\top$. Following the article, we can write that $$ \log p(\mathbf Z^{\rm exp}_{\rm im}|\boldsymbol \xi, \boldsymbol \theta)= - \frac{1}{2} {\mathbf Z^{\rm exp}_{\rm im}}^\top \left(\mathcal L^2_{\rm im} \mathbf K +\sigma_n^2\mathbf I \right)^{-1} \mathbf Z^{\rm exp}_{\rm im} -\frac{1}{2} \log \left| \mathcal L^2_{\rm im} \mathbf K+\sigma_n^2\mathbf I \right| - \frac{N}{2} \log 2\pi $$ We will call $L(\boldsymbol \theta)$ the negative (and shifted) MLL (NMLL): $$ L(\boldsymbol \theta) = - \log p(\mathbf Z^{\rm exp}_{\rm im}|\boldsymbol \xi, \boldsymbol \theta) - \frac{N}{2} \log 2\pi $$ the experimental evidence is maximized for $$ \boldsymbol \theta = \arg \min_{\boldsymbol \theta^\prime}L(\boldsymbol \theta^\prime) $$ The above minimization problem is solved using the `optimize` function given in `scipy` ```python # initialize the parameters for the minimization of the NMLL, see (31) in the manuscript sigma_n = sigma_n_exp sigma_f = 5. ell = 1. theta_0 = np.array([sigma_n, sigma_f, ell]) seq_theta = np.copy(theta_0) def print_results(theta): global seq_theta seq_theta = np.vstack((seq_theta, theta)) print('{0:.7f} {1:.7f} {2:.7f}'.format(theta[0], theta[1], theta[2])) print('sigma_n, sigma_f, ell') # minimize the NMLL L(\theta) w.r.t sigma_n, sigma_f, ell using the Newton-CG method as implemented in scipy res = minimize(GP_DRT.NMLL_fct, theta_0, args=(Z_exp, xi_vec), method='Newton-CG', \ jac=GP_DRT.grad_NMLL_fct, callback=print_results, options={'disp': True}) # collect the optimized parameters sigma_n, sigma_f, ell = res.x ``` sigma_n, sigma_f, ell 0.8903599 5.0014151 1.0120875 0.8136354 5.0035337 1.0291912 0.8291863 5.0357867 1.2588673 0.8303934 5.0832372 1.2117784 0.8304464 5.2060761 1.2283664 0.8305219 5.3874435 1.2524151 0.8305286 5.4068909 1.2546651 0.8305276 5.4070863 1.2546870 0.8305265 5.4070865 1.2546866 Optimization terminated successfully. Current function value: 53.657989 Iterations: 9 Function evaluations: 11 Gradient evaluations: 54 Hessian evaluations: 0 ## 4) Core of the GP-DRT ### 4a) Compute matrices Once we have identified the optimized parameters we can compute $\mathbf K$, $\mathcal L_{\rm im} \mathbf K$, and $\mathcal L^2_{\rm im} \mathbf K$, which are given in equation (18) in the article ```python K = GP_DRT.matrix_K(xi_vec, xi_vec, sigma_f, ell) L_im_K = GP_DRT.matrix_L_im_K(xi_vec, xi_vec, sigma_f, ell) L2_im_K = GP_DRT.matrix_L2_im_K(xi_vec, xi_vec, sigma_f, ell) Sigma = (sigma_n**2)*np.eye(N_freqs) ``` ### 4b) Factorize the matrices and solve the linear equations We are computing $$ \boldsymbol{\gamma}|\mathbf Z^{\rm exp}_{\rm im}\sim \mathcal N\left( \boldsymbol \mu_{\gamma|Z^{\rm exp}_{\rm im}}, \boldsymbol \Sigma_{\gamma| Z^{\rm exp}_{\rm im}}\right) $$ using $$ \begin{align} \boldsymbol \mu_{\gamma|Z^{\rm exp}_{\rm im}} &= \mathcal L_{\rm im} \mathbf K\left(\mathcal L^2_{\rm im} \mathbf K+\sigma_n^2\mathbf I\right)^{-1}\mathbf Z^{\rm exp}_{\rm im} \\ \boldsymbol \Sigma_{\gamma| Z^{\rm exp}_{\rm im}} &= \mathbf K-\mathcal L_{\rm im} \mathbf K\left(\mathcal L^2_{\rm im} \mathbf K+\sigma_n^2\mathbf I\right)^{-1}\mathcal L_{\rm im} \mathbf K^\top \end{align} $$ The key step is to do Cholesky factorization of $\mathcal L^2_{\rm im} \mathbf K+\sigma_n^2\mathbf I$, _i.e._, K_im_full ```python # the matrix $\mathcal L^2_{\rm im} \mathbf K + \sigma_n^2 \mathbf I$ whose inverse is needed K_im_full = L2_im_K + Sigma # check if the K_im_full is positive definite, otherwise, a nearest one would replace the K_im_full if not GP_DRT.is_PD(K_im_full): K_im_full = GP_DRT.nearest_PD(K_im_full) # Cholesky factorization, L is a lower-triangular matrix L = np.linalg.cholesky(K_im_full) # solve for alpha alpha = np.linalg.solve(L, Z_exp.imag) alpha = np.linalg.solve(L.T, alpha) # estimate the gamma of eq (21a) gamma_fct_est = np.dot(L_im_K, alpha) # covariance matrix inv_L = np.linalg.inv(L) inv_K_im_full = np.dot(inv_L.T, inv_L) # estimate the sigma of gamma for eq (21b) cov_gamma_fct_est = K - np.dot(L_im_K, np.dot(inv_K_im_full, L_im_K.T)) sigma_gamma_fct_est = np.sqrt(np.diag(cov_gamma_fct_est)) ``` ### 4c) Plot the obtained DRT against the analytical DRT ```python # plot the DRT and its confidence region plt.semilogx(freq_vec_plot, gamma_fct_plot, linewidth=4, color="black", label="exact") plt.semilogx(freq_vec, gamma_fct_est, linewidth=4, color="red", label="GP-DRT") plt.fill_between(freq_vec, gamma_fct_est-3*sigma_gamma_fct_est, gamma_fct_est+3*sigma_gamma_fct_est, color="0.4", alpha=0.3) plt.rc('text', usetex=True) plt.rc('font', family='serif', size=15) plt.rc('xtick', labelsize=15) plt.rc('ytick', labelsize=15) plt.axis([1E-4,1E4,-5,25]) plt.legend(frameon=False, fontsize = 15) plt.xlabel(r'$f/{\rm Hz}$', fontsize = 20) plt.ylabel(r'$\gamma/\Omega$', fontsize = 20) plt.show() ``` ### 4d) Predict the $\gamma$ and the imaginary part of the GP-DRT impedance #### This part is explained in Section 2.3.3 of the main article ```python # initialize the imaginary part of impedance vector Z_im_vec_star = np.empty_like(xi_vec_star) Sigma_Z_im_vec_star = np.empty_like(xi_vec_star) gamma_vec_star = np.empty_like(xi_vec_star) Sigma_gamma_vec_star = np.empty_like(xi_vec_star) # calculate the imaginary part of impedance at each $\xi$ point for the plot for index, val in enumerate(xi_vec_star): xi_star = np.array([val]) # compute matrices shown in eq (23), xi_star corresponds to a new point k_star = GP_DRT.matrix_K(xi_vec, xi_star, sigma_f, ell) L_im_k_star_up = GP_DRT.matrix_L_im_K(xi_star, xi_vec, sigma_f, ell) L2_im_k_star = GP_DRT.matrix_L2_im_K(xi_vec, xi_star, sigma_f, ell) k_star_star = GP_DRT.matrix_K(xi_star, xi_star, sigma_f, ell) L_im_k_star_star = GP_DRT.matrix_L_im_K(xi_star, xi_star, sigma_f, ell) L2_im_k_star_star = GP_DRT.matrix_L2_im_K(xi_star, xi_star, sigma_f, ell) # compute Z_im_star mean and standard deviation using eq (26) Z_im_vec_star[index] = np.dot(L2_im_k_star.T, np.dot(inv_K_im_full, Z_exp.imag)) Sigma_Z_im_vec_star[index] = L2_im_k_star_star-np.dot(L2_im_k_star.T, np.dot(inv_K_im_full, L2_im_k_star)) # compute gamma_star mean and standard deviation using eq (29) gamma_vec_star[index] = np.dot(L_im_k_star_up, np.dot(inv_K_im_full, Z_exp.imag)) Sigma_gamma_vec_star[index] = k_star_star-np.dot(L_im_k_star_up, np.dot(inv_K_im_full, L_im_k_star_up.T)) ``` ### 4e) Plot the imaginary part of the GP-DRT impedance together with the exact one and the synthetic experiment ```python plt.semilogx(freq_vec_star, -np.imag(Z_exact), ":", linewidth=4, color="blue", label="exact") plt.semilogx(freq_vec, -Z_exp.imag, "o", markersize=10, color="black", label="synth exp") plt.semilogx(freq_vec_star, -Z_im_vec_star, linewidth=4, color="red", label="GP-DRT") plt.fill_between(freq_vec_star, -Z_im_vec_star-3*np.sqrt(abs(Sigma_Z_im_vec_star)), -Z_im_vec_star+3*np.sqrt(abs(Sigma_Z_im_vec_star)), alpha=0.3) plt.rc('text', usetex=True) plt.rc('font', family='serif', size=15) plt.rc('xtick', labelsize=15) plt.rc('ytick', labelsize=15) plt.axis([1E-4,1E4,-5,25]) plt.legend(frameon=False, fontsize = 15) plt.xlabel(r'$f/{\rm Hz}$', fontsize = 20) plt.ylabel(r'$-Z_{\rm im}/\Omega$', fontsize = 20) plt.show() ```

eb88848b4b82d459b5b2abdd47eafd99aa36c1c9

ipynb

Jupyter Notebook

tutorials/ex1_single_ZARC.ipynb

jiapeng-liu/GP-DRT

1bd8232dc07b84293ea6960a669f04e5a875d982

2019-11-26T16:58:01.000Z

2022-02-23T10:27:07.000Z

tutorials/ex1_single_ZARC.ipynb

jiapeng-liu/GP-DRT

1bd8232dc07b84293ea6960a669f04e5a875d982

2021-02-07T17:10:35.000Z

2021-08-06T04:20:22.000Z

tutorials/ex1_single_ZARC.ipynb

jiapeng-liu/GP-DRT

1bd8232dc07b84293ea6960a669f04e5a875d982

2019-11-27T02:38:39.000Z

2022-03-18T08:17:47.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# Algebra Lineal con Python ## Introducción Una de las herramientas matemáticas más utilizadas en [machine learning](http://es.wikipedia.org/wiki/Machine_learning) y [data mining](http://es.wikipedia.org/wiki/Miner%C3%ADa_de_datos) es el [Álgebra lineal](http://es.wikipedia.org/wiki/%C3%81lgebra_lineal); por tanto, si queremos incursionar en el fascinante mundo del aprendizaje automático y el análisis de datos es importante reforzar los conceptos que forman parte de sus cimientos. El [Álgebra lineal](http://es.wikipedia.org/wiki/%C3%81lgebra_lineal) es una rama de las [matemáticas](http://es.wikipedia.org/wiki/Matem%C3%A1ticas) que es sumamente utilizada en el estudio de una gran variedad de ciencias, como ingeniería, finanzas, investigación operativa, entre otras. Es una extensión del [álgebra](http://es.wikipedia.org/wiki/%C3%81lgebra) que aprendemos en la escuela secundaria, hacia un mayor número de dimensiones; en lugar de trabajar con incógnitas a nivel de <a href="http://es.wikipedia.org/wiki/Escalar_(matem%C3%A1tica)">escalares</a> comenzamos a trabajar con <a href="http://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matrices</a> y [vectores](http://es.wikipedia.org/wiki/Vector). El estudio del [Álgebra lineal](http://es.wikipedia.org/wiki/%C3%81lgebra_lineal) implica trabajar con varios objetos matemáticos, como ser: * **Los <a href="http://es.wikipedia.org/wiki/Escalar_(matem%C3%A1tica)">Escalares</a>**: Un *escalar* es un solo número, en contraste con la mayoría de los otros objetos estudiados en [Álgebra lineal](http://es.wikipedia.org/wiki/%C3%81lgebra_lineal), que son generalmente una colección de múltiples números. * **Los [Vectores](http://es.wikipedia.org/wiki/Vector)**:Un *vector* es una serie de números. Los números tienen una orden preestablecido, y podemos identificar cada número individual por su índice en ese orden. Podemos pensar en los *vectores* como la identificación de puntos en el espacio, con cada elemento que da la coordenada a lo largo de un eje diferente. Existen dos tipos de *vectores*, los *vectores de fila* y los *vectores de columna*. Podemos representarlos de la siguiente manera, dónde *f* es un vector de fila y *c* es un vector de columna: $$f=\begin{bmatrix}0&1&-1\end{bmatrix} ; c=\begin{bmatrix}0\\1\\-1\end{bmatrix}$$ * **Las <a href="http://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">Matrices</a>**: Una *matriz* es un arreglo bidimensional de números (llamados entradas de la matriz) ordenados en filas (o renglones) y columnas, donde una fila es cada una de las líneas horizontales de la matriz y una columna es cada una de las líneas verticales. En una *matriz* cada elemento puede ser identificado utilizando dos índices, uno para la fila y otro para la columna en que se encuentra. Las podemos representar de la siguiente manera, *A* es una matriz de 3x2. $$A=\begin{bmatrix}0 & 1& \\-1 & 2 \\ -2 & 3\end{bmatrix}$$ * **Los [Tensores](http://es.wikipedia.org/wiki/C%C3%A1lculo_tensorial)**:En algunos casos necesitaremos una matriz con más de dos ejes. En general, una serie de números dispuestos en una cuadrícula regular con un número variable de ejes es conocido como un *tensor*. Sobre estos objetos podemos realizar las operaciones matemáticas básicas, como ser [adición](http://es.wikipedia.org/wiki/Adici%C3%B3n), [multiplicación](http://es.wikipedia.org/wiki/Multiplicaci%C3%B3n), [sustracción](http://es.wikipedia.org/wiki/Sustracci%C3%B3n) y <a href="http://es.wikipedia.org/wiki/Divisi%C3%B3n_(matem%C3%A1tica)" >división</a>, es decir que vamos a poder sumar [vectores](http://es.wikipedia.org/wiki/Vector) con <a href="http://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matrices</a>, multiplicar <a href="http://es.wikipedia.org/wiki/Escalar_(matem%C3%A1tica)">escalares</a> a [vectores](http://es.wikipedia.org/wiki/Vector) y demás. ## Librerías de Python para álgebra lineal Los principales módulos que [Python](http://python.org/) nos ofrece para realizar operaciones de [Álgebra lineal](http://es.wikipedia.org/wiki/%C3%81lgebra_lineal) son los siguientes: * **[Numpy](http://www.numpy.org/)**: El popular paquete matemático de [Python](http://python.org/), nos va a permitir crear *[vectores](http://es.wikipedia.org/wiki/Vector)*, *<a href="http://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matrices</a>* y *[tensores](http://es.wikipedia.org/wiki/C%C3%A1lculo_tensorial)* con suma facilidad. * **[numpy.linalg](http://docs.scipy.org/doc/numpy/reference/routines.linalg.html)**: Este es un submodulo dentro de [Numpy](http://www.numpy.org/) con un gran número de funciones para resolver ecuaciones de [Álgebra lineal](http://es.wikipedia.org/wiki/%C3%81lgebra_lineal). * **[scipy.linalg](http://docs.scipy.org/doc/scipy/reference/tutorial/linalg.html)**: Este submodulo del paquete científico [Scipy](http://docs.scipy.org/doc/scipy/reference/index.html) es muy similar al anterior, pero con algunas más funciones y optimaciones. * **[Sympy](http://www.sympy.org/es/)**: Esta librería nos permite trabajar con matemática simbólica, convierte a [Python](http://python.org/) en un [sistema algebraico computacional](http://es.wikipedia.org/wiki/Sistema_algebraico_computacional). Nos va a permitir trabajar con ecuaciones y fórmulas simbólicamente, en lugar de numéricamente. * **[CVXOPT](http://cvxopt.org/)**: Este módulo nos permite resolver problemas de optimizaciones de [programación lineal](http://es.wikipedia.org/wiki/Programaci%C3%B3n_lineal). * **[PuLP](http://pythonhosted.org//PuLP/)**: Esta librería nos permite crear modelos de [programación lineal](http://es.wikipedia.org/wiki/Programaci%C3%B3n_lineal) en forma muy sencilla con [Python](http://python.org/). ## Operaciones básicas ### Vectores Un *[vector](http://es.wikipedia.org/wiki/Vector)* de largo `n` es una secuencia (o *array*, o *tupla*) de `n` números. La solemos escribir como x=(x1,...,xn) o x=[x1,...,xn] En [Python](http://python.org/), un *[vector](http://es.wikipedia.org/wiki/Vector)* puede ser representado con una simple *lista*, o con un *array* de [Numpy](http://www.numpy.org/); siendo preferible utilizar esta última opción. ```python # Vector como lista de Python v1 = [2, 4, 6] v1 ``` [2, 4, 6] ```python # Vectores con numpy import numpy as np v2 = np.ones(3) # vector de solo unos. v2 ``` array([1., 1., 1.]) ```python v3 = np.array([1, 3, 5]) # pasando una lista a las arrays de numpy v3 ``` array([1, 3, 5]) ```python v4 = np.arange(1, 8) # utilizando la funcion arange de numpy v4 ``` array([1, 2, 3, 4, 5, 6, 7]) ### Representación gráfica Tradicionalmente, los *[vectores](http://es.wikipedia.org/wiki/Vector)* son representados visualmente como flechas que parten desde el origen hacia un punto. Por ejemplo, si quisiéramos representar graficamente a los vectores v1=[2, 4], v2=[-3, 3] y v3=[-4, -3.5], podríamos hacerlo de la siguiente manera. ```python import matplotlib.pyplot as plt from warnings import filterwarnings %matplotlib inline filterwarnings('ignore') # Ignorar warnings ``` ```python def move_spines(): """Crea la figura de pyplot y los ejes. Mueve las lineas de la izquierda y de abajo para que se intersecten con el origen. Elimina las lineas de la derecha y la de arriba. Devuelve los ejes.""" fix, ax = plt.subplots() for spine in ["left", "bottom"]: ax.spines[spine].set_position("zero") for spine in ["right", "top"]: ax.spines[spine].set_color("none") return ax def vect_fig(): """Genera el grafico de los vectores en el plano""" ax = move_spines() ax.set_xlim(-5, 5) ax.set_ylim(-5, 5) ax.grid() vecs = [[2, 4], [-3, 3], [-4, -3.5]] # lista de vectores for v in vecs: ax.annotate(" ", xy=v, xytext=[0, 0], arrowprops=dict(facecolor="blue", shrink=0, alpha=0.7, width=0.5)) ax.text(1.1 * v[0], 1.1 * v[1], v) ``` ```python vect_fig() # crea el gráfico ``` ### Operaciones con vectores Las operaciones más comunes que utilizamos cuando trabajamos con *[vectores](http://es.wikipedia.org/wiki/Vector)* son la *suma*, la *resta* y la *multiplicación por <a href="http://es.wikipedia.org/wiki/Escalar_(matem%C3%A1tica)">escalares</a>*. Cuando *sumamos* dos *[vectores](http://es.wikipedia.org/wiki/Vector)*, vamos sumando elemento por elemento de cada *[vector](http://es.wikipedia.org/wiki/Vector)*. $$ \begin{split}x + y = \left[ \begin{array}{c} x_1 \\ x_2 \\ \vdots \\ x_n \end{array} \right] + \left[ \begin{array}{c} y_1 \\ y_2 \\ \vdots \\ y_n \end{array} \right] := \left[ \begin{array}{c} x_1 + y_1 \\ x_2 + y_2 \\ \vdots \\ x_n + y_n \end{array} \right]\end{split}$$ De forma similar funciona la operación de resta. $$ \begin{split}x - y = \left[ \begin{array}{c} x_1 \\ x_2 \\ \vdots \\ x_n \end{array} \right] - \left[ \begin{array}{c} y_1 \\ y_2 \\ \vdots \\ y_n \end{array} \right] := \left[ \begin{array}{c} x_1 - y_1 \\ x_2 - y_2 \\ \vdots \\ x_n - y_n \end{array} \right]\end{split}$$ La *multiplicación por <a href="http://es.wikipedia.org/wiki/Escalar_(matem%C3%A1tica)">escalares</a>* es una operación que toma a un número $\gamma$, y a un *[vector](http://es.wikipedia.org/wiki/Vector)* $x$ y produce un nuevo *[vector](http://es.wikipedia.org/wiki/Vector)* donde cada elemento del vector $x$ es multiplicado por el número $\gamma$. $$\begin{split}\gamma x := \left[ \begin{array}{c} \gamma x_1 \\ \gamma x_2 \\ \vdots \\ \gamma x_n \end{array} \right]\end{split}$$ En [Python](http://python.org/) podríamos realizar estas operaciones en forma muy sencilla: ```python # Ejemplo en Python x = np.arange(1, 5) y = np.array([2, 4, 6, 8]) x, y ``` (array([1, 2, 3, 4]), array([2, 4, 6, 8])) ```python # sumando dos vectores numpy x + y ``` array([ 3, 6, 9, 12]) ```python # restando dos vectores x - y ``` array([-1, -2, -3, -4]) ```python # multiplicando por un escalar x * 2 ``` array([2, 4, 6, 8]) ```python y * 3 ``` array([ 6, 12, 18, 24]) #### Producto escalar o interior El [producto escalar](https://es.wikipedia.org/wiki/Producto_escalar) de dos *[vectores](http://es.wikipedia.org/wiki/Vector)* se define como la suma de los productos de sus elementos, suele representarse matemáticamente como < x, y > o x'y, donde x e y son dos vectores. $$< x, y > := \sum_{i=1}^n x_i y_i$$ Dos *[vectores](http://es.wikipedia.org/wiki/Vector)* son <a href="https://es.wikipedia.org/wiki/Ortogonalidad_(matem%C3%A1ticas)">ortogonales</a> o perpendiculares cuando forman ángulo recto entre sí. Si el producto escalar de dos vectores es cero, ambos vectores son <a href="https://es.wikipedia.org/wiki/Ortogonalidad_(matem%C3%A1ticas)">ortogonales</a>. Adicionalmente, todo [producto escalar](https://es.wikipedia.org/wiki/Producto_escalar) induce una [norma](https://es.wikipedia.org/wiki/Norma_vectorial) sobre el espacio en el que está definido, de la siguiente manera: $$\| x \| := \sqrt{< x, x>} := \left( \sum_{i=1}^n x_i^2 \right)^{1/2}$$ En [Python](http://python.org/) lo podemos calcular de la siguiente forma: ```python # Calculando el producto escalar de los vectores x e y np.dot(x, y) ``` 60 ```python # o lo que es lo mismo, que: sum(x * y) ``` 60 ```python # Calculando la norma del vector X np.linalg.norm(x) ``` 5.477225575051661 ```python # otra forma de calcular la norma de x np.sqrt(np.dot(x, x)) ``` 5.477225575051661 ```python # vectores ortogonales v1 = np.array([3, 4]) v2 = np.array([4, -3]) np.dot(v1, v2) ``` 0 ### Matrices Las <a href="http://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matrices</a> son una forma clara y sencilla de organizar los datos para su uso en operaciones lineales. Una <a href="http://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matriz</a> `n × k` es una agrupación rectangular de números con n filas y k columnas; se representa de la siguiente forma: $$\begin{split}A = \left[ \begin{array}{cccc} a_{11} & a_{12} & \cdots & a_{1k} \\ a_{21} & a_{22} & \cdots & a_{2k} \\ \vdots & \vdots & & \vdots \\ a_{n1} & a_{n2} & \cdots & a_{nk} \end{array} \right]\end{split}$$ En la <a href="http://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matriz</a> A, el símbolo $a_{nk}$ representa el elemento n-ésimo de la fila en la k-ésima columna. La <a href="http://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matriz</a> A también puede ser llamada un *[vector](http://es.wikipedia.org/wiki/Vector)* si cualquiera de n o k son iguales a 1. En el caso de n=1, A se llama un *[vector](http://es.wikipedia.org/wiki/Vector) fila*, mientras que en el caso de k=1 se denomina un *[vector](http://es.wikipedia.org/wiki/Vector) columna*. Las <a href="http://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matrices</a> se utilizan para múltiples aplicaciones y sirven, en particular, para representar los coeficientes de los sistemas de ecuaciones lineales o para representar transformaciones lineales dada una base. Pueden sumarse, multiplicarse y descomponerse de varias formas. ### Operaciones con matrices Al igual que con los *[vectores](http://es.wikipedia.org/wiki/Vector)*, que no son más que un caso particular, las <a href="http://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matrices</a> se pueden *sumar*, *restar* y la *multiplicar por <a href="http://es.wikipedia.org/wiki/Escalar_(matem%C3%A1tica)">escalares</a>*. Multiplicacion por escalares: $$\begin{split}\gamma A \left[ \begin{array}{ccc} a_{11} & \cdots & a_{1k} \\ \vdots & \vdots & \vdots \\ a_{n1} & \cdots & a_{nk} \\ \end{array} \right] := \left[ \begin{array}{ccc} \gamma a_{11} & \cdots & \gamma a_{1k} \\ \vdots & \vdots & \vdots \\ \gamma a_{n1} & \cdots & \gamma a_{nk} \\ \end{array} \right]\end{split}$$ Suma de matrices: $$\begin{split}A + B = \left[ \begin{array}{ccc} a_{11} & \cdots & a_{1k} \\ \vdots & \vdots & \vdots \\ a_{n1} & \cdots & a_{nk} \\ \end{array} \right] + \left[ \begin{array}{ccc} b_{11} & \cdots & b_{1k} \\ \vdots & \vdots & \vdots \\ b_{n1} & \cdots & b_{nk} \\ \end{array} \right] := \left[ \begin{array}{ccc} a_{11} + b_{11} & \cdots & a_{1k} + b_{1k} \\ \vdots & \vdots & \vdots \\ a_{n1} + b_{n1} & \cdots & a_{nk} + b_{nk} \\ \end{array} \right]\end{split}$$ Resta de matrices: $$\begin{split}A - B = \left[ \begin{array}{ccc} a_{11} & \cdots & a_{1k} \\ \vdots & \vdots & \vdots \\ a_{n1} & \cdots & a_{nk} \\ \end{array} \right]- \left[ \begin{array}{ccc} b_{11} & \cdots & b_{1k} \\ \vdots & \vdots & \vdots \\ b_{n1} & \cdots & b_{nk} \\ \end{array} \right] := \left[ \begin{array}{ccc} a_{11} - b_{11} & \cdots & a_{1k} - b_{1k} \\ \vdots & \vdots & \vdots \\ a_{n1} - b_{n1} & \cdots & a_{nk} - b_{nk} \\ \end{array} \right]\end{split}$$ Para los casos de suma y resta, hay que tener en cuenta que solo se pueden sumar o restar <a href="http://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matrices</a> que tengan las mismas dimensiones, es decir que si tengo una <a href="http://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matriz</a> A de dimensión 3x2 (3 filas y 2 columnas) solo voy a poder sumar o restar la <a href="http://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matriz</a> B si esta también tiene 3 filas y 2 columnas. ```python # Ejemplo en Python A = np.array([[1, 3, 2], [1, 0, 0], [1, 2, 2]]) B = np.array([[1, 0, 5], [7, 5, 0], [2, 1, 1]]) ``` ```python # suma de las matrices A y B A + B ``` array([[2, 3, 7], [8, 5, 0], [3, 3, 3]]) ```python # resta de matrices A - B ``` array([[ 0, 3, -3], [-6, -5, 0], [-1, 1, 1]]) ```python # multiplicando matrices por escalares A * 2 ``` array([[2, 6, 4], [2, 0, 0], [2, 4, 4]]) ```python B * 3 ``` array([[ 3, 0, 15], [21, 15, 0], [ 6, 3, 3]]) ```python # ver la dimension de una matriz A.shape ``` (3, 3) ```python # ver cantidad de elementos de una matriz A.size ``` 9 #### Multiplicacion o Producto de matrices La regla para la [multiplicación de matrices](https://es.wikipedia.org/wiki/Multiplicaci%C3%B3n_de_matrices) generaliza la idea del [producto interior](https://es.wikipedia.org/wiki/Producto_escalar) que vimos con los [vectores](http://es.wikipedia.org/wiki/Vector); y esta diseñada para facilitar las operaciones lineales básicas. Cuando [multiplicamos matrices](https://es.wikipedia.org/wiki/Multiplicaci%C3%B3n_de_matrices), el número de columnas de la primera <a href="http://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matriz</a> debe ser igual al número de filas de la segunda <a href="http://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matriz</a>; y el resultado de esta multiplicación va a tener el mismo número de filas que la primer <a href="http://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matriz</a> y el número de la columnas de la segunda <a href="http://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matriz</a>. Es decir, que si yo tengo una <a href="http://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matriz</a> A de dimensión 3x4 y la multiplico por una <a href="http://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matriz</a> B de dimensión 4x2, el resultado va a ser una <a href="http://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matriz</a> C de dimensión 3x2. Algo a tener en cuenta a la hora de [multiplicar matrices](https://es.wikipedia.org/wiki/Multiplicaci%C3%B3n_de_matrices) es que la propiedad [connmutativa](https://es.wikipedia.org/wiki/Conmutatividad) no se cumple. AxB no es lo mismo que BxA. Veamos los ejemplos en [Python](http://python.org/). ```python # Ejemplo multiplicación de matrices A = np.arange(1, 13).reshape(3, 4) #matriz de dimension 3x4 A ``` array([[ 1, 2, 3, 4], [ 5, 6, 7, 8], [ 9, 10, 11, 12]]) ```python B = np.arange(8).reshape(4,2) #matriz de dimension 4x2 B ``` array([[0, 1], [2, 3], [4, 5], [6, 7]]) ```python # Multiplicando A x B A.dot(B) #resulta en una matriz de dimension 3x2 ``` array([[ 40, 50], [ 88, 114], [136, 178]]) ```python # Multiplicando B x A B.dot(A) ``` Este ultimo ejemplo vemos que la propiedad conmutativa no se cumple, es más, [Python](http://python.org/) nos arroja un error, ya que el número de columnas de B no coincide con el número de filas de A, por lo que ni siquiera se puede realizar la multiplicación de B x A. Para una explicación más detallada del proceso de [multiplicación de matrices](https://es.wikipedia.org/wiki/Multiplicaci%C3%B3n_de_matrices), pueden consultar el siguiente [tutorial](http://www.mathsisfun.com/algebra/matrix-multiplying.html). #### La matriz identidad, la matriz inversa, la matrix transpuesta y el determinante La [matriz identidad](https://es.wikipedia.org/wiki/Matriz_identidad) es el elemento neutro en la [multiplicación de matrices](https://es.wikipedia.org/wiki/Multiplicaci%C3%B3n_de_matrices), es el equivalente al número 1. Cualquier matriz multiplicada por la [matriz identidad](https://es.wikipedia.org/wiki/Matriz_identidad) nos da como resultado la misma matriz. La [matriz identidad](https://es.wikipedia.org/wiki/Matriz_identidad) es una [matriz cuadrada](https://es.wikipedia.org/wiki/Matriz_cuadrada) (tiene siempre el mismo número de filas que de columnas); y su diagonal principal se compone de todos elementos 1 y el resto de los elementos se completan con 0. Suele representase con la letra I Por ejemplo la matriz identidad de 3x3 sería la siguiente: $$I=\begin{bmatrix}1 & 0 & 0 & \\0 & 1 & 0\\ 0 & 0 & 1\end{bmatrix}$$ Ahora que conocemos el concepto de la [matriz identidad](https://es.wikipedia.org/wiki/Matriz_identidad), podemos llegar al concepto de la [matriz inversa](https://es.wikipedia.org/wiki/Matriz_invertible). Si tenemos una matriz A, la [matriz inversa](https://es.wikipedia.org/wiki/Matriz_invertible) de A, que se representa como $A^{-1}$ es aquella [matriz cuadrada](https://es.wikipedia.org/wiki/Matriz_cuadrada) que hace que la multiplicación $A$x$A^{-1}$ sea igual a la [matriz identidad](https://es.wikipedia.org/wiki/Matriz_identidad) I. Es decir que es la <a href="http://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matriz</a> recíproca de A. $$A × A^{-1} = A^{-1} × A = I$$ Tener en cuenta que esta [matriz inversa](https://es.wikipedia.org/wiki/Matriz_invertible) en muchos casos puede no existir.En este caso se dice que la matriz es singular o degenerada. Una matriz es singular si y solo si su <a href="https://es.wikipedia.org/wiki/Determinante_(matem%C3%A1tica)">determinante</a> es nulo. El <a href="https://es.wikipedia.org/wiki/Determinante_(matem%C3%A1tica)">determinante</a> es un número especial que puede calcularse sobre las [matrices cuadradas](https://es.wikipedia.org/wiki/Matriz_cuadrada). Se calcula como la suma de los productos de las diagonales de la matriz en una dirección menos la suma de los productos de las diagonales en la otra dirección. Se represente con el símbolo |A|. $$A=\begin{bmatrix}a_{11} & a_{12} & a_{13} & \\a_{21} & a_{22} & a_{23} & \\ a_{31} & a_{32} & a_{33} & \end{bmatrix}$$ $$|A| = (a_{11} a_{22} a_{33} + a_{12} a_{23} a_{31} + a_{13} a_{21} a_{32} ) - (a_{31} a_{22} a_{13} + a_{32} a_{23} a_{11} + a_{33} a_{21} a_{12}) $$ Por último, la [matriz transpuesta](http://es.wikipedia.org/wiki/Matriz_transpuesta) es aquella en que las filas se transforman en columnas y las columnas en filas. Se representa con el símbolo $A^\intercal$ $$\begin{bmatrix}a & b & \\c & d & \\ e & f & \end{bmatrix}^T:=\begin{bmatrix}a & c & e &\\b & d & f & \end{bmatrix}$$ Ejemplos en [Python](http://python.org/): ```python # Creando una matriz identidad de 2x2 I = np.eye(2) I ``` array([[1., 0.], [0., 1.]]) ```python # Multiplicar una matriz por la identidad nos da la misma matriz A = np.array([[4, 7], [2, 6]]) A ``` array([[4, 7], [2, 6]]) ```python A.dot(I) # AxI = A ``` array([[4., 7.], [2., 6.]]) ```python # Calculando el determinante de la matriz A np.linalg.det(A) ``` 10.000000000000002 ```python # Calculando la inversa de A. A_inv = np.linalg.inv(A) A_inv ``` array([[ 0.6, -0.7], [-0.2, 0.4]]) ```python # A x A_inv nos da como resultado I. A.dot(A_inv) ``` array([[ 1.00000000e+00, -1.11022302e-16], [ 1.11022302e-16, 1.00000000e+00]]) ```python # Trasponiendo una matriz A = np.arange(6).reshape(3, 2) A ``` array([[0, 1], [2, 3], [4, 5]]) ```python np.transpose(A) ``` array([[0, 2, 4], [1, 3, 5]]) ### Sistemas de ecuaciones lineales Una de las principales aplicaciones del [Álgebra lineal](http://es.wikipedia.org/wiki/%C3%81lgebra_lineal) consiste en resolver problemas de sistemas de ecuaciones lineales. Una [ecuación lineal](https://es.wikipedia.org/wiki/Ecuaci%C3%B3n_de_primer_grado) es una ecuación que solo involucra sumas y restas de una variable o mas variables a la primera potencia. Es la ecuación de la línea recta.Cuando nuestro problema esta representado por más de una [ecuación lineal](https://es.wikipedia.org/wiki/Ecuaci%C3%B3n_de_primer_grado), hablamos de un [sistema de ecuaciones lineales](http://es.wikipedia.org/wiki/Sistema_de_ecuaciones_lineales). Por ejemplo, podríamos tener un sistema de dos ecuaciones con dos incógnitas como el siguiente: $$ x - 2y = 1$$ $$3x + 2y = 11$$ La idea es encontrar el valor de $x$ e $y$ que resuelva ambas ecuaciones. Una forma en que podemos hacer esto, puede ser representando graficamente ambas rectas y buscar los puntos en que las rectas se cruzan. En [Python](http://python.org/) esto se puede hacer en forma muy sencilla con la ayuda de [matplotlib](http://matplotlib.org/). ```python # graficando el sistema de ecuaciones. x_vals = np.linspace(0, 5, 50) # crea 50 valores entre 0 y 5 plt.plot(x_vals, (1 - x_vals)/-2) # grafica x - 2y = 1 plt.plot(x_vals, (11 - (3*x_vals))/2) # grafica 3x + 2y = 11 plt.axis(ymin = 0) ``` x - 2y = 1 x - 2y -x = 1 -x -2y = 1 -x -2y /2 = (1 - x)/2 -y = (1-x)/2 -y * (-1) = (1-x)/2 * (-1) y = (1-x)/(-2) y = -(1-x)/2 = (-1-(-x))/2 = (-1 + x)/2 = (x-1)/2 Luego de haber graficado las funciones, podemos ver que ambas rectas se cruzan en el punto (3, 1), es decir que la solución de nuestro sistema sería $x=3$ e $y=1$. En este caso, al tratarse de un sistema simple y con solo dos incógnitas, la solución gráfica puede ser de utilidad, pero para sistemas más complicados se necesita una solución numérica, es aquí donde entran a jugar las <a href="http://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matrices</a>. Ese mismo sistema se podría representar como una ecuación matricial de la siguiente forma: $$\begin{bmatrix}1 & -2 & \\3 & 2 & \end{bmatrix} \begin{bmatrix}x & \\y & \end{bmatrix} = \begin{bmatrix}1 & \\11 & \end{bmatrix}$$ Lo que es lo mismo que decir que la <a href="http://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matriz</a> A por la <a href="http://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matriz</a> $x$ nos da como resultado el [vector](http://es.wikipedia.org/wiki/Vector) b. $$ Ax = b$$ En este caso, ya sabemos el resultado de $x$, por lo que podemos comprobar que nuestra solución es correcta realizando la [multiplicación de matrices](https://es.wikipedia.org/wiki/Multiplicaci%C3%B3n_de_matrices). ```python # Comprobando la solucion con la multiplicación de matrices. A = np.array([[1., -2.], [3., 2.]]) x = np.array([[3.],[1.]]) A.dot(x) ``` array([[ 1.], [11.]]) Para resolver en forma numérica los [sistema de ecuaciones](http://es.wikipedia.org/wiki/Sistema_de_ecuaciones_lineales), existen varios métodos: * **El método de sustitución**: El cual consiste en despejar en una de las ecuaciones cualquier incógnita, preferiblemente la que tenga menor coeficiente y a continuación sustituirla en otra ecuación por su valor. * **El método de igualacion**: El cual se puede entender como un caso particular del método de sustitución en el que se despeja la misma incógnita en dos ecuaciones y a continuación se igualan entre sí la parte derecha de ambas ecuaciones. * **El método de reduccion**: El procedimiento de este método consiste en transformar una de las ecuaciones (generalmente, mediante productos), de manera que obtengamos dos ecuaciones en la que una misma incógnita aparezca con el mismo coeficiente y distinto signo. A continuación, se suman ambas ecuaciones produciéndose así la reducción o cancelación de dicha incógnita, obteniendo una ecuación con una sola incógnita, donde el método de resolución es simple. * **El método gráfico**: Que consiste en construir el gráfica de cada una de las ecuaciones del sistema. Este método (manualmente aplicado) solo resulta eficiente en el plano cartesiano (solo dos incógnitas). * **El método de Gauss**: El método de eliminación de Gauss o simplemente método de Gauss consiste en convertir un sistema lineal de n ecuaciones con n incógnitas, en uno escalonado, en el que la primera ecuación tiene n incógnitas, la segunda ecuación tiene n - 1 incógnitas, ..., hasta la última ecuación, que tiene 1 incógnita. De esta forma, será fácil partir de la última ecuación e ir subiendo para calcular el valor de las demás incógnitas. * **El método de Eliminación de Gauss-Jordan**: El cual es una variante del método anterior, y consistente en triangular la matriz aumentada del sistema mediante transformaciones elementales, hasta obtener ecuaciones de una sola incógnita. * **El método de Cramer**: El cual consiste en aplicar la [regla de Cramer](http://es.wikipedia.org/wiki/Regla_de_Cramer) para resolver el sistema. Este método solo se puede aplicar cuando la matriz de coeficientes del sistema es cuadrada y de determinante no nulo. La idea no es explicar cada uno de estos métodos, sino saber que existen y que [Python](http://python.org/) nos hacer la vida mucho más fácil, ya que para resolver un [sistema de ecuaciones](http://es.wikipedia.org/wiki/Sistema_de_ecuaciones_lineales) simplemente debemos llamar a la función `solve()`. Por ejemplo, para resolver este sistema de 3 ecuaciones y 3 incógnitas. $$ x + 2y + 3z = 6$$ $$ 2x + 5y + 2z = 4$$ $$ 6x - 3y + z = 2$$ Primero armamos la <a href="http://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matriz</a> A de coeficientes y la <a href="http://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matriz</a> b de resultados y luego utilizamos `solve()` para resolverla. ```python # Creando matriz de coeficientes A = np.array([[1, 2, 3], [2, 5, 2], [6, -3, 1]]) A ``` array([[ 1, 2, 3], [ 2, 5, 2], [ 6, -3, 1]]) ```python # Creando matriz de resultados b = np.array([6, 4, 2]) b ``` array([6, 4, 2]) ```python # Resolviendo sistema de ecuaciones x = np.linalg.solve(A, b) x ``` array([-1.48029737e-16, -1.48029737e-16, 2.00000000e+00]) ```python # Comprobando la solucion A.dot(x) == b ``` array([False, True, True]) ### Programación lineal La [programación lineal](http://es.wikipedia.org/wiki/Programaci%C3%B3n_lineal) estudia las situaciones en las que se exige maximizar o minimizar funciones que se encuentran sujetas a determinadas restricciones. Consiste en optimizar (minimizar o maximizar) una función lineal, denominada función objetivo, de tal forma que las variables de dicha función estén sujetas a una serie de restricciones que expresamos mediante un [sistema de inecuaciones lineales](http://es.wikipedia.org/wiki/Inecuaci%C3%B3n#Sistema_de_inecuaciones). Para resolver un problema de programación lineal, debemos seguir los siguientes pasos: 1. Elegir las incógnitas. 2. Escribir la función objetivo en función de los datos del problema. 3. Escribir las restricciones en forma de sistema de inecuaciones. 4. Averiguar el conjunto de soluciones factibles representando gráficamente las restricciones. 5. Calcular las coordenadas de los vértices del recinto de soluciones factibles (si son pocos). 6. Calcular el valor de la función objetivo en cada uno de los vértices para ver en cuál de ellos presenta el valor máximo o mínimo según nos pida el problema (hay que tener en cuenta aquí la posible no existencia de solución). Veamos un ejemplo y como [Python](http://python.org/) nos ayuda a resolverlo en forma sencilla. Supongamos que tenemos la siguiente *función objetivo*: $$f(x_{1},x_{2})= 50x_{1} + 40x_{2}$$ y las siguientes *restricciones*: $$x_{1} + 1.5x_{2} \leq 750$$ $$2x_{1} + x_{2} \leq 1000$$ $$x_{1} \geq 0$$ $$x_{2} \geq 0$$ Podemos resolverlo utilizando [PuLP](http://pythonhosted.org//PuLP/), [CVXOPT](http://cvxopt.org/) o graficamente (con [matplotlib](http://matplotlib.org/)) de la siguiente forma. ```python !python -m pip install pulp ``` Requirement already satisfied: pulp in c:\users\admin\appdata\local\programs\python\python37\lib\site-packages (2.6.0) ```python !python -m pip install --upgrade pip ``` Requirement already satisfied: pip in c:\users\admin\appdata\local\programs\python\python37\lib\site-packages (21.3.1) ```python !pip install PyHamcrest ``` Requirement already satisfied: PyHamcrest in c:\users\admin\appdata\local\programs\python\python37\lib\site-packages (2.0.2) ```python # Resolviendo la optimizacion con pulp from pulp import * # declarando las variables x1 = LpVariable("x1", 0, 800) # 0<= x1 <= 40 x2 = LpVariable("x2", 0, 1000) # 0<= x2 <= 1000 # definiendo el problema prob = LpProblem("problem", LpMaximize) # definiendo las restricciones prob += x1+1.5*x2 <= 750 prob += 2*x1+x2 <= 1000 prob += x1>=0 prob += x2>=0 # definiendo la funcion objetivo a maximizar prob += 50*x1+40*x2 # resolviendo el problema status = prob.solve(use_mps=False) LpStatus[status] # imprimiendo los resultados (value(x1), value(x2)) ``` (375.0, 250.0) ```python !pip install cvxopt ``` Requirement already satisfied: cvxopt in c:\users\admin\appdata\local\programs\python\python37\lib\site-packages (1.2.7) ```python # Resolviendo el problema con cvxopt from cvxopt import matrix, solvers A = matrix([[-1., -2., 1., 0.], # columna de x1 [-1.5, -1., 0., 1.]]) # columna de x2 b = matrix([750., 1000., 0., 0.]) # resultados c = matrix([50., 40.]) # funcion objetivo # resolviendo el problema sol=solvers.lp(c,A,b) ``` pcost dcost gap pres dres k/t 0: -2.5472e+04 -3.6797e+04 5e+03 0e+00 3e-01 1e+00 1: -2.8720e+04 -2.9111e+04 1e+02 5e-16 9e-03 2e+01 2: -2.8750e+04 -2.8754e+04 1e+00 3e-16 9e-05 2e-01 3: -2.8750e+04 -2.8750e+04 1e-02 4e-17 9e-07 2e-03 4: -2.8750e+04 -2.8750e+04 1e-04 2e-16 9e-09 2e-05 Optimal solution found. ```python # imprimiendo la solucion. print('{0:.2f}, {1:.2f}'.format(sol['x'][0]*-1, sol['x'][1]*-1)) ``` 375.00, 250.00 ```python # Resolviendo la optimizacion graficamente. x_vals = np.linspace(0, 800, 10) # 10 valores entre 0 y 800 plt.plot(x_vals, ((750 - x_vals)/1.5)) # grafica x1 + 1.5x2 = 750 plt.plot(x_vals, (1000 - 2*x_vals)) # grafica 2x1 + x2 = 1000 plt.axis(ymin = 0) ``` Como podemos ver en el gráfico, ambas rectas se cruzan en la solución óptima, x1=375 y x2=250. Con esto termino esta introducción al [Álgebra lineal](http://es.wikipedia.org/wiki/%C3%81lgebra_lineal) con [Python](http://python.org/). ## Campos Un <a href="https://es.wikipedia.org/wiki/Cuerpo_(matem%C3%A1ticas)">Campo</a>, $F$, es una [estructura algebraica](https://es.wikipedia.org/wiki/Estructura_algebraica) en la cual las operaciones de <a href="https://es.wikipedia.org/wiki/Adici%C3%B3n_(matem%C3%A1ticas)">adición</a> y [multiplicación](https://es.wikipedia.org/wiki/Multiplicaci%C3%B3n) se pueden realizar y cumplen con las siguientes propiedades: 1. La [propiedad conmutativa](https://es.wikipedia.org/wiki/Conmutatividad) tanto para la <a href="https://es.wikipedia.org/wiki/Adici%C3%B3n_(matem%C3%A1ticas)">adición</a> como para la [multiplicación](https://es.wikipedia.org/wiki/Multiplicaci%C3%B3n); es decir: $a + b = b + a$; y $a \cdot b = b \cdot a$; para todo $a, b \in F$ 2. La <a href="https://es.wikipedia.org/wiki/Asociatividad_(%C3%A1lgebra)">propiedad asociativa</a>, tanto para la <a href="https://es.wikipedia.org/wiki/Adici%C3%B3n_(matem%C3%A1ticas)">adición</a> como para la [multiplicación](https://es.wikipedia.org/wiki/Multiplicaci%C3%B3n); es decir: $(a + b) + c = a + (b + c)$; y $(a \cdot b) \cdot c = a \cdot (b \cdot c)$; para todo $a, b, c \in F$ 3. La [propiedad distributiva](https://es.wikipedia.org/wiki/Distributividad) de la [multiplicación](https://es.wikipedia.org/wiki/Multiplicaci%C3%B3n) sobre la <a href="https://es.wikipedia.org/wiki/Adici%C3%B3n_(matem%C3%A1ticas)">adición</a>; es decir: $a \cdot (b + c) = a \cdot b + a \cdot c$; para todo $a, b, c \in F$ 4. La existencia de un *[elemento neutro](https://es.wikipedia.org/wiki/Elemento_neutro)* tanto para la <a href="https://es.wikipedia.org/wiki/Adici%C3%B3n_(matem%C3%A1ticas)">adición</a> como para la [multiplicación](https://es.wikipedia.org/wiki/Multiplicaci%C3%B3n); es decir: $a + 0 = a$; y $a \cdot 1 = a$; para todo $a \in F$. 5. La existencia de un *[elemento inverso](https://es.wikipedia.org/wiki/Elemento_sim%C3%A9trico)* tanto para la <a href="https://es.wikipedia.org/wiki/Adici%C3%B3n_(matem%C3%A1ticas)">adición</a> como para la [multiplicación](https://es.wikipedia.org/wiki/Multiplicaci%C3%B3n); es decir: $a + (-a) = 0$; y $a \cdot a^{-1} = 1$; para todo $a \in F$ y $a \ne 0$. Dos de los <a href="https://es.wikipedia.org/wiki/Cuerpo_(matem%C3%A1ticas)">Campos</a> más comunes con los que nos vamos a encontrar al trabajar en problemas de [Álgebra lineal](http://relopezbriega.github.io/tag/algebra.html), van a ser el [conjunto](http://relopezbriega.github.io/blog/2015/10/11/conjuntos-con-python/) de los [números reales](https://es.wikipedia.org/wiki/N%C3%BAmero_real), $\mathbb{R}$; y el [conjunto](http://relopezbriega.github.io/blog/2015/10/11/conjuntos-con-python/) de los [números complejos](http://relopezbriega.github.io/blog/2015/10/12/numeros-complejos-con-python/), $\mathbb{C}$. ## Vectores Muchas nociones físicas, tales como las fuerzas, velocidades y aceleraciones, involucran una magnitud (el valor de la fuerza, velocidad o aceleración) y una dirección. Cualquier entidad que involucre magnitud y dirección se llama [vector](http://es.wikipedia.org/wiki/Vector). Los [vectores](http://es.wikipedia.org/wiki/Vector) se representan por flechas en las que la longitud de ellas define la magnitud; y la dirección de la flecha representa la dirección del [vector](http://es.wikipedia.org/wiki/Vector). Podemos pensar en los [vectores](http://es.wikipedia.org/wiki/Vector) como una serie de números. Éstos números tienen una orden preestablecido, y podemos identificar cada número individual por su índice en ese orden. Los [vectores](http://es.wikipedia.org/wiki/Vector) identifican puntos en el espacio, en donde cada elemento representa una coordenada del eje en el espacio. La típica forma de representarlos es la siguiente: $$v = \left[ \begin{array}{c} x_1 \\ x_2 \\ \vdots \\ x_n \end{array} \right]$$ Geométricamente podemos representarlos del siguiente modo en el plano de 2 dimensiones: ```python !pip install scipy ``` Requirement already satisfied: scipy in c:\users\admin\appdata\local\programs\python\python37\lib\site-packages (1.7.3) Requirement already satisfied: numpy<1.23.0,>=1.16.5 in c:\users\admin\appdata\local\programs\python\python37\lib\site-packages (from scipy) (1.21.4) ```python !pip install sympy ``` Requirement already satisfied: sympy in c:\users\admin\appdata\local\programs\python\python37\lib\site-packages (1.9) Requirement already satisfied: mpmath>=0.19 in c:\users\admin\appdata\local\programs\python\python37\lib\site-packages (from sympy) (1.2.1) ```python # <!-- collapse=True --> # importando modulos necesarios %matplotlib inline import matplotlib.pyplot as plt import numpy as np import scipy.sparse as sp import scipy.sparse.linalg import scipy.linalg as la import sympy # imprimir con notación matemática. sympy.init_printing(use_latex='mathjax') ``` ```python # <!-- collapse=True --> # graficando vector en R^2 [2, 4] def move_spines(): """Crea la figura de pyplot y los ejes. Mueve las lineas de la izquierda y de abajo para que se intersecten con el origen. Elimina las lineas de la derecha y la de arriba. Devuelve los ejes.""" fix, ax = plt.subplots() for spine in ["left", "bottom"]: ax.spines[spine].set_position("zero") for spine in ["right", "top"]: ax.spines[spine].set_color("none") return ax def vect_fig(vector, color): """Genera el grafico de los vectores en el plano""" v = vector ax.annotate(" ", xy=v, xytext=[0, 0], color=color, arrowprops=dict(facecolor=color, shrink=0, alpha=0.7, width=0.5)) ax.text(1.1 * v[0], 1.1 * v[1], v) ax = move_spines() ax.set_xlim(-5, 5) ax.set_ylim(-5, 5) ax.grid() vect_fig([2, 4], "blue") ``` ## Combinaciones lineales Cuando trabajamos con [vectores](http://es.wikipedia.org/wiki/Vector), nos vamos a encontrar con dos operaciones fundamentales, la *suma* o *<a href="https://es.wikipedia.org/wiki/Adici%C3%B3n_(matem%C3%A1ticas)">adición</a>*; y la *multiplicación por <a href="http://es.wikipedia.org/wiki/Escalar_(matem%C3%A1tica)">escalares</a>*. Cuando *sumamos* dos vectores $v$ y $w$, sumamos elemento por elemento, del siguiente modo: $$v + w = \left[ \begin{array}{c} v_1 \\ v_2 \\ \vdots \\ v_n \end{array} \right] + \left[ \begin{array}{c} w_1 \\ w_2 \\ \vdots \\ w_n \end{array} \right] = \left[ \begin{array}{c} v_1 + w_1 \\ v_2 + w_2 \\ \vdots \\ v_n + w_n \end{array} \right]$$ Geométricamente lo podemos ver representado del siguiente modo: ```python # <!-- collapse=True --> # graficando suma de vectores en R^2 # [2, 4] + [2, -2] ax = move_spines() ax.set_xlim(-5, 5) ax.set_ylim(-5, 5) ax.grid() vecs = [[2, 4], [2, -2]] # lista de vectores for v in vecs: vect_fig(v, "blue") v = np.array([2, 4]) + np.array([2, -2]) vect_fig(v, "red") ax.plot([2, 4], [-2, 2], linestyle='--') a =ax.plot([2, 4], [4, 2], linestyle='--' ) ``` Cuando *multiplicamos [vectores](http://es.wikipedia.org/wiki/Vector) por <a href="http://es.wikipedia.org/wiki/Escalar_(matem%C3%A1tica)">escalares</a>*, lo que hacemos es tomar un número $\alpha$ y un [vector](http://es.wikipedia.org/wiki/Vector) $v$; y creamos un nuevo [vector](http://es.wikipedia.org/wiki/Vector) $w$ en el cada elemento de $v$ es *multiplicado* por $\alpha$ del siguiente modo: $$\begin{split}\alpha v = \left[ \begin{array}{c} \alpha v_1 \\ \alpha v_2 \\ \vdots \\ \alpha v_n \end{array} \right]\end{split}$$ Geométricamente podemos representar a esta operación en el plano de 2 dimensiones del siguiente modo: ```python # <!-- collapse=True --> # graficando multiplicación por escalares en R^2 # [2, 3] * 2 ax = move_spines() ax.set_xlim(-6, 6) ax.set_ylim(-6, 6) ax.grid() v = np.array([2, 3]) vect_fig(v, "blue") v = v * 2 vect_fig(v, "red") ``` Cuando combinamos estas dos operaciones, formamos lo que se conoce en [Álgebra lineal](http://relopezbriega.github.io/tag/algebra.html) como [combinaciones lineales](https://es.wikipedia.org/wiki/Combinaci%C3%B3n_lineal). Es decir que una [combinación lineal](https://es.wikipedia.org/wiki/Combinaci%C3%B3n_lineal) va a ser una expresión matemática construida sobre un conjunto de [vectores](http://es.wikipedia.org/wiki/Vector), en el que cada vector es *multiplicado por un <a href="http://es.wikipedia.org/wiki/Escalar_(matem%C3%A1tica)">escalar</a>* y los resultados son luego *sumados*. Matemáticamente lo podemos expresar de la siguiente forma: $$w = \alpha_1 v_1 + \alpha_2 v_2 + \dots + \alpha_n v_n = \sum_{i=1}^n \alpha_i v_i $$ en donde, $v_n$ son [vectores](http://es.wikipedia.org/wiki/Vector) y $\alpha_n$ son <a href="http://es.wikipedia.org/wiki/Escalar_(matem%C3%A1tica)">escalares</a>. ## Matrices, combinaciones lineales y Ax = b Una <a href="https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matriz</a> es un arreglo bidimensional de números ordenados en filas y columnas, donde una fila es cada una de las líneas horizontales de la matriz y una columna es cada una de las líneas verticales. En una <a href="https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matriz</a> cada elemento puede ser identificado utilizando dos índices, uno para la fila y otro para la columna en que se encuentra. Las podemos representar de la siguiente manera: $$A=\begin{bmatrix}a_{11} & a_{12} & \dots & a_{1n}\\a_{21} & a_{22} & \dots & a_{2n} \\ \vdots & \vdots & \ddots & \vdots \\ a_{n1} & a_{n2} & \dots & a_{nn}\end{bmatrix}$$ Las <a href="https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matrices</a> se utilizan para múltiples aplicaciones y sirven, en particular, para representar los coeficientes de los [sistemas de ecuaciones lineales](https://es.wikipedia.org/wiki/Sistema_de_ecuaciones_lineales) o para representar [combinaciones lineales](https://es.wikipedia.org/wiki/Combinaci%C3%B3n_lineal). Supongamos que tenemos los siguientes 3 vectores: $$x_1 = \left[ \begin{array}{c} 1 \\ -1 \\ 0 \end{array} \right] x_2 = \left[ \begin{array}{c} 0 \\ 1 \\ -1 \end{array} \right] \ x_3 = \left[ \begin{array}{c} 0 \\ 0 \\ 1 \end{array} \right]$$ su [combinación lineal](https://es.wikipedia.org/wiki/Combinaci%C3%B3n_lineal) en el espacio de 3 dimensiones va a ser igual a $\alpha_1 x_1 + \alpha_2 x_2 + \alpha_3 x_3$; lo que es lo mismo que decir: $$\alpha_1 \left[ \begin{array}{c} 1 \\ -1 \\ 0 \end{array} \right] + \alpha_2 \left[ \begin{array}{c} 0 \\ 1 \\ -1 \end{array} \right] + \alpha_3 \left[ \begin{array}{c} 0 \\ 0 \\ 1 \end{array} \right] = \left[ \begin{array}{c} \alpha_1 \\ \alpha_2 - \alpha_1 \\ \alpha_3 - \alpha_2 \end{array} \right]$$ Ahora esta [combinación lineal](https://es.wikipedia.org/wiki/Combinaci%C3%B3n_lineal) la podríamos reescribir en forma matricial. Los vectores $x_1, x_2$ y $x_3$, pasarían a formar las columnas de la <a href="https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matriz</a> $A$ y los <a href="http://es.wikipedia.org/wiki/Escalar_(matem%C3%A1tica)">escalares</a> $\alpha_1, \alpha_2$ y $\alpha_3$ pasarían a ser los componentes del [vector](http://es.wikipedia.org/wiki/Vector) $x$ del siguiente modo: $$\begin{bmatrix}1 & 0 & 0\\-1 & 1 & 0 \\ 0 & -1 & 1\end{bmatrix}\begin{bmatrix} \alpha_1 \\ \alpha_2 \\ \alpha_3\end{bmatrix}= \begin{bmatrix}\alpha_1 \\ \alpha_2 - \alpha_1 \\ \alpha_3 - \alpha_2 \end{bmatrix}$$ De esta forma la <a href="https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matriz</a> $A$ multiplicada por el [vector](http://es.wikipedia.org/wiki/Vector) $x$, nos da como resultado la misma [combinación lineal](https://es.wikipedia.org/wiki/Combinaci%C3%B3n_lineal) $b$. De esta forma, arribamos a una de las ecuaciones más fundamentales del [Álgebra lineal](http://relopezbriega.github.io/tag/algebra.html): $$Ax = b$$ Esta ecuación no solo nos va a servir para expresar [combinaciones lineales](https://es.wikipedia.org/wiki/Combinaci%C3%B3n_lineal), sino que también se vuelve de suma importancia a la hora de resolver [sistemas de ecuaciones lineales](https://es.wikipedia.org/wiki/Sistema_de_ecuaciones_lineales), en dónde $b$ va a ser conocido y la incógnita pasa a ser $x$. Por ejemplo, supongamos que queremos resolver el siguiente [sistemas de ecuaciones](https://es.wikipedia.org/wiki/Sistema_de_ecuaciones_lineales) de 3 incógnitas: $$ 2x_1 + 3x_2 + 5x_3 = 52 \\ 3x_1 + 6x_2 + 2x_3 = 61 \\ 8x_1 + 3x_2 + 6x_3 = 75 $$ Podemos ayudarnos de [SymPy](http://www.sympy.org/es/) para expresar a la <a href="https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matriz</a> $A$ y $b$ para luego arribar a la solución del [vector](http://es.wikipedia.org/wiki/Vector) $x$. ```python # Resolviendo sistema de ecuaciones con SymPy A = sympy.Matrix(( (2, 3, 5), (3, 6, 2), (8, 3, 6) )) A ``` $\displaystyle \left[\begin{matrix}2 & 3 & 5\\3 & 6 & 2\\8 & 3 & 6\end{matrix}\right]$ ```python b = sympy.Matrix(3,1,(52,61,75)) b ``` $\displaystyle \left[\begin{matrix}52\\61\\75\end{matrix}\right]$ ```python # Resolviendo Ax = b x = A.LUsolve(b) x ``` $\displaystyle \left[\begin{matrix}3\\7\\5\end{matrix}\right]$ ```python # Comprobando la solución A*x ``` $\displaystyle \left[\begin{matrix}52\\61\\75\end{matrix}\right]$ ## La matriz identidad , la matriz transpuesta y la matriz invertible Tres <a href="https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matrices</a> de suma importancia en problemas de [Álgebra lineal](http://relopezbriega.github.io/tag/algebra.html). Son la [matriz identidad](https://es.wikipedia.org/wiki/Matriz_identidad), la [matriz transpuesta](http://es.wikipedia.org/wiki/Matriz_transpuesta) y la [matriz invertible](https://es.wikipedia.org/wiki/Matriz_invertible). La [matriz identidad](https://es.wikipedia.org/wiki/Matriz_identidad) es el elemento neutro en la [multiplicación de matrices](https://es.wikipedia.org/wiki/Multiplicaci%C3%B3n_de_matrices), es el equivalente al número 1. Cualquier <a href="https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matriz</a> multiplicada por la [matriz identidad](https://es.wikipedia.org/wiki/Matriz_identidad) nos da como resultado la misma <a href="https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matriz</a>. La [matriz identidad](https://es.wikipedia.org/wiki/Matriz_identidad) es una [matriz cuadrada](https://es.wikipedia.org/wiki/Matriz_cuadrada) (tiene siempre el mismo número de filas que de columnas); y su diagonal principal se compone de todos elementos 1 y el resto de los elementos se completan con 0. Suele representase con la letra $I$. Por ejemplo la [matriz identidad](https://es.wikipedia.org/wiki/Matriz_identidad) de 3x3 sería la siguiente: $$I=\begin{bmatrix}1 & 0 & 0 & \\0 & 1 & 0\\ 0 & 0 & 1\end{bmatrix}$$ La [matriz transpuesta](http://es.wikipedia.org/wiki/Matriz_transpuesta) de una <a href="https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matriz</a> $A$ de $m \times n$ va a ser igual a la <a href="https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matriz</a> $n \times m$ $A^T$, la cual se obtiene al transformar las filas en columnas y las columnas en filas, del siguiente modo: $$\begin{bmatrix}a & b & \\c & d & \\ e & f & \end{bmatrix}^T= \begin{bmatrix}a & c & e &\\b & d & f & \end{bmatrix}$$ Una [matriz cuadrada](https://es.wikipedia.org/wiki/Matriz_cuadrada) va a ser *[simétrica](https://es.wikipedia.org/wiki/Matriz_sim%C3%A9trica)* si $A^T = A$, es decir si $A$ es igual a su propia [matriz transpuesta](http://es.wikipedia.org/wiki/Matriz_transpuesta). Algunas de las propiedades de las [matrices transpuestas](http://es.wikipedia.org/wiki/Matriz_transpuesta) son: a. $(A^T)^T = A$ b. $(A + B)^T = A^T + B^T$ c. $k(A)^T = k(A^T)$ d. $(AB)^T = B^T A^T$ e. $(A^r)^T = (A^T)^r$ para todos los $r$ no negativos. f. Si $A$ es una [matriz cuadrada](https://es.wikipedia.org/wiki/Matriz_cuadrada), entonces $A + A^T$ es una [matriz simétrica](https://es.wikipedia.org/wiki/Matriz_sim%C3%A9trica). g. Para cualquier <a href="https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matriz</a> $A$, $A A^T$ y $A^T A$ son [matrices simétricas](https://es.wikipedia.org/wiki/Matriz_sim%C3%A9trica). Veamos algunos ejemplos en [Python](http://python.org/) ```python # Matriz transpuesta A = sympy.Matrix( [[ 2,-3,-8, 7], [-2,-1, 2,-7], [ 1, 0,-3, 6]] ) A ``` $\displaystyle \left[\begin{matrix}2 & -3 & -8 & 7\\-2 & -1 & 2 & -7\\1 & 0 & -3 & 6\end{matrix}\right]$ ```python A.transpose() ``` $\displaystyle \left[\begin{matrix}2 & -2 & 1\\-3 & -1 & 0\\-8 & 2 & -3\\7 & -7 & 6\end{matrix}\right]$ ```python # transpuesta de transpuesta vuelve a A. A.transpose().transpose() ``` $\displaystyle \left[\begin{matrix}2 & -3 & -8 & 7\\-2 & -1 & 2 & -7\\1 & 0 & -3 & 6\end{matrix}\right]$ ```python # creando matriz simetrica As = A*A.transpose() As ``` $\displaystyle \left[\begin{matrix}126 & -66 & 68\\-66 & 58 & -50\\68 & -50 & 46\end{matrix}\right]$ ```python # comprobando simetria. As.transpose() ``` $\displaystyle \left[\begin{matrix}126 & -66 & 68\\-66 & 58 & -50\\68 & -50 & 46\end{matrix}\right]$ La [matriz invertible](https://es.wikipedia.org/wiki/Matriz_invertible) es muy importante, ya que esta relacionada con la ecuación $Ax = b$. Si tenemos una [matriz cuadrada](https://es.wikipedia.org/wiki/Matriz_cuadrada) $A$ de $n \times n$, entonces la [matriz inversa](https://es.wikipedia.org/wiki/Matriz_invertible) de $A$ es una <a href="https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matriz</a> $A'$ o $A^{-1}$ de $n \times n$ que hace que la multiplicación $A A^{-1}$ sea igual a la [matriz identidad](https://es.wikipedia.org/wiki/Matriz_identidad) $I$. Es decir que es la <a href="https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matriz</a> recíproca de $A$. $A A^{-1} = I$ o $A^{-1} A = I$ En caso de que estas condiciones se cumplan, decimos que la [matriz es invertible](https://es.wikipedia.org/wiki/Matriz_invertible). Que una <a href="https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matriz</a> sea [invertible](https://es.wikipedia.org/wiki/Matriz_invertible) tiene importantes implicaciones, como ser: a. Si $A$ es una [matriz invertible](https://es.wikipedia.org/wiki/Matriz_invertible), entonces su [matriz inversa](https://es.wikipedia.org/wiki/Matriz_invertible) es única. b. Si $A$ es una [matriz invertible](https://es.wikipedia.org/wiki/Matriz_invertible) de $n \times n$, entonces el [sistemas de ecuaciones lineales](https://es.wikipedia.org/wiki/Sistema_de_ecuaciones_lineales) dado por $Ax = b$ tiene una única solución $x = A^{-1}b$ para cualquier $b$ en $\mathbb{R}^n$. c. Una <a href="https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matriz</a> va a ser [invertible](https://es.wikipedia.org/wiki/Matriz_invertible) si y solo si su <a href="https://es.wikipedia.org/wiki/Determinante_(matem%C3%A1tica)">determinante</a> es distinto de cero. En el caso de que el <a href="https://es.wikipedia.org/wiki/Determinante_(matem%C3%A1tica)">determinante</a> sea cero se dice que la <a href="https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matriz</a> es singular. d. Si $A$ es una [matriz invertible](https://es.wikipedia.org/wiki/Matriz_invertible), entonces el [sistema](https://es.wikipedia.org/wiki/Sistema_de_ecuaciones_lineales) $Ax = 0$ solo tiene una solución *trivial*. Es decir, en las que todas las incógnitas son ceros. e. Si $A$ es una [matriz invertible](https://es.wikipedia.org/wiki/Matriz_invertible), entonces su [forma escalonada](https://es.wikipedia.org/wiki/Matriz_escalonada) va a ser igual a la [matriz identidad](https://es.wikipedia.org/wiki/Matriz_identidad). f. Si $A$ es una [matriz invertible](https://es.wikipedia.org/wiki/Matriz_invertible), entonces $A^{-1}$ es [invertible](https://es.wikipedia.org/wiki/Matriz_invertible) y: $$(A^{-1})^{-1} = A$$ g. Si $A$ es una [matriz invertible](https://es.wikipedia.org/wiki/Matriz_invertible) y $\alpha$ es un <a href="http://es.wikipedia.org/wiki/Escalar_(matem%C3%A1tica)">escalar</a> distinto de cero, entonces $\alpha A$ es [invertible](https://es.wikipedia.org/wiki/Matriz_invertible) y: $$(\alpha A)^{-1} = \frac{1}{\alpha}A^{-1}$$ h. Si $A$ y $B$ son [matrices invertibles](https://es.wikipedia.org/wiki/Matriz_invertible) del mismo tamaño, entonces $AB$ es [invertible](https://es.wikipedia.org/wiki/Matriz_invertible) y: $$(AB)^{-1} = B^{-1} A^{-1}$$ i. Si $A$ es una [matriz invertible](https://es.wikipedia.org/wiki/Matriz_invertible), entonces $A^T$ es [invertible](https://es.wikipedia.org/wiki/Matriz_invertible) y: $$(A^T)^{-1} = (A^{-1})^T$$ Con [SymPy](http://www.sympy.org/es/) podemos trabajar con las [matrices invertibles](https://es.wikipedia.org/wiki/Matriz_invertible) del siguiente modo: ```python # Matriz invertible A = sympy.Matrix( [[1,2], [3,9]] ) A ``` $\displaystyle \left[\begin{matrix}1 & 2\\3 & 9\end{matrix}\right]$ ```python A_inv = A.inv() A_inv ``` $\displaystyle \left[\begin{matrix}3 & - \frac{2}{3}\\-1 & \frac{1}{3}\end{matrix}\right]$ ```python # A * A_inv = I A*A_inv ``` $\displaystyle \left[\begin{matrix}1 & 0\\0 & 1\end{matrix}\right]$ ```python # forma escalonada igual a indentidad. A.rref() ``` $\displaystyle \left( \left[\begin{matrix}1 & 0\\0 & 1\end{matrix}\right], \ \left( 0, \ 1\right)\right)$ ```python # la inversa de A_inv es A A_inv.inv() ``` $\displaystyle \left[\begin{matrix}1 & 2\\3 & 9\end{matrix}\right]$ ## Espacios vectoriales Las Matemáticas derivan su poder en gran medida de su capacidad para encontrar las características comunes de los diversos problemas y estudiarlos de manera abstracta. Existen muchos problemas que implican los conceptos relacionados de *<a href="https://es.wikipedia.org/wiki/Adici%C3%B3n_(matem%C3%A1ticas)">adición</a>*, *multiplicación por <a href="http://es.wikipedia.org/wiki/Escalar_(matem%C3%A1tica)">escalares</a>*, y la [linealidad](https://es.wikipedia.org/wiki/Lineal). Para estudiar estas propiedades de manera abstracta, debemos introducir la noción de [espacio vectorial](https://es.wikipedia.org/wiki/Espacio_vectorial). Para alcanzar la definición de un [espacio vectorial](https://es.wikipedia.org/wiki/Espacio_vectorial), debemos combinar los conceptos que venimos viendo hasta ahora de <a href="https://es.wikipedia.org/wiki/Cuerpo_(matem%C3%A1ticas)">Campo</a>, [vector](http://es.wikipedia.org/wiki/Vector) y las operaciones de *<a href="https://es.wikipedia.org/wiki/Adici%C3%B3n_(matem%C3%A1ticas)">adición</a>*; y *multiplicación por <a href="http://es.wikipedia.org/wiki/Escalar_(matem%C3%A1tica)">escalares</a>*. De esta forma un [espacio vectorial](https://es.wikipedia.org/wiki/Espacio_vectorial), $V$, sobre un <a href="https://es.wikipedia.org/wiki/Cuerpo_(matem%C3%A1ticas)">Campo</a>, $F$, va a ser un [conjunto](http://relopezbriega.github.io/blog/2015/10/11/conjuntos-con-python/) en el que están definidas las operaciones de *<a href="https://es.wikipedia.org/wiki/Adici%C3%B3n_(matem%C3%A1ticas)">adición</a>* y *multiplicación por <a href="http://es.wikipedia.org/wiki/Escalar_(matem%C3%A1tica)">escalares</a>*, tal que para cualquier par de elementos $x$ e $y$ en $V$, existe un elemento único $x + y$ en $V$, y para cada elemento $\alpha$ en $F$ y cada elemento $x$ en $V$, exista un único elemento $\alpha x$ en $V$, de manera que se cumplan las siguientes condiciones: 1. Para todo $x, y$ en $V$, $x + y = y + x$ ([conmutatividad](https://es.wikipedia.org/wiki/Conmutatividad) de la adición). 2. Para todo $x, y, z$ en $V$, $(x + y) + z = x + (y + z)$. (<a href="https://es.wikipedia.org/wiki/Asociatividad_(%C3%A1lgebra)">asociatividad</a> de la adición). 3. Existe un elemento en $V$ llamado $0$ tal que $x + 0 = x$ para todo $x$ en $V$. 4. Para cada elemento $x$ en $V$, existe un elemento $y$ en $V$ tal que $x + y = 0$. 5. Para cada elemento $x$ en $V$, $1 x = x$. 6. Para cada par, $\alpha, \beta$ en $F$ y cada elemento $x$ en $V$, $(\alpha \beta) x = \alpha (\beta x)$. 7. Para cada elemento $\alpha$ en $F$ y cada para de elementos $x, y$ en $V$, $\alpha(x + y) = \alpha x + \alpha y$. 8. Para cada par de elementos $\alpha, \beta$ en $F$ y cada elemento $x$ en $V$, $(\alpha + \beta)x = \alpha x + \beta x$. Los [espacios vectoriales](https://es.wikipedia.org/wiki/Espacio_vectorial) más comunes son $\mathbb{R}^2$, el cual representa el plano de 2 dimensiones y consiste de todos los pares ordenados de los [números reales](https://es.wikipedia.org/wiki/N%C3%BAmero_real): $$\mathbb{R}^2 = \{(x, y): x, y \in \mathbb{R}\}$$ y $\mathbb{R}^3$, que representa el espacio ordinario de 3 dimensiones y consiste en todos los tríos ordenados de los [números reales](https://es.wikipedia.org/wiki/N%C3%BAmero_real): $$\mathbb{R}^3 = \{(x, y, z): x, y, z \in \mathbb{R}\}$$ Una de las grandes bellezas del [Álgebra lineal](http://relopezbriega.github.io/tag/algebra.html) es que podemos fácilmente pasar a trabajar sobre espacios de $n$ dimensiones, $\mathbb{R}^n$! Tampoco tenemos porque quedarnos con solo los [números reales](https://es.wikipedia.org/wiki/N%C3%BAmero_real), ya que la definición que dimos de un [espacio vectorial](https://es.wikipedia.org/wiki/Espacio_vectorial) reside sobre un <a href="https://es.wikipedia.org/wiki/Cuerpo_(matem%C3%A1ticas)">Campo</a>; y los <a href="https://es.wikipedia.org/wiki/Cuerpo_(matem%C3%A1ticas)">campos</a> pueden estar representados por [números complejos](http://relopezbriega.github.io/blog/2015/10/12/numeros-complejos-con-python/). Por tanto también podemos tener [espacios vectoriales](https://es.wikipedia.org/wiki/Espacio_vectorial) $\mathbb{C}^2, \mathbb{C}^3, \dots, \mathbb{C}^n$. ### Subespacios Normalmente, en el estudio de cualquier estructura algebraica es interesante examinar subconjuntos que tengan la misma estructura que el [conjunto](http://relopezbriega.github.io/blog/2015/10/11/conjuntos-con-python/) que esta siendo considerado. Así, dentro de los [espacios vectoriales](https://es.wikipedia.org/wiki/Espacio_vectorial), podemos tener [subespacios vectoriales](https://es.wikipedia.org/wiki/Subespacio_vectorial), los cuales son un subconjunto que cumplen con las mismas *propiedades* que el [espacio vectorial](https://es.wikipedia.org/wiki/Espacio_vectorial) que los contiene. De esta forma, $\mathbb{R}^3$ representa un [subespacio](https://es.wikipedia.org/wiki/Subespacio_vectorial) del [espacio vectorial](https://es.wikipedia.org/wiki/Espacio_vectorial) $\mathbb{R}^n$. ## Independencia lineal La [independencia lineal](https://es.wikipedia.org/wiki/Dependencia_e_independencia_lineal) es un concepto aparentemente simple con consecuencias que se extienden profundamente en muchos aspectos del análisis. Si deseamos entender cuándo una matriz puede ser [invertible](https://es.wikipedia.org/wiki/Matriz_invertible), o cuándo un [sistema de ecuaciones lineales](https://es.wikipedia.org/wiki/Sistema_de_ecuaciones_lineales) tiene una única solución, o cuándo una estimación por [mínimos cuadrados](https://es.wikipedia.org/wiki/M%C3%ADnimos_cuadrados) se define de forma única, la idea fundamental más importante es la de [independencia lineal](https://es.wikipedia.org/wiki/Dependencia_e_independencia_lineal) de [vectores](http://es.wikipedia.org/wiki/Vector). Dado un conjunto finito de [vectores](http://es.wikipedia.org/wiki/Vector) $x_1, x_2, \dots, x_n$ se dice que los mismos son *[linealmente independientes](https://es.wikipedia.org/wiki/Dependencia_e_independencia_lineal)*, si y solo si, los únicos <a href="http://es.wikipedia.org/wiki/Escalar_(matem%C3%A1tica)">escalares</a> $\alpha_1, \alpha_2, \dots, \alpha_n$ que satisfacen la ecuación: $$\alpha_1 x_1 + \alpha_2 x_2 + \dots + \alpha_n x_n = 0$$ son todos ceros, $\alpha_1 = \alpha_2 = \dots = \alpha_n = 0$. En caso de que esto no se cumpla, es decir, que existe una solución a la ecuación de arriba en que no todos los <a href="http://es.wikipedia.org/wiki/Escalar_(matem%C3%A1tica)">escalares</a> son ceros, a esta solución se la llama *no trivial* y se dice que los [vectores](http://es.wikipedia.org/wiki/Vector) son *[linealmente dependientes](https://es.wikipedia.org/wiki/Dependencia_e_independencia_lineal)*. Para ilustrar la definición y que quede más clara, veamos algunos ejemplos. Supongamos que queremos determinar si los siguientes [vectores](http://es.wikipedia.org/wiki/Vector) son *[linealmente independientes](https://es.wikipedia.org/wiki/Dependencia_e_independencia_lineal)*: $$\begin{split}x_1 = \left[ \begin{array}{c} 1.2 \\ 1.1 \\ \end{array} \right] \ \ \ x_2 = \left[ \begin{array}{c} -2.2 \\ 1.4 \\ \end{array} \right]\end{split}$$ Para lograr esto, deberíamos resolver el siguiente [sistema de ecuaciones](https://es.wikipedia.org/wiki/Sistema_de_ecuaciones_lineales) y verificar si la única solución es aquella en que los <a href="http://es.wikipedia.org/wiki/Escalar_(matem%C3%A1tica)">escalares</a> sean ceros. $$\begin{split}\alpha_1 \left[ \begin{array}{c} 1.2 \\ 1.1 \\ \end{array} \right] + \alpha_2 \left[ \begin{array}{c} -2.2 \\ 1.4 \\ \end{array} \right]\end{split} = 0 $$ Para resolver este [sistema de ecuaciones](https://es.wikipedia.org/wiki/Sistema_de_ecuaciones_lineales), podemos recurrir a la ayuda de [Python](http://python.org/). ```python # Resolviendo el sistema de ecuaciones. A = np.array([[1.2, -2.2], [1.1, 1.4]]) b = np.array([0., 0.]) x = np.linalg.solve(A, b) x ``` array([0., 0.]) ```python # <!-- collapse=True --> # Solución gráfica. x_vals = np.linspace(-5, 5, 50) # crea 50 valores entre 0 y 5 ax = move_spines() ax.set_xlim(-5, 5) ax.set_ylim(-5, 5) ax.grid() ax.plot(x_vals, (1.2 * x_vals) / -2.2) # grafica 1.2x_1 - 2.2x_2 = 0 a = ax.plot(x_vals, (1.1 * x_vals) / 1.4) # grafica 1.1x + 1.4x_2 = 0 ``` Como podemos ver, tanto por la solución numérica como por la solución gráfica, estos vectores son *[linealmente independientes](https://es.wikipedia.org/wiki/Dependencia_e_independencia_lineal)*, ya que la única solución a la ecuación $\alpha_1 x_1 + \alpha_2 x_2 + \dots + \alpha_n x_n = 0$, es aquella en que los <a href="http://es.wikipedia.org/wiki/Escalar_(matem%C3%A1tica)">escalares</a> son cero. Determinemos ahora si por ejemplo, los siguientes [vectores](http://es.wikipedia.org/wiki/Vector) en $\mathbb{R}^4$ son *[linealmente independientes](https://es.wikipedia.org/wiki/Dependencia_e_independencia_lineal)*: $\{(3, 2, 2, 3), (3, 2, 1, 2), (3, 2, 0, 1)\}$. Aquí, ahora deberíamos resolver la siguiente ecuación: $$\alpha_1 (3, 2, 2, 3) +\alpha_2 (3, 2, 1, 2) + \alpha_3 (3, 2, 0, 1) = (0, 0, 0, 0)$$ Para resolver este sistema de ecuaciones que no es cuadrado (tiene 4 ecuaciones y solo 3 incógnitas); podemos utilizar [SymPy](http://www.sympy.org/es/). ```python # Sympy para resolver el sistema de ecuaciones lineales a1, a2, a3 = sympy.symbols('a1, a2, a3') A = sympy.Matrix(( (3, 3, 3, 0), (2, 2, 2, 0), (2, 1, 0, 0), (3, 2, 1, 0) )) A ``` $\displaystyle \left[\begin{matrix}3 & 3 & 3 & 0\\2 & 2 & 2 & 0\\2 & 1 & 0 & 0\\3 & 2 & 1 & 0\end{matrix}\right]$ ```python sympy.solve_linear_system(A, a1, a2, a3) ``` $\displaystyle \left\{ a_{1} : a_{3}, \ a_{2} : - 2 a_{3}\right\}$ Como vemos, esta solución es *no trivial*, ya que por ejemplo existe la solución $\alpha_1 = 1, \ \alpha_2 = -2 , \ \alpha_3 = 1$ en la que los <a href="http://es.wikipedia.org/wiki/Escalar_(matem%C3%A1tica)">escalares</a> no son ceros. Por lo tanto este sistema es *[linealmente dependiente](https://es.wikipedia.org/wiki/Dependencia_e_independencia_lineal)*. Por último, podríamos considerar si los siguientes [polinomios](https://es.wikipedia.org/wiki/Polinomio) son *[linealmente independientes](https://es.wikipedia.org/wiki/Dependencia_e_independencia_lineal)*: $1 -2x -x^2$, $1 + x$, $1 + x + 2x^2$. En este caso, deberíamos resolver la siguiente ecuación: $$\alpha_1 (1 − 2x − x^2) + \alpha_2 (1 + x) + \alpha_3 (1 + x + 2x^2) = 0$$ y esta ecuación es equivalente a la siguiente: $$(\alpha_1 + \alpha_2 + \alpha_3 ) + (−2 \alpha_1 + \alpha_2 + \alpha_3 )x + (−\alpha_1 + 2 \alpha_2 )x^2 = 0$$ Por lo tanto, podemos armar el siguiente [sistema de ecuaciones](https://es.wikipedia.org/wiki/Sistema_de_ecuaciones_lineales): $$\alpha_1 + \alpha_2 + \alpha_3 = 0, \\ -2 \alpha_1 + \alpha_2 + \alpha_3 = 0, \\ -\alpha_1 + 2 \alpha_2 = 0. $$ El cual podemos nuevamente resolver con la ayuda de [SymPy](http://www.sympy.org/es/). ```python A = sympy.Matrix(( (1, 1, 1, 0), (-2, 1, 1, 0), (-1, 2, 0, 0) )) A ``` $\displaystyle \left[\begin{matrix}1 & 1 & 1 & 0\\-2 & 1 & 1 & 0\\-1 & 2 & 0 & 0\end{matrix}\right]$ ```python sympy.solve_linear_system(A, a1, a2, a3) ``` $\displaystyle \left\{ a_{1} : 0, \ a_{2} : 0, \ a_{3} : 0\right\}$ Como vemos, todos los <a href="http://es.wikipedia.org/wiki/Escalar_(matem%C3%A1tica)">escalares</a> son ceros, por lo tanto estos [polinomios](https://es.wikipedia.org/wiki/Polinomio) son *[linealmente independientes](https://es.wikipedia.org/wiki/Dependencia_e_independencia_lineal)*. ### Espacio nulo, espacio columna y espacio fila Un termino particularmente relacionado con la [independencia lineal](https://es.wikipedia.org/wiki/Dependencia_e_independencia_lineal) es el de <a href="https://es.wikipedia.org/wiki/N%C3%BAcleo_(matem%C3%A1tica)">espacio nulo o núcleo</a>. El <a href="https://es.wikipedia.org/wiki/N%C3%BAcleo_(matem%C3%A1tica)">espacio nulo</a> de una <a href="https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matriz</a> $A$, el cual lo vamos a expresar como $N(A)$, va a consistir de todas las soluciones a la ecuación fundamental $Ax = 0$. Por supuesto, una solución inmediata a esta ecuación es el caso de $x = 0$, que ya vimos que establece la [independencia lineal](https://es.wikipedia.org/wiki/Dependencia_e_independencia_lineal). Esta solución solo va a ser la única que exista para los casos de [matrices invertibles](https://es.wikipedia.org/wiki/Matriz_invertible). Pero en el caso de las matrices singulares (aquellas que no son [invertibles](https://es.wikipedia.org/wiki/Matriz_invertible), que tienen <a href="https://es.wikipedia.org/wiki/Determinante_(matem%C3%A1tica)">determinante</a> igual a cero), van a existir soluciones que no son cero para la ecuación $Ax = 0$. El conjunto de todas estas soluciones, va a representar el <a href="https://es.wikipedia.org/wiki/N%C3%BAcleo_(matem%C3%A1tica)">espacio nulo</a>. Para encontrar el <a href="https://es.wikipedia.org/wiki/N%C3%BAcleo_(matem%C3%A1tica)">espacio nulo</a> también nos podemos ayudar de [SymPy](http://www.sympy.org/es/). ```python # Espacio nulo de un matriz A = sympy.Matrix(((1, 5, 7), (0, 0, 9))) A ``` $\displaystyle \left[\begin{matrix}1 & 5 & 7\\0 & 0 & 9\end{matrix}\right]$ ```python # Calculando el espacio nulo x = A.nullspace() x ``` $\displaystyle \left[ \left[\begin{matrix}-5\\1\\0\end{matrix}\right]\right]$ ```python # Comprobando la solución A_aum = sympy.Matrix(((1, 5, 7, 0), (0, 0, 9, 0))) sympy.solve_linear_system(A_aum, a1, a2, a3) ``` $\displaystyle \left\{ a_{1} : - 5 a_{2}, \ a_{3} : 0\right\}$ ```python # Comprobación con numpy A = np.array([[1, 5, 7], [0, 0, 9]]) x = np.array([[-5], [1], [0]]) A.dot(x) ``` array([[0], [0]]) Otro espacio de suma importancia es el [espacio columna](https://es.wikipedia.org/wiki/Subespacios_fundamentales_de_una_matriz). El [espacio columna](https://es.wikipedia.org/wiki/Subespacios_fundamentales_de_una_matriz), $C(A)$, consiste en todas las [combinaciones lineales](https://es.wikipedia.org/wiki/Combinaci%C3%B3n_lineal) de las columnas de una <a href="https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matriz</a> $A$. Estas combinaciones son los posibles vectores $Ax$. Este espacio es fundamental para resolver la ecuación $Ax = b$; ya que para resolver esta ecuación debemos expresar a $b$ como una combinación de columnas. El sistema $Ax = b$, va a tener solución solamente si $b$ esta en el espacio columna de $A$. Como las <a href="https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matrices</a> tienen la forma $m \times n$, sus columnas tienen $m$ componentes ($n$ son las filas). Por lo tanto el [espacio columna](https://es.wikipedia.org/wiki/Subespacios_fundamentales_de_una_matriz) es un *subespacio* de $\mathbb{R}^m$ y no $\mathbb{R}^n$. Por último, el otro espacio que conforma los [espacios fundamentales](https://es.wikipedia.org/wiki/Subespacios_fundamentales_de_una_matriz) de una <a href="https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matriz</a>, es el [espacio fila](https://es.wikipedia.org/wiki/Subespacios_fundamentales_de_una_matriz), el cual esta constituido por las [combinaciones lineales](https://es.wikipedia.org/wiki/Combinaci%C3%B3n_lineal) de las filas de una <a href="https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matriz</a>. Para obtener estos espacios, nuevamente podemos recurrir a [SymPy](http://www.sympy.org/es/). Para poder obtener estos espacios, primero vamos a tener que obtener la [forma escalonada](https://es.wikipedia.org/wiki/Matriz_escalonada) de la <a href="https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matriz</a>, la cual es la forma a la que arribamos luego del proceso de [eliminación](https://es.wikipedia.org/wiki/Eliminaci%C3%B3n_de_Gauss-Jordan). ```python # A.rref() forma escalonada. A = sympy.Matrix( [[2,-3,-8, 7], [-2,-1,2,-7], [1 ,0,-3, 6]]) A.rref() # [0, 1, 2] es la ubicación de las pivot. ``` $\displaystyle \left( \left[\begin{matrix}1 & 0 & 0 & 0\\0 & 1 & 0 & 3\\0 & 0 & 1 & -2\end{matrix}\right], \ \left( 0, \ 1, \ 2\right)\right)$ ```python # Espacio columna [ A[:,c] for c in A.rref()[1] ] ``` $\displaystyle \left[ \left[\begin{matrix}2\\-2\\1\end{matrix}\right], \ \left[\begin{matrix}-3\\-1\\0\end{matrix}\right], \ \left[\begin{matrix}-8\\2\\-3\end{matrix}\right]\right]$ ```python # Espacio fila [ A.rref()[0][r,:] for r in A.rref()[1] ] ``` $\displaystyle \left[ \left[\begin{matrix}1 & 0 & 0 & 0\end{matrix}\right], \ \left[\begin{matrix}0 & 1 & 0 & 3\end{matrix}\right], \ \left[\begin{matrix}0 & 0 & 1 & -2\end{matrix}\right]\right]$ ## Rango Otro concepto que también esta ligado a la [independencia lineal](https://es.wikipedia.org/wiki/Dependencia_e_independencia_lineal) es el de <a href="https://es.wikipedia.org/wiki/Rango_(%C3%A1lgebra_lineal)">rango</a>. Los números de columnas $m$ y filas $n$ pueden darnos el tamaño de una <a href="https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matriz</a>, pero esto no necesariamente representa el verdadero tamaño del [sistema lineal](https://es.wikipedia.org/wiki/Sistema_de_ecuaciones_lineales), ya que por ejemplo si existen dos filas iguales en una <a href="https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matriz</a> $A$, la segunda fila desaparecía en el proceso de [eliminación](https://es.wikipedia.org/wiki/Eliminaci%C3%B3n_de_Gauss-Jordan). El verdadero tamaño de $A$ va a estar dado por su <a href="https://es.wikipedia.org/wiki/Rango_(%C3%A1lgebra_lineal)">rango</a>. El <a href="https://es.wikipedia.org/wiki/Rango_(%C3%A1lgebra_lineal)">rango</a> de una <a href="https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matriz</a> es el número máximo de columnas (filas respectivamente) que son [linealmente independientes](https://es.wikipedia.org/wiki/Dependencia_e_independencia_lineal). Por ejemplo si tenemos la siguiente <a href="https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matriz</a> de 3 x 4: $$A = \begin{bmatrix}1 & 1 & 2 & 4\\1 & 2 & 2 & 5 \\ 1 & 3 & 2 & 6\end{bmatrix}$$ Podemos ver que la tercer columna $(2, 2, 2)$ es un múltiplo de la primera y que la cuarta columna $(4, 5, 6)$ es la suma de las primeras 3 columnas. Por tanto el <a href="https://es.wikipedia.org/wiki/Rango_(%C3%A1lgebra_lineal)">rango</a> de $A$ va a ser igual a 2; ya que la tercer y cuarta columna pueden ser eliminadas. Obviamente, el <a href="https://es.wikipedia.org/wiki/Rango_(%C3%A1lgebra_lineal)">rango</a> también lo podemos calcular con la ayuda de [Python](http://python.org/). ```python # Calculando el rango con SymPy A = sympy.Matrix([[1, 1, 2, 4], [1, 2, 2, 5], [1, 3, 2, 6]]) A ``` $\displaystyle \left[\begin{matrix}1 & 1 & 2 & 4\\1 & 2 & 2 & 5\\1 & 3 & 2 & 6\end{matrix}\right]$ ```python # Rango con SymPy A.rank() ``` $\displaystyle 2$ ```python # Rango con numpy A = np.array([[1, 1, 2, 4], [1, 2, 2, 5], [1, 3, 2, 6]]) np.linalg.matrix_rank(A) ``` 2 Una útil aplicación de calcular el <a href="https://es.wikipedia.org/wiki/Rango_(%C3%A1lgebra_lineal)">rango</a> de una <a href="https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matriz</a> es la de determinar el número de soluciones al [sistema de ecuaciones lineales](https://es.wikipedia.org/wiki/Sistema_de_ecuaciones_lineales), de acuerdo al enunciado del [Teorema de Rouché–Frobenius](https://es.wikipedia.org/wiki/Teorema_de_Rouch%C3%A9%E2%80%93Frobenius). El sistema tiene por lo menos una solución si el <a href="https://es.wikipedia.org/wiki/Rango_(%C3%A1lgebra_lineal)">rango</a> de la <a href="https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matriz</a> de coeficientes equivale al <a href="https://es.wikipedia.org/wiki/Rango_(%C3%A1lgebra_lineal)">rango</a> de la [matriz aumentada](https://es.wikipedia.org/wiki/Matriz_aumentada). En ese caso, ésta tiene exactamente una solución si el rango equivale al número de incógnitas. ## La norma y la Ortogonalidad Si quisiéramos saber cual es el *largo* del un [vector](http://es.wikipedia.org/wiki/Vector), lo único que necesitamos es el famoso [teorema de Pitágoras](https://es.wikipedia.org/wiki/Teorema_de_Pit%C3%A1goras). En el plano $\mathbb{R}^2$, el *largo* de un [vector](http://es.wikipedia.org/wiki/Vector) $v=\begin{bmatrix}a \\ b \end{bmatrix}$ va a ser igual a la distancia desde el origen $(0, 0)$ hasta el punto $(a, b)$. Esta distancia puede ser fácilmente calculada gracias al [teorema de Pitágoras](https://es.wikipedia.org/wiki/Teorema_de_Pit%C3%A1goras) y va ser igual a $\sqrt{a^2 + b^2}$, como se puede ver en la siguiente figura: ```python # <!-- collapse=True --> # Calculando largo de un vector # forma un triángulo rectángulo ax = move_spines() ax.set_xlim(-6, 6) ax.set_ylim(-6, 6) ax.grid() v = np.array([4, 6]) vect_fig(v, "blue") a = ax.vlines(x=v[0], ymin=0, ymax = 6, linestyle='--', color='g') ``` En esta definición podemos observar que $a^2 + b^2 = v \cdot v$, por lo que ya estamos en condiciones de poder definir lo que en [Álgebra lineal](http://relopezbriega.github.io/tag/algebra.html) se conoce como [norma](https://es.wikipedia.org/wiki/Norma_vectorial). El *largo* o [norma](https://es.wikipedia.org/wiki/Norma_vectorial) de un [vector](http://es.wikipedia.org/wiki/Vector) $v = \begin{bmatrix} v_1 \\ v_2 \\ \vdots \\ v_n \end{bmatrix}$, en $\mathbb{R}^n$ va a ser igual a un número no negativo $||v||$ definido por: $$||v|| = \sqrt{v \cdot v} = \sqrt{v_1^2 + v_2^2 + \dots + v_n^2}$$ Es decir que la [norma](https://es.wikipedia.org/wiki/Norma_vectorial) de un [vector](http://es.wikipedia.org/wiki/Vector) va a ser igual a la raíz cuadrada de la suma de los cuadrados de sus componentes. ### Ortogonalidad El concepto de [perpendicularidad](https://es.wikipedia.org/wiki/Perpendicularidad) es fundamental en [geometría](https://es.wikipedia.org/wiki/Geometr%C3%ADa). Este concepto llevado a los [vectores](http://es.wikipedia.org/wiki/Vector) en $\mathbb{R}^n$ se llama <a href="https://es.wikipedia.org/wiki/Ortogonalidad_(matem%C3%A1ticas)">ortogonalidad</a>. Dos [vectores](http://es.wikipedia.org/wiki/Vector) $v$ y $w$ en $\mathbb{R}^n$ van a ser <a href="https://es.wikipedia.org/wiki/Ortogonalidad_(matem%C3%A1ticas)">ortogonales</a> el uno al otro si su [producto interior](https://es.wikipedia.org/wiki/Producto_escalar) es igual a cero. Es decir, $v \cdot w = 0$. Geométricamente lo podemos ver de la siguiente manera: ```python # <!-- collapse=True --> # Vectores ortogonales ax = move_spines() ax.set_xlim(-6, 6) ax.set_ylim(-6, 6) ax.grid() vecs = [np.array([4, 6]), np.array([-3, 2])] for v in vecs: vect_fig(v, "blue") a = ax.plot([-3, 4], [2, 6], linestyle='--', color='g') ``` ```python # comprobando su producto interior. v = np.array([4, 6]) w = np.array([-3, 2]) v.dot(w) ``` 0 Un [conjunto](http://relopezbriega.github.io/blog/2015/10/11/conjuntos-con-python/) de [vectores](http://es.wikipedia.org/wiki/Vector) en $\mathbb{R}^n$ va a ser <a href="https://es.wikipedia.org/wiki/Ortogonalidad_(matem%C3%A1ticas)">ortogonal</a> si todo los pares de los distintos [vectores](http://es.wikipedia.org/wiki/Vector) en el [conjunto](http://relopezbriega.github.io/blog/2015/10/11/conjuntos-con-python/) son <a href="https://es.wikipedia.org/wiki/Ortogonalidad_(matem%C3%A1ticas)">ortogonales</a> entre sí. O sea: $v_i \cdot v_j = 0$ para todo $i, j = 1, 2, \dots, k$ y donde $i \ne j$. Por ejemplo, si tenemos el siguiente [conjunto](http://relopezbriega.github.io/blog/2015/10/11/conjuntos-con-python/) de [vectores](http://es.wikipedia.org/wiki/Vector) en $\mathbb{R}^3$: $$v1=\begin{bmatrix} 2 \\ 1 \\ -1\end{bmatrix} \ v2=\begin{bmatrix} 0 \\ 1 \\ 1\end{bmatrix} v3=\begin{bmatrix} 1 \\ -1 \\ 1\end{bmatrix}$$ En este caso, deberíamos combrobar que: $$v1 \cdot v2 = 0 \\ v2 \cdot v3 = 0 \\ v1 \cdot v3 = 0 $$ ```python # comprobando ortogonalidad del conjunto v1 = np.array([2, 1, -1]) v2 = np.array([0, 1, 1]) v3 = np.array([1, -1, 1]) v1.dot(v2), v2.dot(v3), v1.dot(v3) ``` (0, 0, 0) Como vemos, este conjunto es <a href="https://es.wikipedia.org/wiki/Ortogonalidad_(matem%C3%A1ticas)">ortogonal</a>. Una de las principales ventajas de trabajar con [conjuntos](http://relopezbriega.github.io/blog/2015/10/11/conjuntos-con-python/) de [vectores](http://es.wikipedia.org/wiki/Vector) <a href="https://es.wikipedia.org/wiki/Ortogonalidad_(matem%C3%A1ticas)">ortogonales</a> es que los mismos son necesariamente [linealmente independientes](https://es.wikipedia.org/wiki/Dependencia_e_independencia_lineal). El concepto de <a href="https://es.wikipedia.org/wiki/Ortogonalidad_(matem%C3%A1ticas)">ortogonalidad</a> es uno de los más importantes y útiles en [Álgebra lineal](http://relopezbriega.github.io/tag/algebra.html) y surge en muchas situaciones prácticas, sobre todo cuando queremos calcular distancias. ## Determinante El <a href="https://es.wikipedia.org/wiki/Determinante_(matem%C3%A1tica)">determinante</a> es un número especial que puede calcularse sobre las [matrices cuadradas](https://es.wikipedia.org/wiki/Matriz_cuadrada). Este número nos va a decir muchas cosas sobre la <a href="https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matriz</a>. Por ejemplo, nos va decir si la <a href="https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matriz</a> es [invertible](https://es.wikipedia.org/wiki/Matriz_invertible) o no. Si el <a href="https://es.wikipedia.org/wiki/Determinante_(matem%C3%A1tica)">determinante</a> es igual a cero, la <a href="https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matriz</a> no es [invertible](https://es.wikipedia.org/wiki/Matriz_invertible). Cuando la <a href="https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matriz</a> es [invertible](https://es.wikipedia.org/wiki/Matriz_invertible), el <a href="https://es.wikipedia.org/wiki/Determinante_(matem%C3%A1tica)">determinante</a> de $A^{-1}= 1/(\det \ A)$. El <a href="https://es.wikipedia.org/wiki/Determinante_(matem%C3%A1tica)">determinante</a> también puede ser útil para calcular áreas. Para obtener el <a href="https://es.wikipedia.org/wiki/Determinante_(matem%C3%A1tica)">determinante</a> de una <a href="https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matriz</a> debemos calcular la suma de los productos de las diagonales de la <a href="https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matriz</a> en una dirección menos la suma de los productos de las diagonales en la otra dirección. Se represente con el símbolo $|A|$ o $\det A$. Algunas de sus propiedades que debemos tener en cuenta son: a. El <a href="https://es.wikipedia.org/wiki/Determinante_(matem%C3%A1tica)">determinante</a> de la [matriz identidad](https://es.wikipedia.org/wiki/Matriz_identidad) es igual a 1. $\det I = 1$. b. Una <a href="https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matriz</a> $A$ es *singular* (no tiene [inversa](https://es.wikipedia.org/wiki/Matriz_invertible)) si su <a href="https://es.wikipedia.org/wiki/Determinante_(matem%C3%A1tica)">determinante</a> es igual a cero. c. El <a href="https://es.wikipedia.org/wiki/Determinante_(matem%C3%A1tica)">determinante</a> cambia de signo cuando dos columnas(o filas) son intercambiadas. d. Si dos filas de una <a href="https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matriz</a> $A$ son iguales, entonces el <a href="https://es.wikipedia.org/wiki/Determinante_(matem%C3%A1tica)">determinante</a> es cero. e. Si alguna fila de la <a href="https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)">matriz</a> $A$ son todos ceros, entonces el <a href="https://es.wikipedia.org/wiki/Determinante_(matem%C3%A1tica)">determinante</a> es cero. f. La [matriz transpuesta](http://es.wikipedia.org/wiki/Matriz_transpuesta) $A^T$, tiene el mismo <a href="https://es.wikipedia.org/wiki/Determinante_(matem%C3%A1tica)">determinante</a> que $A$. g. El <a href="https://es.wikipedia.org/wiki/Determinante_(matem%C3%A1tica)">determinante</a> de $AB$ es igual al <a href="https://es.wikipedia.org/wiki/Determinante_(matem%C3%A1tica)">determinante</a> de $A$ multiplicado por el <a href="https://es.wikipedia.org/wiki/Determinante_(matem%C3%A1tica)">determinante</a> de $B$. $\det (AB) = \det A \cdot \det B$. h. El <a href="https://es.wikipedia.org/wiki/Determinante_(matem%C3%A1tica)">determinante</a> es una [función lineal](https://es.wikipedia.org/wiki/Funci%C3%B3n_lineal) de cada una de las filas en forma separada. Si multiplicamos solo una fila por $\alpha$, entonces el <a href="https://es.wikipedia.org/wiki/Determinante_(matem%C3%A1tica)">determinante</a> también es multiplicado por $\alpha$. Veamos como podemos obtener el <a href="https://es.wikipedia.org/wiki/Determinante_(matem%C3%A1tica)">determinante</a> con la ayuda de [Python](http://python.org/) ```python # Determinante con sympy A = sympy.Matrix( [[1, 2, 3], [2,-2, 4], [2, 2, 5]] ) A.det() ``` $\displaystyle 2$ ```python # Determinante con numpy A = np.array([[1, 2, 3], [2,-2, 4], [2, 2, 5]] ) np.linalg.det(A) ``` $\displaystyle 2.0$ ```python # Determinante como funcion lineal de fila A[0] = A[0:1]*5 np.linalg.det(A) ``` $\displaystyle 9.99999999999998$ ```python # cambio de signo de determinante A = sympy.Matrix( [[2,-2, 4], [1, 2, 3], [2, 2, 5]] ) A.det() ``` $\displaystyle -2$ *Esta notebook fue creada originalmente como un blog post por [Raúl E. López Briega](http://relopezbriega.com.ar/) en [Mi blog sobre Python](http://relopezbriega.github.io). El contenido esta bajo la licencia BSD.* *Este post fue escrito utilizando IPython notebook. Pueden descargar este [notebook](https://github.com/relopezbriega/relopezbriega.github.io/blob/master/downloads/LinearAlgebraPython.ipynb) o ver su version estática en [nbviewer](http://nbviewer.ipython.org/github/relopezbriega/relopezbriega.github.io/blob/master/downloads/LinearAlgebraPython.ipynb).* ```python ```

523a24404f34f580ac69f5f36ca14bb6385fd52c

ipynb

Jupyter Notebook

2-EDA/4-Mates para DS/Algebra_Lineal.ipynb

erfederuiz/thebridge_ft_nov21

00f7216024ac0cf05e564eb8b1be6e888f277ea4

2-EDA/4-Mates para DS/Algebra_Lineal.ipynb

erfederuiz/thebridge_ft_nov21

00f7216024ac0cf05e564eb8b1be6e888f277ea4

2-EDA/4-Mates para DS/Algebra_Lineal.ipynb

erfederuiz/thebridge_ft_nov21

00f7216024ac0cf05e564eb8b1be6e888f277ea4

Qwen/Qwen-72B

1. YES 2. YES

__label__spa_Latn

# Modeling Magnetic Anomalies In this section we discuss how to solve PDE for magnetic field anomalies due to a variation of the magnetic susceptibility in the subsurface using `esys.escript`. It is assumed that you have worked through the [introduction section on `esys.escript`](escriptBasics.ipynb). First we will provide the basic theory: ## Theoretical Background The observed magnetic field results $\mathbf{B}_t$ from the interaction between the Earth's background field $\mathbf{B}_b$ and the magnetisation $\mathbf{M}$. Under the assumption of a small magnetisation the magnetisation is given as \begin{equation} \mathbf{M} = k \mathbf{B}_b \end{equation} where $k \ge 0$ is the magnetic susceptibility. The magnetisation induces a total magnetic field $\mathbf{B}_t$ which can be decomposed in the background field $\mathbf{B}_b$ and the magenetic anomaly field $\mathbf{B}_a$: \begin{align} \mathbf{B}_t & = \mathbf{B}_H + \mathbf{B} \end{align} In the SI system $\mathbf{B}$ has the units is in Tesla $T$. The Earth's background field $\mathbf{B}_H$ varies between $25,000$ and $65,000 nT$ ($nT = 10^{-9} T $ referes to *nano Tesla*) The total magnetic field anomaly $b_a$ is the difference of the intensity of the total magnetic field $\mathbf{B}$ and of the background field $\mathbf{B}_H$: \begin{equation} b_a=|\mathbf{B}_t|-|\mathbf{B}_b| \end{equation} where in 2D \begin{equation} |\mathbf{B}| = \sqrt{B_x^2 + B_z^2} \mbox{ if } \mathbf{B}=(B_x, B_z) \end{equation} The total magnetic field anomaly $b_a$ is what is measured in the field. The Gauss's law for magnetism states that the magnetic flux $\mathbf{B_F}=\mathbf{B}_t+\mathbf{M}$ is divergence free: \begin{equation} \nabla^t \mathbf{B_F} = 0 \end{equation} Assuming that $\nabla^t \mathbf{B}_b=0$ this simplifies to \begin{equation} \label{EQGAUSS} \nabla^t (\mathbf{B} + k \mathbf{B}_b ) = 0 \end{equation} Analogously to gravity one can introduce a scalar potential $U$ with \begin{equation} \label{EQPOTENTIAL} \mathbf{B} = - \nabla U = (-\frac{\partial U}{\partial x}, -\frac{\partial U}{\partial z}) \end{equation} in the 2D case. Equations \eqref{EQGAUSS} and \eqref{EQPOTENTIAL} form a PDE for the scalar potential $U$. ## In the `esys.escript` form Recall the `esys.escript` PDE template: When $u$ is the unknown the `flux` vector $\mathbf{F}$ is defined as \begin{equation} \label{EQFLUX} \mathbf{F} = - \mathbf{A} \mathbf{\nabla} u +\mathbf{X} \end{equation} with some matrix $\mathbf{A}$ and some vector $\mathbf{X}$. Then the flux vector $\mathbf{F}$ needs to fulfill the conservation equation : \begin{equation}\label{EQCONSERVATION} \mathbf{\nabla}^t \; \mathbf{F} + D \; u = Y \end{equation} where $D$ is a scalar and $Y$ is the right hand side. We identify the flux $\mathbf{F}$ from \eqref{EQGAUSS} as $\mathbf{B} + k \mathbf{B}_b$ which gives with \eqref{EQPOTENTIAL} \begin{equation} \label{EQFLUX2} \mathbf{F} = - \mathbf{\nabla} U +k \mathbf{B}_b \end{equation} from which we see that we need to choose $\mathbf{A}$ as the identity matrix and $\mathbf{X}=k \mathbf{B}_b$ (that is the magnetization). In this case it is $D=0$ and $Y=0$. ###### Problem For a domain of $2 \times 2 km$ we want to model the total magnetic field anomaly $b_a$ over a horizontal transect. The transect is located at a height of $H_0=1200m$ above the bottom edge of the domain and is assumed to define the surface of the Earth. The magnetic anomaly is produced by a vertical dyke of width $w=60m$ where the top end of the dyke is located at a depth $D=100m$ below the surface along the vertical center line of the domain (at $x_0=500m$). It is assumed that a 2D model is sufficient. Of particular interest is the question how the total magnetic field response of the dyke would eb different at the North Pole, the South Pole and the equator. ```python dx=8 # grid line spacing in [m] NEx=250 NEz=250 H0=1200 # height [m] of transect above bottom of domain (will be locked to grid) b_b=45000.0 # intensity of the background magnetic field in nT ksi=0.015 # assumed susceptibility D=100 w=60 %matplotlib notebook ``` ## Domain and Transect Set-up Before we can do any modeling we need to set up the domain. This analogously to the gravity case. ```python from esys.escript import * from esys.finley import Rectangle Lx=dx*NEx Lz=dx*NEz print("Domain dimension = %g x %g m"%(Lx, Lz)) domain=Rectangle(n0=NEx, n1=NEz, l0=Lx, l1=Lz) ``` Domain dimension = 2000 x 2000 m Here we also define the `Locator` to pick the values for the total magnetic field anomaly $b_a$ from a `Data` object. Again we first create the offsets along the transect. ```python x0_transect=np.linspace(0., Lx, NEx) ``` We then add the appropriate $x_1$ coordinate (=`H0`) to build up the 2D coordinates in the domain: ```python x_transect=[ (x0, H0) for x0 in x0_transect] ``` Now we are ready to create the `Locator` named `transect_locator` which we later to fetch the values of the total magnetic field anomaly $b_a$ for the transect. We will calculate $b_a$ at element centers indicated by the argument `where=ReducedFunction(domain)`: ```python from esys.escript.pdetools import Locator transect_locator=Locator(where=ReducedFunction(domain), x=x_transect ) ``` As `transect_locator` could have moved the requested point `x_transect` locations toward element centers but we want to use these locations later for plotting $b_a$ over the profile we obtain the actually used $x_0$-coordinates (=offset within the transect): ```python x0_transect=[ x[0] for x in transect_locator.getX()] ``` ## Setup the PDE Now we are ready to set up the PDE we need to solve to obtain the scalar potential $U$ for the magnetic field anomaly $\mathbf{B}$: ```python from esys.escript.linearPDEs import LinearSinglePDE model=LinearSinglePDE(domain) ``` The easy bit is to `A`. It is the same as in the gravity case: ```python model.setValue(A=identityTensor(domain)) ``` Again we fix the potential to zero at the top and the bottom of the domain: ```python x=domain.getX() q_bottom=whereZero(x[1]) # 1 for face x_1=0 q_top=whereZero(x[1]-Lz) # 1 for face x_1=Lz model.setValue(q=q_bottom+q_top) ``` The magnetic anomaly is defined as product of the background magnetic field $\mathbf{B}_b$ and the susceptibility $k$. This is the magnetization which in fact becomes the value for $\mathbf{X}$ in the PDE template. We start with susceptibility $k$. We want to have the ksi for locations with an $x_1$ lower than $H_0-D$ where $H_0$ is the surface location above the bottom of the domain and $D$ is the depth of the top edge of the dyke below the surface. Again we use the `whereNegative` to set this up. This time we define the susceptibility at the center of elements: ```python X=ReducedFunction(domain).getX() m1=whereNegative(X[1]-(H0-D)) ``` As second condition we want to have a positive susceptibility $k$ only for those location that are less then $\frac{w}{2}$ away from the central vertical line at $x_0=\frac{Lx}{2}$ that means that \begin{equation} | x_0 - \frac{Lx}{2} | < \frac{w}{2} \end{equation} which is implemented using the `whereNegative` once again: ```python m2=whereNegative(abs(X[0]-Lx/2)-w/2) ``` The susceptibility $k$ is then set to: ```python k=ksi*m1*m2 ``` Let's quickly check if we have done the right thing and plot the distribution of `k` with `matplotlib`: ```python k_np=convertToNumpy(k) x_np=convertToNumpy(k.getFunctionSpace().getX()) import matplotlib.pyplot as plt plt.clf() plt.figure(figsize=(5,5)) plt.tricontourf(x_np[0], x_np[1], k_np[0], 15) plt.xlabel('x [m]') plt.ylabel('y [m]') plt.title("susceptibility distribution") ``` <IPython.core.display.Javascript object> <IPython.core.display.Javascript object> Text(0.5,1,'susceptibility distribution') At the equator the background magnetic field has south-east orientation parallel to the surface of the Earth: \begin{equation}\label{EQBBEquator} \mathbf{B}_b= \begin{bmatrix} -b_b \\ 0 \end{bmatrix} \end{equation} With this we can now set the coefficient `X`: ```python B_b=[-b_b, 0.] model.setValue(X=k*B_b) ``` and get the scalar potential ```python u=model.getSolution() ``` Now we can get magenetic anomaly field $\mathbf{B}_a$ as the gradient of the scalar potential. Here we calculate the gradient at the center of elements: ```python B_a=-grad(u, where=ReducedFunction(domain)) ``` The total magnetic field anomaly $b_a$ is calculated and its values are picked along the transect: ```python b_a=length(B_a+B_b)-b_b b_a_transect=transect_locator.getValue(b_a) ``` ```python plt.figure()#figsize=(12,5)) plt.plot(x0_transect, b_a_transect) plt.xlabel('offset [m]') plt.ylabel('total anomaly [nT]') plt.title("total magnetic field anomaly for dyke at the equator") plt.show() ``` <IPython.core.display.Javascript object> ## Total Magnetic Anomaly at the Poles We want compare the total magnetic field anomaly $b_a$ we have just calculated for the equator with the one at the North Pole. To simplify the coding we write a function `getTotalMagneticFieldAnomaly` that takes a background magnetic field and return the total magnetic field anomaly along the transect. ```python def getTotalMagneticFieldAnomaly(B_b): model.setValue(X=k*B_b) u=model.getSolution() B_a=-grad(u, where=ReducedFunction(domain)) b_a=length(B_a+B_b)-sqrt(B_b[0]**2+B_b[1]**2) b_a_transect=transect_locator.getValue(b_a) return b_a_transect ``` ```python plt.figure()#figsize=(12,5)) plt.plot(x0_transect, getTotalMagneticFieldAnomaly(B_b=[0, -b_b]), label="north pole=south") plt.plot(x0_transect, getTotalMagneticFieldAnomaly(B_b=[-b_b, 0.]), label="equator") plt.plot(x0_transect, getTotalMagneticFieldAnomaly(B_b=[0, b_b]), label="south pole=north") plt.xlabel('offset [m]') plt.ylabel('total anomaly [nT]') plt.title("total magnetic field anomaly for dyke") plt.legend() plt.show() ``` <IPython.core.display.Javascript object>

1a76782065536ca09defdd1fbe28c2f06500c859

ipynb

Jupyter Notebook

B_GeophyicalModeling/Magnetic.ipynb

uqzzhao/Programming-Geophysics-in-Python

e6e8299116b4698892921b78927b71fc47ee018a

2019-11-06T09:08:54.000Z

2021-12-03T08:37:47.000Z

B_GeophyicalModeling/Magnetic.ipynb

uqzzhao/Programming-Geophysics-in-Python

e6e8299116b4698892921b78927b71fc47ee018a

B_GeophyicalModeling/Magnetic.ipynb

uqzzhao/Programming-Geophysics-in-Python

e6e8299116b4698892921b78927b71fc47ee018a

2020-11-23T14:16:06.000Z

2022-03-31T14:45:46.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

| |Pierre Proulx, ing, professeur| |:---|:---| |Département de génie chimique et de génie biotechnologique |** GCH200-Phénomènes d'échanges I **| ## Exemple 7-6.1 #### Solution ##### Bilan de masse $\begin{equation*} \boxed{\rho v_1 S_1 - \rho v_2 S_2 = 0} \end{equation*}$ (1) ##### Bilan de quantité de mouvement linéaire dans la direction z $\begin{equation*} \boxed{ ( v_1w_1 + p_1 S_1)-( v_2w_2 + p_2 S_2) = \vec F_{fluide \rightarrow surface}} \end{equation*}$ (2) mais la force que le fluide exerce sur la conduite peut être évalué en reconnaissant que la force exercée par le fluide sur la conduite dans la direction z est principalement la pression exercée par le fluide sur la surface annulaire juste après l'expansion. Donc $F =-p_1 (S_2-S_1)$ En substituant dans (2): $\begin{equation*} \boxed{ ( v_1w + p_1 S_1)-( v_2w + p_2 S_2) = -p_1 (S_2-S_1)} \end{equation*}$ Souvenons-nous que $w_1=w_2=w$ et que $\rho v_1S_1=\rho v_2 S_2$ $\begin{equation*} \boxed{ S_1( \rho v_1^2 + p_1) - S_2( \rho v_2^2 + p_2) = -p_1 (S_2-S_1)} \end{equation*}$ ou $\begin{equation*} \boxed{ S_1 \rho v_1^2 - S_2 \rho v_2^2 = -S_2(p_1-p_2 )} \end{equation*}$ (3) ## 4. Bilan d'énergie mécanique $\begin{equation*} \boxed{ \bigg ( \frac {1}{2} v_1^2 + \frac {p_1}{\rho_1} \bigg)- \bigg ( \frac {1}{2} v_2^2 + \frac {p_2}{\rho_2} \bigg )= E_v} \end{equation*}$ ```python # Préparation de l'affichage et des outils de calcul symbolique # import sympy as sp from IPython.display import * sp.init_printing(use_latex=True) %matplotlib inline # v_1,v_2,p_1,p_2,S_1,S_2,rho,E_v=sp.symbols('v_1,v_2,p_1,p_2,S_1,S_2,rho,E_v') eq1=sp.Eq(v_1*S_1-v_2*S_2) eq2=sp.Eq(v_1**2*S_1*rho-v_2**2*S_2*rho+S_2*(p_1-p_2)) eq3=sp.Eq(1/2*v_1**2+p_1/rho-1/2*v_2**2+p_2/rho -E_v) solution=sp.solve((eq1,eq2,eq3),v_2,p_2,E_v) display(solution[0][2].simplify()) ``` ```python ```

7ac35466b84d4c38015ff298b04213097502ec7f

ipynb

Jupyter Notebook

Chap-7-ex-7-6-1.ipynb

pierreproulx/GCH200

66786aa96ceb2124b96c93ee3d928a295f8e9a03

2018-02-26T16:29:58.000Z

2018-02-26T16:29:58.000Z

Chap-7-ex-7-6-1.ipynb

pierreproulx/GCH200

66786aa96ceb2124b96c93ee3d928a295f8e9a03

Chap-7-ex-7-6-1.ipynb

pierreproulx/GCH200

66786aa96ceb2124b96c93ee3d928a295f8e9a03

2018-02-27T15:04:33.000Z

2021-06-03T16:38:07.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__fra_Latn

# Solwing the Solow model with R&D ## Intro In this project we will try to solve the solow model with R&D and furthermore extend the model by including human capital. Our goal will be to dig into the following aspects: * Finding the steady state rates by solveing for several transition equation * Finding numeric values for the steady state rates * Visualizing the transition towards steady state The realistic parameters, which will be used to find a numeric value for the steady state rates can be found in the textbook "*Introducing Advanced Macroeconomics*" by Peter Birch Sørensen and Hans Jørgen Whitta-Jacobsen. # Post peer feedback changes * Improved both transition plots - More interactive features, made arrow follow the equilibrium etc. * Some people have troubles running the plots - Theses errors should be fixed now * Fixed typos and mislabels ### More Feedback ideas, which was taken into considerations but ultimately was not implemented * Direction fields * Calculating speed of convergence ```python import numpy as np import matplotlib.pyplot as plt import ipywidgets as widgets import sympy as sm sm.init_printing(use_unicode=True) ``` We consider the following model for a closed economy, where the following equations are given: 1. \\[Y_{t}=K_{t}^{\alpha}\left(A_{t}L_{Y_{t}}\right)^{1-\alpha}, 0<\alpha<1\\] 2. \\[K_{t+1}-K_{t}=s_{K}Y_{t}-\delta K_{t},0<\delta<1,0<s_{k}<1,K_{0}>0 \text{ provided} \\] 3. \\[A_{t+1}-A_{t}=\rho A_{t}^{\phi}L_{A_{t}}^{\lambda},\rho>0,\phi>0,0<\lambda<1 \\] 4. \\[L_{A_{t}}=s_{R}L_{t},0<s_{R}<1 \\] 5. \\[L_{t}=L_{A_{t}}+L_{Y_{t}} \\] 6. \\[L_{t+1}=\left(1+n\right)L_{t},n>0 \\] Equation (1) is a Cobb-Douglas production function, which describes the aggregated production, $Y_{t}$, as a function of financial capital, $K_{t}$, production workers, $L_{Y_{t}}$ and the knowledge level, $A_{t}$, which determines the productivity of the workers. Equation (2) describes how financial capital develops over time, where $s_{K}$ is the saving rate. Equation (3) shows the development in the knowledge level, where $A_{t}$ is an expression for the knowledge at the time $t$ and $L_{A_{t}}$ is the amount of researchers. Equation (4) shows that the latter is the product of the population, $L_{t}$, and the share of researchers, $s_{R}$. The following definitions will also be used throughout this project: 7. \\[ y_{t}=\frac{Y_{t}}{L_{Y_{t}}};k_{t}=\frac{K_{t}}{L_{Y_{t}}} \\] 8. \\[\tilde{y}=\frac{y_{t}}{A_{t}};\tilde{k}=\frac{k_{t}}{A_{t}} \\] Where **7.** is the definition for capital-labo ratio and **8.** is the definition for the technology adjusted capital-labor ratio. # The growth in technology Our first goal in this model is to find the steady state rate for the exact growth rate of technology. The following transitions equation is given for the growth in technology: 9. \\[g_{t+1}=\left(1+n\right)^{\lambda}g_{t}\left(1+g_{t}\right)^{\phi-1}\\] We then wish to find the steady state for this equation. That is to solve for $g^*$ the following equation: 10. \\[g^*=\left(1+n\right)^{\lambda}g^*\left(1+g^*\right)^{\phi-1}\\] ```python # Define parameters as symbols g = sm.symbols('g') n = sm.symbols('n') l = sm.symbols('lambda') phi = sm.symbols('phi') ``` ```python # Define the transition equation trans_g = sm.Eq(1,(1+n)**(l)*1*(1+g)**(phi-1)) ``` ```python # Solve for g ss_g = sm.solve(trans_g,g)[0] ss_g ``` Next we will estimate the numeric value of the steady state growth rate of technology by using realistic parameters. $n = 0.01$ $\lambda = 1$ $\phi = 0.50$ ```python # Define function and print with given parameters sol_func_g = sm.lambdify((n,l,phi),ss_g) sol_num_g = sol_func_g(0.01,1,0.5) f"The steady state growth rate of technology is {sol_num_g:.2f}" ``` 'The steady state growth rate of technology is 0.02' By using these given parameters, the steady state rate of growth in technology is estimated to be 2%. # Solving the "simple" model with R&D Our next step is to solve the simple model with R&D. The transition equation for capital accumulation can then be expressed as: 11. \\[ {\tilde{k}_{t+1}=\frac{1}{\left(1+n\right)\left(1+g_{t}\right)}\left(s_{k}\tilde{k}_{t}^{\alpha}+\left(1-\delta\right)\tilde{k}_{t}\right)} \\] To find the solution for this model, we will have to find the steady state rate. That is to solve for $\tilde{k}$ in the following equation: 12. \\[{\tilde{k}^{*}=\frac{1}{\left(1+n\right)\left(1+g_{t}\right)}\left(s_{k}\tilde{k}^{\alpha*}+\left(1-\delta\right)\tilde{k}^{*}\right)} \\] But first, we will have to define the following parameters and variables as symbols ```python # Define variables and parameters as symbols k = sm.symbols('k') alpha = sm.symbols('alpha') delta = sm.symbols('delta') s_k = sm.symbols('s_K') ``` ```python # Define equation and solve for k trans_k = sm.Eq(k,(s_k*k**alpha+(1-delta)*k)/((1+n)*(1+g))) ss_k = sm.solve(trans_k,k)[0] ss_k ``` Let's try to find the numeric value for the steady state growth rate of capital per effecient worker by using realistic paramters: $$s_K = 0.2$$ $$g = 0.02$$ $$n = 0.01$$ $$\delta = 0.06$$ $$\alpha = 1/3 $$ ```python # Define function and print with parameters sol_func_k = sm.lambdify((s_k,g,n,delta,alpha),ss_k) sol_num_k = sol_func_k(0.2,0.02,0.01,0.06,1/3) f"The Adjusted capital-labor ratio SS is {sol_num_k:.2f}" ``` 'The Adjusted capital-labor ratio SS is 3.30' We could also estimate the rate by changing some parameters and holding the others fixed. Hence, we create a slider ```python # Define function for the solution def sol_num_k_func(s_k,g,n,delta,alpha): return f"The steady state growth rate of capital per effecient worker is {((delta + g * n + g + n)/s_k)**(1/(alpha-1)):.3f}" ``` ```python # Create slider slider_g_r = widgets.interact(sol_num_k_func, s_k=widgets.FloatSlider(description="$s_k$", min=0.0, max=0.5, step=0.05, value=0.2), g=widgets.FloatSlider(description="$g$", min=0.0, max=0.1, step=0.01, value=0.02), n=widgets.FloatSlider(description="$n$", min=0.0, max=0.1, step=0.01, value=0.01), delta=widgets.FloatSlider(description="$\delta$", min=0.0, max=0.2, step=0.02, value=0.06), alpha=widgets.FloatSlider(description="$a$", min=0.1, max=0.67, step=0.03, value=1/3) ) ``` interactive(children=(FloatSlider(value=0.2, description='$s_k$', max=0.5, step=0.05), FloatSlider(value=0.02,… ## Visualization of the path towards steady state - The transition diagram Our next goal is to create a plot for the transition diagram. ```python # Define functions of the transition equation and the numeric SS solutions. def trans_k_func(k, s_k, alpha, delta, n, g): return (s_k*k**alpha+(1-delta)*k)/((1+n)*(1+g)) def sol_val_k_func(s_k,g,n,delta,alpha): return ((delta + g * n + g + n)/s_k)**(1/(alpha-1)) ``` ## Changing the value of the savings ratio What will happen to our plot, if the savaings ratio was to be changed. We will explore this by creating a simple interactive slider. **Please run the below cell twice to resize the plot propely** ```python from ipywidgets import interactive def slider(s_k): plt.figure(dpi = 100) plt.rc('text', usetex=True) plt.rc('font', family='sans-serif') #range for k k = np.arange(0.0, 15, 0.005) # paramters: s_K = 0.2 g = 0.02 n = 0.01 delta = 0.06 alpha = 1/3 # label and title plt.xlabel(r'$k_t$',fontsize=20 ) plt.ylabel(r'$k_{t+1}$', fontsize=20) plt.title(r'The transition diagram', fontsize=20) # plot the transition equation and 45-degree equation plt.plot(k, trans_k_func(k, s_k, alpha, delta, n, g)) plt.plot(k, k) sol_val_k = sol_val_k_func( delta = delta, g = g, n = n, s_k = s_k, alpha = alpha) # Legend plt.legend((r'$\frac{1}{\left(1+n\right)\left(1+g\right)}\left(s\tilde{k}_{t}^{\alpha}+\left(1-\delta\right)\tilde{k}_{t}\right)$', r'$\tilde{k}_{t+1}=\tilde{k}_{t}$'), shadow=True, handlelength=1.4, fontsize=12) # Create arrow, which points at SS plt.annotate( f'Adjusted capital-labor ratio SS {sol_val_k:.3f}', xy=(sol_val_k, sol_val_k), xytext=(sol_val_k-1, sol_val_k-3), arrowprops=dict(facecolor='black', shrink=0.01), ) # plot the figure and interactive slider interactive_plot = interactive(slider, s_k=widgets.FloatSlider(description="$s_k$", min=0.0, max=0.5, step=0.04, value=0.20, continuous_update=True) ) interactive_plot ``` interactive(children=(FloatSlider(value=0.2, description='$s_k$', max=0.5, step=0.04), Output()), _dom_classes… We see as the savings ratio increases, so does the steady state rate. # Extending the model with human capital We now want to extend the model and therefore adds *Human capital*. Equation 1. will be swapped by: 1'. \\[Y_{t}=K_{t}^{\alpha}H_{t}^{\varphi}\left(A_{t}L_{Y_{t}}\right)^{1-\alpha-\varphi} \\] And a new human capital accumulation equation is given as: 13. \\[H_{t+1}-H_{t}=s_{H}Y_{t}-\delta H_{t},0<\delta<1,0<s_{H}<1,H_{0}>0 \text{ provided} \\] which will change equation (1) and (3). Additionally the equation below will be added to the model, which describes how human capital develops over time. Here $s_{H}$ is the saving rate in human capital. $\delta$ is the depreciation rate. The following is the definition of per production worker variable and per effective production worker variable: $h_{t}=\frac{H_{t}}{L_{Y_{y}}}$ & $\tilde{h}=\frac{h_{t}}{A_{t}}$ With human capital included in the model, a new transition equation is given for human capital per effecient worker and capital per effecient worker. 14. \\[ \tilde{h}_{t+1}=\frac{1}{\left(1+n\right)\left(1+g_{t}\right)}\left(s_{K}\tilde{k}_{t}^{\alpha}\tilde{h}_{t}^{\varphi}+\left(1-\delta\right)\tilde{h}_{t}\right) \\] 15. \\[ \tilde{k}_{t+1}=\frac{1}{\left(1+n\right)\left(1+g_{t}\right)}\left(s_{H}\tilde{k}_{t}^{\alpha}\tilde{h}_{t}^{\varphi}+\left(1-\delta\right)\tilde{k}_{t}\right)\\] Similar to the previous simple model, we will have to solve the following two equations to find the steady state values. \\[ \tilde{k}^{*}=\frac{1}{\left(1+n\right)\left(1+g_{t}\right)}\left(s_{K}\tilde{k}^{*{\alpha}}\tilde{h}^{*{\varphi}}+\left(1-\delta\right)\tilde{k}^*\right)\\] \\[ \tilde{h}^{*}=\frac{1}{\left(1+n\right)\left(1+g_{t}\right)}\left(s_{H}\tilde{k}^{*{\alpha}}\tilde{h}^{*{\varphi}}+\left(1-\delta\right)\tilde{h}^*\right)\\] ```python # Define parameters as symbols h = sm.symbols('h') k = sm.symbols('k') s_h =sm.symbols('s_H') s_k = sm.symbols('s_K') g = sm.symbols('g') n = sm.symbols('n') delta = sm.symbols('delta') vphi = sm.symbols('varphi') alpha = sm.symbols('alpha') vphi = sm.symbols('varphi') ``` ```python # Define the two new transition equations trans_k2 = sm.Eq(k,(s_k*k**alpha*h**vphi+(1-delta)*k)/((1+n)*(1+g))) trans_h = sm.Eq(h,(s_h*k**alpha*h**vphi+(1-delta)*h)/((1+n)*(1+g))) ``` ```python # Solve a system of two equations ss_kh = sm.solve([trans_k2,trans_h], (k,h))[0] ss_kh ``` While this might not be the most aesthetically pleasing solution, it is the correct. Next we are able to find the steady state rate for GDP per effecient worker, $\tilde{y}^* = (\tilde{k})^\alpha*(\tilde{h})^\varphi $. ```python # Find the steady state rate for GDP per effecient worker ss_gdp_per_worker = ss_kh[0]**vphi*ss_kh[1]**alpha ss_gdp_per_worker ``` Next we will estimate the numeric value of the steady state rate of: * Capital per effecient worker, $k^*$ * Human Capital per effecient worker, $h^*$ * GDP per effecient worker, $y^*$ by using the following paramters: $$s_K = 0.2$$ $$s_H = 0.2$$ $$g = 0.02$$ $$n = 0.01$$ $$\delta = 0.06$$ $$\alpha = \varphi = 1/3 $$ ```python # Define and insert parameters for capital sol_func_k2 = sm.lambdify((s_k,s_h,g,n,delta,alpha,vphi),ss_kh[0]) sol_num_k2 = sol_func_k2(0.2,0.2,0.02,0.01,0.06,1/3,1/3) f" The Adjusted capital-labor ratio SS is {sol_num_k2:.3f}" ``` ' The Adjusted capital-labor ratio SS is 10.901' ```python # Define and insert parameters for human capital sol_func_h = sm.lambdify((s_k,s_h,g,n,delta,alpha,vphi),ss_kh[1]) sol_num_h = sol_func_h(0.2,0.2,0.02,0.01,0.06,1/3,1/3) f"The Adjusted human capital-labor ratio SS is {sol_num_h:.3f}" ``` 'The Adjusted human capital-labor ratio SS is 10.901' ```python # Define and insert parameters for GDP sol_func_y = sm.lambdify((s_k,s_h,g,n,delta,alpha,vphi),ss_gdp_per_worker) sol_num_y = sol_func_y(0.2,0.2,0.02,0.01,0.06,1/3,1/3) f"The steady state rate for GDP pr. worker is {sol_num_y:.3f}" ``` 'The steady state rate for GDP pr. worker is 4.916' ## Visualization of the path towards steady state - The transition diagram Our next goal is to create a plot for the transition diagram for the model including human capital. First we have to find the "nullclines". In order for us to this, we first have to find the solow equations. This is done by substracting $\tilde{k}_{t}$ or $\tilde{h}_{t}$ from the respective transition equation. 16. \\[ \tilde{h}_{t+1}-\tilde{h}_{t}=\frac{1}{\left(1+n\right)\left(1+g_{t}\right)}\left(s_{K}\tilde{k}_{t}^{\alpha}\tilde{h}_{t}^{\varphi}+\left(1-\delta\right)\tilde{h}_{t}\right)-\tilde{h}_{t} \\] 17. \\[ \tilde{k}_{t+1}-\tilde{k}_{t}=\frac{1}{\left(1+n\right)\left(1+g_{t}\right)}\left(s_{H}\tilde{k}_{t}^{\alpha}\tilde{h}_{t}^{\varphi}+\left(1-\delta\right)\tilde{k}_{t}\right)-\tilde{k}_{t} \\] To find the nullclines, we will have to solve for $\tilde{h}$ in the two solow equations. ```python # Define the two solow equations solow_k = sm.Eq(k-k,((s_k*k**alpha*h**vphi+(1-delta)*k)/((1+n)*(1+g))-k)) solow_h = sm.Eq(h-h,((s_h*k**alpha*h**vphi+(1-delta)*h)/((1+n)*(1+g))-h)) solow_k, solow_h ``` ```python # Now solve for each of the equation with respect to h solow_sol_k = sm.solve(solow_k, h)[0] solow_sol_h = sm.solve(solow_h, h)[0] solow_sol_k, solow_sol_h ``` The first nullcine is labed as ($\Delta\tilde{k}_{t} = 0)$ and the second nullcline as ($\Delta\tilde{h}_{t} = 0)$. ```python # Parameters g = 0.02 n = 0.01 delta = 0.06 alpha = 1/3 vphi = 1/3 # Define the two null clines as functions def nullcline_1(k, s_k, s_h, alpha, delta, n, g): return (((k**(-alpha+1)*(delta + g*n + g + n)) / s_k)**(1/vphi)) def nullcline_2(k, s_k, s_h, alpha, delta, n, g): return (((k**(-alpha)*(delta + g*n + g + n)) / s_h)**(1/(vphi-1))) ``` ```python def slider2(s_k, s_h): # Range for k k = np.arange(0.0,80.0,0.1) plt.figure(dpi=100) # labels and title plt.xlabel(r'$\tilde{k_t}$',fontsize=20, color = "black" ) plt.ylabel(r'$\tilde{h_t}$', fontsize=20, color = "black") plt.title(r'The transition diagram with human capital', fontsize=20) # Plot the nullclines plt.plot(k, nullcline_1(k, s_k, s_h, alpha, delta, n, g)) plt.plot(k, nullcline_2(k, s_k, s_h, alpha, delta, n, g)) # Calculate the numeric SS values sol_val_h = sol_func_h(s_k,s_h,g,n,delta,alpha,vphi) sol_val_k2 = sol_func_k2(s_k,s_h,g,n,delta,alpha,vphi) # Dashed lines for SS values plt.axhline(y=sol_val_h, xmin=0., xmax=1, linestyle = '--', color = "black") plt.axvline(x=sol_val_k2, ymin=0., ymax=1, linestyle = '--', color = "black") # Legend plt.legend((r'$\left[\Delta\tilde{k}_{t}=0\right]$', r'$\left[\Delta\tilde{h}_{t}=0\right]$'), shadow=True, handlelength=1.4, fontsize=16) # labels for dashed lines plt.annotate(r'$\tilde{k}^{*}$', xy=(0, 0), xytext=(sol_val_k2, -5)) plt.annotate(r'$\tilde{h}^{*}$', xy=(0, 0), xytext=(-5, sol_val_h)) plt.axis([0,80,0,80]) plt.show() # plot the figure and interactive slider for s_k and s_h interactive_plot = interactive(slider2, s_k=widgets.FloatSlider(description="$s_k$", min=0.0, max=0.4, step=0.04, value=0.20, continuous_update=True), s_h=widgets.FloatSlider(description="$s_h$", min=0.0, max=0.4, step=0.04, value=0.20, continuous_update=True) ) interactive_plot ``` interactive(children=(FloatSlider(value=0.2, description='$s_k$', max=0.4, step=0.04), FloatSlider(value=0.2, … # Finding the steady state growth path for GDP per capita Under the assumption that $\phi < 1 $, we'll try to derive the steady-state growth path for GDP per capita. \\[\hat{y}_{t}^{*}=\tilde{y}^{*}\left(1-s_{R}\right)\left(\frac{\rho}{g_{se}}\right)^{\frac{1}{1-\phi}}s_{R}^{\frac{\lambda}{1-\phi}}\left(1+g_{se}\right)^{t}L_{0}^{\frac{\lambda}{1-\phi}}\\] ```python # Define the following parameters as symbols y_hat = sm.symbols('\hat{y}_{t}^{*}') y_tilde = sm.symbols(r'\tilde{y}^{*}') l = sm.symbols('lambda') phi = sm.symbols('phi') s_r = sm.symbols('s_{R}') rho = sm.symbols('rho') g_se = sm.symbols('g_{se}') t = sm.symbols('t') L_0 = sm.symbols('L_{0}') ``` ```python # Defining the equation ss_gp = y_tilde*(1-s_r)*(rho/g_se)**(1/(1-phi))*s_r**(l/(1-phi))*(1+g_se)**t*L_0**(l/(1-phi)) ``` Next we will find the "Golden rule" for $s_R$, which is the optimal share of the population being researchers. This is done by differentiation with respect to $s_R$,$\frac{\partial\hat{y}_{t}^{*}}{\partial s_{R}}$, and then solving for $s_R$. ```python # Differentiate the equation with respect to s_R diff_ss_gp = sm.diff(ss_gp,s_r) diff_ss_gp ``` ```python #Solve for s_R golden_rule = sm.solve(diff_ss_gp,s_r)[0] golden_rule ``` As presented above, the optimal share of researchers is $\left[\frac{\lambda}{\lambda-\phi+1}\right]$. Next let's try to find the numerical value by using the following realistic parameters. $\lambda = 1, \phi = 0.5$ ```python # parametrize the golden rule golden_rule_num = sm.lambdify((l,phi),golden_rule) g_r = golden_rule_num(1,0.5) f"The optimal share of researchers are {g_r:.3f}" ``` 'The optimal share of researchers are 0.667' Last, let's create a simple slider for changing values of $\phi$ while holding $\lambda$ fixed. ```python # Define function of the golden rule def g_rule(l,phi): return f"s_r = {l/(1+l-phi):.3f}" ``` ```python # Create slider slider_g_r = widgets.interact(g_rule, phi=widgets.FloatSlider(description="$\phi$", min=0.0, max=1.0, step=0.05, value=0.5), l=widgets.fixed(1) ) ``` interactive(children=(FloatSlider(value=0.5, description='$\\phi$', max=1.0, step=0.05), Output()), _dom_class… We see as $\phi$, which is a messaure for how capital affects "knowledge", continues to grow the optimal share of researchers also increases. # Overall conclusion and further perspectives In this project, we have succeded in solving the solow model with R&D and extended it with human capital. The dynamic paths towards steady state have been visualized by using realistic parameters. We have also seen how the steady state rate develops, when some of the parameters are changed. To extend this project more simulations and visualization are posible options.

74c2486c14e7e2e739875daafd734b038a3851d0

ipynb

Jupyter Notebook

modelproject/model_project.ipynb

NumEconCopenhagen/projects-2019-pickles

7f4d66612bf8f575b745a2c1c32477938e3dcbb6

modelproject/model_project.ipynb

NumEconCopenhagen/projects-2019-pickles

7f4d66612bf8f575b745a2c1c32477938e3dcbb6

2019-04-08T17:31:57.000Z

2019-05-14T18:47:13.000Z

modelproject/model_project.ipynb

NumEconCopenhagen/projects-2019-pickles

7f4d66612bf8f575b745a2c1c32477938e3dcbb6

2019-05-14T08:10:26.000Z

2019-12-09T09:29:09.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# the German tank problem the Germans have a population of $n$ tanks labeled with serial numbers $1,2,...,n$ on the tanks. The number of tanks $n$ is unknown and of interest to the Allied forces. The Allied forces randomly capture $k$ tanks from the Germans with replacement and observe their serial numbers $\{x_1, x_2, ..., x_k\}$. The goal is to, from observing the serial numbers on this random sample of the tanks, estimate $n$. the *estimator* of $n$ maps an outcome of the experiment to an estimate of $n$, $\hat{n}$. ```julia using StatsBase using PyPlot using Statistics using Printf PyPlot.matplotlib.style.use("seaborn-pastel") rcParams = PyPlot.PyDict(PyPlot.matplotlib."rcParams") rcParams["font.size"] = 16; ``` ## data structure for a tank for elegance ```julia struct Tank serial_no::Int end tank = Tank(3) ``` Tank(3) ## visualizing the captured tanks and their serial numbers ```julia function viz_tanks(tanks::Array{Tank}, savename=nothing) nb_tanks = length(tanks) img = PyPlot.matplotlib.image.imread("tank.png") fig, ax = subplots(1, nb_tanks) for (t, tank) in enumerate(tanks) ax[t].imshow(img) ax[t].set_title(tank.serial_no) ax[t].axis("off") end tight_layout() if ! isnothing(savename) savefig(savename * ".png", format="png", dpi=300) # Linux command line tool to trim white space run(`convert $savename.png -trim $savename.png`) end end n = 7 tanks = [Tank(s) for s in 1:n] viz_tanks(tanks) ``` ## simulating tank capture write a function `capture_tanks` to simulate the random sampling of `nb_tanks_captured` tanks from all `nb_tanks` tanks the Germans have (without replacement). return a random sample of tanks. ```julia function capture_tanks(num_captured::Int, num_tanks::Int) return sample([Tank(i) for i in 1:num_tanks], num_captured, replace=false) end tanks = capture_tanks(4, 50) viz_tanks(tanks) ``` ## defining different estimators an estimator maps an outcome $\{x_1, x_2, ..., x_k\}$ to an estimate for $n$, $\hat{n}$. ### estimator (1): maximum serial number this is the maximum likelihood estimator. \begin{equation} \hat{n} = \max_i x_i \end{equation} ```julia function max_serial_no(captured_tanks::Array{Tank}) return maximum([t.serial_no for t in captured_tanks]) end max_serial_no(tanks) ``` 44 ### estimator (2): maximum serial number plus initial gap \begin{equation} \hat{n} = \max_i x_i + \bigl(\min_i x_i -1\bigr) \end{equation} ```julia function max_plus_first_gap(captured_tanks::Array{Tank}) # only need to store this array once serials = [t.serial_no for t in captured_tanks] return maximum(serials) + minimum(serials) - 1 end max_plus_first_gap(tanks) ``` 52 ### estimator (3): maximum serial number plus gap if samples are evenly spaced \begin{equation} \hat{n} = \max_i x_i + \bigl( \max_i x_i / k -1 \bigr) \end{equation} ```julia function max_plus_even_gap(captured_tanks::Array{Tank}) serials = [t.serial_no for t in captured_tanks] max_serial = maximum(serials) # operations are costly; don't do it this way # return maximum(serials) * (1 + 1 / length(serials)) - 1 return max_serial + max_serial / length(serials) - 1 end max_plus_even_gap(tanks) ``` 54.0 ## assessing the bias and variance of different estimators say the Germans have `nb_tanks` tanks, and we randomly capture `nb_tanks_captured`. what is the distribution of the estimators (over different outcomes of this random experiment), and how does the distribution compare to the true `nb_tanks`? ```julia function sim_̂n(num_sims::Int, num_tanks::Int, num_tanks_captured::Int, estimator::Function) return [estimator(capture_tanks(num_tanks_captured, num_tanks)) for i in 1:num_sims] end num_tanks = 100 num_captured = 5 num_sims = 1000 mean(sim_̂n(num_sims, num_tanks, num_captured, max_serial_no)) ``` 84.74 ```julia num_sims = 10000 fig, ax = subplots(1, 1, figsize=(18, 8)) estimators = [max_serial_no, max_plus_first_gap, max_plus_even_gap] for e in estimators results = sim_̂n(num_sims, num_tanks, num_captured, e) est_name = replace(string(e), "_" => " ") ax.hist(results, label=est_name, alpha=0.7) println(est_name) println(" (̂n):", mean(results)) println(" std(̂n):", std(results), "\n") end ax.axvline(num_tanks, color="k", ls="--", linewidth=3) ax.legend() ``` ```julia print(max_plus_even_gap) ``` max_plus_even_gap notes: * **efficiency**: small variance * **consistency**: as number of samples in the estimate increases, the estimator converges * **unbiasedness**: average estimator is correct ## what happens as we capture more and more tanks, i.e. increase $k$? assess estimator (3). ```julia ``` ## one-sided confidence interval how confident are we that the Germans don't have *more* tanks? significance level: $\alpha$ test statistic = estimator (3) = $\hat{n} = \max_i x_i + \bigl( \max_i x_i / k -1 \bigr)$ **null hypothesis**: the number of tanks is $n=n_0$<br> **alternative hypothesis**: the number of tanks is less than $n_0$ we reject the null hypothesis (say, "the data does not support the null hypothesis") that the number of tanks is $n=n_0$ if the p-value is less than $\alpha$. the p-value is the probability that, if the null hypothesis is true, we get a test statistic equal to or smaller than we observed. we want to find the highest $n_0$ such that we have statistical power to reject the null hypothesis in favor of the alternative hypothesis. this is the upper bound on the confidence interval! then the idea is that, if the null hypothesis is that the number of tanks is absurdly large compared to the largest serial number we saw in our sample, it would be very unlikely that we would see such small serial numbers compared to the number of tanks, so we'd reject the null hypothesis. ```julia ``` say $\alpha=0.05$ and we seek a 95% one-sided confidence interval ```julia ``` ```julia ```

a6f97a896d5a264829a39d1db70792df9ef864d5

ipynb

Jupyter Notebook

In-Class Notes/German Tank Problem/German tank problem_sparse.ipynb

cartemic/CHE-599-intro-to-data-science

a2afe72b51a3b9e844de94d59961bedc3534a405

In-Class Notes/German Tank Problem/German tank problem_sparse.ipynb

cartemic/CHE-599-intro-to-data-science

a2afe72b51a3b9e844de94d59961bedc3534a405

In-Class Notes/German Tank Problem/German tank problem_sparse.ipynb

cartemic/CHE-599-intro-to-data-science

a2afe72b51a3b9e844de94d59961bedc3534a405

2019-10-02T16:11:36.000Z

2019-10-15T20:10:40.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# Кластерный анализ ## Метод к-средних Дана матрица данных $X$ и дано число $k$ предполагаемых кластеров. Цель кластеризации представить данные в виде групп кластеров $C=\{C_1, C_2, \ldots, C_k\}$. Каждый кластер имеет свой центр: \begin{equation} \mu_i = \frac{1}{n_i} \sum \limits_{x_j \in C_i} x_j \end{equation} где $n_i = |C_i|$ - это количество точек в кластере $C_i$. Таким образом, мы имеем некоторые кластеры $C=\{C_1, C_2, \ldots, C_k\}$ и необходимо оценить качество разбиения. Для этого будем вычислять сумму квадратических ошибок (SSE): \begin{equation} SSE(C) = \sum \limits_{i=1}^{k} \sum \limits_{x_j \in C_i} ||x_j - \mu_i||^2 \end{equation} Цель найти \begin{equation} C^* = arg\min\limits_C \{SSE(C)\} \end{equation} ### Алгоритм к-средних На вход алгоритм получает матрицу данных $D$, количество кластеров $k$, и критерий остановки $\epsilon$: 1. t = 0 2. случайным образом инициализируем $k$ центров кластеров: $\mu_1^t, \mu_2^t, \ldots, \mu_k^t \in R^d$; 3. повторять 4. $t = t + 1$; 5. $C_j = 0$ для всех $j = 1, \ldots, k$ 6. для каждого $x_j \in D$ 7. $j^* = arg\min\limits_C \{||X_j - \mu_i^{t-1}||^2\}$ \\\ присваиваем $x_j$ к ближайшему центру 8. $C_{j^*} = C_{j^*} \cup {x_j}$ 9. для каждого i=1 до k 10. $\mu_i = \frac{1}{|C_i|} \sum_{x_j \in C_i} x_j$ 11. пока $\sum_{i=1}^k ||\mu_i^{t} - \mu_i^{t-1}||^2 \leq \epsilon$ ## Задание 1. Написать программу, реализующую алгоритм к-средних. 2. Визуализировать сходимость центров кластеров. 3. Оценить $SSE$ для значений $k = 1, \ldots, 10$ и построить график зависимости $SSE$ от количества кластеров. ```python import matplotlib.pyplot as plt import numpy as np from scipy.spatial import distance from sklearn.datasets import make_blobs X, Y = make_blobs(n_samples = 1000, n_features=2, centers=5, cluster_std = 1.2, random_state=17) plt.scatter(X[:,0], X[:,1]) plt.show() ``` ```python def get_center(cluster): return np.array([cluster[:,0].mean(), cluster[:,1].mean()]) def get_dist(point_1, point_2): return np.linalg.norm(point_1 - point_2) def get_clusters(X, centers): clusters = dict() for point in X: best_cluster = min([(index, get_dist(point, center)) for index, center in enumerate(centers)], key=lambda t:t[1])[0] try: clusters[best_cluster].append(point) except KeyError: clusters[best_cluster] = [point] return {key: np.array(clusters[key]) for key in clusters} def get_new_value_centers(clusters): new_centers = list() for key in clusters: new_centers.append(np.mean(clusters[key], axis = 0)) return np.array(new_centers) def get_cluster_plt(clusters): for key in clusters: plt.scatter(clusters[key][0:,0], clusters[key][0:,1]) plt.show() def k_means(X, k, early_stop, show_clusters=False): centers = np.array([get_center(cluster) for cluster in np.array_split(X, k)]) eps = float("inf") while eps >= early_stop: clusters = get_clusters(X, centers) if show_clusters: get_cluster_plt(clusters) new_centers = get_new_value_centers(clusters) eps = sum([get_dist(centers[index], new_centers[index]) for index, _ in enumerate(new_centers)]) centers = new_centers return clusters ``` Сходимость центров кластеров ```python clusters = k_means(X, 4, 0.1, show_clusters=True) ``` Оценка SSE ```python def k_means_centers(X, k, early_stop, show_clusters=False): centers = np.array([get_center(cluster) for cluster in np.array_split(X, k)]) eps = float("inf") while eps >= early_stop: clusters = get_clusters(X, centers) if show_clusters: get_cluster_plt(clusters) new_centers = get_new_value_centers(clusters) eps = sum([get_dist(centers[index], new_centers[index]) for index, _ in enumerate(new_centers)]) centers = new_centers return centers ``` ```python def get_sse(data,clusters): error = 0 for j in range(len(data)): min_cluster_distance = min([distance.euclidean(clusters[i],data[j]) for i in range(len(clusters))]) error = error + min_cluster_distance ** 2 return error k = list(range(1,11)) k_sse = [get_sse(X,k_means_centers(X,k[i],0.1)) for i in range(len(k))] plt.plot(k, k_sse) plt.gcf().set_size_inches(18.5, 10.5) ``` ## Реальные данные используйте метод KMeans из sklearn.clustering 1. Выбрать оптимальное количество кластеров. 2. Построить 2. Произвести анализ получившихся кластеров: 1. определите средний год автомобилей; 2. определите средний пробег автомобилей; 3. определите среднюю мощность; 4. определите среднюю цену автомобилей; 5. основные марки автомобилей в кластере; 6. определите тип топлива; 7. определите основной тип кузова; 8. определите основной тип привода; 9. определите основной тип КПП; 10. определите количество хозяев автомобиля. Охарактеризуйте каждый класстер. ```python import pandas as pd import numpy as np import matplotlib.pyplot as plt df = pd.read_csv('data.csv', encoding='cp1251') df = df.drop(columns=['Модель', 'Цвет']) df.head() ``` <div> <style scoped> .dataframe tbody tr th:only-of-type { vertical-align: middle; } .dataframe tbody tr th { vertical-align: top; } .dataframe thead th { text-align: right; } </style> <table border="1" class="dataframe"> <thead> <tr style="text-align: right;"> <th></th> <th>Марка</th> <th>Год</th> <th>Состояние</th> <th>Пробег</th> <th>Объем</th> <th>Топливо</th> <th>Мощность</th> <th>Кузов</th> <th>Привод</th> <th>КПП</th> <th>Руль</th> <th>Хозяев в ПТС</th> <th>Цена</th> </tr> </thead> <tbody> <tr> <th>0</th> <td>Volkswagen</td> <td>2013.0</td> <td>БУ</td> <td>42000.0</td> <td>1200.0</td> <td>бензин</td> <td>105.0</td> <td>хэтчбек</td> <td>передний</td> <td>автомат</td> <td>левый</td> <td>1 владелец</td> <td>689196.0</td> </tr> <tr> <th>1</th> <td>Skoda</td> <td>2012.0</td> <td>БУ</td> <td>62000.0</td> <td>1800.0</td> <td>бензин</td> <td>152.0</td> <td>кроссовер</td> <td>полный</td> <td>механика</td> <td>левый</td> <td>1 владелец</td> <td>639196.0</td> </tr> <tr> <th>2</th> <td>Renault</td> <td>2015.0</td> <td>БУ</td> <td>4700.0</td> <td>1600.0</td> <td>бензин</td> <td>106.0</td> <td>хэтчбек</td> <td>передний</td> <td>механика</td> <td>левый</td> <td>1 владелец</td> <td>629196.0</td> </tr> <tr> <th>3</th> <td>Nissan</td> <td>2012.0</td> <td>БУ</td> <td>70000.0</td> <td>1600.0</td> <td>бензин</td> <td>110.0</td> <td>хэтчбек</td> <td>передний</td> <td>автомат</td> <td>левый</td> <td>1 владелец</td> <td>479196.0</td> </tr> <tr> <th>4</th> <td>УАЗ</td> <td>2014.0</td> <td>БУ</td> <td>50000.0</td> <td>2700.0</td> <td>бензин</td> <td>128.0</td> <td>внедорожник</td> <td>полный</td> <td>механика</td> <td>левый</td> <td>1 владелец</td> <td>599196.0</td> </tr> </tbody> </table> </div> ```python new_df = pd.get_dummies(df) new_df.head() ``` <div> <style scoped> .dataframe tbody tr th:only-of-type { vertical-align: middle; } .dataframe tbody tr th { vertical-align: top; } .dataframe thead th { text-align: right; } </style> <table border="1" class="dataframe"> <thead> <tr style="text-align: right;"> <th></th> <th>Год</th> <th>Пробег</th> <th>Объем</th> <th>Мощность</th> <th>Цена</th> <th>Марка_Acura</th> <th>Марка_Alfa Romeo</th> <th>Марка_Audi</th> <th>Марка_BMW</th> <th>Марка_BYD</th> <th>...</th> <th>Привод_полный</th> <th>КПП_автомат</th> <th>КПП_вариатор</th> <th>КПП_механика</th> <th>КПП_роботизированная</th> <th>Руль_левый</th> <th>Руль_правый</th> <th>Хозяев в ПТС_1 владелец</th> <th>Хозяев в ПТС_2 владельца</th> <th>Хозяев в ПТС_3 и более</th> </tr> </thead> <tbody> <tr> <th>0</th> <td>2013.0</td> <td>42000.0</td> <td>1200.0</td> <td>105.0</td> <td>689196.0</td> <td>0</td> <td>0</td> <td>0</td> <td>0</td> <td>0</td> <td>...</td> <td>0</td> <td>1</td> <td>0</td> <td>0</td> <td>0</td> <td>1</td> <td>0</td> <td>1</td> <td>0</td> <td>0</td> </tr> <tr> <th>1</th> <td>2012.0</td> <td>62000.0</td> <td>1800.0</td> <td>152.0</td> <td>639196.0</td> <td>0</td> <td>0</td> <td>0</td> <td>0</td> <td>0</td> <td>...</td> <td>1</td> <td>0</td> <td>0</td> <td>1</td> <td>0</td> <td>1</td> <td>0</td> <td>1</td> <td>0</td> <td>0</td> </tr> <tr> <th>2</th> <td>2015.0</td> <td>4700.0</td> <td>1600.0</td> <td>106.0</td> <td>629196.0</td> <td>0</td> <td>0</td> <td>0</td> <td>0</td> <td>0</td> <td>...</td> <td>0</td> <td>0</td> <td>0</td> <td>1</td> <td>0</td> <td>1</td> <td>0</td> <td>1</td> <td>0</td> <td>0</td> </tr> <tr> <th>3</th> <td>2012.0</td> <td>70000.0</td> <td>1600.0</td> <td>110.0</td> <td>479196.0</td> <td>0</td> <td>0</td> <td>0</td> <td>0</td> <td>0</td> <td>...</td> <td>0</td> <td>1</td> <td>0</td> <td>0</td> <td>0</td> <td>1</td> <td>0</td> <td>1</td> <td>0</td> <td>0</td> </tr> <tr> <th>4</th> <td>2014.0</td> <td>50000.0</td> <td>2700.0</td> <td>128.0</td> <td>599196.0</td> <td>0</td> <td>0</td> <td>0</td> <td>0</td> <td>0</td> <td>...</td> <td>1</td> <td>0</td> <td>0</td> <td>1</td> <td>0</td> <td>1</td> <td>0</td> <td>1</td> <td>0</td> <td>0</td> </tr> </tbody> </table> <p>5 rows × 126 columns</p> </div> ```python from sklearn.preprocessing import StandardScaler ss = StandardScaler() new_df[['Год', 'Пробег', 'Объем', 'Мощность', 'Цена']] = ss.fit_transform(new_df[['Год', 'Пробег', 'Объем', 'Мощность', 'Цена']]) new_df.head() ``` <div> <style scoped> .dataframe tbody tr th:only-of-type { vertical-align: middle; } .dataframe tbody tr th { vertical-align: top; } .dataframe thead th { text-align: right; } </style> <table border="1" class="dataframe"> <thead> <tr style="text-align: right;"> <th></th> <th>Год</th> <th>Пробег</th> <th>Объем</th> <th>Мощность</th> <th>Цена</th> <th>Марка_Acura</th> <th>Марка_Alfa Romeo</th> <th>Марка_Audi</th> <th>Марка_BMW</th> <th>Марка_BYD</th> <th>...</th> <th>Привод_полный</th> <th>КПП_автомат</th> <th>КПП_вариатор</th> <th>КПП_механика</th> <th>КПП_роботизированная</th> <th>Руль_левый</th> <th>Руль_правый</th> <th>Хозяев в ПТС_1 владелец</th> <th>Хозяев в ПТС_2 владельца</th> <th>Хозяев в ПТС_3 и более</th> </tr> </thead> <tbody> <tr> <th>0</th> <td>1.055883</td> <td>-1.129295</td> <td>-1.096928</td> <td>-0.458895</td> <td>0.420103</td> <td>0</td> <td>0</td> <td>0</td> <td>0</td> <td>0</td> <td>...</td> <td>0</td> <td>1</td> <td>0</td> <td>0</td> <td>0</td> <td>1</td> <td>0</td> <td>1</td> <td>0</td> <td>0</td> </tr> <tr> <th>1</th> <td>0.868335</td> <td>-0.842782</td> <td>-0.125615</td> <td>0.440164</td> <td>0.315187</td> <td>0</td> <td>0</td> <td>0</td> <td>0</td> <td>0</td> <td>...</td> <td>1</td> <td>0</td> <td>0</td> <td>1</td> <td>0</td> <td>1</td> <td>0</td> <td>1</td> <td>0</td> <td>0</td> </tr> <tr> <th>2</th> <td>1.430978</td> <td>-1.663641</td> <td>-0.449386</td> <td>-0.439766</td> <td>0.294203</td> <td>0</td> <td>0</td> <td>0</td> <td>0</td> <td>0</td> <td>...</td> <td>0</td> <td>0</td> <td>0</td> <td>1</td> <td>0</td> <td>1</td> <td>0</td> <td>1</td> <td>0</td> <td>0</td> </tr> <tr> <th>3</th> <td>0.868335</td> <td>-0.728177</td> <td>-0.449386</td> <td>-0.363250</td> <td>-0.020546</td> <td>0</td> <td>0</td> <td>0</td> <td>0</td> <td>0</td> <td>...</td> <td>0</td> <td>1</td> <td>0</td> <td>0</td> <td>0</td> <td>1</td> <td>0</td> <td>1</td> <td>0</td> <td>0</td> </tr> <tr> <th>4</th> <td>1.243431</td> <td>-1.014690</td> <td>1.331355</td> <td>-0.018930</td> <td>0.231254</td> <td>0</td> <td>0</td> <td>0</td> <td>0</td> <td>0</td> <td>...</td> <td>1</td> <td>0</td> <td>0</td> <td>1</td> <td>0</td> <td>1</td> <td>0</td> <td>1</td> <td>0</td> <td>0</td> </tr> </tbody> </table> <p>5 rows × 126 columns</p> </div> ```python from sklearn.cluster import KMeans, AgglomerativeClustering, DBSCAN, AffinityPropagation inertia = [] for it in np.arange(1,20,1): method = KMeans(n_clusters=it) method.fit(new_df) inertia.append(method.inertia_) print(it) ``` 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 ```python for i in range(len(inertia)): print(i+1,inertia[i]) ``` 1 303666.09226419945 2 238066.35809271294 3 203215.59994571476 4 188096.71848079565 5 176308.26383170072 6 166868.51967859885 7 160779.23246553304 8 155563.4221062198 9 150434.37152236237 10 146538.95858094987 11 143247.76194929198 12 140234.2185084517 13 137206.36955768696 14 134389.44205518265 15 132121.6934500015 16 129743.02831074157 17 127996.209894227 18 126181.09337907878 19 124530.70736049648 Оптимальное количество кластеров 15 ```python def cls_info(df, k): print('------ Кластер ', k, ' -------') claster = df[method.labels_ == k] print(claster['Год'].mean()) print(claster['Пробег'].mean()) print(claster['Объем'].mean()) print(claster['Мощность'].mean()) print(claster['Цена'].mean()) print(claster['Привод'].value_counts().head(1)) print(claster['Марка'].value_counts().head(2)) print(claster['Кузов'].value_counts().head(2)) print(claster['КПП'].value_counts().head(2)) print(claster['Хозяев в ПТС'].value_counts().head(2)) print('---------------------------') ``` ```python print('------ Реальность -------') print(df['Год'].mean()) print(df['Пробег'].mean()) print(df['Объем'].mean()) print(df['Мощность'].mean()) print(df['Цена'].mean()) print(df['Привод'].value_counts().head(1)) print(df['Марка'].value_counts().head(2)) print(df['Кузов'].value_counts().head(2)) print(df['КПП'].value_counts().head(2)) print(df['Хозяев в ПТС'].value_counts().head(2)) print('---------------------------') ``` ------ Реальность ------- 2007.3700562551758 120830.33855906794 1877.595019846369 128.98960564265113 488987.6818298638 передний 23933 Name: Привод, dtype: int64 ВАЗ 5497 Toyota 2700 Name: Марка, dtype: int64 седан 14241 хэтчбек 8462 Name: Кузов, dtype: int64 механика 19308 автомат 13935 Name: КПП, dtype: int64 3 и более 12613 2 владельца 12070 Name: Хозяев в ПТС, dtype: int64 --------------------------- ```python for it in range(16): cls_info(df, it) ``` ------ Кластер 0 ------- 2012.1751925192518 63387.76347634764 1542.7117711771177 104.2871287128713 432276.9573707371 передний 3525 Name: Привод, dtype: int64 ВАЗ 684 Renault 345 Name: Марка, dtype: int64 седан 1675 хэтчбек 1113 Name: Кузов, dtype: int64 механика 3556 роботизированная 60 Name: КПП, dtype: int64 1 владелец 3519 3 и более 75 Name: Хозяев в ПТС, dtype: int64 --------------------------- ------ Кластер 1 ------- 1998.067221067221 72930.8024948025 1722.3146223146223 84.61607761607762 86363.76507276508 задний 554 Name: Привод, dtype: int64 ВАЗ 889 УАЗ 143 Name: Марка, dtype: int64 седан 730 внедорожник 323 Name: Кузов, dtype: int64 механика 1383 автомат 60 Name: КПП, dtype: int64 3 и более 757 2 владельца 468 Name: Хозяев в ПТС, dtype: int64 --------------------------- ------ Кластер 2 ------- 2012.8614298323037 60326.43865842895 2132.8773168578996 171.48455428067078 1227472.0706090026 полный 1404 Name: Привод, dtype: int64 Toyota 344 Audi 203 Name: Марка, dtype: int64 кроссовер 1228 седан 552 Name: Кузов, dtype: int64 автомат 1815 вариатор 229 Name: КПП, dtype: int64 1 владелец 1587 2 владельца 590 Name: Хозяев в ПТС, dtype: int64 --------------------------- ------ Кластер 3 ------- 1999.6247086247085 237500.89393939395 2937.5291375291376 191.7937062937063 407217.94755244756 полный 506 Name: Привод, dtype: int64 Mercedes-Benz 142 BMW 111 Name: Марка, dtype: int64 седан 326 внедорожник 279 Name: Кузов, dtype: int64 автомат 717 механика 133 Name: КПП, dtype: int64 3 и более 563 2 владельца 235 Name: Хозяев в ПТС, dtype: int64 --------------------------- ------ Кластер 4 ------- 2008.9737206085754 98074.15952051636 1448.6399262332873 95.61180267404333 298626.3042876902 передний 2132 Name: Привод, dtype: int64 ВАЗ 520 Ford 235 Name: Марка, dtype: int64 хэтчбек 2138 внедорожник 7 Name: Кузов, dtype: int64 механика 1736 автомат 294 Name: КПП, dtype: int64 2 владельца 2168 1 владелец 1 Name: Хозяев в ПТС, dtype: int64 --------------------------- ------ Кластер 5 ------- 2008.9607907742998 108518.84349258649 1605.7001647446457 106.36507413509061 326849.65667215816 передний 2910 Name: Привод, dtype: int64 ВАЗ 495 Chevrolet 268 Name: Марка, dtype: int64 седан 2368 универсал 238 Name: Кузов, dtype: int64 механика 2757 автомат 194 Name: КПП, dtype: int64 2 владельца 3035 Name: Хозяев в ПТС, dtype: int64 --------------------------- ------ Кластер 6 ------- 2002.2536157024792 193473.40857438016 1476.9111570247933 82.2448347107438 98850.0444214876 передний 1843 Name: Привод, dtype: int64 ВАЗ 1406 Daewoo 62 Name: Марка, dtype: int64 седан 918 хэтчбек 783 Name: Кузов, dtype: int64 механика 1914 автомат 15 Name: КПП, dtype: int64 3 и более 1259 2 владельца 491 Name: Хозяев в ПТС, dtype: int64 --------------------------- ------ Кластер 7 ------- 2011.2364380757422 91274.27328556807 3325.793244626407 256.89252814738995 1657216.7727737974 полный 909 Name: Привод, dtype: int64 Toyota 183 BMW 150 Name: Марка, dtype: int64 кроссовер 440 внедорожник 345 Name: Кузов, dtype: int64 автомат 931 вариатор 24 Name: КПП, dtype: int64 2 владельца 431 1 владелец 430 Name: Хозяев в ПТС, dtype: int64 --------------------------- ------ Кластер 8 ------- 2009.939024390244 72631.38455284553 2067.967479674797 105.95365853658537 418875.9130081301 полный 1204 Name: Привод, dtype: int64 УАЗ 344 Chevrolet 289 Name: Марка, dtype: int64 внедорожник 1038 кроссовер 95 Name: Кузов, dtype: int64 механика 1215 автомат 12 Name: КПП, dtype: int64 1 владелец 596 2 владельца 433 Name: Хозяев в ПТС, dtype: int64 --------------------------- ------ Кластер 9 ------- 2007.0385576579793 136103.9032488397 1629.9892895394503 106.0124955373081 262912.8768297037 передний 2686 Name: Привод, dtype: int64 ВАЗ 370 Ford 294 Name: Марка, dtype: int64 седан 2489 универсал 116 Name: Кузов, dtype: int64 механика 2465 автомат 249 Name: КПП, dtype: int64 3 и более 2475 1 владелец 326 Name: Хозяев в ПТС, dtype: int64 --------------------------- ------ Кластер 10 ------- 2006.8225130890053 145801.34764397907 2130.418848167539 165.565445026178 513192.24659685866 передний 1478 Name: Привод, dtype: int64 Toyota 243 BMW 167 Name: Марка, dtype: int64 седан 1502 хэтчбек 129 Name: Кузов, dtype: int64 автомат 1589 механика 179 Name: КПП, dtype: int64 3 и более 1009 2 владельца 704 Name: Хозяев в ПТС, dtype: int64 --------------------------- ------ Кластер 11 ------- 2007.657043305127 138630.5719263315 2279.5420607267297 162.04828272772522 671646.3285216526 полный 1892 Name: Привод, dtype: int64 Nissan 256 Hyundai 249 Name: Марка, dtype: int64 кроссовер 1178 внедорожник 450 Name: Кузов, dtype: int64 автомат 1238 механика 627 Name: КПП, dtype: int64 2 владельца 967 3 и более 709 Name: Хозяев в ПТС, dtype: int64 --------------------------- ------ Кластер 12 ------- 1998.7640871525168 258800.57325319308 1972.1262208865514 123.88354620586026 209069.97595792636 передний 854 Name: Привод, dtype: int64 Volkswagen 117 Mercedes-Benz 107 Name: Марка, dtype: int64 седан 813 хэтчбек 132 Name: Кузов, dtype: int64 механика 1069 автомат 245 Name: КПП, dtype: int64 3 и более 949 2 владельца 282 Name: Хозяев в ПТС, dtype: int64 --------------------------- ------ Кластер 13 ------- 2006.2400306748466 153372.99386503067 3458.128834355828 258.6296012269939 755522.2369631901 полный 1070 Name: Привод, dtype: int64 BMW 201 Mercedes-Benz 143 Name: Марка, dtype: int64 кроссовер 613 седан 320 Name: Кузов, dtype: int64 автомат 1210 вариатор 68 Name: КПП, dtype: int64 3 и более 628 2 владельца 495 Name: Хозяев в ПТС, dtype: int64 --------------------------- ------ Кластер 14 ------- 1997.5278246205733 249334.54890387857 1879.4266441821248 127.0725126475548 195677.2639123103 передний 771 Name: Привод, dtype: int64 Toyota 464 Nissan 236 Name: Марка, dtype: int64 седан 585 минивэн 231 Name: Кузов, dtype: int64 автомат 988 механика 120 Name: КПП, dtype: int64 3 и более 829 2 владельца 235 Name: Хозяев в ПТС, dtype: int64 --------------------------- ------ Кластер 15 ------- 2007.2490660024907 118465.71731008717 1459.194686591947 92.75425487754255 233711.92818596927 передний 2355 Name: Привод, dtype: int64 ВАЗ 808 Ford 284 Name: Марка, dtype: int64 хэтчбек 2276 универсал 66 Name: Кузов, dtype: int64 механика 1886 автомат 363 Name: КПП, dtype: int64 3 и более 2108 1 владелец 301 Name: Хозяев в ПТС, dtype: int64 --------------------------- Для задачи классификации исходных данных я посчитал оптимальным 15 кластеров. Каждый кластер описывает новые данные об автомобилях, однако начиная с 15 отличия в кластерах менее очевидны (если 4 и 9 отличаются довольно сильно, то сходства между 9 и 15 гораздо больше) ## Работу выполнил --- Студент группы **РИМ-181226** Кабанов Евгений Алексеевич

b03c91f3ad2e1a72afd558af796601be1e215645

ipynb

Jupyter Notebook

DA-LR6-Kabanov.ipynb

ghspbravo/Data-Analysis

25a0102378bf73bfd775ab15a2ad64fcd658ad73

DA-LR6-Kabanov.ipynb

ghspbravo/Data-Analysis

25a0102378bf73bfd775ab15a2ad64fcd658ad73

DA-LR6-Kabanov.ipynb

ghspbravo/Data-Analysis

25a0102378bf73bfd775ab15a2ad64fcd658ad73

Qwen/Qwen-72B

1. YES 2. YES

__label__kor_Hang

# Physics 420/580 Midterm Exam ## October 19, 2017 1pm-2pm Do the following problems. Use the Jupyter notebook, inserting your code and any textual answers/explanations in cells between the questions. (Feel free to add additional cells!) Marks will be given based on how clearly you demonstrate your understanding. There are no restrictions on downloading from the internet, eclass, or the use of books, notes, or any other widely available computing resources. However, **you are not allowed** to communicate with each other or collaborate in any way and uploading to the internet or sending or receiving direct communications is not appropriate. When you are finished, upload the jupyter notebook to eclass. Eclass times out after 2:05 so make sure that you upload things before then. Also be careful to save the notebook periodically and that you upload your final exam file. ```python import numpy as np import matplotlib.pyplot as plt import matplotlib as mpl import scipy from scipy.integrate import odeint from scipy.integrate import quad from scipy.optimize import minimize from scipy.optimize import fsolve from scipy.optimize import least_squares from scipy.interpolate import interp1d from scipy.interpolate import CubicSpline ``` ```python mpl.rc('figure',dpi=250) mpl.rc('text',usetex=True) ``` ```python def add_labels(xlabel, ylabel, title): plt.xlabel(xlabel) plt.ylabel(ylabel) plt.title(title) plt.legend() ``` ## Graphics Plot the two curves: $$\begin{align} y&=4x^3-3x-2\\ x&=\sin(\frac{y^4}{4}-2y^2+2) \end{align} $$ How many intersections are there? Read the x,y value corresponding to the intersections from the plots. ```python fsolve(lambda x: x**3 - 1, 9) ``` array([1.]) ```python """ Plan: -Initialize an array of xdata, ydata. -Create two functions and then plot the two functions. -Find the intersections by inspection, or if time allows, using fsolve/brute force. - Read off the x, y values. """ ``` ```python y1 = lambda x: 4*x**3 - 3*x - 2 xdata = np.linspace(-2, 2, 1000) plt.plot(xdata, y1(xdata)) x1 = lambda y: np.sin(y**4/4 - 2*y**2 + 2) ydata = np.linspace(-10, 10,1000) plt.plot(x1(ydata), ydata) curve1_x = xdata curve1_y = y1(xdata) curve2_x = x1(ydata) curve2_y = ydata tol = 1e-4 plt.ylim(-5, 2.5) plt.xlim(-1.5, 1.5) ``` ```python from ipywidgets import interact, interact_manual def plot(a): x = np.linspace(0, 5, 50) plt.plot(x, np.exp(a*x)) plt.ylim(0, 5) interact_manual(plot, a=5) ``` # Reconstruction A instantaneous flash of light occurs in a large tank of water at time $t_0$ and at position $\vec{x_0}$ The group velocity of light in water is about $2.2 \times 10^8$ m/s. Four sensors detect the light flash, and report a measurement of the time at which light strikes the sensor. The locations of the sensors and the time which each sensor was hit is recorded in the table below: |Sensor #| x| y| z| Time| |--------|------------|------------|------------|------------| | |[m]| [m]| [m]| [s]| |1 |0 |0| 10 | 6.3859E-08| |2 |8.66025404| 0| -5| 1.1032E-07| |3 |-4.33012702| 7.5| -5| 7.9394E-08| |4 |-4.33012702| -7.5| -5| 1.0759E-07| Calculate the initial time $t_0$ and the location of the flash. Here is a sketch of the general geometry. Note that the gray region is not different from the rest of the water- it is just to show the tetrahedral arrangement of the light sensors. The flash, shown as the yellow star is in an arbitrary location which you want to find. ```python """ Plan: - Pick a random point called position. Calculate the distance to the each sensors, call it d - The optimal point minimizes d - v*t for each sensor. - Calculate the residuals - Run least_squares on the residuals - Find the optimal point and print it. """ ``` ```python "cost function solution" sen1 = np.array([0, 0, 10, 6.3859E-08]) sen2 = np.array([8.66025404, 0, -5, 1.1032E-07]) sen3 = np.array([-4.33012702, 7.5, -5, 7.9394E-08]) sen4 = np.array([-4.33012702, -7.5, -5, 1.0759E-07]) v = 2.2*10**8 def cost(pos): error = 0 for sen in [sen1, sen2, sen3, sen4]: error += (np.linalg.norm(pos - sen[0:3]) - v*sen[3])**2 return error minimize(cost, np.random.randn(3)) ``` fun: 2.889558609330956 hess_inv: array([[ 2.7050527 , 1.63590179, 0.27960445], [ 1.63590179, 1.60674196, -0.18068716], [ 0.27960445, -0.18068716, 0.51680401]]) jac: array([ 1.04308128e-06, 8.94069672e-08, -1.07288361e-06]) message: 'Optimization terminated successfully.' nfev: 85 nit: 12 njev: 17 status: 0 success: True x: array([-7.8833527 , 10.57964442, 10.80804805]) ```python from scipy.optimize import least_squares "residuals solution" sen1 = np.array([0, 0, 10, 6.3859E-08]) sen2 = np.array([8.66025404, 0, -5, 1.1032E-07]) sen3 = np.array([-4.33012702, 7.5, -5, 7.9394E-08]) sen4 = np.array([-4.33012702, -7.5, -5, 1.0759E-07]) def cost(pos): error = np.zeros(4) for i, sen in enumerate([sen1, sen2, sen3, sen4]): error[i] = (np.linalg.norm(pos - sen[0:3]) - v*sen[3]) return error least_squares(cost, np.random.randn(3)) ``` active_mask: array([0., 0., 0.]) cost: 1.4447793059407599 fun: array([-0.83046438, 0.93904664, -0.97413042, 0.6075762 ]) grad: array([-1.42800140e-05, -1.02340696e-05, -8.34587431e-07]) jac: array([[-0.59639614, 0.80035917, 0.06112968], [-0.65625106, 0.41966651, 0.62706827], [-0.21545151, 0.1867243 , 0.95849604], [-0.14636443, 0.74470816, 0.651143 ]]) message: '`ftol` termination condition is satisfied.' nfev: 15 njev: 15 optimality: 1.4280013981682327e-05 status: 2 success: True x: array([-7.88347184, 10.57956012, 10.80804357]) ```python ''' Alternative solution ''' class Sensor(): def __init__(self, position, time): self.position = position self.time = time self.velocity = 2.2*10**8 def draw_radius(self): r = self.velocity*self.time possible_vals = [] for phi in np.linspace(0, 2*np.pi): for theta in np.linspace(0, np.pi): x = np.array([np.sin(theta)*np.cos(phi), np.sin(theta)*np.sin(phi), np.cos(theta)]) possible_vals.append(self.position + r*x) return np.array(possible_vals) ``` ```python sen1 = Sensor(np.array([0, 0, 10]), 6.3859E-08) sen2 = Sensor(np.array([8.66025404, 0, -5]), 1.1032E-07) sen3 = Sensor(np.array([4.33012702, 7.5, -5]), 7.9394E-08) sen4 = Sensor(np.array([-4.33012702, -7.5, -5]), 1.0759E-07) circ = [] for i in [sen1, sen2, sen3, sen4]: circ.append(i.draw_radius()) ``` ```python tol = 18 mask = np.abs(circ[0]-circ[1]-circ[2]-circ[3]) < tol for i, j in enumerate(mask): if j.all() == True: print(i, j) print(circ[0][i]) ``` 1010 [ True True True] [-7.04232267 4.58404406 21.25904395] 1460 [ True True True] [-7.04232267 -4.58404406 21.25904395] ## Trajectories An alpha-particle is a helium nucleus, with mass 6.644×10−27 kg or 4.002 u, and charge equal to twice the charge of an electron (but positive). Calculate the trajectory of a 5MeV=(5*1.609 e-13 J) alpha particle as it moves by a gold nucleus (mass 196.966 u), with charge 79e, as a function of the impact parameter b, below. Assume both the alpha and the gold are point particles, and ignore special relativity. Plot the scattering angle $\theta$ and energy loss of the alpha as a function of $b$, for values of b between 1e-16 and 1e-9m. The force between two charge particles is given by the Coulomb potential: $$\vec{F}=\frac{1}{4\pi\epsilon_0}\frac{q_1q_2 (\vec{r_2}-\vec{r_1})}{|\vec{r_2}-\vec{r_1}|^3}$$ with $\epsilon_0=8.85\times10^{-12}\frac{\rm{C}^2}{\rm{N\cdot m^2}}$ ```python """ Plan: - Write NEwtons law as system of coupled ODE and integrate. - F is couloumbs law, so the acceleration is F/m - """ ``` ```python eps = 8.85*10**-12 elementary_charge = 1.60*10**-19 q1 = 2*elementary_charge q2 = 79*elementary_charge u = 1.66*10**-27 m1 = 4*u m2 = 196.966*u def CouloubsLaw(r1, r2, q1, q2): distance = np.linalg.norm(r2-r1) direction = (r2-r1)/distance F = (1/(4*np.pi*eps))*(q2/distance**2)*direction return F ``` ```python kinetic = 5*1.609e-13 velocity = np.sqrt(2*kinetic/m1) velocity ``` 15566607.758546297 ```python import numpy as np from scipy.integrate import odeint def main(y, t, m1 = m1, m2 = m2): ''' Main function to be integrated with odeint. Input: y (array of elements 12), t (scalar) Output: dydt (array of elements 12) ''' particle1_x = y[0:2] particle1_dx = y[2:4] particle2_x = np.array([0, velocity]) F = CouloubsLaw(particle1_x, particle2_x, q1, q2) dxdt = np.zeros(4) dxdt[0:2] = particle1_dx dxdt[2:4] = F/m1 #print(y[0:2]) return dxdt b = 1e-16 y0 = np.array([0, b, velocity, 0]) t = np.linspace(0, 3, num=500) y = odeint(main, y0, t) ``` ```python y plt.plot(y[:,0], y[:,1]) ``` ```python energy = 1/2*m1*y[:, 2]**2 + 1/2*m1*y[:, 3]**2 plt.plot(t, energy) ``` ```python for b in np.logspace(-16, -9, num=10): y0 = np.array([0, b, velocity, 0]) t = np.linspace(0, 3, num=500) y = odeint(main, y0, t) plt.plot(y[:,0], y[:,1], label=b) add_labels('x', 'y', 'Scattering for various b') ``` ```python for b in np.logspace(-16, -9, num=10): y0 = np.array([0, b, velocity, 0]) t = np.linspace(0, 3, num=500) y = odeint(main, y0, t) energy = 1/2*m1*y[:, 2]**2 + 1/2*m1*y[:, 3]**2 plt.plot(t, energy, label = b) add_labels('x', 'y', 'Scattering for various b') ``` ```python ``` ```python def f(x): return np.array([x**2, np.sin(x)]) xdata = np.linspace(0, 10, num=10) ydata = f(xdata) g = scipy.interpolate.interp1d(xdata, ydata, kind='cubic') ``` ```python x = np.linspace(0, 10) plt.plot(x, g(x)[0]) plt.plot(x, g(x)[1]) ``` ```python ``` # Don't forget to upload your work to eclass! ```python ```

56722069cd1d6e945bac1f368991e53a8823f819

ipynb

Jupyter Notebook

Assignments/Finished/.ipynb_checkpoints/Midterm 2018 (1)-checkpoint.ipynb

hanzhihua72/phys-420

748d29b55d57680212b15bb70879a24b79cb16a9

Assignments/Finished/.ipynb_checkpoints/Midterm 2018 (1)-checkpoint.ipynb

hanzhihua72/phys-420

748d29b55d57680212b15bb70879a24b79cb16a9

Assignments/Finished/.ipynb_checkpoints/Midterm 2018 (1)-checkpoint.ipynb

hanzhihua72/phys-420

748d29b55d57680212b15bb70879a24b79cb16a9

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# Sweep Signals and their Spectra *This Jupyter notebook is part of a [collection of notebooks](../index.ipynb) in the masters module Selected Topics in Audio Signal Processing, Communications Engineering, Universität Rostock. Please direct questions and suggestions to [Sascha.Spors@uni-rostock.de](mailto:Sascha.Spors@uni-rostock.de).* ## The Linear Sweep A [linear sweep](https://en.wikipedia.org/wiki/Chirp#Linear) is an exponential signal with linear increase in its instantaneous frequency. It is defined as \begin{equation} x(t) = e^{j \omega(t) t} \end{equation} with \begin{equation} \omega(t) = \omega_\text{l} - \frac{\omega_\text{u} - \omega_\text{l}}{2 T} t \end{equation} where $\omega_\text{l}$ and $\omega_\text{u}$ denote its lower and upper frequency limit, and $T$ its total duration. The linear sweep is generated in the following by sampling the continuous time. ```python import numpy as np import matplotlib.pyplot as plt import soundfile as sf fs = 48000 # sampling frequency om_l = 2*np.pi*200 # lower angluar frequency of sweep om_u = 2*np.pi*18000 # upper angular frequency of sweep T = 5 # duration of sweep k = (om_u - om_l)/(2*T) t = np.linspace(0, T, fs*T) x = np.exp(1j*(om_l + k*t)*t) ``` A short section of the linear sweep signal is plotted for illustration ```python idx = range(5000) # portion of the signal to show plt.figure(figsize=(10, 5)) plt.plot(t[idx], np.real(x[idx])) plt.xlabel(r'$t$ in s') plt.ylabel(r'$x(t)$') plt.grid() ``` ### Auralization Lets listen to the linear sweep. Please be careful with the volume of your speakers or headphones. Start with a very low volume and increase if necessary. This holds especially for the low and high frequencies which can damage your speakers at high levels. ```python sf.write('linear_sweep.wav', np.real(x), fs) ``` <audio src="linear_sweep.wav" controls>Your browser does not support the audio element.</audio> [linear_sweep.wav](linear_sweep.wav) ### Spectrogram The spectrogram of the linear sweep is computed and plotted ```python plt.figure(figsize=(8, 6)) plt.specgram(x, Fs=fs, sides='onesided') plt.xlabel('$t$ in s') plt.ylabel('$f$ in Hz'); ``` ### Spectrum of a Linear Sweep (Analytic Solution) The analytic solution of the Fourier transform of the linear sweep signal is used to compute and plot its overall magnitude spectrum $|X(j \omega)|$ ```python from scipy.special import fresnel f = np.linspace(10, 20000, 1000) om = 2*np.pi*f om_s = 2*np.pi*200 # lower angluar frequency of sweep om_e = 2*np.pi*18000 # upper angular frequency of sweep T = 5 # duration of sweep k = (om_e - om_s)/(2*T) a = (om-om_s)/np.sqrt(2*np.pi*k) b = (2*k*T-(om-om_s))/np.sqrt(2*np.pi*k) Sa, Ca = fresnel(a) Sb, Cb = fresnel(b) X = np.sqrt(np.pi/(2*k)) * np.sqrt((Ca + Cb)**2 + (Sa + Sb)**2) plt.figure(figsize=(8, 5)) plt.plot(f, X) plt.xlabel('$f$ in Hz') plt.ylabel(r'$|X(f)|$') plt.grid() ``` ### Crest Factor The [Crest factor](https://en.wikipedia.org/wiki/Crest_factor) of the sweep is computed ```python xrms = np.sqrt(1/T * np.sum(np.real(x)**2) * 1/fs) C = np.max(np.real(x)) / xrms print('Crest factor C = {:<1.5f}'.format(C)) ``` Crest factor C = 1.41421 ## Exponential Sweep An [exponential sweep](https://en.wikipedia.org/wiki/Chirp#Exponential) is an exponential signal with an exponential increase in its instantaneous frequency. It is defined as \begin{equation} x(t) = e^{j \frac{\omega_l}{\ln(k)} (k^t - 1)} \end{equation} with \begin{equation} k = \left( \frac{\omega_\text{u}}{\omega_\text{l}} \right)^\frac{1}{T} \end{equation} where $\omega_\text{l}$ and $\omega_\text{u}$ denote its lower and upper frequency limit, and $T$ its total duration. The exponential sweep is generated in the following by sampling the continuous time. ```python om_l = 2*np.pi*100 # lower angluar frequency of sweep om_u = 2*np.pi*18000 # upper angular frequency of sweep T = 5 # duration of sweep k = (om_e / om_s)**(1/T) t = np.linspace(0, T, fs*T) x = np.exp(1j*om_s * (k**(t) - 1) / np.log(k)) ``` A short section of the linear sweep signal is plotted for illustration ```python idx = range(5000) # portion of the signal to show plt.figure(figsize=(10, 5)) plt.plot(t[idx], np.real(x[idx])) plt.xlabel(r'$t$ in s') plt.ylabel(r'$x(t)$') plt.grid() ``` ### Spectrogram The spectrogram of the logarithmic sweep is computed and plotted ```python plt.figure(figsize=(8, 6)) plt.specgram(x, Fs=fs, sides='onesided') plt.xlabel('$t$ in s') plt.ylabel('$f$ in Hz'); ``` ### Spectrum The discrete Fourier transform of the logarithmic sweep is computed and its magnitude spectrum is plotted. ```python X = np.fft.rfft(np.real(x)) f = np.linspace(0, fs/2, len(X)) plt.figure(figsize=(8, 6)) plt.plot(f, 20*np.log10(np.abs(X))) plt.xlabel(r'$f$ in Hz') plt.ylabel(r'$|X(f)|$ in dB') plt.axis([20, 20000, 40, 70]) plt.grid() ``` ### Auralization Lets listen to the exponential sweep. Please be careful with the volume of your speakers or headphones. Start with a very low volume and increase if necessary. This holds especially for the low and high frequencies which can damage your speakers at high levels. ```python sf.write('exponential_sweep.wav', np.real(x), fs) ``` <audio src="exponential_sweep.wav" controls>Your browser does not support the audio element.</audio> [exponential_sweep.wav](exponential_sweep.wav) **Copyright** This notebook is provided as [Open Educational Resources](https://en.wikipedia.org/wiki/Open_educational_resources). Feel free to use the notebook for your own purposes. The text/images/data are licensed under [Creative Commons Attribution 4.0](https://creativecommons.org/licenses/by/4.0/), the code of the IPython examples under the [MIT license](https://opensource.org/licenses/MIT). Please attribute the work as follows: *Sascha Spors, Selected Topics in Audio Signal Processing - Supplementary Material*.

fde5143298e1d254127b57b95b908e62597dbbb9

ipynb

Jupyter Notebook

electroacoustics/sweep_spectrum.ipynb

spatialaudio/-selected-topics-in-audio-signal-processing-lecture-

d56c54401ad15f72042baeba88a22809c6c9f85c

2017-10-19T14:54:02.000Z

2021-12-30T12:39:02.000Z

electroacoustics/sweep_spectrum.ipynb

spatialaudio/-selected-topics-in-audio-signal-processing-lecture-

d56c54401ad15f72042baeba88a22809c6c9f85c

electroacoustics/sweep_spectrum.ipynb

spatialaudio/-selected-topics-in-audio-signal-processing-lecture-

d56c54401ad15f72042baeba88a22809c6c9f85c

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

<b>Construir o gráfico e encontrar o foco e uma equação da diretriz.</b> <b>4. $x^2 + y = 0$</b> <b>Arrumando a equação</b><br><br> $x^2 = -y$<br><br> $2p = -1$,<b>logo</b><br><br> $p = -\frac{1}{2}$<br><br><br> <b>Calculando o foco</b><br><br> $F = -\frac{p}{2}$<br><br> $F = \frac{-\frac{1}{2}}{2}$<br><br> $F = -\frac{1}{2}\cdot \frac{1}{2}$<br><br> $F = -\frac{1}{4}$<br><br> $F(0,-\frac{1}{4})$<br><br><br> <b>Calculando a diretriz</b><br><br> $d = -\frac{p}{2}$<br><br> $d = -(-\frac{1}{4})$<br><br> $d : y = \frac{1}{4}$<br><br> $V(0,0)$<br><br> $F(0,-\frac{1}{4})$ <b>Gráfico da parábola</b> ```python from sympy import * from sympy.plotting import plot_implicit x, y = symbols("x y") plot_implicit(Eq((x-0)**2, -1*(y+0)), (x,-3,3), (y,-3,3), title=u'Gráfico da parábola', xlabel='x', ylabel='y'); ```

b25aa0622b84fb0a6385a733ac4343d9173e4313

ipynb

Jupyter Notebook

Problemas Propostos. Pag. 172 - 175/04.ipynb

mateuschaves/GEOMETRIA-ANALITICA

bc47ece7ebab154e2894226c6d939b7e7f332878

2020-02-03T16:40:45.000Z

2020-02-03T16:40:45.000Z

Problemas Propostos. Pag. 172 - 175/04.ipynb

mateuschaves/GEOMETRIA-ANALITICA

bc47ece7ebab154e2894226c6d939b7e7f332878

Problemas Propostos. Pag. 172 - 175/04.ipynb

mateuschaves/GEOMETRIA-ANALITICA

bc47ece7ebab154e2894226c6d939b7e7f332878

Qwen/Qwen-72B

1. YES 2. YES

__label__por_Latn

# GPS Based on D. Kalman's method, I expand the four constraint equations as following: $ \begin{align} 2.4x + 4.6y + 0.4z - 2(0.047^2)9.9999 t &= 1.2^2 + 2.3^2 + 0.2^2 + x^2 + y^2 + z^2 - 0.047^2 t^2 \\ -1x + 3y + 3.6z - 2(0.047^2)13.0681 t &= 0.5^2 + 1.5^2 + 1.8^2 + x^2 + y^2 + z^2 - 0.047^2 t^2 \\ -3.4x + 1.6y + 2.6z - 2(0.047^2)2.0251 t &= 1.7^2 + 0.8^2 + 1.3^2 + x^2 + y^2 + z^2 - 0.047^2 t^2 \\ 3.4x + 2.8y - 1z - 2(0.047^2)10.5317 t &= 1.7^2 + 1.4^2 + 0.5^2 + x^2 + y^2 + z^2 - 0.047^2 t^2 \end{align}, $ And subtract the first equation from the rest. $ \begin{align} -3.4x - 1.6y + 3.2z - 2(0.047^2)3.0682 t &= -1.0299 \\ -5.8x - 3y + 2.2z + 2(0.047^2)7.9750 t &= -1.5499 \\ 1x - 1.8y - 1.4z - 2(0.047^2)0.5318 t &= -1.6699 \end{align}, $ Converting it to matrix format as following: $ \begin{equation} \begin{bmatrix} -3.4 & 1.6 & 3.2 & -0.01355 \\ -5.8 & -3 & 2.2 & 0.0352 \\ 1 & -1.8 & -1.4 & -0.00235 \end{bmatrix} \begin{bmatrix} x \\ y \\ z \\ t \end{bmatrix} = \begin{bmatrix} -1.0299 \\ -1.5499 \\ -1.6699 \end{bmatrix} \end{equation}. $ # Newton's Method For having $f(x)=0$, based on state variables $x=(x, y, z, t)$ we can convert the nonlinear distance equation as following: $ \begin{equation} f(x) = \frac{1}{2} \begin{bmatrix} (x-1.2)^2+(y-2.3)^2+(z-0.2)^2-(0.047*(t-09.9999))^2 \\ (x+0.5)^2+(y-1.5)^2+(z-1.8)^2-(0.047*(t-13.0681))^2 \\ (x+1.7)^2+(y-0.8)^2+(z-1.3)^2-(0.047*(t-02.0251))^2 \\ (x-1.7)^2+(y-1.4)^2+(z+0.5)^2-(0.047*(t-10.5317))^2 \end{bmatrix} = 0. \end{equation} $ ```julia f(x) = [(x[1]-1.2)^2+(x[2]-2.3)^2+(x[3]-0.2)^2-0.047*(x[4]-09.9999)^2, (x[1]+0.5)^2+(x[2]-1.5)^2+(x[3]-1.8)^2-0.047*(x[4]-13.0681)^2, (x[1]+1.7)^2+(x[2]-0.8)^2+(x[3]-1.3)^2-0.047*(x[4]-02.0251)^2, (x[1]-1.7)^2+(x[2]-1.4)^2+(x[3]+0.5)^2-0.047*(x[4]-10.5317)^2]./2 f([1.2 2.3 0.2 9.9999]) ``` 4-element Array{Float64,1}: 0.0 2.82377449586 4.4404602765600005 0.7683539358599999 ## Jacobian $ \begin{equation} Df(x_0) = \begin{bmatrix} (x-1.2) & (y-2.3) & (z-0.2) & -0.047(t-09.9999)\\ (x+0.5) & (y-1.5) & (z-1.8) & -0.047(t-13.0681)\\ (x+1.7) & (y-0.8) & (z-1.3) & -0.047(t-02.0251)\\ (x-1.7) & (y-1.4) & (z+0.5) & -0.047(t-10.5317) \end{bmatrix}. \end{equation} $ ```julia D(x) = [x[1]-1.2 x[2]-2.3 x[3]-0.2 -0.047*(x[4]-09.9999); x[1]+0.5 x[2]-1.5 x[3]-1.8 -0.047*(x[4]-13.0681); x[1]+1.7 x[2]-0.8 x[3]-1.3 -0.047*(x[4]-02.0251); x[1]-1.7 x[2]-1.4 x[3]+0.5 -0.047*(x[4]-10.5317)]/2 D([1.7 1.4 -0.5 10.5317]) ``` 4×4 Array{Float64,2}: 0.25 -0.45 -0.35 -0.0124973 1.1 -0.05 -1.15 0.0596054 1.7 0.3 -0.9 -0.199905 0.0 0.0 0.0 -0.0 # Solutions ```julia using LinearAlgebra function gps(x) t = 1 # tolerance of answers for i=1:1e5 d = f(x)\D(x) x -= d if norm(d)<1e-15 return x end end return x end s = gps([0 0 0 0]) ``` 1×4 Array{Float64,2}: -0.152014 1.16284 0.239069 3.61735 ```julia b = [-1.0299;-1.5499;-1.6699] A = [-3.4 1.6 3.2 -0.01355 ; -5.8 -3 2.2 0.0352 ; 1 -1.8 -1.4 -0.00235] s = b\A ``` 1×4 Transpose{Float64,Array{Float64,1}}: 1.73099 0.961006 -0.698654 -0.00586697 ## Adjourn ```julia using Dates println("mahdiar") Dates.format(now(), "Y/U/d HH:MM") ``` mahdiar "2021/March/19 11:13"

3a8bc4e4aa901efc53c60b136a6fc6843ffb08c1

ipynb

Jupyter Notebook

HW08/3.ipynb

mahdiarsadeghi/NumericalAnalysis

95a0914c06963b0510971388f006a6b2fc0c4ef9

HW08/3.ipynb

mahdiarsadeghi/NumericalAnalysis

95a0914c06963b0510971388f006a6b2fc0c4ef9

HW08/3.ipynb

mahdiarsadeghi/NumericalAnalysis

95a0914c06963b0510971388f006a6b2fc0c4ef9

Qwen/Qwen-72B

1. YES 2. YES

__label__yue_Hant

<a href="https://colab.research.google.com/github/MathewsJosh/mecanica-estruturas-ufjf/blob/main/%5BMAC023%5D_Trabalho_02.ipynb" target="_parent"></a> # **MAC023 - Mecânica das Estruturas** # ME-02 - Segunda Avaliação de Conhecimentos Alunos: Brian Luis Coimbra Maia Mathews Edwirds Gomes Almeida # Condições Gerais Esta avaliação tem como objetivo avaliar os conhecimentos adquiridos na primeira parte da disciplina de Mecânica das Estruturas. --- As condicões abaixo devem ser observadas: 1. Serão formadas equipes e cada uma delas com no mínimo **2** e no máximo **3** integrantes. 2. A avaliação será realizada por meio da entrega de uma cópia deste notebook com as soluções desenvolvidas até a data estipulada de entrega. 3. Da entrega da avaliação. * Os documentos necessários para a entrega do trabalho são (1) os códigos desenvolvidos pela equipe e (2) vídeo com a descrição da solução. * A equipe deve usar este modelo de notebook para desenvolver os códigos. * Os códigos podem ser desenvolvidos combinado a linguagem LaTeX e computação simbólica ou computação numérica quando necessário. * Os gráficos necessários para a apresentação da solução devem estar embutidos no notebook. 4. Da distribuição das questões. * A quantidade de questões será a mesma para cada grupo. * Serão atribuídas as mesmas questões para todos os grupos. * A pontuacão referente a cada questão será igualitária e o valor total da avaliação será 100 pontos. 5. As equipes devem ser formadas até às **23:59 horas o dia 18/01/2022** por meio do preenchimento da planilha [[MAC023] Formação das Equipes](https://docs.google.com/spreadsheets/d/1Dlftymao970nnrE4mu958iP8nMqKqSuhHiiLH91BKpQ/edit#gid=153704268). 6. A formação das equipes pode ser acompanhada arquivo indicado acima. Cada equipe será indentificada por uma letra em ordem alfabética seguida do número 2 (A2, B2, C2, e assim por diante). O arquivo está aberto para edição e pode ser alterado pelos alunos até a data estipulada. 7. Equipes formadas após a data estabelecida para a formação das equipes terão a nota da avaliação multiplicada por um coeficiente de **0.80**. 8. A equipe deve indicar no arquivo de indicação de equipes um responsável pela entrega do projeto. * Somente o responsável pela entrega deve fazer o upload do arquivo na plataforma 9. A entrega dos projetos deve ocorrer até às **23:59 do dia 04/02/2021** na plataforma da disciplina pelo responsável pela entrega. * Caso a entrega seja feita por outro integrante diferente daquele indicado pela pela equipe a avaliação será desconsiderada e não será corrigida até que a a condição de entrega seja satisfeita. 10. Quaisquer dúvidas ou esclarecimentos devem ser encaminhadas pela sala de aula virtual. ## (Q1) Encontre para a estrutura abaixo: (a) a deflexão máxima e (b) o ângulo máximo em relação a horizontal. --- Dado que, uma simples viga AB é sujeita a uma carga distribuída de intensidade $w(x) = w_0 * sin(\frac{Πx}{L})$, onde $w_0$ é a intensidade máxima da carga. Vamos integrar sucessivamente a equação de w(x) a fim de encontrar as devidas equações de deflexão, *slope*, momento, cortante etc. $EIv^{(iv)} = -w_0 * sin(\frac{πx}{L}) \\ EIv''' = w_0 * \frac{L}{π} * cos(\frac{πx}{L}) + c1 \\ EIv'' = w_0 * (\frac{L}{π})^2 * sin(\frac{πx}{L}) + c1*x + c2 \\ EIv' = - w_0 * (\frac{L}{π})^3 * cos(\frac{πx}{L}) + c1*(\frac{x^2}{2}) + c2*x + c3 \\ EIv = - w_0 * (\frac{L}{π})^4 * sin(\frac{πx}{L}) + c1*(\frac{x^3}{6}) + c2*(\frac{x^2}{2}) + c3*x + c4$ \\ Igualando as constantes de integração à zero: $C1 = C2 = C3 = C4 = 0 ⇒ \\ EIv = - w_0 * (\frac{L}{π})^4 * sin(\frac{πx}{L})$ a) Assim, a deflexão máxima foi encontrada pela integração do esforço cortante e equações de carga: $v = - \frac{w_o * L^4}{π^4*EI} * sin(\frac{πx}{L})$ ou, considerando que a deflexão máxima ocorre no centro da viga ($\frac{L}{2}$), temos: $v = - \frac{w_o * L^4}{π^4*EI} * sin(\frac{πx}{L}) ⇒ \\ v(\frac{L}{2}) = - \frac{w_o * L^4}{π^4*EI} * sin(\frac{π*L}{L*2}) ⇒ \\ v(\frac{L}{2}) = - \frac{w_o * L^4}{π^4*EI} * sin(\frac{π}{2}) ⇒ \\ v(\frac{L}{2}) = - \frac{w_o * L^4}{π^4*EI} * 1 $ <br><br> Assim, temos a deflexão máxima: $δ_{max} = v(\frac{L}{2}) = + \frac{w_0 * L^4}{π^4 * EI}$ b) Para encontrar o angulo máximo de rotação em relação ao eixo horizontal, basta substituir os devidos valores da viga na equação da deflexão (encontrada logo acima) para os apoios A($0$) e B($L$): Para o apoio A: \\ $θ_A (0) = v' = - \frac{w_0 * L^3}{π^3 * EI} * cos(\frac{π0}{L}) ⇒ \\ θ_A (0) = - \frac{w_0 * L^3}{π^3 * EI} * cos(0) ⇒ \\ θ_A (0) = - \frac{w_0 * L^3}{π^3 * EI} * 1 $ <br><br> Para o apoio B: $θ_B (L) = v' = - \frac{w_0 * L^3}{π^3 * EI} * cos(\frac{πL}{L}) ⇒ \\ θ_B (L) = v' = - \frac{w_0 * L^3}{π^3 * EI} * cos(π) ⇒ \\ θ_B (L) = v' = - \frac{w_0 * L^3}{π^3 * EI} * (-1) ⇒ \\ θ_B (L) = v' = + \frac{w_0 * L^3}{π^3 * EI}$ ## (Q2) Determina a razão $P/Q$ para que (a) o ângulo em $C$ seja zero e (b) a deflexão em $B$ seja nula --- Primeiro determinamos o momento fletor e as derivadas parciais para o seguimento BC: $ M_{BC} = - Px ,\textrm{ sendo }(0 ≤ x ≤ L) $ \\ $\frac{∂M_{BC}}{∂Q} = 0$ \\ $\frac{∂M_{BC}}{∂P} = -x$ \\ Em segundo lugar, determinamos o momento fletor e as derivadas parciais para o seguimento AB: $ M_{AB} = Q(L - x) - Px ,\textrm{ sendo }(0 ≤ x ≤ L) $ \\ $\frac{∂M_{AB}}{∂Q} = L - x $ \\ $\frac{∂M_{AB}}{∂P} = -x $ \\ a) Primeiro calculamos a deflexão em C: $δ_C = \frac{1}{EI} \displaystyle \int_{0}^{L} (M_{BC})(\frac{∂M_{BC}}{∂P})dx + \frac{1}{EI} \displaystyle \int_{0}^{L} (M_{AB})(\frac{∂M_{AB}}{∂P})dx$ \\ $δ_C = \frac{1}{EI} \displaystyle \int_{0}^{L} (-Px)(-x)dx + \frac{1}{EI} \displaystyle \int_{0}^{L} (Q*(L - x) - Px)(-x)dx$ \\ $δ_C = L^3 * (\frac{2 P}{3 EI} - \frac{Q}{6 EI}) = \frac{L^3 * (4 P - Q)}{6 EI}$ <br><br> Então derivamos a deflexão para encontrar o angulo em C: \\ $δ_C' = θ_C ⇒ \frac{\partial f}{\partial L} \frac{L^3 (4 P - Q)}{6 EI} = \frac{(4 P - Q) L^2}{2 EI}$ \\ $θ_C = \frac{L^2 * (4 P - Q)}{2 EI}$ <br><br> Sendo assim, para encontrar a razão $\frac{P}{Q}$ em C, precisaremos igualar $θ_C$ a 0, então: $θ_C = \frac{L^2 * (4 P - Q)}{2 EI} = 0$ \\ $(4 P - Q) = 0$ \\ $4 P = Q$ \\ $\frac{P}{Q} = \frac{1}{4} \textrm{ ou } 0.25$ b) Agora calculamos a deflexão em B: $δ_B = \frac{1}{EI} \displaystyle \int_{0}^{L} (M_{AB})(\frac{∂M_{AB}}{∂Q})dx$ $δ_B = \frac{1}{EI} \displaystyle \int_{0}^{L} (Q*(L - x) - Px)(L-x)dx$ $δ_B = \frac{L^3 (2Q - P)}{6 EI}$ <br><br> Sendo assim, para encontrar a razão $\frac{P}{Q}$, vamos igualar a deflexão em B a 0 ($δ_B = 0$), faremos: \\ $δ_B = \frac{L^3 (2Q - P)}{6 EI} = 0$ \\ $(2 Q - P) = 0$ \\ $2Q = P $ \\ $\frac{P}{Q} = 2$ ## (Q3) Determine o deslocamento no meio do vão --- ``` # Importação das bibliotecas e inicialização de parâmetros import sympy as sp from sympy import N sp.init_printing(use_unicode=False, wrap_line=False, no_global=True) x, l, w, E, I, a, b = sp.var('x L w E I a b', real=True, positive=True) # Separando as equações do momento fletor real por trechos MR = [(w/8)*(3*l*x - 4*x**2), (w/8)*(l**2-l*x)] #AC e CB print("Equações do momento fletor real por trechos:") display(MR) # Separando as equações do momento fletor virtual por trechos MV = [x/2, x/2-(x-l/2)] print("\n") print("Equações do momento fletor virtual por trechos:") display(MV) # Integrando em cada trecho delta1 = sp.integrate(MR[0]*MV[0]/(2*E*I),(x,0,l/2)) delta2 = sp.integrate(MR[1]*MV[1]/(E*I),(x,l/2,l)) print("\n") print("O deslocamento no meio do vão é dado pela soma dos resultados das duas integrações:") delta1+delta2 ``` Outra solução pode ser pela separação da figura em dois trechos AC e CB, seguida pela montagem de suas deflexões: $y_{AC} = - \frac{wx}{384*2*EI}*(9L^3 -24Lx^2 + 16x^3)$ \\ $y_{CB} = - \frac{wx}{384*EI}*(8x^3 -24Lx^2 + 17L^2x - L^3)$ \\ Derivando essas equações, encontramos os *slopes* para os pontos AC, CB: $Θ_{AC} = - \frac{w}{384*2*EI}*(9L^3 -72Lx^2 + 64x^3)$ \\ $Θ_{CB} = - \frac{wL}{384*EI}*(24x^2 -48Lx + 17L^2)$ \\ Assim, basta substituirmos a posição (L) na equação $Θ_{CB}$, para encontrarmos o deslocamento no meio do vão. $Θ_{B} (x)= - \frac{wL}{384*EI}*(24x^2 -48Lx + 17L^2)$ \\ $Θ_{B} (L)= \frac{7wL^4}{1536*EI}$ \\ ## (Q4) Encontre uma expressão para (a) o deslocamento **vertical** no ponto de aplicação da carga **que está aplicada a um terço do comprimento horizontal a partir do ponto $B$** e (b) o deslocamento horizontal do ponto $C$ --- ##A) ``` #-- separando as equações do momento fletor real por trechos MR=[ 0, # trecho AB, origem em A w*x*(2/3)/l, # trecho BW, origem em B w*(1/3)*(l-x)/l, # trecho WC, origem em W 0, # trecho CD, origem em C ] # Separando as equações do momento fletor virtual por trechos MV=[ x, # trecho AB, origem em A x, # trecho BW, origem em B x, # trecho WC, origem em W x, # trecho CD, origem em C ] # Integrando em cada trecho delta1 = sp.integrate(MR[0]*MV[0]/(E*I),(x,0,l)) delta2 = sp.integrate(MR[1]*MV[1]/(E*I),(x,0,l/3)) print("O deslocamento no ponto de aplicação da carga é dado pela soma dos resultados das integrações envolvendo AB e BW:") desloc_W = delta1+delta2 N(desloc_W, 4) ``` ##B) ``` delta1 = sp.integrate(MR[0]*MV[0]/(E*I),(x,0,l)) delta2 = sp.integrate(MR[1]*MV[1]/(E*I),(x,0,l/3)) delta3 = sp.integrate(MR[2]*MV[2]/(E*I),(x,l/3,l)) print("O deslocamento horizontal do ponto C é dado pela soma dos resultados das integrações envolvendo AB, BW e WC:") desloc_C = delta1+delta2+delta3 N(desloc_C, 4) ``` ## (Q5) Determine o deslocamento vertical na extremidade livre da viga em balanço. Observe que a barra possui uma variação linear na sua altura que influencia as propriedades geométricas. Modifique a formulação do método da carga unitária para acomodar a variação da altura ao longo do comprimento. Dados: tf - tonelada-força ``` print("Primeiro equacionamos os momentos reais de cada uma das barras da figura") MR = 2*x - 2*l display(MR) print("Agora equacionamos os momentos virtuais em cada uma das barra da figura") MV = x - l display(MV) print("Assim temos:") I = -1.575E-3*x/l + 1.8E-3 display(I) ``` ``` delta_B = sp.integrate(MR*MV/(E*I),(x,0,l)) display(delta_B) ``` Formula dos Trapézios (Δx=L/m): $\int_{x_0}^{x_n} y(x) dx ≈ (\frac{Δx}{2})(y_0+2y_1+2y_2+...+2y_{m-1}+y_m)$ Fórmula de Simpson (Δx=L/2m): $\int_{x_0}^{x_n} y(x)dx ≈ (\frac{Δx}{3})(y_0+4y_1+2y_2+4y_3+...+4y_{2m-3}+2y_{2m-2}+4y_{2m-1}+y_{2m})$ Fórmula de Simpson (Δx=L/3): $\int_{x_0}^{x_n} y(x)dx ≈ (\frac{3Δx}{8})(y_0+3y_1+3y_2+2y_3+...+2y_{3m-3}+3y_{3m-2}+3y_{3m-1}+y_{3m})$ ``` # Importação das bibliotecas e inicialização de parâmetros import pandas as pd # Definindo os dados iniciais h1, h2, L, b = 0.3, 0.6, 6, 0.1 #m P = 2 #tf E = 2100000 #tf/m^2 divisoes = ['6 (Δx=1)', '12 (Δx=1/2)', '18 (Δx=1/3)', '24 (Δx=1/4)'] trapezios = [6.2421, 6.2333, 6.2320, 6.2314] simpson_l_2 = [6.2365, 6.2310, 6.2307, 6.2306] simpson_l_3 = [6.2420, 6.2315, 6.2308, 6.2307] print("A partir dos valores dados, podemos encontrar os deslocamentos verticais dos pontos para diferentes divisões da viga, usando as formulas dos Trápezios (Δx=L/m), Simpson(Δx=L/2m) e Simpson(Δx=l/3m)\n") d = {'Intervalos': divisoes, 'Trápezios (Δx=L/m)': trapezios, 'Simpson(Δx=L/2m)':simpson_l_2, 'Simpson(Δx=l/3m)':simpson_l_3} df = pd.DataFrame(data=d) print(df.to_string(index=False)) ``` A partir dos valores dados, podemos encontrar os deslocamentos verticais dos pontos para diferentes divisões da viga, usando as formulas dos Trápezios (Δx=L/m), Simpson(Δx=L/2m) e Simpson(Δx=l/3m) Intervalos Trápezios (Δx=L/m) Simpson(Δx=L/2m) Simpson(Δx=l/3m) 6 (Δx=1) 6.2421 6.2365 6.2420 12 (Δx=1/2) 6.2333 6.2310 6.2315 18 (Δx=1/3) 6.2320 6.2307 6.2308 24 (Δx=1/4) 6.2314 6.2306 6.2307

30445e2e790d54efda02f55fa75417c733cd9f67

ipynb

Jupyter Notebook

[MAC023]_Trabalho_02.ipynb

MathewsJosh/mecanica-estruturas-ufjf

7f94b9a7cdacdb5a22b8fc491959f309be65acfb

[MAC023]_Trabalho_02.ipynb

MathewsJosh/mecanica-estruturas-ufjf

7f94b9a7cdacdb5a22b8fc491959f309be65acfb

[MAC023]_Trabalho_02.ipynb

MathewsJosh/mecanica-estruturas-ufjf

7f94b9a7cdacdb5a22b8fc491959f309be65acfb

Qwen/Qwen-72B

1. YES 2. YES

__label__por_Latn

# Direct Optimal Control Plotting ```python import sys; sys.path.append(2*'../') # go n dirs back from src import * # Change device according to your configuration # device = torch.device('cuda:1') if torch.cuda.is_available() else torch.device('cpu') device = torch.device('cpu') # feel free to change :) ``` ```python import time import torch import torch.nn as nn import matplotlib.pyplot as plt from torchdyn.core import NeuralODE from torchdyn.datasets import * from torchdyn.numerics import odeint, Euler, HyperEuler ``` ## Optimal Control We want to control an inverted pendulum and stabilize it in the upright position. The equations in Hamiltonian form describing an inverted pendulum with a torsional spring are as following: $$\begin{equation} \begin{bmatrix} \dot{q}\\ \dot{p}\\ \end{bmatrix} = \begin{bmatrix} 0& 1/m \\ -k& -\beta/m\\ \end{bmatrix} \begin{bmatrix} q\\ p\\ \end{bmatrix} - \begin{bmatrix} 0\\ mgl \sin{q}\\ \end{bmatrix}+ \begin{bmatrix} 0\\ 1\\ \end{bmatrix} u \end{equation}$$ ```python class ControlledPendulum(nn.Module): """ Inverted pendulum with torsional spring """ def __init__(self, u, m=1., k=.5, l=1., qr=0., β=.01, g=9.81): super().__init__() self.u = u # controller (nn.Module) self.nfe = 0 # number of function evaluations self.cur_f = None # current function evaluation self.cur_u = None # current controller evaluation self.m, self.k, self.l, self.qr, self.β, self.g = m, k, l, qr, β, g # physics def forward(self, t, x): self.nfe += 1 q, p = x[..., :1], x[..., 1:] self.cur_u = self.u(t, x) dq = p/self.m dp = -self.k*(q - self.qr) - self.m*self.g*self.l*torch.sin(q) \ -self.β*p/self.m + self.cur_u self.cur_f = torch.cat([dq, dp], -1) return self.cur_f from math import pi as π x_star = torch.Tensor([0., 0.]).to(device) cost_func = IntegralCost(x_star, P=1, Q=1) # final position is more important # Time span dt = 0.2 t0, tf = 0, 3 # initial and final time for controlling the system steps = int((tf - t0)/dt) + 1 # so we have a time step of 0.2s t_span = torch.linspace(t0, tf, steps).to(device) ``` ```python u_euler = torch.load('saved_models/u_euler.pt') u_hyper = torch.load('saved_models/u_hyper.pt') u_mp = torch.load('saved_models/u_mp.pt') u_rk4 = torch.load('saved_models/u_rk4.pt') ``` ```python # Testing the controller on the real system frac = 0.95 init_dist = torch.distributions.Uniform(torch.Tensor([-frac*π, -frac*π]), torch.Tensor([frac*π, frac*π])) x0 = init_dist.sample((50,)).to(device) t0, tf, steps = 0, 5, 10*10 + 1 # nominal trajectory t_span_fine = torch.linspace(t0, tf, steps).to(device) sys = ControlledPendulum(None) sys.u = u_euler; _, traj_eu = odeint(sys, x0, t_span_fine, solver='tsit5', atol=1e-5, rtol=1e-5) sys.u = u_hyper; _, traj_hyper = odeint(sys, x0, t_span_fine, solver='tsit5', atol=1e-5, rtol=1e-5) sys.u = u_mp; _, traj_mp = odeint(sys, x0, t_span_fine, solver='tsit5', atol=1e-5, rtol=1e-5) sys.u = u_rk4; _, traj_rk4 = odeint(sys, x0, t_span_fine, solver='tsit5', atol=1e-5, rtol=1e-5) print(cost_func(traj_eu), cost_func(traj_hyper), cost_func(traj_mp), cost_func(traj_rk4)) t_span_fine = t_span_fine.detach().cpu() traj_eu, traj_hyper, traj_mp, traj_rk4 = traj_eu.detach().cpu(), traj_hyper.detach().cpu(), traj_mp.detach().cpu(), traj_rk4.detach().cpu() # Plotting fig, axs = plt.subplots(4, 2, figsize=(16,8)) for i in range(len(x0)): axs[0,0].plot(t_span_fine, traj_eu[:,i,0], 'r', alpha=.3, label='p' if i==0 else None) axs[0,1].plot(t_span_fine, traj_eu[:,i,1], 'r-.', alpha=.3, label='q' if i==0 else None) axs[1,0].plot(t_span_fine, traj_hyper[:,i,0], color='orange', alpha=.3, label='p' if i==0 else None) axs[1,1].plot(t_span_fine, traj_hyper[:,i,1], color='orange', linestyle='-.', alpha=.3, label='q' if i==0 else None) axs[2,0].plot(t_span_fine, traj_mp[:,i,0], color='green', alpha=.3, label='p' if i==0 else None) axs[2,1].plot(t_span_fine, traj_mp[:,i,1], color='green', linestyle='-.', alpha=.3, label='q' if i==0 else None) axs[3,0].plot(t_span_fine, traj_rk4[:,i,0], color='purple', alpha=.3, label='p' if i==0 else None) axs[3,1].plot(t_span_fine, traj_rk4[:,i,1], color='purple', linestyle='-.', alpha=.3, label='q' if i==0 else None) # ax.legend() # ax.set_title('Controlled trajectories') # ax.set_xlabel(r"$t~[s]$") ``` Great 🎉 Training the controller with `HyperEuler` resulted in a working controller stabilizing the system in the given time; more importantly, while in the first part we used a high accuracy solver to obtain similar results training with the same number of epochs and all the same hyperparameters but using the hypersolver took less than time than higher-order solvers! Now, let's see the results ```python # plt.rcParams.update({ # "text.usetex": True, # "font.family": "serif", # "font.serif": ["Palatino"], # }) ``` ```python # Cool plots from matplotlib import colors, cm import matplotlib.gridspec as gridspec norm = colors.Normalize(vmin=0, vmax=16) controller = [u_hyper, u_euler, u_mp, u_rk4] colors = ['tab:orange', 'tab:red', 'tab:green', 'tab:purple'] labels = ['HyperEuler', 'Euler', 'Midpoint', 'RK4'] cmap='bone' titles = ['HyperEuler', 'Euler', 'Midpoint', 'RK4'] sys = [] fig = plt.figure(figsize=(11,5), constrained_layout=False) spec = gridspec.GridSpec(ncols=4, nrows=8, figure=fig) # Time span t0, tf = 0, 5 # initial and final time for controlling the system steps = int((tf - t0)/dt) + 1 # so we have a time step of 0.2s t_span = torch.linspace(t0, tf, steps*20).to(device) # nominal lim = π graph_lim = lim*1.6 # x0 = torch.Tensor(50, 2).uniform_(-lim, lim).to(device) x0_test = init_dist.sample((1000,)).to(device) # test on 1000 trajectories from random points axs = [] axs_q, axs_p = [], [] for i in range(4): axs.append(fig.add_subplot(spec[:4, i])) axs_q.append(fig.add_subplot(spec[4:6, i])) axs_p.append(fig.add_subplot(spec[6:8, i])) #, sharex=axs_q[-1] for u, ax, i in zip(controller, axs, range(len(controller))): sys.append(ControlledPendulum(u).to(device)) n_grid = 50 x = torch.linspace(-graph_lim, graph_lim, n_grid).to(device) Q, P = torch.meshgrid(x, x) ; z = torch.cat([Q.reshape(-1, 1), P.reshape(-1, 1)], 1) f = sys[-1](0, z).detach().cpu() Fq, Fp = f[:,0].reshape(n_grid, n_grid), f[:,1].reshape(n_grid, n_grid) val = sys[-1].u(0, z).detach().cpu() U = val.reshape(n_grid, n_grid) ax.streamplot(Q.T.detach().cpu().numpy(), P.T.detach().cpu().numpy(), Fq.T.detach().cpu().numpy(), Fp.T.detach().cpu().numpy(), color='black', density=0.6, linewidth=0.5) ax.set_xlim([-graph_lim*0.7, graph_lim*0.7]) ; ax.set_ylim([-graph_lim, graph_lim]) traj = odeint(sys[-1], x0, t_span, solver='dopri5')[1].detach().cpu() for j in range(traj.shape[1]): ax.plot(traj[:,j,0], traj[:,j,1], c=colors[i], alpha=.4, label=labels[i] if j==0 else "") axs_q[i].plot(t_span, traj[:,j,0], c=colors[i], alpha=.4) axs_p[i].plot(t_span, traj[:,j,1], c=colors[i], alpha=.4) traj_test = odeint(sys[-1], x0_test, t_span, solver='dopri5')[1].detach().cpu() print(titles[i], ' loss:\n', cost_func(traj.to(device)).item()) distance_mean, distance_std = traj_test[-1,:,0].mean(), traj_test[-1,...,0].std() # Not actually "error", this the mean value of positions and std print(titles[i], ' error mean:', distance_mean, ' error_std: ', distance_std) ax.set_xlabel(r'$q$', labelpad=-10) ax.set_ylabel(r'$p$', labelpad=0) ax.set_xticks([-3, 3]) ax.set_yticks([-5, 0, 5]) ax.set_title(titles[i], family='cursive') plt.suptitle('Pendulum Controlled Trajectories',fontsize=16, weight='bold', y=0.97) axs_q[0].set_ylabel(r'$q(t)$', labelpad=0) axs_p[0].set_ylabel(r'$p(t)$', labelpad=0) for axq, axp in zip(axs_q, axs_p): axq.set_xticks([0, 1, 2, 3, 4, 5]) axp.set_xticks([0, 1, 2, 3, 4, 5]) axp.set_xlabel(r'$t$', labelpad=0) axq.tick_params(labelbottom=False) axq.set_yticks([-4, 0, 4]) axp.set_yticks([-5, 0, 5]) axq.set_ylim([-4, 4]) axp.set_ylim([-5, 5]) axs_q[0].set_yticks([-4, 0, 4]) axs_p[0].set_yticks([-5, 0, 5]) for i in range(1, 4, 1): axs_q[i].tick_params(labelleft=False) axs_p[i].tick_params(labelleft=False) pad = 3 axs[0].annotate("Phase Space", xy=(0, 0.5), xytext=(-axs[0].yaxis.labelpad - pad, 0), xycoords=axs[0].yaxis.label, textcoords='offset points', size='large', ha='right', va='center', rotation='vertical', fontweight='bold') axs_q[0].annotate("Position", xy=(0, 0.5), xytext=(-axs_q[0].yaxis.labelpad - pad, 0), xycoords=axs_q[0].yaxis.label, textcoords='offset points', size='large', ha='right', va='center', rotation='vertical', fontweight='bold') axs_p[0].annotate("Momentum", xy=(0, 0.5), xytext=(-axs_p[0].yaxis.labelpad - pad, 0), xycoords=axs_p[0].yaxis.label, textcoords='offset points', size='large', ha='right', va='center', rotation='vertical', fontweight='bold') fig.tight_layout(h_pad=0, w_pad=-0.1) # Saving # import tikzplotlib fig.savefig('media/pendulum_control.pdf', bbox_inches = 'tight') # tikzplotlib.save("media/pendulum_control.tex") ``` ## Calculating MACs and plotting losses We can use the number of MACs instead of NFEs so we obtain a simpler ```python from ptflops import get_model_complexity_info bs = 1024 # batch size we used in training def get_macs(net:nn.Module): params = [] for p in net.parameters(): params.append(p.shape) with torch.cuda.device(0): macs, _ = get_model_complexity_info(net, (bs, params[0][1]), as_strings=False) return int(macs) ``` ```python controller = nn.Sequential( nn.Linear(2, 64), nn.Softplus(), nn.Linear(64, 64), nn.Softplus(), nn.Linear(64, 64), nn.Tanh(), nn.Linear(64, 1)) hypersolver = nn.Sequential(nn.Linear(2, 32), nn.Tanh(), nn.Linear(32, 1)).to(device) hs_macs = get_macs(hypersolver) u_macs = get_macs(controller) print('Controller MACs per NFE:', u_macs, '\nHypersolver MACs per NFE:', hs_macs) ``` ```python unit_mac_hyper = u_macs + hs_macs unit_mac_euler = u_macs unit_mac_midpoint = u_macs*2 # midpoint has to evaluate the vector field twice per NFE unit_mac_rk4 = u_macs*4 # rk4 has to do it 4 times ``` ```python multiplier = 2 # mac to flops macs_hyper = unit_mac_hyper*multiplier macs_euler = unit_mac_euler*multiplier macs_midpoint = unit_mac_midpoint*multiplier macs_rk4 = unit_mac_rk4*multiplier ``` ## Getting FLOPs per each evaluation ```python # # losses from above # # Flops are 2*GMACs # # https://github.com/sovrasov/flops-counter.pytorch/issues/16 print('HyperEuler FLOPs:', macs_hyper) print('Euler FLOPs:', macs_euler) print('Midpoing FLOPs:', macs_midpoint) print('RK4 FLOPs:', macs_rk4) ``` HyperEuler FLOPs: 17367492 Euler FLOPs: 17170818 Midpoing FLOPs: 34341636 RK4 FLOPs: 68683272 ```python # Ratio print('Hyper vs euler:', macs_hyper/macs_euler*100, '%') print('Hyper vs midpoint:', 1-(macs_hyper/macs_midpoint)*100, '%') ``` Hyper vs euler: 101.14539680054845 % Hyper vs midpoint: -49.57269840027423 %

d52e17236757a27674e2d9f16da41d778c784fa0

ipynb

Jupyter Notebook

hypersolvers-control/experiments/pendulum/03c_plot.ipynb

Juju-botu/diffeqml-research

aa796c87447e5299ec4f25a07fc4d032afb1f63e

hypersolvers-control/experiments/pendulum/03c_plot.ipynb

Juju-botu/diffeqml-research

aa796c87447e5299ec4f25a07fc4d032afb1f63e

hypersolvers-control/experiments/pendulum/03c_plot.ipynb

Juju-botu/diffeqml-research

aa796c87447e5299ec4f25a07fc4d032afb1f63e

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

Before you turn this problem in, make sure everything runs as expected. First, **restart the kernel** (in the menubar, select Kernel$\rightarrow$Restart) and then **run all cells** (in the menubar, select Cell$\rightarrow$Run All). Make sure you fill in any place that says `YOUR CODE HERE` or "YOUR ANSWER HERE", as well as your name and collaborators below: ```python NAME = "Prabal CHowdhury" COLLABORATORS = "" ``` --- # Differentiation: Forward, Backward, And Central --- ## Task 1: Differentiation We have already learnt about *forward differentiation*, *backward diferentiation* and *central differentiation*. In this part of the assignment we will write methods to calculate this values and check how they perform. The equations are as follows, \begin{align} \text{forward differentiation}, f^\prime(x) \simeq \frac{f(x+h)-f(x)}{h} \tag{4.6} \\ \text{backward differentiation}, f^\prime(x) \simeq \frac{f(x)-f(x-h)}{h} \tag{4.7} \\ \text{central differentiation}, f^\prime(x) \simeq \frac{f(x+h)-f(x-h)}{2h} \tag{4.8} \end{align} ## Importing libraries ```python import numpy as np import matplotlib.pyplot as plt from numpy.polynomial import Polynomial ``` Here, `forward_diff(f, h, x)`, `backward_diff(f, h, x)`, and `central_diff(f, h, x)` calculates the *forward differentiation*, *backward differentiation* and *central differentiation* respectively. finally the `error(f, f_prime, h, x)` method calculates the different values for various $h$ and returns the errors. Later we will run some code to test out performance. The first one is done for you. ```python def forward_diff(f, h, x): return (f(x+h) - f(x)) / h ``` ```python def backward_diff(f, h, x): # -------------------------------------------- # YOUR CODE HERE return (f(x-h) - f(x)) / h # -------------------------------------------- ``` ```python def central_diff(f, h, x): # -------------------------------------------- # YOUR CODE HERE return (f(x+h) - f(x-h)) / (2*h) # -------------------------------------------- ``` ```python def error(f, f_prime, h, x): Y_correct = f_prime(x) f_error = np.array([]) b_error = np.array([]) c_error = np.array([]) for h_i in h: # for different values of h (h_i) # calculate the error at the point x for (i) forward method # (ii) backward method # (ii) central method # the first one is done for you f_error_h_i = forward_diff(f, h_i, x) - Y_correct f_error = np.append(f_error, f_error_h_i) b_error_h_i = backward_diff(f, h_i, x) - Y_correct b_error = np.append(b_error, b_error_h_i) c_error_h_i = central_diff(f, h_i, x) - Y_correct c_error = np.append(c_error, c_error_h_i) return f_error, b_error, c_error ``` ## Plot1 Polynomial and Actual Derivative Function ```python fig, ax = plt.subplots() ax.axhline(y=0, color='k') p = Polynomial([2.0, 1.0, -6.0, -2.0, 2.5, 1.0]) data = p.linspace(domain=[-2.4, 1.5]) ax.plot(data[0], data[1], label='Function') p_prime = p.deriv(1) data2 = p_prime.linspace(domain=[-2.4, 1.5]) ax.plot(data2[0], data2[1], label='Derivative') ax.legend() ``` ```python h = 1 fig, bx = plt.subplots() bx.axhline(y=0, color='k') x = np.linspace(-2.0, 1.3, 50, endpoint=True) y = forward_diff(p, h, x) bx.plot(x, y, label='Forward; h=1') y = backward_diff(p, h, x) bx.plot(x, y, label='Backward; h=1') y = central_diff(p, h, x) bx.plot(x, y, label='Central; h=1') data2 = p_prime.linspace(domain=[-2.0, 1.3]) bx.plot(data2[0], data2[1], label='actual') bx.legend() ``` ```python h = 0.1 fig, bx = plt.subplots() bx.axhline(y=0, color='k') x = np.linspace(-2.2, 1.3, 50, endpoint=True) y = forward_diff(p, h, x) bx.plot(x, y, label='Forward; h=0.1') y = backward_diff(p, h, x) bx.plot(x, y, label='Backward; h=0.1') y = central_diff(p, h, x) bx.plot(x, y, label='Central; h=0.1') data2 = p_prime.linspace(domain=[-2.2, 1.3]) bx.plot(data2[0], data2[1], label='actual') bx.legend() ``` ```python h = 0.01 fig, bx = plt.subplots() bx.axhline(y=0, color='k') x = np.linspace(-2.2, 1.3, 50, endpoint=True) y = forward_diff(p, h, x) bx.plot(x, y, label='Forward; h=0.01') y = backward_diff(p, h, x) bx.plot(x, y, label='Backward; h=0.01') y = central_diff(p, h, x) bx.plot(x, y, label='Central; h=0.01') data2 = p_prime.linspace(domain=[-2.2, 1.3]) bx.plot(data2[0], data2[1], label='actual') bx.legend() ``` ```python fig, bx = plt.subplots() bx.axhline(y=0, color='k') h = np.array([1., 0.55, 0.3, .17, 0.1, 0.055, 0.03, 0.017, 0.01]) err = error(p, p_prime, h, 2.0) bx.plot(h, err[0], label='Forward') bx.plot(h, err[1], label='Backward') bx.plot(h, err[2], label='Central') bx.legend() ``` ```python ```

2cfc6b18a9465c463bf20d6d07db11d4c4509b8a

ipynb

Jupyter Notebook

Forward_Backward_and_Central_Differentiation.ipynb

PrabalChowdhury/CSE330-NUMERICAL-METHODS

aabfea01f4ceaecfbb50d771ee990777d6e1122c

Forward_Backward_and_Central_Differentiation.ipynb

PrabalChowdhury/CSE330-NUMERICAL-METHODS

aabfea01f4ceaecfbb50d771ee990777d6e1122c

Forward_Backward_and_Central_Differentiation.ipynb

PrabalChowdhury/CSE330-NUMERICAL-METHODS

aabfea01f4ceaecfbb50d771ee990777d6e1122c

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# Artificial Intelligence in Finance ## Normative Finance Dr Yves J Hilpisch | The AI Machine http://aimachine.io | http://twitter.com/dyjh ## Uncertainty and Risk ```python import numpy as np ``` ```python S0 = 10 B0 = 10 ``` ```python S1 = np.array((20, 5)) B1 = np.array((11, 11)) ``` ```python M0 = np.array((S0, B0)) M0 ``` ```python M1 = np.array((S1, B1)).T M1 ``` ```python K = 14.5 ``` ```python C1 = np.maximum(S1 - K, 0) C1 ``` ```python phi = np.linalg.solve(M1, C1) phi ``` ```python np.allclose(C1, np.dot(M1, phi)) ``` ```python C0 = np.dot(M0, phi) C0 ``` ## Expected Utility Theory ```python def u(x): return np.sqrt(x) ``` ```python phi_A = np.array((0.75, 0.25)) phi_D = np.array((0.25, 0.75)) ``` ```python np.dot(M0, phi_A) == np.dot(M0, phi_D) ``` ```python A1 = np.dot(M1, phi_A) A1 ``` ```python D1 = np.dot(M1, phi_D) D1 ``` ```python P = np.array((0.5, 0.5)) ``` ```python def EUT(x): return np.dot(P, u(x)) ``` ```python EUT(A1) ``` ```python EUT(D1) ``` ```python from scipy.optimize import minimize ``` ```python w = 10 ``` ```python cons = {'type': 'eq', 'fun': lambda phi: np.dot(M0, phi) - w} ``` ```python def EUT_(phi): x = np.dot(M1, phi) return EUT(x) ``` ```python opt = minimize(lambda phi: -EUT_(phi), x0=phi_A, constraints=cons) ``` ```python opt ``` ```python EUT_(opt['x']) ``` ```python np.dot(M0, opt['x']) ``` ## Mean-Variance Portfolio Theory ```python rS = S1 / S0 - 1 rS ``` ```python rB = B1 / B0 - 1 rB ``` ```python def mu(rX): return np.dot(P, rX) ``` ```python mu(rS) ``` ```python mu(rB) ``` ```python rM = M1 / M0 - 1 rM ``` ```python mu(rM) ``` ```python def var(rX): return ((rX - mu(rX)) ** 2).mean() ``` ```python var(rS) ``` ```python var(rB) ``` ```python def sigma(rX): return np.sqrt(var(rX)) ``` ```python sigma(rS) ``` ```python sigma(rB) ``` ```python np.cov(rM.T, aweights=P, ddof=0) ``` ```python phi = np.array((0.5, 0.5)) ``` ```python def mu_phi(phi): return np.dot(phi, mu(rM)) ``` ```python mu_phi(phi) ``` ```python def var_phi(phi): cv = np.cov(rM.T, aweights=P, ddof=0) return np.dot(phi, np.dot(cv, phi)) ``` ```python var_phi(phi) ``` ```python def sigma_phi(phi): return var_phi(phi) ** 0.5 ``` ```python sigma_phi(phi) ``` ```python from pylab import plt, mpl plt.style.use('seaborn') mpl.rcParams['savefig.dpi'] = 300 mpl.rcParams['font.family'] = 'serif' ``` ```python phi_mcs = np.random.random((2, 200)) ``` ```python phi_mcs = (phi_mcs / phi_mcs.sum(axis=0)).T ``` ```python mcs = np.array([(sigma_phi(phi), mu_phi(phi)) for phi in phi_mcs]) ``` ```python plt.figure(figsize=(10, 6)) plt.plot(mcs[:, 0], mcs[:, 1], 'ro') plt.xlabel('expected volatility') plt.ylabel('expected return'); ``` ```python P = np.ones(3) / 3 P ``` ```python S1 = np.array((20, 10, 5)) ``` ```python T0 = 10 T1 = np.array((1, 12, 13)) ``` ```python M0 = np.array((S0, T0)) M0 ``` ```python M1 = np.array((S1, T1)).T M1 ``` ```python rM = M1 / M0 - 1 rM ``` ```python mcs = np.array([(sigma_phi(phi), mu_phi(phi)) for phi in phi_mcs]) ``` ```python plt.figure(figsize=(10, 6)) plt.plot(mcs[:, 0], mcs[:, 1], 'ro') plt.xlabel('expected volatility') plt.ylabel('expected return'); ``` ```python cons = {'type': 'eq', 'fun': lambda phi: np.sum(phi) - 1} ``` ```python bnds = ((0, 1), (0, 1)) ``` ```python min_var = minimize(sigma_phi, (0.5, 0.5), constraints=cons, bounds=bnds) ``` ```python min_var ``` ```python def sharpe(phi): return mu_phi(phi) / sigma_phi(phi) ``` ```python max_sharpe = minimize(lambda phi: -sharpe(phi), (0.5, 0.5), constraints=cons, bounds=bnds) ``` ```python max_sharpe ``` ```python plt.figure(figsize=(10, 6)) plt.plot(mcs[:, 0], mcs[:, 1], 'ro', ms=5) plt.plot(sigma_phi(min_var['x']), mu_phi(min_var['x']), '^', ms=12.5, label='minimum volatility') plt.plot(sigma_phi(max_sharpe['x']), mu_phi(max_sharpe['x']), 'v', ms=12.5, label='maximum Sharpe ratio') plt.xlabel('expected volatility') plt.ylabel('expected return') plt.legend(); ``` ```python cons = [{'type': 'eq', 'fun': lambda phi: np.sum(phi) - 1}, {'type': 'eq', 'fun': lambda phi: mu_phi(phi) - target}] ``` ```python bnds = ((0, 1), (0, 1)) ``` ```python targets = np.linspace(mu_phi(min_var['x']), 0.16) ``` ```python frontier = [] for target in targets: phi_eff = minimize(sigma_phi, (0.5, 0.5), constraints=cons, bounds=bnds)['x'] frontier.append((sigma_phi(phi_eff), mu_phi(phi_eff))) frontier = np.array(frontier) ``` ```python plt.figure(figsize=(10, 6)) plt.plot(frontier[:, 0], frontier[:, 1], 'mo', ms=5, label='efficient frontier') plt.plot(sigma_phi(min_var['x']), mu_phi(min_var['x']), '^', ms=12.5, label='minimum volatility') plt.plot(sigma_phi(max_sharpe['x']), mu_phi(max_sharpe['x']), 'v', ms=12.5, label='maximum Sharpe ratio') plt.xlabel('expected volatility') plt.ylabel('expected return') plt.legend(); ``` ## Capital Asset Pricing Model ```python plt.figure(figsize=(10, 6)) plt.plot((0, 0.3), (0.01, 0.22), label='capital market line') plt.plot(0, 0.01, 'o', ms=9, label='risk-less asset') plt.plot(0.2, 0.15, '^', ms=9, label='market portfolio') plt.annotate('$(0, \\bar{r})$', (0, 0.01), (-0.01, 0.02)) plt.annotate('$(\sigma_M, \mu_M)$', (0.2, 0.15), (0.19, 0.16)) plt.xlabel('expected volatility') plt.ylabel('expected return') plt.legend(); ``` ```python phi_M = np.array((0.8, 0.2)) ``` ```python mu_M = mu_phi(phi_M) mu_M ``` ```python sigma_M = sigma_phi(phi_M) sigma_M ``` ```python r = 0.0025 ``` ```python plt.figure(figsize=(10, 6)) plt.plot(frontier[:, 0], frontier[:, 1], 'm.', ms=5, label='efficient frontier') plt.plot(0, r, 'o', ms=9, label='risk-less asset') plt.plot(sigma_M, mu_M, '^', ms=9, label='market portfolio') plt.plot((0, 0.6), (r, r + ((mu_M - r) / sigma_M) * 0.6), 'r', label='capital market line', lw=2.0) plt.annotate('$(0, \\bar{r})$', (0, r), (-0.015, r + 0.01)) plt.annotate('$(\sigma_M, \mu_M)$', (sigma_M, mu_M), (sigma_M - 0.025, mu_M + 0.01)) plt.xlabel('expected volatility') plt.ylabel('expected return') plt.legend(); ``` ```python def U(p): mu, sigma = p return mu - 1 / 2 * (sigma ** 2 + mu ** 2) ``` ```python cons = {'type': 'eq', 'fun': lambda p: p[0] - (r + (mu_M - r) / sigma_M * p[1])} ``` ```python opt = minimize(lambda p: -U(p), (0.1, 0.3), constraints=cons) ``` ```python opt ``` ```python from sympy import * init_printing(use_unicode=False, use_latex=False) ``` ```python mu, sigma, b, v = symbols('mu sigma b v') ``` ```python sol = solve('mu - b / 2 * (sigma ** 2 + mu ** 2) - v', mu) ``` ```python sol ``` ```python u1 = sol[0].subs({'b': 1, 'v': 0.1}) u1 ``` ```python u2 = sol[0].subs({'b': 1, 'v': 0.125}) u2 ``` ```python f1 = lambdify(sigma, u1) f2 = lambdify(sigma, u2) ``` ```python sigma_ = np.linspace(0.0, 0.5) u1_ = f1(sigma_) u2_ = f2(sigma_) ``` ```python plt.figure(figsize=(10, 6)) plt.plot(sigma_, u1_, label='$v=0.1$') plt.plot(sigma_, u2_, '--', label='$v=0.125$') plt.xlabel('expected volatility') plt.ylabel('expected return') plt.legend(); ``` ```python u = sol[0].subs({'b': 1, 'v': -opt['fun']}) u ``` ```python f = lambdify(sigma, u) ``` ```python u_ = f(sigma_) ``` ```python plt.figure(figsize=(10, 6)) plt.plot(0, r, 'o', ms=9, label='risk-less asset') plt.plot(sigma_M, mu_M, '^', ms=9, label='market portfolio') plt.plot(opt['x'][1], opt['x'][0], 'v', ms=9, label='optimal portfolio') plt.plot((0, 0.5), (r, r + (mu_M - r) / sigma_M * 0.5), label='capital market line', lw=2.0) plt.plot(sigma_, u_, '--', label='$v={}$'.format(-round(opt['fun'], 3))) plt.xlabel('expected volatility') plt.ylabel('expected return') plt.legend(); ``` ## Arbitrage Pricing Theory ```python M1 ``` ```python M0 ``` ```python V1 = np.array((12, 15, 7)) ``` ```python reg = np.linalg.lstsq(M1, V1, rcond=-1)[0] reg ``` ```python np.dot(M1, reg) ``` ```python np.dot(M1, reg) - V1 ``` ```python V0 = np.dot(M0, reg) V0 ``` ```python U0 = 10 U1 = np.array((12, 5, 11)) ``` ```python M0_ = np.array((S0, T0, U0)) ``` ```python M1_ = np.concatenate((M1.T, np.array([U1,]))).T ``` ```python M1_ ``` ```python np.linalg.matrix_rank(M1_) ``` ```python reg = np.linalg.lstsq(M1_, V1, rcond=-1)[0] reg ``` ```python np.allclose(np.dot(M1_, reg), V1) ``` ```python V0_ = np.dot(M0_, reg) V0_ ``` <br><br><br><a href="http://tpq.io" target="_blank">http://tpq.io</a> | <a href="http://twitter.com/dyjh" target="_blank">@dyjh</a> | <a href="mailto:ai@tpq.io">ai@tpq.io</a>

a811b7554bd4caa263f653a260bb437e5977626b

ipynb

Jupyter Notebook

03_normative_finance.ipynb

pepelawycliffe/AI_in_Finance

5eb29afed137c809955d116e7a7764b5914add96

2021-03-15T05:30:50.000Z

2021-12-14T07:28:44.000Z

03_normative_finance.ipynb

pepelawycliffe/AI_in_Finance

5eb29afed137c809955d116e7a7764b5914add96

03_normative_finance.ipynb

pepelawycliffe/AI_in_Finance

5eb29afed137c809955d116e7a7764b5914add96

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

```python %matplotlib notebook import numpy as np import matplotlib.pyplot as plt import matplotlib as mpl import pathlib import os import pwd import figformat fig_width,fig_height,params=figformat.figure_format(fig_width=3.4,fig_height=3.4) mpl.rcParams.update(params) #mpl.rcParams.keys() #help(figformat) def get_username(): return pwd.getpwuid(os.getuid())[0] user = get_username() run_dir = pathlib.Path(rf"/Users/{user}/GitHub/LEC/examples/") #path to TABLES print(f"run_dir: {run_dir}") ``` run_dir: /Users/StevE/GitHub/LEC/examples ### The function $q(\chi_e)$ for $\chi_e\ll 1$ \begin{equation} q(\chi_e\ll 1)\approx 1-\frac{55}{16}\sqrt{3}\chi + 48\chi^2 \nonumber \end{equation} ```python def func(x): f=1-(55/16)*np.sqrt(3)*x + 48*x**2 return f x=np.arange(0.001,10,0.001) ``` ### The function $q(\chi_e)$ for $\chi_e\gg 1$ \begin{equation} q(\chi_e\gg 1)\approx\frac{48}{243}\Gamma(\frac{2}{3})\chi^{-4/3} \left[ 1 -\frac{81}{16\Gamma(2/3)}(3\chi)^{-2/3} \right] \nonumber \end{equation} ```python def func2(y): f2=(48/243)*1.354*2.08*y**(-4/3)*(1-(81/16)*0.73855*(3*y)**(-2/3)) return f2 y=np.arange(0.1,100,0.001) ``` ### Extract $\chi_e$, $P_\mathrm{Q}$, $P_\mathrm{C}$, and $q(\chi_e)$ ```python Xi,Prad,Pc,g = np.loadtxt('P_rad.dat',unpack=True,usecols=[0,1,2,3],dtype=np.float) ``` ```python fig, ax = plt.subplots() ax.plot(x,func(x), "b", ls='--') ax.plot(y,func2(y),"g", ls='-.') ax.plot(Xi, g, color='black') ax.set_xlim(0.001,100) ax.set_ylim(0.001,3) ax.set_yscale('log') ax.set_xscale('log') ax.set_xlabel("$\chi_e$") ax.set_ylabel("$q(\chi_e)$") ax.minorticks_on() ax2 = ax.twinx() ax2.plot(Xi,Prad,'-y',color='red',label='$P_Q$') ax2.plot(Xi,Pc,'--',color='red',label='$P_Q$') ax2.set_ylim(1,1e7) ax2.set_yscale('log') ax2.set_ylabel("$P_\mathrm{rad} (W)$",color='red') ax2.minorticks_on() ax2.tick_params(axis='y',labelcolor='red') ax2.tick_params(which='major',color='red') ax2.tick_params(which='minor',color='red') ax2.spines['right'].set_color('red') eq1 = r"\begin{eqnarray*}" + \ r"g(\chi_e\ll 1)&\approx&1-\frac{55}{16}\sqrt{3}\chi \\&+& 48\chi^2" + \ r"\end{eqnarray*}" #ax.text(0.35, 0.4, eq1, {'color': 'b', 'fontsize': 15}, va="top", ha="right") eq2 = r"\begin{eqnarray*}" + \ r"&&g(\chi_e\gg 1)\approx\frac{48}{243}\Gamma(\frac{2}{3})\chi^{-4/3} \\" + \ r"&& \times \{ 1 -\frac{81}{16\Gamma(2/3)}(3\chi)^{-2/3} \}" + \ r"\end{eqnarray*}" #ax.text(1, 0.01, eq2, {'color': 'g', 'fontsize': 15}, va="top", ha="right") fig = plt.gcf() fig.set_size_inches(fig_width, fig_width/1.618) fig.tight_layout() plt.show() ``` <IPython.core.display.Javascript object> ```python fig.savefig(rf"/Users/StevE/GitHub/LEC/docs/source/figures/qchi.png",format='png',dpi=600,transparent=True, bbox_inches='tight') ``` ```python ```

50e2344d3b2074c3bc38239697b38779643e966c

ipynb

Jupyter Notebook

examples/01_Python_emission_qfactor.ipynb

StevE-Ong/LEC

df479b38de83f6629ad5453760c166f9289b38e6

2020-07-02T14:57:31.000Z

2021-11-19T09:44:40.000Z

examples/01_Python_emission_qfactor.ipynb

StevE-Ong/LEC

df479b38de83f6629ad5453760c166f9289b38e6

2020-07-23T15:05:27.000Z

2021-11-19T12:12:53.000Z

examples/01_Python_emission_qfactor.ipynb

StevE-Ong/LEC

df479b38de83f6629ad5453760c166f9289b38e6

2020-07-24T08:11:32.000Z

2022-01-10T02:58:14.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__yue_Hant

# Anomaly Detection with LSTM in Keras Predict Anomalies using Confidence Intervals https://towardsdatascience.com/anomaly-detection-with-lstm-in-keras-8d8d7e50ab1b Detection of anomaly is useful in every business and the difficultness to detect these observations depends on the field of applications. If you are engaged in a problem of anomaly detection, which involves human activities (like prediction of sales or demand), you can take advantages from fundamental assumptions of human behaviors and plan a more efficient solution. We try to predict the Taxi demand in NYC in a critical time period. We formulate easy and important assumptions about human behaviors, which will permit us to detect an easy solution to forecast anomalies. All the dirty job is made by a loyalty LSTM, developed in Keras, which makes predictions and detection of anomalies at the same time! ```python import numpy as np import pandas as pd import matplotlib.pyplot as plt import re import os import tqdm import random import datetime from sklearn.metrics import mean_squared_log_error import tensorflow as tf from tensorflow.keras.layers import * from tensorflow.keras.models import * import tensorflow.keras.backend as K import statsmodels.api as sm import statsmodels.formula.api as smf %matplotlib inline ``` ## THE DATASET I took the dataset for our analysis from [Numenta](https://numenta.org/) community. In particular I chose the [NYC Taxi Dataset](https://github.com/numenta/NAB/blob/master/data/realKnownCause/nyc_taxi.csv). This dataset shows the NYC taxi demand from 2014–07–01 to 2015–01–31 with an observation every half hour. ```python ### READ DATA df = pd.read_csv('../dataset/nyc_taxi.csv',index_col='timestamp') # Converting the index as date df.index = pd.to_datetime(df.index) ### CREATE FEATURES FOR year, month, day, hour ### df['yr'] = df.index.year df['mt'] = df.index.month df['d'] = df.index.day df['H'] = df.index.hour print(df.shape) df.head() ``` (10320, 5) <div> <style scoped> .dataframe tbody tr th:only-of-type { vertical-align: middle; } .dataframe tbody tr th { vertical-align: top; } .dataframe thead th { text-align: right; } </style> <table border="1" class="dataframe"> <thead> <tr style="text-align: right;"> <th></th> <th>value</th> <th>yr</th> <th>mt</th> <th>d</th> <th>H</th> </tr> <tr> <th>timestamp</th> <th></th> <th></th> <th></th> <th></th> <th></th> </tr> </thead> <tbody> <tr> <th>2014-07-01 00:00:00</th> <td>10844</td> <td>2014</td> <td>7</td> <td>1</td> <td>0</td> </tr> <tr> <th>2014-07-01 00:30:00</th> <td>8127</td> <td>2014</td> <td>7</td> <td>1</td> <td>0</td> </tr> <tr> <th>2014-07-01 01:00:00</th> <td>6210</td> <td>2014</td> <td>7</td> <td>1</td> <td>1</td> </tr> <tr> <th>2014-07-01 01:30:00</th> <td>4656</td> <td>2014</td> <td>7</td> <td>1</td> <td>1</td> </tr> <tr> <th>2014-07-01 02:00:00</th> <td>3820</td> <td>2014</td> <td>7</td> <td>1</td> <td>2</td> </tr> </tbody> </table> </div> In this period 5 anomalies are present, in terms of deviation from normal behavior. They occur respectively during the - NYC marathon, - Thanksgiving, - Christmas, - New Year’s day, and a - snowstorm. ### Exemple of Weekly NORMAL observations ```python ### PLOT SAMPLE OF DATA ### df.iloc[4000:4000+7*48,:].value.plot(title='NORMAL observations'); ``` ### NYC Marathon ```python ### PLOT SAMPLE OF DATA ### df.iloc[4000+37*48:4000+37*48+7*48,:].value.plot(title='NYC Marathon anomality'); ``` ### Christmas ```python ### PLOT SAMPLE OF DATA ### df.iloc[8400:8400+7*48,:].value.plot(title='Christmas anomality'); ``` ### Anormality (outlier) detection: The objective is to learn what "normal" data look like, and then use that to detect abnormal instances, such as new trends in the time series. Our purpose is to detect these abnormal observetions in advance! The first consideration we noticed, looking at the data, is the presence of an obvious daily pattern (during the day the demand is higher than night hours). The taxi demand seems to be driven also by a weekly trend: in certain days of the week the taxi demand is higher than others. We simply prove this computing autocorrelation. ```python ### WEEKLY AUTOCORR PLOT (10 WEEKS DEPTH) ### timeLags = np.arange(1,10*48*7) autoCorr = [df.value.autocorr(lag=dt) for dt in timeLags] plt.plot(1.0/(48*7)*timeLags, autoCorr); plt.xlabel('time lag [weeks]'); plt.ylabel('correlation coeff', fontsize=12); plt.title('AutoCorrelation 10 weeks depth') plt.show() ``` What we can do now is to take note of this important behaviours for our further analysis. I compute and store the means for every days of the weeks at every hours. This will be useful when we’ll standardized the data to build our model in order to reduce every kind of temporal dependency (I compute the means for the first 5000 observations that will become our future train set). ## THE MODEL We need a strategy to detect outliers in advance. To do this, we decided to care about taxi demand predictions. We want to develop a model which is able to forecast demand taking into account uncertainty. One way to do this is to develop [quantile regression](https://en.wikipedia.org/wiki/Quantile_regression). ### Quantile Regression Let’s examine the python [statsmodels example for QuantReg](https://www.statsmodels.org/dev/examples/notebooks/generated/quantile_regression.html), which takes a look at the relationship between income and expenditures on food for a sample of working class Belgian households in 1857 [Engel], and see what kind of statistical analysis we can do. We first need to load some modules and to retrieve the data. Conveniently, the Engel dataset is shipped with statsmodels. ```python data = sm.datasets.engel.load_pandas().data data.head() ``` <div> <style scoped> .dataframe tbody tr th:only-of-type { vertical-align: middle; } .dataframe tbody tr th { vertical-align: top; } .dataframe thead th { text-align: right; } </style> <table border="1" class="dataframe"> <thead> <tr style="text-align: right;"> <th></th> <th>income</th> <th>foodexp</th> </tr> </thead> <tbody> <tr> <th>0</th> <td>420.157651</td> <td>255.839425</td> </tr> <tr> <th>1</th> <td>541.411707</td> <td>310.958667</td> </tr> <tr> <th>2</th> <td>901.157457</td> <td>485.680014</td> </tr> <tr> <th>3</th> <td>639.080229</td> <td>402.997356</td> </tr> <tr> <th>4</th> <td>750.875606</td> <td>495.560775</td> </tr> </tbody> </table> </div> ```python data.plot.scatter(x='income',y='foodexp'); ``` #### Least Absolute Deviation (LAD) The LAD model is a special case of quantile regression where $q=0.5$. ```python mod = smf.quantreg('foodexp ~ income', data) res = mod.fit(q=.5) print(res.summary()) print('Parameters: ', res.params) print('R2: ', res.rsquared) # plot x = np.arange(data.income.min(), data.income.max(), 50) get_y = lambda a, b: a + b * x y = get_y(res.params['Intercept'], res.params['income']) fig, ax = plt.subplots(figsize=(8, 6)) ax.plot(x, y, color='red', label='LAD $p=0.5$') ax.legend() data.plot.scatter(x='income',y='foodexp',ax=ax); plt.show() ``` We estimate the quantile regression model for many quantiles between .05 and .95, and compare best fit line from each of these models to Ordinary Least Squares results. ```python quantiles = np.arange(.05, .96, .15) def fit_model(q): res = mod.fit(q=q) return [q, res.params['Intercept'], res.params['income']] + \ res.conf_int().loc['income'].tolist() models = [fit_model(x) for x in quantiles] models = pd.DataFrame(models, columns=['q', 'a', 'b', 'lb', 'ub']) models = models.set_index('q') print(models) # plot x = np.arange(data.income.min(), data.income.max(), 50) get_y = lambda a, b: a + b * x fig, ax = plt.subplots(figsize=(8, 6)) for i in quantiles: y = get_y(models.a[i], models.b[i]) ax.plot(x, y, linestyle='dotted', label='LAD $q={:.2f}$'.format(i)) ax.legend() data.plot.scatter(x='income',y='foodexp',ax=ax); plt.show() ``` #### Ordinary Least Squares (OLS) [OLS](https://en.wikipedia.org/wiki/Ordinary_least_squares) is a type of linear least squares method for estimating the unknown parameters in a linear regression model. **Principle of least squares**: minimizing the sum of the squares of the differences between the observed dependent variable $Y$ and those predicted by the linear function of the independent variable $X$. ```python mod=smf.ols('foodexp ~ income', data) res=mod.fit() print(res.summary()) print('Parameters: ', res.params) print('Limits: ', res.conf_int().loc['income'].tolist()) print('R2: ', res.rsquared) # plot x = np.arange(data.income.min(), data.income.max(), 50) get_y = lambda a, b: a + b * x fig, ax = plt.subplots(figsize=(8, 6)) for i in quantiles: y = get_y(models.a[i], models.b[i]) ax.plot(x, y, linestyle='dotted', label='LAD $q={:.2f}$'.format(i)) y = get_y(res.params['Intercept'], res.params['income']) ax.plot(x, y, color='red', label='OLS') ax.legend() data.plot.scatter(x='income',y='foodexp',ax=ax); plt.show() ``` **note**: LAD for $q=0.5$ and OLS are not the same. The first can be interpreted as the median and the second as the mean. ```python n = models.shape[0] p1 = plt.plot(models.index, models.b, color='black', label='Quantile Reg.') p2 = plt.plot(models.index, models.ub, linestyle='dotted', color='black') p3 = plt.plot(models.index, models.lb, linestyle='dotted', color='black') p4 = plt.plot(models.index, [res.params['income']] * n, color='red', label='OLS') p5 = plt.plot(models.index, [res.conf_int().loc['income'].tolist()[0]] * n, linestyle='dotted', color='red') p6 = plt.plot(models.index, [res.conf_int().loc['income'].tolist()[1]] * n, linestyle='dotted', color='red') plt.ylabel(r'$\beta_{income}$') plt.xlabel('Quantiles of the conditional food expenditure distribution') plt.legend() plt.show() ``` The dotted black lines form 95% point-wise confidence band around 10 quantile regression estimates (solid black line). The red lines represent OLS regression results along with their 95% confidence interval. In most cases, the quantile regression point estimates lie outside the OLS confidence interval, which suggests that the effect of income on food expenditure may not be constant across the distribution. #### [Deep Quantile Regression](https://github.com/sachinruk/KerasQuantileModel/blob/master/Keras%20Quantile%20Model.ipynb) One area that Deep Learning has not explored extensively is the uncertainty in estimates. However, as far as decision making goes, most people actually require quantiles as opposed to true uncertainty in an estimate. eg. For a given age the weight of an individual will vary. What would be interesting is the (for arguments sake) the 10th and 90th percentile. The uncertainty of the estimate of an individuals weight is less interesting. Standardise the inputs and outputs so that it is easier to train. I have't saved the mean and standard deviations, but you should. ```python data['income_st']= (data.income - data.income.mean())/data.income.std() data['foodexp_st']= (data.foodexp - data.foodexp.mean())/data.foodexp.std() data ``` <div> <style scoped> .dataframe tbody tr th:only-of-type { vertical-align: middle; } .dataframe tbody tr th { vertical-align: top; } .dataframe thead th { text-align: right; } </style> <table border="1" class="dataframe"> <thead> <tr style="text-align: right;"> <th></th> <th>income</th> <th>foodexp</th> <th>income_st</th> <th>foodexp_st</th> </tr> </thead> <tbody> <tr> <th>0</th> <td>420.157651</td> <td>255.839425</td> <td>-1.082978</td> <td>-1.332253</td> </tr> <tr> <th>1</th> <td>541.411707</td> <td>310.958667</td> <td>-0.849451</td> <td>-1.132876</td> </tr> <tr> <th>2</th> <td>901.157457</td> <td>485.680014</td> <td>-0.156608</td> <td>-0.500874</td> </tr> <tr> <th>3</th> <td>639.080229</td> <td>402.997356</td> <td>-0.661349</td> <td>-0.799954</td> </tr> <tr> <th>4</th> <td>750.875606</td> <td>495.560775</td> <td>-0.446039</td> <td>-0.465133</td> </tr> <tr> <th>...</th> <td>...</td> <td>...</td> <td>...</td> <td>...</td> </tr> <tr> <th>230</th> <td>440.517424</td> <td>306.519079</td> <td>-1.043766</td> <td>-1.148935</td> </tr> <tr> <th>231</th> <td>541.200597</td> <td>299.199328</td> <td>-0.849858</td> <td>-1.175412</td> </tr> <tr> <th>232</th> <td>581.359892</td> <td>468.000798</td> <td>-0.772514</td> <td>-0.564823</td> </tr> <tr> <th>233</th> <td>743.077243</td> <td>522.601906</td> <td>-0.461058</td> <td>-0.367320</td> </tr> <tr> <th>234</th> <td>1057.676711</td> <td>750.320163</td> <td>0.144837</td> <td>0.456382</td> </tr> </tbody> </table> <p>235 rows × 4 columns</p> </div> ```python model = Sequential() model.add(Dense(units=10, input_dim=1,activation='relu')) model.add(Dense(units=10, input_dim=1,activation='relu')) model.add(Dense(1)) model.compile(loss='mae', optimizer='adadelta') model.fit(data.income_st.values, data.foodexp_st.values, epochs=50000, batch_size=32, verbose=0) model.evaluate(data.income_st.values, data.foodexp_st.values) ``` 8/8 [==============================] - 0s 4ms/step - loss: 0.2606 0.2605687081813812 ```python t_test = np.linspace(data.income_st.min(),data.income_st.max(),200) y_test = model.predict(t_test) plt.scatter(data.income_st,data.foodexp_st) plt.plot(t_test, y_test,'r') plt.show() ``` ##### Quantile Regression Loss function In regression the most commonly used loss function is the mean squared error function. If we were to take the negative of this loss and exponentiate it, the result would correspond to the gaussian distribution. The mode of this distribution (the peak) corresponds to the mean parameter. Hence, when we predict using a neural net that minimised this loss we are predicting the mean value of the output which may have been noisy in the training set. The loss in Quantile Regression for an individual data point is defined as: $$ \begin{align} \mathcal{L}(\xi_i|\alpha)=\begin{cases} \alpha \xi_i &amp;\text{if }\xi_i\ge 0, \\ (\alpha-1) \xi_i &amp;\text{if }\xi_i<0. \end{cases} \end{align} $$ where $\alpha$ is the required quantile (a value between 0 and 1) and $\xi_i = y_i - f(\mathbf{x}_i)$ and, $f(\mathbf{x}_i)$ is the predicted (quantile) model and $y$ is the observed value for the corresponding input $x$. The final overall loss is defines as: $$ \mathcal{L}(\mathbf{y},\mathbf{f}|\alpha)=\frac{1}{N} \sum_{i=1}^N \mathcal{L}(y_i-f(\mathbf{x}_i)|\alpha) $$ If we were to take the negative of the individual loss and exponentiate it, we get the distribution know as the Asymmetric Laplace distribution, shown below. The reason that this loss function works is that if we were to find the area under the graph to the left of zero it would be alpha, the required quantile. https://miro.medium.com/max/700/1*gUrYM90-7NNKwYO6-ONc5A.png The following function defines the loss function for a quantile model. Note: The following 4 lines is ALL that you change in comparison to a normal Deep Learning method, i.e. The loss function is all that changes. ```python def tilted_loss(q,y,f): e = (y-f) return K.mean(K.maximum(q*e, (q-1)*e), axis=-1) ``` ```python def engelModel(): model = Sequential() model.add(Dense(units=10, input_dim=1,activation='relu')) model.add(Dense(units=10, input_dim=1,activation='relu')) model.add(Dense(1)) return model ``` ```python qs = [0.1, 0.5, 0.9] t_test = np.linspace(data.income_st.min(),data.income_st.max(),200) plt.scatter(data.income_st,data.foodexp_st) for q in qs: model = engelModel() model.compile(loss=lambda y,f: tilted_loss(q,y,f), optimizer='adadelta') model.fit(data.income_st.values, data.foodexp_st.values, epochs=50000, batch_size=32, verbose=0) # Predict the quantile y_test = model.predict(t_test) plt.plot(t_test, y_test, label=q) # plot out this quantile plt.legend() plt.show() ``` ##### Final Notes 1. Note that the quantile 0.5 is the same as median, which you can attain by minimising Mean Absolute Error, which you can attain in Keras regardless with loss='mae'. 2. Uncertainty and quantiles are not the same thing. But most of the time you care about quantiles and not uncertainty. 3. If you really do want uncertainty with deep nets checkout http://mlg.eng.cam.ac.uk/yarin/blog_3d801aa532c1ce.html *** back to the outlyer detection Model *** We focus on predictions of extreme values: lower (10th quantile), upper (90th quantile) and the classical 50th quantile. Computing also the 90th and 10th quantile we cover the most likely values the reality can assume. The width of this range can be very depth; we know that it is small when our model is sure about the future and it can be huge when our model isn’t able to see important changes in the domain of interest. We took advantage from this behaviour and let our model says something about outliers detection in the field of taxi demand preditcion. We are expecting to get a tiny interval (90–10 quantile range) when our model is sure about the future because it has all under control; on the other hand we are expecting to get an anomaly when the interval becomes bigger. This is possible because our model isn’t trained to handle this kind of scenario which can results in anomaly. We make all this magic reality building a simple LSTM Neural Network in Keras. Our model will receive as input the past observations. We resize our data for feeding our LSTM with daily window size (48 observations: one observation for every half hour). When we were generating data, as I cited above, we operated logarithmic transformation and standardization subtracting the mean daily hour values, in order to see an observation as the logarithmic variation from its daily mean hour value. We build our target variables in the same way with half hour shifting (we want to predict the demand values for the next thirty minutes). ```python ### CREATE WEEKDAY FEATURE AND COMPUTE THE MEAN FOR WEEKDAYS AT EVERY HOURS ### df['weekday'] = df.index.weekday df['weekday_hour'] = df.weekday.astype(str) +' '+ df.H.astype(str) df['m_weekday'] = df.weekday_hour.replace(df[:5000].groupby('weekday_hour')['value'].mean().to_dict()) df ``` <div> <style scoped> .dataframe tbody tr th:only-of-type { vertical-align: middle; } .dataframe tbody tr th { vertical-align: top; } .dataframe thead th { text-align: right; } </style> <table border="1" class="dataframe"> <thead> <tr style="text-align: right;"> <th></th> <th>value</th> <th>yr</th> <th>mt</th> <th>d</th> <th>H</th> <th>weekday</th> <th>weekday_hour</th> <th>m_weekday</th> </tr> <tr> <th>timestamp</th> <th></th> <th></th> <th></th> <th></th> <th></th> <th></th> <th></th> <th></th> </tr> </thead> <tbody> <tr> <th>2014-07-01 00:00:00</th> <td>10844</td> <td>2014</td> <td>7</td> <td>1</td> <td>0</td> <td>1</td> <td>1 0</td> <td>8774.433333</td> </tr> <tr> <th>2014-07-01 00:30:00</th> <td>8127</td> <td>2014</td> <td>7</td> <td>1</td> <td>0</td> <td>1</td> <td>1 0</td> <td>8774.433333</td> </tr> <tr> <th>2014-07-01 01:00:00</th> <td>6210</td> <td>2014</td> <td>7</td> <td>1</td> <td>1</td> <td>1</td> <td>1 1</td> <td>5242.933333</td> </tr> <tr> <th>2014-07-01 01:30:00</th> <td>4656</td> <td>2014</td> <td>7</td> <td>1</td> <td>1</td> <td>1</td> <td>1 1</td> <td>5242.933333</td> </tr> <tr> <th>2014-07-01 02:00:00</th> <td>3820</td> <td>2014</td> <td>7</td> <td>1</td> <td>2</td> <td>1</td> <td>1 2</td> <td>3170.433333</td> </tr> <tr> <th>...</th> <td>...</td> <td>...</td> <td>...</td> <td>...</td> <td>...</td> <td>...</td> <td>...</td> <td>...</td> </tr> <tr> <th>2015-01-31 21:30:00</th> <td>24670</td> <td>2015</td> <td>1</td> <td>31</td> <td>21</td> <td>5</td> <td>5 21</td> <td>21298.033333</td> </tr> <tr> <th>2015-01-31 22:00:00</th> <td>25721</td> <td>2015</td> <td>1</td> <td>31</td> <td>22</td> <td>5</td> <td>5 22</td> <td>23126.666667</td> </tr> <tr> <th>2015-01-31 22:30:00</th> <td>27309</td> <td>2015</td> <td>1</td> <td>31</td> <td>22</td> <td>5</td> <td>5 22</td> <td>23126.666667</td> </tr> <tr> <th>2015-01-31 23:00:00</th> <td>26591</td> <td>2015</td> <td>1</td> <td>31</td> <td>23</td> <td>5</td> <td>5 23</td> <td>24726.433333</td> </tr> <tr> <th>2015-01-31 23:30:00</th> <td>26288</td> <td>2015</td> <td>1</td> <td>31</td> <td>23</td> <td>5</td> <td>5 23</td> <td>24726.433333</td> </tr> </tbody> </table> <p>10320 rows × 8 columns</p> </div> ```python ### CREATE GENERATOR FOR LSTM ### sequence_length = 48 def gen_index(id_df, seq_length, seq_cols): data_matrix = id_df[seq_cols] num_elements = data_matrix.shape[0] for start, stop in zip(range(0, num_elements-seq_length, 1), range(seq_length, num_elements, 1)): yield data_matrix[stop-sequence_length:stop].values.reshape((-1,len(seq_cols))) ``` ```python ### CREATE AND STANDARDIZE DATA FOR LSTM ### cnt, mean = [], [] for sequence in gen_index(df, sequence_length, ['value']): cnt.append(sequence) for sequence in gen_index(df, sequence_length, ['m_weekday']): mean.append(sequence) cnt, mean = np.log(cnt), np.log(mean) cnt = cnt - mean cnt.shape ``` (10272, 48, 1) ```python ### CREATE AND STANDARDIZE LABEL FOR LSTM ### init = df.m_weekday[sequence_length:].apply(np.log).values label = df.value[sequence_length:].apply(np.log).values - init label.shape ``` (10272,) Operate quantile regression in Keras is very simple (I took inspiration from [this post](https://towardsdatascience.com/deep-quantile-regression-c85481548b5a)). We easily define the custom quantile loss function which penalizes errors based on the quantile and whether the error was positive (actual > predicted) or negative (actual < predicted). Our network has 3 outputs and 3 losses, one for every quantile we try to predict. ```python ### DEFINE QUANTILE LOSS ### def q_loss(q,y,f): e = (y-f) return K.mean(K.maximum(q*e, (q-1)*e), axis=-1) ``` ```python ### TRAIN TEST SPLIT ### X_train, X_test = cnt[:5000], cnt[5000:] y_train, y_test = label[:5000], label[5000:] train_date, test_date = df.index.values[sequence_length:5000+sequence_length], df.index.values[5000+sequence_length:] ``` ```python tf.random.set_seed(33) os.environ['PYTHONHASHSEED'] = str(33) np.random.seed(33) random.seed(33) session_conf = tf.compat.v1.ConfigProto( intra_op_parallelism_threads=1, inter_op_parallelism_threads=1 ) sess = tf.compat.v1.Session( graph=tf.compat.v1.get_default_graph(), config=session_conf ) tf.compat.v1.keras.backend.set_session(sess) ### CREATE MODEL ### losses = [lambda y,f: q_loss(0.1,y,f), lambda y,f: q_loss(0.5,y,f), lambda y,f: q_loss(0.9,y,f)] inputs = Input(shape=(X_train.shape[1], X_train.shape[2])) lstm = Bidirectional(LSTM(64, return_sequences=True, dropout=0.3))(inputs, training = True) lstm = Bidirectional(LSTM(16, return_sequences=False, dropout=0.3))(lstm, training = True) dense = Dense(50)(lstm) out10 = Dense(1)(dense) out50 = Dense(1)(dense) out90 = Dense(1)(dense) model = Model(inputs, [out10,out50,out90]) model.compile(loss=losses, optimizer='adam', loss_weights = [0.3,0.3,0.3]) model.fit(X_train, [y_train,y_train,y_train], epochs=50, batch_size=128, verbose=2) ``` Epoch 1/50 WARNING:tensorflow:AutoGraph could not transform <function <lambda> at 0x14cd1a680> and will run it as-is. Cause: could not parse the source code of <function <lambda> at 0x14cd1a680>: found multiple definitions with identical signatures at the location. This error may be avoided by defining each lambda on a single line and with unique argument names. Match 0: (lambda y, f: q_loss(0.1, y, f)) Match 1: (lambda y, f: q_loss(0.5, y, f)) Match 2: (lambda y, f: q_loss(0.9, y, f)) To silence this warning, decorate the function with @tf.autograph.experimental.do_not_convert WARNING: AutoGraph could not transform <function <lambda> at 0x14cd1a680> and will run it as-is. Cause: could not parse the source code of <function <lambda> at 0x14cd1a680>: found multiple definitions with identical signatures at the location. This error may be avoided by defining each lambda on a single line and with unique argument names. Match 0: (lambda y, f: q_loss(0.1, y, f)) Match 1: (lambda y, f: q_loss(0.5, y, f)) Match 2: (lambda y, f: q_loss(0.9, y, f)) To silence this warning, decorate the function with @tf.autograph.experimental.do_not_convert WARNING:tensorflow:AutoGraph could not transform <function <lambda> at 0x14cd1a290> and will run it as-is. Cause: could not parse the source code of <function <lambda> at 0x14cd1a290>: found multiple definitions with identical signatures at the location. This error may be avoided by defining each lambda on a single line and with unique argument names. Match 0: (lambda y, f: q_loss(0.1, y, f)) Match 1: (lambda y, f: q_loss(0.5, y, f)) Match 2: (lambda y, f: q_loss(0.9, y, f)) To silence this warning, decorate the function with @tf.autograph.experimental.do_not_convert WARNING: AutoGraph could not transform <function <lambda> at 0x14cd1a290> and will run it as-is. Cause: could not parse the source code of <function <lambda> at 0x14cd1a290>: found multiple definitions with identical signatures at the location. This error may be avoided by defining each lambda on a single line and with unique argument names. Match 0: (lambda y, f: q_loss(0.1, y, f)) Match 1: (lambda y, f: q_loss(0.5, y, f)) Match 2: (lambda y, f: q_loss(0.9, y, f)) To silence this warning, decorate the function with @tf.autograph.experimental.do_not_convert WARNING:tensorflow:AutoGraph could not transform <function <lambda> at 0x14cb12c20> and will run it as-is. Cause: could not parse the source code of <function <lambda> at 0x14cb12c20>: found multiple definitions with identical signatures at the location. This error may be avoided by defining each lambda on a single line and with unique argument names. Match 0: (lambda y, f: q_loss(0.1, y, f)) Match 1: (lambda y, f: q_loss(0.5, y, f)) Match 2: (lambda y, f: q_loss(0.9, y, f)) To silence this warning, decorate the function with @tf.autograph.experimental.do_not_convert WARNING: AutoGraph could not transform <function <lambda> at 0x14cb12c20> and will run it as-is. Cause: could not parse the source code of <function <lambda> at 0x14cb12c20>: found multiple definitions with identical signatures at the location. This error may be avoided by defining each lambda on a single line and with unique argument names. Match 0: (lambda y, f: q_loss(0.1, y, f)) Match 1: (lambda y, f: q_loss(0.5, y, f)) Match 2: (lambda y, f: q_loss(0.9, y, f)) To silence this warning, decorate the function with @tf.autograph.experimental.do_not_convert 40/40 - 8s - loss: 0.0285 - dense_13_loss: 0.0274 - dense_14_loss: 0.0438 - dense_15_loss: 0.0238 Epoch 2/50 40/40 - 3s - loss: 0.0259 - dense_13_loss: 0.0233 - dense_14_loss: 0.0413 - dense_15_loss: 0.0216 Epoch 3/50 40/40 - 3s - loss: 0.0252 - dense_13_loss: 0.0223 - dense_14_loss: 0.0405 - dense_15_loss: 0.0213 Epoch 4/50 40/40 - 3s - loss: 0.0248 - dense_13_loss: 0.0221 - dense_14_loss: 0.0398 - dense_15_loss: 0.0207 Epoch 5/50 40/40 - 3s - loss: 0.0241 - dense_13_loss: 0.0210 - dense_14_loss: 0.0390 - dense_15_loss: 0.0205 Epoch 6/50 40/40 - 3s - loss: 0.0235 - dense_13_loss: 0.0203 - dense_14_loss: 0.0383 - dense_15_loss: 0.0198 Epoch 7/50 40/40 - 3s - loss: 0.0233 - dense_13_loss: 0.0200 - dense_14_loss: 0.0379 - dense_15_loss: 0.0198 Epoch 8/50 40/40 - 3s - loss: 0.0224 - dense_13_loss: 0.0191 - dense_14_loss: 0.0368 - dense_15_loss: 0.0189 Epoch 9/50 40/40 - 3s - loss: 0.0219 - dense_13_loss: 0.0186 - dense_14_loss: 0.0360 - dense_15_loss: 0.0184 Epoch 10/50 40/40 - 3s - loss: 0.0211 - dense_13_loss: 0.0177 - dense_14_loss: 0.0347 - dense_15_loss: 0.0180 Epoch 11/50 40/40 - 3s - loss: 0.0207 - dense_13_loss: 0.0176 - dense_14_loss: 0.0340 - dense_15_loss: 0.0175 Epoch 12/50 40/40 - 3s - loss: 0.0205 - dense_13_loss: 0.0176 - dense_14_loss: 0.0336 - dense_15_loss: 0.0173 Epoch 13/50 40/40 - 3s - loss: 0.0199 - dense_13_loss: 0.0171 - dense_14_loss: 0.0327 - dense_15_loss: 0.0165 Epoch 14/50 40/40 - 3s - loss: 0.0198 - dense_13_loss: 0.0170 - dense_14_loss: 0.0326 - dense_15_loss: 0.0163 Epoch 15/50 40/40 - 3s - loss: 0.0195 - dense_13_loss: 0.0169 - dense_14_loss: 0.0320 - dense_15_loss: 0.0161 Epoch 16/50 40/40 - 3s - loss: 0.0194 - dense_13_loss: 0.0164 - dense_14_loss: 0.0322 - dense_15_loss: 0.0162 Epoch 17/50 40/40 - 3s - loss: 0.0189 - dense_13_loss: 0.0163 - dense_14_loss: 0.0312 - dense_15_loss: 0.0155 Epoch 18/50 40/40 - 3s - loss: 0.0189 - dense_13_loss: 0.0161 - dense_14_loss: 0.0312 - dense_15_loss: 0.0157 Epoch 19/50 40/40 - 3s - loss: 0.0188 - dense_13_loss: 0.0160 - dense_14_loss: 0.0312 - dense_15_loss: 0.0153 Epoch 20/50 40/40 - 3s - loss: 0.0184 - dense_13_loss: 0.0157 - dense_14_loss: 0.0308 - dense_15_loss: 0.0150 Epoch 21/50 40/40 - 3s - loss: 0.0184 - dense_13_loss: 0.0155 - dense_14_loss: 0.0310 - dense_15_loss: 0.0147 Epoch 22/50 40/40 - 3s - loss: 0.0182 - dense_13_loss: 0.0152 - dense_14_loss: 0.0305 - dense_15_loss: 0.0149 Epoch 23/50 40/40 - 3s - loss: 0.0178 - dense_13_loss: 0.0152 - dense_14_loss: 0.0299 - dense_15_loss: 0.0142 Epoch 24/50 40/40 - 3s - loss: 0.0177 - dense_13_loss: 0.0151 - dense_14_loss: 0.0299 - dense_15_loss: 0.0140 Epoch 25/50 40/40 - 3s - loss: 0.0174 - dense_13_loss: 0.0148 - dense_14_loss: 0.0293 - dense_15_loss: 0.0140 Epoch 26/50 40/40 - 3s - loss: 0.0180 - dense_13_loss: 0.0151 - dense_14_loss: 0.0305 - dense_15_loss: 0.0145 Epoch 27/50 40/40 - 3s - loss: 0.0174 - dense_13_loss: 0.0147 - dense_14_loss: 0.0294 - dense_15_loss: 0.0140 Epoch 28/50 40/40 - 3s - loss: 0.0173 - dense_13_loss: 0.0147 - dense_14_loss: 0.0293 - dense_15_loss: 0.0136 Epoch 29/50 40/40 - 3s - loss: 0.0172 - dense_13_loss: 0.0145 - dense_14_loss: 0.0292 - dense_15_loss: 0.0135 Epoch 30/50 40/40 - 3s - loss: 0.0171 - dense_13_loss: 0.0143 - dense_14_loss: 0.0294 - dense_15_loss: 0.0135 Epoch 31/50 40/40 - 3s - loss: 0.0170 - dense_13_loss: 0.0142 - dense_14_loss: 0.0288 - dense_15_loss: 0.0137 Epoch 32/50 40/40 - 3s - loss: 0.0171 - dense_13_loss: 0.0145 - dense_14_loss: 0.0291 - dense_15_loss: 0.0133 Epoch 33/50 40/40 - 3s - loss: 0.0171 - dense_13_loss: 0.0146 - dense_14_loss: 0.0293 - dense_15_loss: 0.0132 Epoch 34/50 40/40 - 3s - loss: 0.0167 - dense_13_loss: 0.0142 - dense_14_loss: 0.0285 - dense_15_loss: 0.0131 Epoch 35/50 40/40 - 3s - loss: 0.0169 - dense_13_loss: 0.0144 - dense_14_loss: 0.0287 - dense_15_loss: 0.0132 Epoch 36/50 40/40 - 3s - loss: 0.0169 - dense_13_loss: 0.0142 - dense_14_loss: 0.0288 - dense_15_loss: 0.0135 Epoch 37/50 40/40 - 3s - loss: 0.0168 - dense_13_loss: 0.0139 - dense_14_loss: 0.0287 - dense_15_loss: 0.0136 Epoch 38/50 40/40 - 3s - loss: 0.0170 - dense_13_loss: 0.0141 - dense_14_loss: 0.0288 - dense_15_loss: 0.0136 Epoch 39/50 40/40 - 3s - loss: 0.0169 - dense_13_loss: 0.0140 - dense_14_loss: 0.0288 - dense_15_loss: 0.0134 Epoch 40/50 40/40 - 3s - loss: 0.0167 - dense_13_loss: 0.0141 - dense_14_loss: 0.0283 - dense_15_loss: 0.0133 Epoch 41/50 40/40 - 3s - loss: 0.0171 - dense_13_loss: 0.0142 - dense_14_loss: 0.0296 - dense_15_loss: 0.0132 Epoch 42/50 40/40 - 3s - loss: 0.0166 - dense_13_loss: 0.0138 - dense_14_loss: 0.0284 - dense_15_loss: 0.0131 Epoch 43/50 40/40 - 3s - loss: 0.0167 - dense_13_loss: 0.0137 - dense_14_loss: 0.0286 - dense_15_loss: 0.0132 Epoch 44/50 40/40 - 3s - loss: 0.0167 - dense_13_loss: 0.0139 - dense_14_loss: 0.0284 - dense_15_loss: 0.0134 Epoch 45/50 40/40 - 3s - loss: 0.0169 - dense_13_loss: 0.0141 - dense_14_loss: 0.0289 - dense_15_loss: 0.0134 Epoch 46/50 40/40 - 3s - loss: 0.0169 - dense_13_loss: 0.0140 - dense_14_loss: 0.0288 - dense_15_loss: 0.0135 Epoch 47/50 40/40 - 3s - loss: 0.0165 - dense_13_loss: 0.0138 - dense_14_loss: 0.0284 - dense_15_loss: 0.0130 Epoch 48/50 40/40 - 3s - loss: 0.0167 - dense_13_loss: 0.0141 - dense_14_loss: 0.0286 - dense_15_loss: 0.0130 Epoch 49/50 40/40 - 3s - loss: 0.0166 - dense_13_loss: 0.0138 - dense_14_loss: 0.0285 - dense_15_loss: 0.0131 Epoch 50/50 40/40 - 3s - loss: 0.0168 - dense_13_loss: 0.0140 - dense_14_loss: 0.0286 - dense_15_loss: 0.0133 <tensorflow.python.keras.callbacks.History at 0x14bd0bc50> ## CROSSOVER PROBLEM When dealing with Neural Network in Keras, one of the tedious problem is the uncertainty of results due to the internal weigths initialization. With its formulation, our problem seems to particularly suffer of this kind of problem; i.e. computing quantile predictions we can’t permit quantiles overlapping, this not make sense! To avoid this pitfall I make use of bootstrapping in prediction phase: I reactivate dropout of my network (trainable: true in the model), iterate predition for 100 times, store them and finally calculate the desired quantiles (I make use of this clever technique also in this post). ```python ### QUANTILEs BOOTSTRAPPING ### pred_10, pred_50, pred_90 = [], [], [] for i in tqdm.tqdm(range(0,100)): predd = model.predict(X_test) pred_10.append(predd[0]) pred_50.append(predd[1]) pred_90.append(predd[2]) pred_10 = np.asarray(pred_10)[:,:,0] pred_50 = np.asarray(pred_50)[:,:,0] pred_90 = np.asarray(pred_90)[:,:,0] ``` 100%|██████████| 100/100 [02:43<00:00, 1.64s/it] This process is graphically explained below with a little focus on a subset of predictions. Given quantile bootstraps, we calculated summary measures (red lines) of them, avoiding crossover. ```python ### REVERSE TRANSFORM PREDICTIONS ### pred_90_m = np.exp(np.quantile(pred_90,0.9,axis=0) + init[5000:]) pred_50_m = np.exp(pred_50.mean(axis=0) + init[5000:]) pred_10_m = np.exp(np.quantile(pred_10,0.1,axis=0) + init[5000:]) ``` ```python ### EVALUATION METRIC ### mean_squared_log_error(np.exp(y_test + init[5000:]), pred_50_m) ``` 0.06907365954001285 ## RESULTS As I previously cited, I used the firstly 5000 observations for training and the remaining (around 5000) for testing. Our model reaches a great performance forecasting taxi demand with the 50th quantile. Around 0.055 Mean Squared Log Error is a brilliant result! This means that the LSTM Network is able to understand the underling rules that drive taxi demand. So our approach for anomaly detection sounds great… We computed the difference among the 90th quantile predictions and 10th quantile predictions and see what’s appened. ```python ### PLOT QUANTILE PREDICTIONS ### plt.figure(figsize=(16,8)) plt.plot(test_date, pred_90_m, color='cyan') plt.plot(test_date, pred_50_m, color='blue') plt.plot(test_date, pred_10_m, color='green') ### CROSSOVER CHECK ### plt.scatter(np.where(np.logical_or(pred_50_m>pred_90_m, pred_50_m<pred_10_m))[0], pred_50_m[np.logical_or(pred_50_m>pred_90_m, pred_50_m<pred_10_m)], c='red', s=50) ``` The quantile interval range (blue dots) is higher in period of uncertainty. In the other cases, the model tends to generalize well, as we expected. Going deeper, we start to investigate about these periods of high uncertainty. We noticed that these coincide with our initial assumptions. The orange circles plotted below are respectively: NYC marathon, Thanksgiving, Christmas, New Years day, and a snow storm. ```python ### PLOT UNCERTAINTY INTERVAL LENGHT WITH REAL DATA ### plt.figure(figsize=(16,8)) plt.plot(test_date, np.exp(y_test + init[5000:]), color='red', alpha=0.4) plt.scatter(test_date, pred_90_m - pred_10_m) ``` We can conclude that we reach our initial targets: achive a great forecating power and exploit the strength of our model to identificate uncertainty. We also make use of this to say something about anomalies detection. ## SUMMARY Wereproduce a good solution for anomaly detection and forecasting. We make use of a LSTM Network to learn the behaviour of taxi demand in NYC. We utilized what we learned to make predition and estimate uncertainty at the same time. We implicitly define an anomaly as an unpredictable observation — i.e. with a great amout of uncertainty. This simple assumption permits to our LSTM to make all the work for us.

a3ef2227b3f473ac04f3771bce6927d07a372ba4

ipynb

Jupyter Notebook

misc/Anomaly-Detection-LSTM.ipynb

OleBo/Stock-Prediction-Models

3abd726d57b5d588d560c6a27db19b589cdae52f

misc/Anomaly-Detection-LSTM.ipynb

OleBo/Stock-Prediction-Models

3abd726d57b5d588d560c6a27db19b589cdae52f

misc/Anomaly-Detection-LSTM.ipynb

OleBo/Stock-Prediction-Models

3abd726d57b5d588d560c6a27db19b589cdae52f

2020-03-27T15:25:41.000Z

2020-12-17T10:51:15.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# Euler angle worksheet This is a [jupyter notebook](https://jupyter.org/). Jupyter Notebooks allows you to combine notes, code, and output into a single document. You can even export your document as a presentation or presentation. In this worksheet, we will use the python3 SymPy package to derive expressions for converting between euler angles and matrices. If you would like more information about jupyter notebook features: * [Getting started tutorial](https://realpython.com/jupyter-notebook-introduction/#creating-a-notebook) * [Reference on markdown text](https://help.github.com/articles/markdown-basics/) For this assignment, you do not need to run this notebook. It has been compiled for you and saved as a webpage. However, if you would like to play with it, start by running all the cells (from the menu: goto 'Cell' -> 'Run All'). ```python # python3 from sympy import * init_printing(use_latex='mathjax') import math ``` ```python # Define symbols cx,sx = symbols('cx sx') cy,sy = symbols('cy sy') cz,sz = symbols('cz sz') Rx = Matrix([ [1, 0, 0], [0, cx,-sx], [0, sx, cx]]) Ry = Matrix([ [ cy, 0, sy], [ 0, 1, 0], [-sy, 0, cy]]) Rz = Matrix([ [cz, -sz, 0], [sz, cz, 0], [0, 0, 1]]) ``` # Convert from ZYX euler angles to a matrix We can compute the matrix Rzyx by multiplying matrixes corresponding to each consecutive rotation, e.g. $$ R_{zyx}(\theta_x, \theta_y, \theta_z) = R_z(\theta_z) * R_y(\theta_y) * R_x(\theta_x) $$ In this file, we will use the [SymPy](https://www.sympy.org/en/index.html) to compute algebraic expressions for euler angle matrices. Using these expressions, we will be able to derive formulas for converting from matrices to euler angles. In the following example, let * cx = $cos(\theta_x)$ * sx = $sin(\theta_x)$ * cy = $cos(\theta_y)$ * sy = $sin(\theta_y)$ * cz = $cos(\theta_z)$ * sz = $sin(\theta_z)$ ```python Rzyx = Rz * Ry * Rx pprint(Rzyx) ``` ⎡cy⋅cz -cx⋅sz + cz⋅sx⋅sy cx⋅cz⋅sy + sx⋅sz⎤ ⎢ ⎥ ⎢cy⋅sz cx⋅cz + sx⋅sy⋅sz cx⋅sy⋅sz - cz⋅sx⎥ ⎢ ⎥ ⎣ -sy cy⋅sx cx⋅cy ⎦ Now that we have a matrix expression for the ZYX euler angles, we have formulas which describe how matrices and euler angles relate to each. Specifically, suppose we have a 3x3 rotation matrix R with the following elements $$ R = \begin{bmatrix} r_{00} & r_{01} & r_{02} \\ r_{10} & r_{11} & r_{12} \\ r_{20} & r_{21} & r_{22} \\ \end{bmatrix} $$ where each $r_{ij}$ represents a scalar value in $\mathbb{R}$. Usually math texts will use indexing at 1, but here let's use 0-based indexing so that it will be easier to use implement these formulas later. Now suppose we wish to extract the euler angles from this matrix. We can get the Y rotation back from the term $r_{20}$. $$ r_{20} = -\sin(\theta_y) \\ => \theta_y = \sin(-r_{20}) $$ What about the rotations around X and Z? We can obtain these similarly using the terms from the first column and last row. A robust method involves using the fact that $$ \tan(\theta) = \frac{\sin(\theta)}{\cos(\theta)} $$ to form the following expression for obtaining $\theta_x$ $$ \frac{r_{21}}{r_{22}} = \frac{\sin(\theta_x)}{\cos(\theta_x)} = \tan(\theta_x) \\ => \theta_x = \text{atan2}(r_{21}, r_{22}) $$ The expression for $\theta_z$ can be obtained similarly $$ \frac{r_{10}}{r_{00}} = \frac{\sin(\theta_z)}{\cos(\theta_z)} = \tan(\theta_z) \\ => \theta_z = \text{atan2}(r_{10}, r_{00}) $$ Using atan2 makes it easier to handle the cases when $\theta$ is near 0, 90, or 180 degrees, which makes sine and cosine close to zero and 1. Be careful when using acos and asin because values even *slightly* out of the range [-1,1] can lead to NaNs. The computer will not tolerate nansense! ## What happens to Rzyx when y is +/- 90 degrees? When the middle euler angle is 90 degrees, we need to look to the non-zero terms to values for the first and last angles. For example, for ZYX euler angles, we need to handle the case when Y is either positive or negative 90 degrees. ```python # Compute Rzyx when y is +90 Ry90 = Matrix([ [ 0, 0, 1], [ 0, 1, 0], [-1, 0, 0]]) Rzyx = Rz * Ry90 * Rx pprint(Rzyx) ``` ⎡0 -cx⋅sz + cz⋅sx cx⋅cz + sx⋅sz⎤ ⎢ ⎥ ⎢0 cx⋅cz + sx⋅sz cx⋅sz - cz⋅sx⎥ ⎢ ⎥ ⎣-1 0 0 ⎦ So now we have the above expression. We know that the Y rotation is 90 but what about the X and Z rotations? We need to look at the upper part of the matrix to figure these out. Let's apply the sine and cosine [addition rules](https://en.wikipedia.org/wiki/List_of_trigonometric_identities) $$ \sin(z + x) = \sin(z) \cos(x) + \cos(z) \sin(x) \\ \sin(z - x) = \sin(z) \cos(x) - \cos(z) \sin(x) \\ \cos(z + x) = \cos(z) \cos(x) - \sin(z) \sin(x) \\ \cos(z - x) = \cos(z) \cos(x) + \sin(z) \sin(x) \\ $$ Another useful property of sine and cosine is the following $$ \sin(-\theta) = -\sin(\theta) \\ \cos(-\theta) = \cos(\theta) $$ Let's try to simplify the above matrix using these rules. For example, the term in position $r_{12}$ has two terms containing both sine and cosine, so it corresponds to one of the sine rules. It also has a negative, so its the difference between two angles X and Z. $$ \begin{bmatrix} 0 & s(x-z) & c(x-z) \\ 0 & c(x-z) & s(z-x) \\ -1 & 0 & 0 \end{bmatrix} $$ which can be rewritten so every term has angle $x-z$ $$ \begin{bmatrix} 0 & s(x-z) & c(x-z) \\ 0 & c(x-z) & -s(x-z) \\ -1 & 0 & 0 \end{bmatrix} $$ Therefore, we can use atan2($r_{12}$, $r_{13}$) to get the $\theta$ angle corresponding to the difference between $x-z$. Many values for X and Z could combine to be $\theta$. Let's choose one of X or Z to be zero and then the other can be $\theta$. ```python # Compute Rzyx when y is -90 Ry90_Minus = Ry90.T Rzyx = Rz * Ry90_Minus * Rx pprint(Rzyx) ``` ⎡0 -cx⋅sz - cz⋅sx -cx⋅cz + sx⋅sz⎤ ⎢ ⎥ ⎢0 cx⋅cz - sx⋅sz -cx⋅sz - cz⋅sx⎥ ⎢ ⎥ ⎣1 0 0 ⎦ $$ \begin{bmatrix} 0 & -s(x+z) & c(x+z) \\ 0 & c(z+x) & -s(x+z) \\ 1 & 0 & 0 \end{bmatrix} $$ # Convert from all euler angles to a matrix The other five euler angle combinations can be derived similarly. # XYZ ```python print("Rxyz") pprint(Rx * Ry * Rz) print() print() print("Y = 90") pprint(Rx * Ry90 * Rz) print() print() print("Y = -90") pprint(Rx * Ry90_Minus * Rz) print() print() ``` Rxyz ⎡ cy⋅cz -cy⋅sz sy ⎤ ⎢ ⎥ ⎢cx⋅sz + cz⋅sx⋅sy cx⋅cz - sx⋅sy⋅sz -cy⋅sx⎥ ⎢ ⎥ ⎣-cx⋅cz⋅sy + sx⋅sz cx⋅sy⋅sz + cz⋅sx cx⋅cy ⎦ Y = 90 ⎡ 0 0 1⎤ ⎢ ⎥ ⎢cx⋅sz + cz⋅sx cx⋅cz - sx⋅sz 0⎥ ⎢ ⎥ ⎣-cx⋅cz + sx⋅sz cx⋅sz + cz⋅sx 0⎦ Y = -90 ⎡ 0 0 -1⎤ ⎢ ⎥ ⎢cx⋅sz - cz⋅sx cx⋅cz + sx⋅sz 0 ⎥ ⎢ ⎥ ⎣cx⋅cz + sx⋅sz -cx⋅sz + cz⋅sx 0 ⎦ Y = 90 $$ \begin{bmatrix} 0 & 0 & 1 \\ s(x+z) & c(x+z) & 0\\ -c(x+z) & s(x+z) & 0 \\ \end{bmatrix} $$ Y = -90 $$ \begin{bmatrix} 0 & 0 & -1 \\ s(z-x) & c(z-x) & 0 \\ c(z-x) & -s(z-x) & 0 \\ \end{bmatrix} $$ # YXZ ```python print("Ryxz") pprint(Ry * Rx * Rz) print() print() Rx90 = Matrix([ [1, 0, 0], [0, 0,-1], [0, 1, 0]]) print("+90") pprint(Ry * Rx90 * Rz) print() print() Rx90_Minus = Rx90.T print("-90") pprint(Ry * Rx90.T * Rz) print() print() ``` Ryxz ⎡cy⋅cz + sx⋅sy⋅sz -cy⋅sz + cz⋅sx⋅sy cx⋅sy⎤ ⎢ ⎥ ⎢ cx⋅sz cx⋅cz -sx ⎥ ⎢ ⎥ ⎣cy⋅sx⋅sz - cz⋅sy cy⋅cz⋅sx + sy⋅sz cx⋅cy⎦ +90 ⎡cy⋅cz + sy⋅sz -cy⋅sz + cz⋅sy 0 ⎤ ⎢ ⎥ ⎢ 0 0 -1⎥ ⎢ ⎥ ⎣cy⋅sz - cz⋅sy cy⋅cz + sy⋅sz 0 ⎦ -90 ⎡cy⋅cz - sy⋅sz -cy⋅sz - cz⋅sy 0⎤ ⎢ ⎥ ⎢ 0 0 1⎥ ⎢ ⎥ ⎣-cy⋅sz - cz⋅sy -cy⋅cz + sy⋅sz 0⎦ X = 90 $$ \begin{bmatrix} c(y-z) & s(y-z) & 0\\ 0 & 0 & -1 \\ -s(y-z) & c(y-z) & 0 \\ \end{bmatrix} $$ X = -90 $$ \begin{bmatrix} c(y+z) & -s(y+z) & 0 \\ 0 & 0 & 1 \\ -s(y+z) & -c(y+z) & 0 \\ \end{bmatrix} $$ # ZXY ```python print("Rzxy") pprint(Rz * Rx * Ry) print() print() print("+90") pprint(Rz * Rx90 * Ry) print() print() print("-90") pprint(Rz * Rx90.T * Ry) print() print() ``` Rzxy ⎡cy⋅cz - sx⋅sy⋅sz -cx⋅sz cy⋅sx⋅sz + cz⋅sy ⎤ ⎢ ⎥ ⎢cy⋅sz + cz⋅sx⋅sy cx⋅cz -cy⋅cz⋅sx + sy⋅sz⎥ ⎢ ⎥ ⎣ -cx⋅sy sx cx⋅cy ⎦ +90 ⎡cy⋅cz - sy⋅sz 0 cy⋅sz + cz⋅sy ⎤ ⎢ ⎥ ⎢cy⋅sz + cz⋅sy 0 -cy⋅cz + sy⋅sz⎥ ⎢ ⎥ ⎣ 0 1 0 ⎦ -90 ⎡cy⋅cz + sy⋅sz 0 -cy⋅sz + cz⋅sy⎤ ⎢ ⎥ ⎢cy⋅sz - cz⋅sy 0 cy⋅cz + sy⋅sz ⎥ ⎢ ⎥ ⎣ 0 -1 0 ⎦ X = 90 $$ \begin{bmatrix} c(y+z) & 0 & s(y+z) \\ s(y+z) & 0 & -c(y+z) \\ 0 & 1 & 0 \\ \end{bmatrix} $$ X = -90 $$ \begin{bmatrix} c(y-z) & 0 & s(y-z) \\ -s(y-z) & 0 & c(y-z) \\ 0 & -1 & 0 \\ \end{bmatrix} $$ # XZY ```python print("Rxzy") pprint(Rx * Rz * Ry) print() print() Rz90 = Matrix([ [0, -1, 0], [1, 0, 0], [0, 0, 1]]) print("+90") pprint(Rx * Rz90 * Ry) print() print() print("-90") pprint(Rx * Rz90.T * Ry) print() print() ``` Rxzy ⎡ cy⋅cz -sz cz⋅sy ⎤ ⎢ ⎥ ⎢cx⋅cy⋅sz + sx⋅sy cx⋅cz cx⋅sy⋅sz - cy⋅sx⎥ ⎢ ⎥ ⎣-cx⋅sy + cy⋅sx⋅sz cz⋅sx cx⋅cy + sx⋅sy⋅sz⎦ +90 ⎡ 0 -1 0 ⎤ ⎢ ⎥ ⎢cx⋅cy + sx⋅sy 0 cx⋅sy - cy⋅sx⎥ ⎢ ⎥ ⎣-cx⋅sy + cy⋅sx 0 cx⋅cy + sx⋅sy⎦ -90 ⎡ 0 1 0 ⎤ ⎢ ⎥ ⎢-cx⋅cy + sx⋅sy 0 -cx⋅sy - cy⋅sx⎥ ⎢ ⎥ ⎣-cx⋅sy - cy⋅sx 0 cx⋅cy - sx⋅sy ⎦ Z = 90 $$ \begin{bmatrix} 0 & -1 & 0 \\ c(x-y) & 0 & -s(x-y) \\ s(x-y) & 0 & c(x-y) \\ \end{bmatrix} $$ Z = -90 $$ \begin{bmatrix} 0 & 1 & 0 \\ -c(x+y) & 0 & -s(x+y) \\ -s(x+y) & 0 & c(x+y) \\ \end{bmatrix} $$ # YZX ```python print("Ryzx") pprint(Ry * Rz * Rx) print() print() print("+90") pprint(Ry * Rz90 * Rx) print() print() print("-90") pprint(Ry * Rz90.T * Rx) print() print() ``` Ryzx ⎡cy⋅cz -cx⋅cy⋅sz + sx⋅sy cx⋅sy + cy⋅sx⋅sz⎤ ⎢ ⎥ ⎢ sz cx⋅cz -cz⋅sx ⎥ ⎢ ⎥ ⎣-cz⋅sy cx⋅sy⋅sz + cy⋅sx cx⋅cy - sx⋅sy⋅sz⎦ +90 ⎡0 -cx⋅cy + sx⋅sy cx⋅sy + cy⋅sx⎤ ⎢ ⎥ ⎢1 0 0 ⎥ ⎢ ⎥ ⎣0 cx⋅sy + cy⋅sx cx⋅cy - sx⋅sy⎦ -90 ⎡0 cx⋅cy + sx⋅sy cx⋅sy - cy⋅sx⎤ ⎢ ⎥ ⎢-1 0 0 ⎥ ⎢ ⎥ ⎣0 -cx⋅sy + cy⋅sx cx⋅cy + sx⋅sy⎦ Z = 90 $$ \begin{bmatrix} 0 & c(x-y) & -s(x-y) \\ 1 & 0 & 0 \\ 0 & s(x-y) & c(x-y) \\ \end{bmatrix} $$ Z = -90 $$ \begin{bmatrix} 0 & c(y-x) & s(y-x) \\ -1 & 0 & 0 \\ 0 & -s(y-x) & c(y-x) \\ \end{bmatrix} $$

e6851d2a32d1cee8e3520944e094d933b8bfb427

ipynb

Jupyter Notebook

Labs/EulerAngles.ipynb

isaacwasserman/website

c052e1e8b28b9a600623589768691585eeda774d

Labs/EulerAngles.ipynb

isaacwasserman/website

c052e1e8b28b9a600623589768691585eeda774d

Labs/EulerAngles.ipynb

isaacwasserman/website

c052e1e8b28b9a600623589768691585eeda774d

2021-09-28T20:41:54.000Z

2021-09-28T20:41:54.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# 逆行列を求める方法 - `np.linalg` に `inv` という関数がある ```python import numpy as np ``` ```python a = np.array([[3, 1, 1], [1, 2, 1], [0, -1, 1]]) ``` ```python np.linalg.inv(a) ``` array([[ 0.42857143, -0.28571429, -0.14285714], [-0.14285714, 0.42857143, -0.28571429], [-0.14285714, 0.42857143, 0.71428571]]) # ひとつの連立方程式を解く方法 下記の連立方程式を解くには逆行列を求めるよりも `solve` 関数を使うほうが良い。(高速かつ数値安定的なアルゴリズムを背後で利用しているため) \begin{equation} \begin{pmatrix} 3& 1& 1\\ 1& 2& 1\\ 0& -1& 1 \end{pmatrix} \begin{pmatrix} x \\ y\\ z \end{pmatrix} = \begin{pmatrix} 1 \\ 2 \\ 3 \end{pmatrix} \end{equation} ```python b = np.array([[3, 1, 1], [1, 2, 1], [0, -1, 1]]) ``` ```python c = np.array([1, 2, 3]) ``` ```python np.linalg.solve(b, c) ``` array([-0.57142857, -0.14285714, 2.85714286]) # 同じ係数行列からなく複数の連立方程式を解く方法 \begin{equation} Ax=b_1, Ax=b_2, \dots, Ax=b_m \end{equation} となる連立方程式があったときは、 $A^{-1}$ を計算することで、 \begin{equation} A^{-1}b_1, A^{-1}b_2, \dots, A^{-1}b_m \end{equation} と解が計算できる。しかし、もっと良い方法がある。 ## LU分解 $A=PLU$ の形に分解することで連立方程式を高速かつ数値安定的に解くことができる。 ここで $L$ は下三角行列で対角成分が $1$ となるもの、 $U$ は上三角行列、 $P$ は各行に $1$ となる成分がただひとつだけある行列でそのほかの成分は $0$(置換行列) \begin{equation} PLUx = b \end{equation} という連立方程式は次の3つの方程式を逐次的に解くことで解 $x$ を求めることができる。 \begin{align} Uz &= b \\ Ly &= z \\ Px &= y \end{align} ```python # scipy を利用 from scipy import linalg ``` ```python a = np.array([[3, 1, 1], [1, 2, 1], [0, -1, 1]]) b = np.array([1, 2, 3]) ``` ```python lu, p = linalg.lu_factor(a) linalg.lu_solve((lu, p), b) ``` array([-0.57142857, -0.14285714, 2.85714286]) ```python ```

3c7d876a06b6931b103f45efa16f6673a3092cdc

ipynb

Jupyter Notebook

notebooks/linear_equations.ipynb

515hikaru/essence-of-machine-learning

7f46be9316d227626f27a06deac64b43191cb4d7

notebooks/linear_equations.ipynb

515hikaru/essence-of-machine-learning

7f46be9316d227626f27a06deac64b43191cb4d7

2018-10-04T14:33:15.000Z

2018-10-09T13:40:35.000Z

notebooks/linear_equations.ipynb

515hikaru/essence-of-machine-learning

7f46be9316d227626f27a06deac64b43191cb4d7

Qwen/Qwen-72B

1. YES 2. YES

__label__yue_Hant

# Matérn Spectral Mixture (MSM) kernel ## Gaussian process priors for pitch detection in polyphonic music ### Learning kernels in frequency domain #### Written by Pablo A. Alvarado, Centre for Digital Music, Queen Mary University of London. *Last updated Friday, 12 May 2017.* The aim of this notebook is to ilustrate the approach proposed in (link) for pitch detection in polyphonic signals, applying Gaussian processes (GPs) models in Python using [GPflow](https://github.com/GPflow/GPflow). We first outline the mathematical formulation of the proposed model. Then we introduce how to learn hyperparameters in frequency domain. Finally we present an example for detecting two pitches in a polyphonic music signal. The dataset used in this tutorial corresponds to the electric guitar mixture signal in http://winnie.kuis.kyoto-u.ac.jp/~yoshii/psdtf/. The first 4 seconds of the data were used for training, this segment corresponds to 2 isolated sound events, with pitch C4 and E4 respectively. The test data was made of three sound events with pitches C4, E4, C4+E4, i.e. the training data in addition to an event with both pitches. ## GP additive model for pitch detection Automatic music transcription aims to infer a symbolic representation, such as piano-roll or score, given an observed audio recording. From a Bayesian latent variable perspective, transcription consists in updating our beliefs about the symbolic description for a certain piece of music, after observing a corresponding audio recording. We approach the transcription problem from a time-domain source separation perspective. That is, given an audio recording $\mathcal{D}=\left\lbrace y_n, t_n \right\rbrace_{n=1}^{N}$, we seek to formulate a generative probabilistic model that describes how the observed polyphonic signal (mixture of sources) was generated and, moreover, that allows us to infer the latent variables associated with the piano-roll representation. To do so, we use the regression model \begin{align} y_n = f(t_n) + \epsilon, \end{align} where $y_n$ is the value of the analysed polyphonic signal at time $t_n$, the noise follows a normal distribution $\epsilon \sim \mathcal{N}(0,\sigma^2)$, and the function $f(t)$ is a random process composed by a linear combination of $M$ sources $\left\lbrace f_m(t) \right\rbrace _{m=1}^{M} $, that is \begin{align} f(t) = \sum_{m=1}^{M} f_{m}(t). \end{align} Each source is decomposed into the product of two factors, an amplitude-envelope or activation function $\phi_m(t)$, and a quasi-periodic or component function $w_{m}(t)$. The overall model is then \begin{align} y(t) = \sum_{m=1}^{M} \phi_{m}(t) w_{m}(t) + \epsilon. \end{align} We can interpret the set $\left\lbrace w_{m}(t)\right\rbrace_{m=1}^{M}$ as a dictionary where each component $ w_{m}(t)$ is a quasi-periodic stochastic function with a defined pitch. Likewise, each stochastic function in $\left\lbrace \phi_{m}(t)\right\rbrace_{m=1}^{M}$ represents a row of the piano roll-matrix, i.e the time dependent non-negative activation of a specific pitch throughout the analysed piece of music. Components $\left\lbrace w_{m}(t)\right\rbrace_{m=1}^{M}$ follow \begin{align} w_m(t) \sim \mathcal{GP}(0,k_m(t,t')), \end{align} where the covariance $k_m(t,t')$ reflect the frequency content of the $m^{\text{th}}$ component, and has the form of a Matérn spectral mixture (MSM) kernel. To guarantee the activations to be non-negative we apply non-linear transformations to GPs. To do so, we use the sigmoid function \begin{align} \sigma(x) = \left[ 1 + \exp(-x) \right]^{-1}, \end{align} Then, activations are defined as \begin{align*} \phi_m(t) = \sigma( {g_{m}(t)} ), \end{align*} where $ \left\lbrace g_{m}(t)\right\rbrace_{m=1}^{M} $ are GPs. The sigmoid model follows \begin{align} y(t)= \sum_{m = 1}^{M} \sigma( {g_{m}(t)} ) \ w_{m}(t) + \epsilon. \end{align} ## Learning hyperparameters in frequency domain In this section we describe how to learn the hyperparameters for the components $\left\lbrace w_{m}(t)\right\rbrace_{m=1}^{M}$, and the activations $\left\lbrace g_{m}(t)\right\rbrace_{m=1}^{M}$. ```python %matplotlib inline ``` ```python import matplotlib.pyplot as plt plt.style.use('ggplot') plt.rcParams['figure.figsize'] = (16, 4) import numpy as np import scipy as sp import scipy.io as sio import scipy.io.wavfile as wav from scipy import signal from scipy.fftpack import fft import gpflow import GPitch ``` ```python sf, y = wav.read('guitar.wav') #loading dataset y = y.astype(np.float64) yaudio = y / np.max(np.abs(y)) N = np.size(yaudio) Xaudio = np.linspace(0, (N-1.)/sf, N) X1, y1 = Xaudio[0:2*sf], yaudio[0:2*sf] # define training data for component 1 and 2 X2, y2 = Xaudio[2*sf:4*sf], yaudio[2*sf:4*sf] y1f, y2f = sp.fftpack.fft(y1), sp.fftpack.fft(y2) # get spectral density for each isolated sound event N1 = y1.size # Number of sample points T = 1.0 / sf # sample period F = np.linspace(0.0, 1.0/(2.0*T), N1/2) S1 = 2.0/N1 * np.abs(y1f[0:N1/2]) S2 = 2.0/N1 * np.abs(y2f[0:N1/2]) ``` ```python plt.figure() plt.subplot(1,2,1), plt.title('Waveform sound event with pitch C4'), plt.xlabel('Time (s)'), plt.plot(X1, y1), plt.subplot(1,2,2), plt.title('Waveform sound event with pitch E4'), plt.xlabel('Time (s)'), plt.plot(X2, y2) plt.figure() plt.subplot(1,2,1), plt.title('Spectral density sound event with pitch C4'), plt.xlabel('Frequency (Hz)'), plt.plot(F, S1, lw=2), plt.xlim([0, 5000]) plt.subplot(1,2,2), plt.title('Spectral density sound event with pitch E4'), plt.xlabel('Frequency (Hz)'), plt.plot(F, S2, lw=2), plt.xlim([0, 5000]); ``` ### Learning frequency content of each component process $\left\lbrace w_{m}(t)\right\rbrace_{m=1}^{M}$ #### Example fitting one frequency component ```python # example fitting one harmonic idx = np.argmax(S1) a, b = idx - 50, idx + 50 X, y = F[a: b,].reshape(-1,), S1[a: b,].reshape(-1,) p0 = np.array([1., 1., 2*np.pi*F[idx]]) phat = sp.optimize.minimize(GPitch.Lloss, p0, method='L-BFGS-B', args=(X, y), tol = 1e-10, options={'disp': True}) pstar = phat.x Xaux = np.linspace(X.min(), X.max(), 1000) L = GPitch.Lorentzian(pstar,Xaux) plt.figure(), plt.xlim([X.min(), X.max()]) plt.plot(Xaux, L, lw=2) plt.plot(X, y, '.', ms=8); ``` ```python Nh = 15 # maximun number of harmonics s_1, l_1, f_1 = GPitch.learnparams(F, S1, Nh) Nh1 = s_1.size s_2, l_2, f_2 = GPitch.learnparams(F, S2, Nh) Nh2 = s_2.size ``` ```python plt.figure() for i in range(0, Nh1): idx = np.argmin(np.abs(F - f_1[i])) a = idx - 50 b = idx + 50 pstar = np.array([s_1[i], 1./l_1[i], 2.*np.pi*f_1[i]]) learntfun = GPitch.Lorentzian(pstar, F) plt.subplot(1,Nh,i+1) plt.plot(F[a:b],learntfun[a:b],'', lw = 2) plt.plot(F[a:b],S1[a:b],'.', ms = 3) plt.axis('off') plt.ylim([S1.min(), S1.max()]) plt.figure() for i in range(0, Nh2): idx = np.argmin(np.abs(F - f_2[i])) a = idx - 50 b = idx + 50 pstar = np.array([s_2[i], 1./l_2[i], 2.*np.pi*f_2[i]]) learntfun = GPitch.Lorentzian(pstar, F) plt.subplot(1,Nh,i+1) plt.plot(F[a:b],learntfun[a:b],'', lw = 2) plt.plot(F[a:b],S2[a:b],'.', ms = 3) plt.axis('off') plt.ylim([S2.min(), S2.max()]) ``` ```python S1k = GPitch.LorM(F, s=s_1, l=1./l_1, f=2*np.pi*f_1) S2k = GPitch.LorM(F, s=s_2, l=1./l_2, f=2*np.pi*f_2) plt.figure(), plt.title('Approximate spectrum using Lorentzian mixture') plt.subplot(1,2,1), plt.plot(F, S1, lw=2), plt.plot(F, S1k, lw=2) plt.legend(['FT source 1', 'S kernel 1']), plt.xlabel('Frequency (Hz)') plt.subplot(1,2,2), plt.plot(F, S2, lw=2), plt.plot(F, S2k, lw=2) plt.legend(['FT source 2', 'S kernel 2']), plt.xlabel('Frequency (Hz)'); ``` ```python Xk = np.linspace(-1.,1.,2*16000).reshape(-1,1) IFT_y1 = np.fft.ifft(np.abs(y1f)) IFT_y2 = np.fft.ifft(np.abs(y2f)) k1 = GPitch.MaternSM(Xk, s=s_1, l=1./l_1, f=2*np.pi*f_1) k2 = GPitch.MaternSM(Xk, s=s_2, l=1./l_2, f=2*np.pi*f_2) plt.figure() plt.subplot(1,2,1), plt.plot(Xk, k1, lw=2), plt.xlim([-0.005, 0.005]) plt.subplot(1,2,2), plt.plot(Xk, k2, lw=2), plt.xlim([-0.005, 0.005]) plt.figure() plt.subplot(1,2,1), plt.plot(Xk, k1) plt.subplot(1,2,2), plt.plot(Xk, k2) plt.figure(), plt.subplot(1,2,1), plt.plot(X1[0:16000],IFT_y1[0:16000], lw=1), plt.plot(X1[0:16000],k1[16000:32000], lw=1) plt.xlim([0, 0.03]) plt.subplot(1,2,2), plt.plot(X1[0:16000],IFT_y2[0:16000], lw=1), plt.plot(X1[0:16000],k2[16000:32000], lw=1) plt.xlim([0, 0.03]); ``` ### Learning hyperparameters of activation processes $\left\lbrace \phi_{m}(t)\right\rbrace_{m=1}^{M}$ So far we have learnt the harmoninc content of the isolated events. Now we try to learn the parameters of the GP that describes the amplitude envelope. ```python win = signal.hann(200) env1 = signal.convolve(np.abs(y1), win, mode='same') / sum(win) env1 = np.max(np.abs(y1))*(env1 / np.max(env1)) env1 = env1.reshape(-1,) env2 = signal.convolve(np.abs(y2), win, mode='same') / sum(win) env2 = np.max(np.abs(y2))*(env2 / np.max(env2)) env2 = env2.reshape(-1,) plt.figure() plt.subplot(1,2,1), plt.plot(X1, y1, ''), plt.plot(X1, env1, '', lw = 2) plt.subplot(1,2,2), plt.plot(X2, y2, ''), plt.plot(X2, env2, '', lw = 2); ``` ```python yf = fft(env1) xf = np.linspace(-1.0/(2.0*T), 1.0/(2.0*T), N1) S = 1.0/N1 * np.abs(yf) sht = np.fft.fftshift(S) a = np.argmin(np.abs(xf - (-10.))) b = np.argmin(np.abs(xf - ( 10.))) X, y = xf[a:b].reshape(-1,), sht[a:b].reshape(-1,) p0 = np.array([1., 1., 0.]) phat = sp.optimize.minimize(GPitch.Lloss, p0, method='L-BFGS-B', args=(X, y), tol = 1e-10, options={'disp': True}) X2 = np.linspace(X.min(), X.max(), 1000) L = GPitch.Lorentzian(phat.x, X2) plt.figure() plt.subplot(1,2,1), plt.plot(X2, L), plt.plot(X, y, '.', ms=8) plt.subplot(1,2,2), plt.plot(X2, L), plt.plot(X, y, '.', ms=8) s_env, l_env, f_env = np.hsplit(phat.x, 3) ``` # Using the learnt MSM kernel for pitch detection We keep the same form for the learnt variances $\sigma^{2}$, but we modify the lengthscale because we learnt the inverse, i.e. $l = \lambda^{-1}$. Also, we learnt the frequency vector in radians, that is why we convert it to Hz. ```python # To run the pitch detection change: RunExperiment = True RunExperiment = False if RunExperiment == True: GPitch.pitch('guitar.wav', windowsize=16000) else: results = np.load('SIG_FL_results.npz') X = results['X'] g1 = results['mu_g1'] g2 = results['mu_g2'] phi1 = GPitch.logistic(g1) phi2 = GPitch.logistic(g2) w1 = results['mu_f1'] w2 = results['mu_f2'] f1 = phi1*w1 f2 = phi2*w2 Xtest1, ytest1 = Xaudio[0:4*sf], yaudio[0:4*sf] Xtest2, ytest2 = Xaudio[6*sf:8*sf], yaudio[6*sf:8*sf] Xtest = np.hstack((Xtest1, Xtest2)).reshape(-1,1) ytest = np.hstack((ytest1, ytest2)).reshape(-1,1) sf, sourceC = wav.read('source_C.wav') sourceC = sourceC.astype(np.float64) sourceC = sourceC / np.max(np.abs(sourceC)) sf, sourceE = wav.read('source_E.wav') sourceE = sourceE.astype(np.float64) sourceE = sourceE / np.max(np.abs(sourceE)) plt.figure() plt.plot(Xtest, ytest) ``` ```python plt.figure() plt.subplot(1,2,1), plt.plot(Xaudio, sourceC) plt.xlim([X.min(), X.max()]) plt.subplot(1,2,2), plt.plot(Xaudio, sourceE) plt.xlim([X.min(), X.max()]) plt.figure() plt.subplot(1,2,1), plt.plot(X, f1) plt.subplot(1,2,2), plt.plot(X, f2) plt.figure() plt.subplot(1,2,1), plt.plot(X, phi1) plt.subplot(1,2,2), plt.plot(X, phi2) plt.figure() plt.subplot(1,2,1), plt.plot(X, w1) plt.subplot(1,2,2), plt.plot(X, w2) ``` ## Piano-roll ```python #%% genetare piano-roll ground truth jump = 100 #downsample Xsubset = X[::jump] oct1 = 24 oct2 = 84 Y = np.arange(oct1,oct2).reshape(-1,1) Ns = Xsubset.size Phi = np.zeros((Y.size, Ns)) #Phi[47-oct1, (Xsubset> 0.050 and Xsubset< 1.973)] = 1. C4_a1 = np.argmin(np.abs(Xsubset-0.050)) C4_b1 = np.argmin(np.abs(Xsubset-1.973)) C4_a2 = np.argmin(np.abs(Xsubset-6.050)) C4_b2 = np.argmin(np.abs(Xsubset-7.979)) Phi[47-oct1, C4_a1:C4_b1 ] = 1. Phi[47-oct1, C4_a2:C4_b2 ] = 1. Phi[47-oct1, C4_a3:C4_b3 ] = 1. Phi[47-oct1, C4_a4:C4_b4 ] = 1. E4_a1 = np.argmin(np.abs(Xsubset-2.050)) E4_b1 = np.argmin(np.abs(Xsubset-3.979)) E4_a2 = np.argmin(np.abs(Xsubset-6.050)) E4_b2 = np.argmin(np.abs(Xsubset-7.979)) Phi[51-oct1, E4_a1:E4_b1 ] = 1. Phi[51-oct1, E4_a2:E4_b2 ] = 1. Phi[51-oct1, E4_a3:E4_b3 ] = 1. Phi[51-oct1, E4_a4:E4_b4 ] = 1. Phi = np.abs(Phi-1) [Xm, Ym] = np.meshgrid(Xsubset,Y) #infered piano roll Phi_i = np.zeros((Y.size, Ns)) Phi_i[47-oct1, :] = phi1[::jump].reshape(-1,) Phi_i[51-oct1, :] = phi2[::jump].reshape(-1,) Phi_i = np.abs(Phi_i-1) ``` ```python plt.figure() plt.ylabel('') plt.xlabel('Time (s)') plt.pcolormesh(Xm, Ym, Phi, cmap='gray') plt.ylim([oct1, oct2]) plt.xlim([0, 8]) plt.xlabel('Time (seconds)') plt.figure() plt.ylabel('') plt.xlabel('Time (s)') plt.pcolormesh(Xm, Ym, Phi_i, cmap='gray') plt.ylim([oct1, oct2]) plt.xlim([0, 8]) plt.xlabel('Time (seconds)') ```

ec4ec47787a11f33be7f9b33cdd5982e2033c3be

ipynb

Jupyter Notebook

demo_MSMK.ipynb

PabloAlvarado/MSMK

9976429cf0a7f38e52d890e1cf6e6fc982fe2882

2018-02-20T20:38:40.000Z

2021-12-12T14:26:12.000Z

demo_MSMK.ipynb

PabloAlvarado/MSMK

9976429cf0a7f38e52d890e1cf6e6fc982fe2882

2018-11-16T15:00:03.000Z

2019-04-08T08:27:10.000Z

demo_MSMK.ipynb

PabloAlvarado/MSMK

9976429cf0a7f38e52d890e1cf6e6fc982fe2882

2020-06-01T07:21:59.000Z

2020-06-01T07:21:59.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# Music Machine Learning - Probability distributions ### Author: Philippe Esling (esling@ircam.fr) In this course we will cover 1. A [quick recap](#recap) on simple probability concepts 2. An introduction to [probability distributions](#distributions) 3. An explanation on how to [sample](#sampling) from distributions ourselves <a id="recap"> </a> ## Quick recap on probability The field of probability aims to model random or uncertain events through random variables $X$ denoting a quantity that is uncertain, which take values $\omega$ in a sample space $\omega \in \Omega$. If we observe several occurrences of this variable $\{\mathbf{x}_{i}\}_{i=1}$, we might try to model the _probability distribution_ $p(\mathbf{x})$ of that variable. We recall here that the probability of an event $a$ is a real number $p(a)$, with $0 \leq p(a) \leq 1$, knowing that $p(\Omega)=1$ and $p(\{\})=0$. The probability of two events occuring simultaneously is defined as $p\left(a \cup b \right)$. Therefore, the probability of one event **or** the other occuring is defined as $ \begin{equation} p\left(a \cap b \right) = p(a) + p(b) - p\left(a \cup b \right) \end{equation} $ The *conditional probability* of an event $a$ occuring *given* another event $b$ is denoted $p \left(a \mid b \right)$ and is defined as $$ \begin{equation} p \left(a \mid b \right) = \frac{p \left(a , b \right)}{p \left(b \right)} \end{equation} $$ This can be understood as the probability of event $a$ to occur if we restrict the world of possibilities to event $b$. The *chain rule* defines the probabilities of a set of events to co-occur simultaneously $$ \begin{equation} p \left(x_{1},...,x_{n} \right) = \prod_{i=n}^{1}{p \left(x_{i}\mid x_{i-1},..., x_{1} \right)} \end{equation} $$ Finally, we say that two events are independent if $p(a\mid b) = p(a)$. To understand these concepts graphically, we will rely on `PyTorch` and specifically the `distributions` package. ```python import torch.distributions as distribution import torch.distributions.transforms as transform import matplotlib.pyplot as plt import numpy as np import seaborn as sns from helper_plot import hdr_plot_style hdr_plot_style() ``` <a id="distributions"> </a> ### Probability distributions Let $X$ be a random variable associated with a *probability distribution function* that assigns probabilities to the different outcomes $X$ can take in the sample space. We can divide random variables into three different types: - **$X$ is discrete**: Discrete random variables may only assume values on a specified list. - **$X$ is continuous**: Continuous random variable can take on arbitrarily exact values. - **$X$ is mixed**: Mixed random variables assign probabilities to both discrete and continuous random variables, (i.e. a combination of the above two categories). **Expected Value** The expected value $\mathbb{E}\left[X\right]$ for a given probability distribution can be described as _"the mean expected value for many repeated samples from that distribution."_ As the number of repeated observation goes to infinity, the difference between the average outcome and the expected value becomes arbitrarily small. Formally, it is defined for discrete variables as $$ \mathbb{E}\left[X\right] = \sum\limits_{i}\bx_i p(\bx=\bx_i) $$ #### Discrete distributions If $X$ is discrete, then its distribution is called a *probability mass function* (pmf), which measures the probability $X$ takes on the value $x_{i}$, denoted $P(X=x_{i})$. Let $\mathbf{x}$ be a discrete random variable with range $R_{X}=\{x_1,\cdots,x_n\}$ (finite or countably infinite). The function $$ p_{X}(x_{i})=p(X=x_{i}), \forall i\in\{1,\cdots,n\} $$ is called the probability mass function (PMF) of $X$. Hence, the PMF defines the probabilities of all possible values for a random variable. The above notation allows to express that the PMF is defined for the random variable $X$, so that $p_{X}(1)$ gives the probability that $X=1$. For discrete random variables, the PMF is also called the \textit{probability distribution}. The PMF is a probability measure, therefore it satisfies all the corresponding properties - $0 \leq p_{X}(x_i) < 1, \forall x_i$ - $\sum_{x_i\in R_{X}} p_{X}(x_i) = 1$ - $\forall A \subset R_{X}, p(X \in A)=\sum_{x_a \in A}p_{X}(x_a)$ A very simple example of discrete distribution is the `Bernoulli` distribution. With this distribution, _we can model a coin flip_, if it has equal probability. More formally, a Bernoulli distribution is defined as $$ Bernoulli(x)= p^x (1-p)^{(1-x)} $$ with $p$ controlling the probability of the two classes. Hence, a fair coin should have $p=0.5$, and if we throw the coin a very large number of times, we hope to see on average an equal amount of _heads_ and _tails_. ```python bernoulli = distribution.Bernoulli(0.5) samples = bernoulli.sample((10000,)) plt.figure(figsize=(10,8)) sns.distplot(samples) plt.title("Samples from a Bernoulli (coin toss)") plt.show() ``` However, we can also _sample_ from the distribution to have individual values of a single throw. In that case, we obtain a series of separate events that _follow_ the distribution ```python vals = ['heads', 'tails'] samples = bernoulli.sample((10, )) for s in samples: print('Coin is tossed on ' + vals[int(s)]) ``` Now, we can mess up our probability to model an unfair (loaded) coin, as shown in the following example (where we use a cheated coin that should give us a lot more of _heads_ than _tails_) ```python bernoulli = distribution.Bernoulli(0.3) samples = bernoulli.sample((10000,)) plt.figure(figsize=(10, 8)); sns.distplot(samples) plt.title("Samples from an unfair coin"); plt.show() vals = ['heads', 'tails'] samples = bernoulli.sample((10, )) for s in samples: print('Coin is tossed on ' + vals[int(s)]) ``` #### Poisson distribution Let's introduce one of the (many) useful probability mass functions. We say $Z$ is *Poisson*-distributed if: $$ \begin{equation} P\left(Z = k\right) =\frac{ \lambda^k e^{-\lambda} }{k!}, \; \; k \in \mathbb{N^{+}} \end{equation} $$ $\lambda \in \mathbb{R}$ is a parameter of the distribution that controls its shape (usually termed the *intensity* of the Poisson distribution). By increasing $\lambda$, we add more probability to larger values. One can describe $\lambda$ as the *intensity* of the Poisson distribution. If a random variable $Z$ has a Poisson mass distribution, we denote it by $$ \begin{equation} Z \sim \text{Poi}(\lambda) \end{equation} $$ One useful property of the Poisson distribution is that its expected value is equal to its parameter, i.e.: $$E\large[ \;Z\; | \; \lambda \;\large] = \lambda $$ We will plot the probability mass distribution for different $\lambda$ values. ### Continuous distributions The same ideas apply to _continuous_ random variables, which can model for instance the height of human beings. If we try to guess the height of someone that we do not know, there is a higher probability that this person will be around 1m70, instead of 20cm or 3m. For the rest of this course, we will use the shorthand notation $p(\mathbf{x})$ for the distribution $p(\mathbf{x}=x_{i})$, which expresses for a real-valued random variable $\mathbf{x}$, evaluated at $x_{i}$, the probability that $\mathbf{x}$ takes the value $x_i$. One notorious example of such distributions is the Gaussian (or Normal) distribution, which is defined as \begin{equation} p(x)=\mathcal{N}(\mu,\sigma)=\frac{1}{\sqrt{2\pi\sigma^{2}}}e^{-\frac{(x-\mu)^{2}}{2\sigma^{2}}} \end{equation} Similarly as before, we can observe the behavior of this distribution with the following code (in our height example) ```python normal = distribution.Normal(150., 30.) samples = normal.sample((10000, )) sns.distplot(samples) plt.title("Samples from a standard Normal") plt.show() ``` If we have access to this complete probability distribution (its exact parameterization and function), we can generate samples (in this case "new humans") that follow the correct distribution. You can experiment with this in the following code space. ```python ###################### # YOUR CODE GOES HERE ###################### ``` An example of continuous random variable is a random variable with *exponential density* $$ \begin{equation} f_Z(z | \lambda) = \lambda e^{-\lambda z }, \;\; z\ge 0 \end{equation} $$ When a random variable $Z$ has an exponential distribution with parameter $\lambda$, we say *$Z$ is exponential* $$Z \sim \text{Exp}(\lambda)$$ Given a specific $\lambda$, the expected value of an exponential random variable is equal to the inverse of $\lambda$, that is $$E[\; Z \;|\; \lambda \;] = \frac{1}{\lambda}$$ <a id="distribs"></a> ### PyTorch distributions Here, we rely on the [PyTorch distributions module](https://pytorch.org/docs/stable/_modules/torch/distributions/), which is defined in `torch.distributions`. Most notably, we are going to rely both on the `Distribution` and `Transform` objects. ```python # Imports for plotting import numpy as np import matplotlib.pyplot as plt # Define grids of points (for later plots) x = np.linspace(-4, 4, 1000) z = np.array(np.meshgrid(x, x)).transpose(1, 2, 0) z = np.reshape(z, [z.shape[0] * z.shape[1], -1]) ``` Inside this toolbox, we can already find some of the major probability distributions that we are used to deal with ```python p = distrib.Normal(loc=0, scale=1) p = distrib.Bernoulli(probs=torch.tensor([0.5])) p = distrib.Beta(concentration1=torch.tensor([0.5]), concentration0=torch.tensor([0.5])) p = distrib.Gamma(concentration=torch.tensor([1.0]), rate=torch.tensor([1.0])) p = distrib.Pareto(alpha=torch.tensor([1.0]), scale=torch.tensor([1.0])) ``` The interesting aspect of these `Distribution` objects is that we can both obtain some samples from it through the `sample` (or `sample_n`) function, but we can also obtain the analytical density at any given point through the `log_prob` function ```python # Based on a normal n = distrib.Normal(0, 1) # Obtain some samples samples = n.sample((1000, )) # Evaluate true density at given points density = torch.exp(n.log_prob(torch.Tensor(x))).numpy() # Plot both samples and density fig, (ax1, ax2) = plt.subplots(1, 2, sharex=True, figsize=(15, 4)) ax1.hist(samples, 50, alpha=0.8); ax1.set_title('Empirical samples', fontsize=18); ax2.plot(x, density); ax2.fill_between(x, density, 0, alpha=0.5) ax2.set_title('True density', fontsize=18); ``` Here you can experiment with different distributions, and try to compare how they behave depending on their parameters and also on how much _samples_ you draw from these. ```python ###################### # YOUR CODE GOES HERE ###################### ``` <a id="sampling"></a> ## Sampling from distributions The advantage of using probability distributions is that we can *sample* from these to obtain examples that follow the distribution. For instance, if we perform sampling repeatedly (up to infinity) from a Gaussian PDF, the different values will be distributed following the exact Gaussian distribution. However, although we know the PDF, we need to compute the *Cumulative Distribution Function* (CDF), and then its inverse to obtain the sampling function. Therefore, if we denote the PDF as $f_{X}(x)$, we need to compute the CDF $$ \begin{equation} F_{X}\left(x\right)=\intop_{\infty}^{x}f_{X}\left(t\right)dt \end{equation} $$ Then, the *inverse sampling method* consists in solving and applying the inverse CDF $F_{X}^{-1}\left(x\right)$. Here, we recall that the Exponential probability is defined with the following function. $$ p_{\lambda}(x) = \lambda e^{-\lambda x} $$ with $\lambda$ defining the _rate_ parameter. Therefore, to be able to define our own `sample` method, we need to solve for $$ F^{-1}_Y(x) = \left(\int_0^x \lambda e^{-\lambda y} dy\right)^{-1} $$ *** **Exercise** 1. Code the exponential probability density functions 2. Perform the inverse transform method on the exponential distribution PDF 3. Code the `sample_exponential` function to sample from the exponential 4. (optional) Perform the same operations for sampling from the Beta distribution *** ```python from scipy.stats import expon nb_samples = 500 nb_bins = 50 def sample_exponential(mu, n, m): ###################### # YOUR CODE GOES HERE ###################### ###################### # Solution samples = np.random.uniform(0, 1, size=(m,n)) samples = - np.log(1 - samples) samples *= mu ###################### return samples # Exponential distribution mu = 2 samples = np.random.exponential(mu, nb_samples) samples_ex = sample_exponential(mu, nb_samples, 1) # Compute the PDF X = np.linspace(0, np.max(samples), int(np.max(samples)) * 100) y1 = expon.pdf(X) #* (nb_samples / nb_bins) * int(np.max(samples) * 1.5) # Display both plt.figure(figsize=(12, 8)) plt.subplot(2,1,1) plt.hist(samples, 50, label='Samples') plt.plot(X,y1,ls='--',c='r',linewidth=2, label='Exponential PDF') plt.legend(loc=1) plt.subplot(2,1,2) plt.hist(samples_ex, 50, label='Samples') plt.plot(X,y1,ls='--',c='r',linewidth=2, label='Our exponential sampples') plt.legend(loc=1) ``` ```python def sampleBeta(a, b, M, N): ###################### # YOUR CODE GOES HERE ###################### ###################### # Solution samples = np.random.beta(a, b, size=(M, N)) ###################### return samples from scipy.stats import beta # Beta distribution a = 0.6 b = 1.5 samples = np.random.beta(a, b, nbSamples) samplesBeta = sampleBeta(a, b, nbSamples, 1) # Compute the PDF X = np.linspace(0, 1, 100) y1 = beta.pdf(X, a, b) * (nbSamples / nbBins) * (np.max(samples) * 1.5) # Display both plt.figure(figsize=(12, 8)) plt.subplot(2,1,1) plt.hist(samples, 50, label='Samples') plt.plot(X,y1,ls='--',c='r',linewidth=2, label='Beta PDF') plt.legend(loc=1) plt.subplot(2,1,2) plt.hist(samplesBeta, 50, label='Samples') plt.plot(X,y1,ls='--',c='r',linewidth=2, label='Beta PDF') plt.legend(loc=1) ``` ### Comparing distributions (KL divergence) $ \newcommand{\R}{\mathbb{R}} \newcommand{\bb}[1]{\mathbf{#1}} \newcommand{\bx}{\bb{x}} \newcommand{\by}{\bb{y}} \newcommand{\bz}{\bb{z}} \newcommand{\KL}[2]{\mathcal{D}_{\text{KL}}\left[#1 \| #2\right]}$ Originally defined in the field of information theory, the _Kullback-Leibler (KL) divergence_ (usually noted $\KL{p(\bx)}{q(\bx)}$) is a dissimilarity measure between two probability distributions $p(\bx)$ and $q(\bx)$. In the view of information theory, it can be understood as the cost in number of bits necessary for coding samples from $p(\bx)$ by using a code optimized for $q(\bx)$ rather than the code optimized for $p(\bx)$. In the view of probability theory, it represents the amount of information lost when we use $q(\bx)$ to approximate the true distribution $p(\bx)$. %that explicit the cost incurred if events were generated by $p(\bx)$ but charged under $q(\bx)$ Given two probability distributions $p(\bx)$ and $q(\bx)$, the Kullback-Leibler divergence of $q(\bx)$ _from_ $p(\bx)$ is defined to be \begin{equation} \KL{p(\bx)}{q(\bx)}=\int_{\R} p(\bx) \log \frac{p(\bx)}{q(\bx)}d\bx \end{equation} Note that this dissimilarity measure is _asymmetric_, therefore, we have \begin{equation} \KL{p(\bx)}{q(\bx)}\neq \KL{q(\bx)}{p(\bx)} \end{equation} This asymmetry also describes an interesting behavior of the KL divergence, depending on the order to which it is evaluated. The KL divergence can either be a _mode-seeking_ or _mode-coverage_ measure (we will come back to these notions in the _approximate inference_ course) ```python ```

8cd934b6febdda2186cdda4118dea1246ccf472a

ipynb

Jupyter Notebook

04b_distributions.ipynb

piptouque/atiam_ml

9da637eae179237d30a15dd9ce3e95a2a956c385

04b_distributions.ipynb

piptouque/atiam_ml

9da637eae179237d30a15dd9ce3e95a2a956c385

04b_distributions.ipynb

piptouque/atiam_ml

9da637eae179237d30a15dd9ce3e95a2a956c385

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

```python from IPython.display import Image from IPython.core.display import HTML from sympy import *; x,h,y = symbols("x h y") Image(url= "https://i.imgur.com/bNY57ZF.png") ``` ```python expr = 4/(x-2) def F(x): return expr F(x) #first step is to find dF(x) #then we do slope point form with dF(x) as m so y = y0 + dF(x)(x-x0) ``` $\displaystyle \frac{4}{x - 2}$ ```python dF = diff(F(x)) dF ``` $\displaystyle - \frac{4}{\left(x - 2\right)^{2}}$ ```python print(dF.subs(x,4)) ``` -1 ```python MofT = (dF.subs(x,4)) y = 2 + MofT*(x - 4) y ``` $\displaystyle 6 - x$ ```python Image(url= "https://i.imgur.com/MJ6qRQd.png") ``` ```python ```

c415478cb7a1e1ff5835b65d17226060fe43e693

ipynb

Jupyter Notebook

Calculus_Homework/WWB08.16.ipynb

NSC9/Sample_of_Work

8f8160fbf0aa4fd514d4a5046668a194997aade6

Calculus_Homework/WWB08.16.ipynb

NSC9/Sample_of_Work

8f8160fbf0aa4fd514d4a5046668a194997aade6

Calculus_Homework/WWB08.16.ipynb

NSC9/Sample_of_Work

8f8160fbf0aa4fd514d4a5046668a194997aade6

Qwen/Qwen-72B

1. YES 2. YES

__label__yue_Hant

# Custom Gradient This is a brief demonstration of tensorflow [custom gradients](https://www.tensorflow.org/api_docs/python/tf/custom_gradient) ## Chain rule Lets say we have a function $f(x) = x^2$. If we now compose this function such that $y = f(f(f(x)))$. Now we want to find the gradient $\frac{dy}{dx}$. We first decompose this into \begin{align*} y &= x_0^2\\ x_0 &= x_1^2\\ x_1 &= x^2 \end{align*} On taking first order derivative, we get \begin{align*} \frac{dy}{dx_0} &= 2x_0\\ \frac{dx_0}{dx_1} &= 2x_1\\ \frac{dx_1}{dx} &= 2x \end{align*} Using chain rule \begin{equation*} \frac{dy}{dx} = \frac{dy}{dx_0} \frac{dx_0}{dx_1} \frac{dx_1}{dx} \end{equation*} To generalize \begin{equation*} \frac{dy}{dx} = \frac{dy}{dx_{0}} ... \frac{dx_i}{dx_{i+1}} ... \frac{dx_n}{dx} \end{equation*} In tensorflow the `upstream` gradient is passed as an argument to the inner function `grad`. \begin{equation*} upstream = \frac{dx_{i+1}}{dx_{i+2}} ... \frac{dx_n}{dx} \end{equation*} Now we can multiply this upstream gradient to the gradient of the current function $\frac{dx_{i}}{dx_{i+1}}$ and pass it downstream. \begin{equation*} downstream = \frac{dx_{i}}{dx_{i+1}} * upstream \end{equation*} ```python import tensorflow as tf ``` ```python # @tf.function @tf.custom_gradient def foo(x): tf.debugging.assert_rank(x, 0) def grad(dy_dx_upstream): dy_dx = 2 * x dy_dx_downstream = dy_dx * dy_dx_upstream tf.print(f'x={x}\tupstream={dy_dx_upstream}\tcurrent={dy_dx}\t\tdownstream={dy_dx_downstream}') return dy_dx_downstream y = x ** 2 tf.print(f'x={x}\ty={y}') return y, grad x = tf.constant(2.0, dtype=tf.float32) with tf.GradientTape(persistent=True) as tape: tape.watch(x) y = foo(foo(foo(x))) # y = x ** 8 tf.print(f'\nfinal dy/dx={tape.gradient(y, x)}') ``` x=2.0 y=4.0 x=4.0 y=16.0 x=16.0 y=256.0 x=16.0 upstream=1.0 current=32.0 downstream=32.0 x=4.0 upstream=32.0 current=8.0 downstream=256.0 x=2.0 upstream=256.0 current=4.0 downstream=1024.0 final dy/dx=1024.0 ### Gradients with multiple variables If the function takes multiple variables, then the gradient for each variable has to be returned as demonstrated in the example. ```python @tf.custom_gradient def bar(x, y): tf.debugging.assert_rank(x, 0) tf.debugging.assert_rank(y, 0) def grad(upstream): dz_dx = y dz_dy = x return upstream * dz_dx, upstream * dz_dy z = x * y return z, grad x = tf.constant(2.0, dtype=tf.float32) y = tf.constant(3.0, dtype=tf.float32) with tf.GradientTape(persistent=True) as tape: tape.watch(x) tape.watch(y) z = bar(x, y) tf.print(z) tf.print(tape.gradient(z, x)) tf.print(tape.gradient(z, y)) tf.print(tape.gradient(x, y)) ``` 6 3 2 None ## Application of custom gradients ### Toy example: Differentiable approximation of non-differentiable functions We take the sign function as an example \begin{equation} sign(x)= \\ \begin{cases} -1, & \text{if}\ x<0 \\ 0, & \text{if}\ x=0 \\ 1, & \text{if}\ x>0 \\ \end{cases}\end{equation} By implementing a custom gradient, we can continue to have the $sign(x)$ function in forward pass but a differentiable approximation in the backward pass. In this case we approximate $sign(x)$ with the sigmoid function $ \sigma(x)$ \begin{equation} \frac{dsign_{approx}(x)}{dx} = \sigma(x) (1 - \sigma(x)) \\ sign_{approx}(x) = \sigma(x) + C \\ \end{equation} ```python # @tf.function @tf.custom_gradient def differentiable_sign(x): tf.debugging.assert_rank(x, 0) def grad(upstream): dy_dx = tf.math.sigmoid(x) * (1 - tf.math.sigmoid(x)) return upstream * dy_dx if x > tf.constant(0.0): return tf.constant(1.0), grad else: return tf.constant(-1.0), grad x = tf.constant(3.0, dtype=tf.float32) with tf.GradientTape(persistent=True) as tape: tape.watch(x) y = differentiable_sign(x) loss = tf.nn.l2_loss(y - tf.constant(-1.0)) tf.print(y) tf.print(tape.gradient(y, x)) tf.print(loss) tf.print(tape.gradient(loss, x)) ``` 1 0.0451766551 2 0.0903533101 ```python x = tf.Variable(-1.0) opt = tf.keras.optimizers.Adam(1e-1) # opt = tf.keras.optimizers.SGD(1) def train_step(): with tf.GradientTape() as tape: y = differentiable_sign(x) loss = tf.nn.l2_loss(y - tf.constant(1.0)) grads = tape.gradient(loss, x) opt.apply_gradients(zip([grads], [x])) return loss, y, grads for i in range(100): loss, y, grads = train_step() if i % 10 == 0: tf.print(i, loss, grads, x, y) ``` 0 2 -0.393223882 -0.89999783 -1 10 0 0 0.0995881185 1 20 0 0 0.6450876 1 30 0 0 0.855591536 1 40 0 0 0.938390434 1 50 0 0 0.970632374 1 60 0 0 0.983009696 1 70 0 0 0.987700462 1 80 0 0 0.989459515 1 90 0 0 0.990113616 1 ```python ```

714b44be1b5c9e4648a47909c84381abb78f802d

ipynb

Jupyter Notebook

notebooks/custom-gradient.ipynb

Ghost---Shadow/gradient-tape-experiments

1ded25074defe2d5936c97d2b8d570a3d3614a18

2020-10-24T19:07:45.000Z

2021-12-23T20:23:43.000Z

notebooks/custom-gradient.ipynb

Ghost---Shadow/gradient-tape-experiments

1ded25074defe2d5936c97d2b8d570a3d3614a18

notebooks/custom-gradient.ipynb

Ghost---Shadow/gradient-tape-experiments

1ded25074defe2d5936c97d2b8d570a3d3614a18

2021-04-06T10:51:35.000Z

2021-04-06T10:51:35.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# Extension of DV Formula $\def\abs#1{\left\lvert #1 \right\rvert} \def\Set#1{\left\{ #1 \right\}} \def\mc#1{\mathcal{#1}} \def\M#1{\boldsymbol{#1}} \def\R#1{\mathsf{#1}} \def\RM#1{\boldsymbol{\mathsf{#1}}} \def\op#1{\operatorname{#1}} \def\E{\op{E}} \def\d{\mathrm{\mathstrut d}}$ ## $f$-divergence Consider the more general problem of estimating the $f$-divergence in {eq}`f-D`: $$ D_f(P_{\R{Z}}\|P_{\R{Z}'}) = E\left[f\left(\frac{dP_{\R{Z}}(\R{Z}')}{dP_{\R{Z}'}(\R{Z}')}\right)\right]. $$ **Exercise** How to estimate $f$-divergence using the DV formula? YOUR ANSWER HERE Instead of using the DV bound, it is desirable to train a network to optimize a tight bound on the $f$-divergence because: - *Estimating KL divergence well does not imply the underlying neural network approximates the density ratio well*: - While KL divergence is just a non-negative real number, - the density ratio is in a high dimensional function space. - DV formula does not directly maximizes a bound on $f$-divergence, i.e. it does not directly minimize the error in estimating $f$-divergence. - $f$-divergence may have bounds that are easier/more stable for training a neural network. **How to extend the DV formula to $f$-divergence?** The idea is to think of the $f$-divergence as a convex *function(al)* evaluated at the density ratio: --- **Proposition** :label: D->F $f$-divergence {eq}`f-D` is $$ \begin{align} D_f(P_{\R{Z}}\|P_{\R{Z}'}) = F\left[ \frac{P_{\R{Z}}}{P_{\R{Z}'}}\right] \end{align} $$ (D->F) where $$ \begin{align} F[r] := E [ \underbrace{(f \circ r)(\R{Z}')}_{f(r(\R{Z}'))}] \end{align} $$ (F) for any function $r:\mc{Z} \to \mathbb{R}$. --- This is more like a re-definition than a proposition as the proof is immediate: {eq}`f-D` is obtained from {eq}`D->F` by substituting $r=\frac{dP_{\R{Z}}}{dP_{\R{Z}'}}$. As mentioned before, the KL divergence $D(P_{\R{Z}}\|P_{\R{Z}'})$ is a special case of $f$-divergence: $$ D(P_{\R{Z}}\|P_{\R{Z}'}) = F\left[r\right] $$ where $$ \begin{align*} F[r] &:= E\left[ r(\R{Z}')\log r(\R{Z}')\right]. \end{align*} $$ (KL:F) **Exercise** When is $F[r]=0$ equal to $0$? YOUR ANSWER HERE **Exercise** Show using the properties of $f$ that $F$ is strictly convex. **Solution** For $\lambda\in [0,1]$ and functions $r_1, r_2\in \Set{r:\mc{Z}\to \mathbb{R}}$, $$ \begin{align*} F[\lambda r_1 + (1-\lambda) r_2] &= E[\underbrace{ f(\lambda r_1(\R{Z}') + (1-\lambda) r_2(\R{Z}'))}_{\stackrel{\text{(a)}}{\geq} \lambda f(r_1(\R{Z}'))+(1-\lambda) f(r_2(\R{Z}'))}]\\ &\stackrel{\text{(b)}}{\geq} \lambda E[f(r_1(\R{Z}'))] + (1-\lambda) E[f(r_2(\R{Z}'))] \end{align*} $$ where (a) is by the convexity of $f$, and (b) is by the linearity of expectation. $F$ is strictly convex because (b) is satisfied with equality iff (a) is almost surely. For a clearer understanding, consider a different choice of $F$ for the KL divergence: $$ D(P_{\R{Z}}\|P_{\R{Z}'}) = F'\left[r\right] $$ where $$ \begin{align*} F'[r] &:= E\left[ \log r(\R{Z})\right]. \end{align*} $$ (rev-KL:F) Note that $F'$ in {eq}`rev-KL:F` defined above is concave in $r$. In other words, {eq}`D2` in {prf:ref}`DV2` $$ \begin{align*} D(P_{\R{Z}}\|P_{\R{Z}'}) & = \sup_{\substack{r:\mc{Z}\to \mathbb{R}_+\\ E[r(\R{Z}')]=1}} E \left[ \log r(\R{Z}) \right] \end{align*} $$ is maximizing a concave function and therefore has a unique solution, namely, $r=\frac{dP_{\R{Z}}}{dP_{\R{Z}'}}$. Here comes the tricky question: **Exercise** Is KL divergence concave or convex in the density ratio $\frac{dP_{\R{Z}}}{dP_{\R{Z}'}}$? Note that $F$ defined in {eq}`KL:F` is convex in $r$. YOUR ANSWER HERE ## Convex conjugation Given $P_{\R{Z}'}\in \mc{P}(\mc{Z})$, consider - a function space $\mc{R}$, $$ \begin{align} \mc{R} &\supseteq \Set{r:\mathcal{Z}\to \mathbb{R}_+\mid E\left[r(\R{Z}')\right] = 1}, \end{align} $$ (R) - a dual space $\mc{T}$, and $$ \begin{align} \mc{T} &\subseteq \Set{t:\mc{Z} \to \mathbb{R}} \end{align} $$ (T) - the corresponding inner product $\langle\cdot,\cdot \rangle$: $$ \begin{align} \langle t,r \rangle &= \int_{z\in \mc{Z}} t(z) r(z) dP_{\R{Z}'}(z) = E\left[ t(\R{Z}') r(\R{Z}') \right]. \end{align} $$ (inner-prod) The following is a generalization of DV formula for estimating $f$-divergence {cite}`nguyen2010estimating`{cite}`ruderman2012tighter`: --- **Proposition** :label: convex-conjugate $$ \begin{align} D_{f}(P_{\R{Z}} \| P_{\R{Z}'}) = \sup _{t\in \mc{T}} E[g(\R{Z})] - F^*[t], \end{align} $$ (convex-conjugate2) where $$ \begin{align} F^*[t] = \sup_{r\in \mc{R}} E[t(\R{Z}') r(\R{Z}')] - F[r]. \end{align} $$ (convex-conjugate1) --- --- **Proof** Note that the supremums in {eq}`convex-conjugate1` and {eq}`convex-conjugate2` are [Fenchel-Legendre transforms][FL]. Denoting the transform as $[\cdot]^*$, $$\underbrace{[[F]^*]^*}_{=F}\left[\frac{dP_{\R{Z}}}{dP_{\R{Z}'}}\right]$$ gives {eq}`convex-conjugate2` by expanding the outer/later transform. The equality is by the property that Fenchel-Legendre transform is its own inverse for strictly convex functional $F$. This completes the proof by {eq}`D->F`. [FL]: https://en.wikipedia.org/wiki/Convex_conjugate --- The proof is illustrated in the following figure: Let's breakdown the details: **Step 1** For the purpose of the illustration, visualize the convex functional $F$ simply as a curve in 2D. The $f$-divergence is then the $y$-coordinate of a point on the curve indicated above, with $r$ being the density ratio $\frac{dP_{\R{Z}}}{dP_{\R{Z}'}}$. **Step 2** To obtain a lower bound on $F$, consider any tangent of the curve with an arbitrary slope $t\cdot dP_{\R{Z}'}$ The lower bound is given by the $y$-coordinate of a point on the tangent with $r$ being the density ratio. **Exercise** Why is the $y$-coordinate of the tangent a lower bound on the $f$-divergence? **Solution** By the convexity of $F$, the tangent must be below $F$. **Step 3** To calculate the lower bound, denote the $y$-intercept as $-F^*[t]$: Thinking of a function as nothing but a vector, the displacement from the $y$-intercept to the lower bound is given by the inner product of the slope and the density ratio. **Step 4** To make the bound tight, maximize the bound over the choice of the slope or $t$: This gives the bound in {eq}`convex-conjugate2`. It remains to show {eq}`convex-conjugate1`. **Step 5** To compute the $y$-intercept or $F^*[t]$, let $r^*$ be the value of $r$ where the tangent touches the convex curve: The displacement from the point at $r^*$ to the $y$-intercept can be computed as the inner product of the slope and $r^*$. **Exercise** Show that for the functional $F$ {eq}`KL:F` defined for KL divergence, $$F^*[t]=\log E[e^{t(\R{Z}')}]$$ with $\mc{R}=\Set{r:\mc{Z}\to \mathbb{R}_+}$ and so {eq}`convex-conjugate2` gives the DV formula {eq}`DV` as a special case. YOUR ANSWER HERE

e3a873e943c12d2450ba903fe091342920d33afb

ipynb

Jupyter Notebook

part1/f-Divergence.ipynb

ccha23/cscit21

87de8c48c640406d9a9d282fc10a238122814f53

part1/f-Divergence.ipynb

ccha23/cscit21

87de8c48c640406d9a9d282fc10a238122814f53

part1/f-Divergence.ipynb

ccha23/cscit21

87de8c48c640406d9a9d282fc10a238122814f53

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

### SETUP Paste the code in [coupled_euler.py](../coupled_euler.py) in a python file in the working directory and make another new .py file Now, use this command to import all the functions and class definitions in coupled_euler.py ```python from coupled_euler import * ``` Also make the following imports, ```python import numpy as np import matplotlib.pyplot as plt ``` ### THE PROBLEM #### CIRCUIT DIAGRAM #### MATH Applying KVL in two inner loops, $$ \begin{equation} L\frac{dI_b}{dt} = C'^{-1}Q_2 - C^{-1}Q_3 - R I_b \end{equation} $$ $$ \begin{equation} L\frac{dI_b}{dt} = C'^{-1}Q_2 - C^{-1}Q_3 - R I_b \end{equation} $$ Now, applying KCL at node b, $$ \begin{equation} I_a = I_b + I_c \end{equation} $$ In our case setting internal resistance R of inductors zero $$ \begin{equation*} \frac{dQ_1}{dt} = -I_a, \frac{dQ_2}{dt} = -I_a - I_b, \frac{dQ_3}{dt} = I_b \end{equation*} $$ #### CODE Now to play with initial value problem understand and use the following code which can also be found in [here](../coupled_oscillators.py). ```python #l stands for inductance L , c1, c2 corresponds to C and C' l,c1,c2 = 0.1,1,1.3 #resistance r=0 ivp = set_problem( f=[lambda t,x,y,q1,q2,q3 : (q1/c1 - q2/c2 -r*x)/l, #Function associated with (1) lambda t,x,y,q1,q2,q3 :(q2/c2 - q3/c1 -r*y)/l, #Function associated with (2) lambda t,x,y,q1,q2,q3 : -x , #Function associated with dq1/dt lambda t,x,y,q1,q2,q3 : -x-y, #Function associated with dq2/dt lambda t,x,y,q1,q2,q3 : y], #Function associated with dq3/dt dom=(0,15), # Time Domain ini=(0,10000,10000,1,0,-1), #initial conditions in ordered tuple(t,I_a,I_b,q1,q2,q3) N=int(20000),# No. of nodes/ control step size vars = ("t","$I_a$","$I_b$","q1","q2","q3") # var names for labels ) d=ivp.rk4() # rk4 called to solve the ivp problem fig,ax = plt.subplots(1,1) ivp.jt_plot(ax,1) # plots I_a vs t on ax ivp.jt_plot(ax,2) # plots I_b vs t on ax #ivp.jt_plot(ax,3) # plots q1 vs t #ivp.jt_plot(ax,5) # plots q3 vs t #ivp.kj_plot(ax,3,5) # plots q3 vs q1 #ivp.kj_plot(ax,1,2) # plots I_b vs I_a on ax plt.legend() plt.show() ``` The result that I obtain for specifically the above Initial value problem, which is clearly not what one expects.

38f152cd41d70e26d632540e0cd1ee47af39eec9

ipynb

Jupyter Notebook

coupled_DE/.ipynb_checkpoints/LC_oscillations-checkpoint.ipynb

plancky/mathematical_physics_II

c912dca1a58c218ddb06dc6cbca021b03a703540

coupled_DE/.ipynb_checkpoints/LC_oscillations-checkpoint.ipynb

plancky/mathematical_physics_II

c912dca1a58c218ddb06dc6cbca021b03a703540

coupled_DE/.ipynb_checkpoints/LC_oscillations-checkpoint.ipynb

plancky/mathematical_physics_II

c912dca1a58c218ddb06dc6cbca021b03a703540

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# Stochastic Processes: <br>Data Analysis and Computer Simulation <br> # Brownian motion 2: computer simulation <br> # 3. Simulations with on-the-fly animation <br> # 3.1. Simulation code with on-the-fly animation ## Import libraries ```python % matplotlib nbagg import numpy as np # import numpy library as np import matplotlib.pyplot as plt # import pyplot library as plt import matplotlib.mlab as mlab # import mlab module to use MATLAB commands with the same names import matplotlib.animation as animation # import animation modules from matplotlib from mpl_toolkits.mplot3d import Axes3D # import Axes3D from mpl_toolkits.mplot3d plt.style.use('ggplot') # use "ggplot" style for graphs ``` ## Define `init` function for `FuncAnimation` ```python def init(): global R,V,W,Rs,Vs,Ws,time R[:,:] = 0.0 # initialize all the variables to zero V[:,:] = 0.0 # initialize all the variables to zero W[:,:] = 0.0 # initialize all the variables to zero Rs[:,:,:] = 0.0 # initialize all the variables to zero Vs[:,:,:] = 0.0 # initialize all the variables to zero Ws[:,:,:] = 0.0 # initialize all the variables to zero time[:] = 0.0 # initialize all the variables to zero title.set_text(r'') # empty title line.set_data([],[]) # set line data to show the trajectory of particle n in 2d (x,y) line.set_3d_properties([]) # add z-data separately for 3d plot particles.set_data([],[]) # set position current (x,y) position data for all particles particles.set_3d_properties([]) # add current z data of particles to get 3d plot return particles,title,line # return listed objects that will be drawn by FuncAnimation ``` ## Define `animate` function for `FuncAnimation` ```python def animate(i): global R,V,W,Rs,Vs,Ws,time # define global variables time[i]=i*dt # store time in each step in an array time W = std*np.random.randn(nump,dim) # generate an array of random forces accordingly to Eqs.(F10) and (F11) R, V = R + V*dt, V*(1-zeta/m*dt)+W/m # update R & V via Eqs.(F5)&(F9) Rs[i,:,:]=R # accumulate particle positions at each step in an array Rs Vs[i,:,:]=V # accumulate particle velocitys at each step in an array Vs Ws[i,:,:]=W # accumulate random forces at each step in an array Ws title.set_text(r"t = "+str(time[i])) # set the title to display the current time line.set_data(Rs[:i+1,n,0],Rs[:i+1,n,1]) # set the line in 2D (x,y) line.set_3d_properties(Rs[:i+1,n,2]) # add z axis to set the line in 3D particles.set_data(R[:,0],R[:,1]) # set the current position of all the particles in 2d (x,y) particles.set_3d_properties(R[:,2]) # add z axis to set the particle in 3D return particles,title,line # return listed objects that will be drawn by FuncAnimation ``` ## Set parameters and initialize variables ```python dim = 3 # system dimension (x,y,z) nump = 1000 # number of independent Brownian particles to simulate nums = 1024 # number of simulation steps dt = 0.05 # set time increment, \Delta t zeta = 1.0 # set friction constant, \zeta m = 1.0 # set particle mass, m kBT = 1.0 # set temperatute, k_B T std = np.sqrt(2*kBT*zeta*dt) # calculate std for \Delta W via Eq.(F11) np.random.seed(0) # initialize random number generator with a seed=0 R = np.zeros([nump,dim]) # array to store current positions and set initial condition Eq.(F12) V = np.zeros([nump,dim]) # array to store current velocities and set initial condition Eq.(F12) W = np.zeros([nump,dim]) # array to store current random forcces Rs = np.zeros([nums,nump,dim]) # array to store positions at all steps Vs = np.zeros([nums,nump,dim]) # array to store velocities at all steps Ws = np.zeros([nums,nump,dim]) # array to store random forces at all steps time = np.zeros([nums]) # an array to store time at all steps ``` ## Perform and animate the simulation using `FuncAnimation` ```python fig = plt.figure(figsize=(10,10)) # set fig with its size 10 x 10 inch ax = fig.add_subplot(111,projection='3d') # creates an additional axis to the standard 2D axes box = 40 # set draw area as box^3 ax.set_xlim(-box/2,box/2) # set x-range ax.set_ylim(-box/2,box/2) # set y-range ax.set_zlim(-box/2,box/2) # set z-range ax.set_xlabel(r"x",fontsize=20) # set x-lavel ax.set_ylabel(r"y",fontsize=20) # set y-lavel ax.set_zlabel(r"z",fontsize=20) # set z-lavel ax.view_init(elev=12,azim=120) # set view point particles, = ax.plot([],[],[],'ro',ms=8,alpha=0.5) # define object particles title = ax.text(-180.,0.,250.,r'',transform=ax.transAxes,va='center') # define object title line, = ax.plot([],[],[],'b',lw=1,alpha=0.8) # define object line n = 0 # trajectry line is plotted for the n-th particle anim = animation.FuncAnimation(fig,func=animate,init_func=init, frames=nums,interval=5,blit=True,repeat=False) ## If you have ffmpeg installed on your machine ## you can save the animation by uncomment the last line ## You may install ffmpeg by typing the following command in command prompt ## conda install -c menpo ffmpeg ## # anim.save('movie.mp4',fps=50,dpi=100) ``` <IPython.core.display.Javascript object> ## Summary of simulation methods ### Original differential equation \begin{equation} \frac{d\mathbf{R}(t)}{dt}=\mathbf{V}(t)\tag{F1} \end{equation} \begin{equation} m\frac{d\mathbf{V}(t)}{dt}=\color{black}{-\zeta\mathbf{V}(t)}+\color{black}{\mathbf{F}(t)} \tag{F2} \end{equation} $\hspace{80mm}$with \begin{equation} \langle \mathbf{F}(t)\rangle=\mathbf{0} \tag{F3} \end{equation} \begin{equation} \langle \mathbf{F}(t)\mathbf{F}(0)\rangle = {2k_B T\zeta}\mathbf{I}\delta(t) \tag{F4} \end{equation} ### Euler method $$ \mathbf{V}_{i+1} =\left(1-\frac{\zeta}{m}\Delta t\right)\mathbf{V}_i + \frac{1}{m} {\Delta \mathbf{W}_i} \tag{F9} $$ $$ \mathbf{R}_{i+1}=\mathbf{R}_i+\mathbf{V}_i \Delta t \hspace{15mm}\tag{B3} $$ $\hspace{80mm}$with \begin{equation} \langle \Delta \mathbf{W}_i\rangle=\mathbf{0} \tag{F10} \end{equation} \begin{equation} \langle \Delta \mathbf{W}_i\Delta \mathbf{W}_j\rangle = {2k_B T\zeta}\Delta t\mathbf{I}\delta_{ij} \tag{F11} \end{equation} ### 2nd order Runge-Kutta method $$ \mathbf{V}'_{i+\frac{1}{2}} =\mathbf{V}_i-\frac{\zeta}{m}\frac{\Delta t}{2}\mathbf{V}_{i} =\left(1-\frac{\zeta}{m}\frac{\Delta t}{2}\right)\mathbf{V}_{i} \tag{F12} $$ $$ \mathbf{V}_{i+1} =\mathbf{V}_i-\frac{\zeta}{m}\Delta t\mathbf{V}'_{i+\frac{1}{2}} + \frac{1}{m} {\Delta \mathbf{W}_i} \tag{F13} $$ $$ \mathbf{R}_{i+1}=\mathbf{R}_i+\mathbf{V}'_{i+\frac{1}{2}} \Delta t \hspace{15mm} \tag{F14} $$ ### 4th order Runge-Kutta method $$ \mathbf{V}'_{i+\frac{1}{2}} =\mathbf{V}_i-\frac{\zeta}{m}\frac{\Delta t}{2}\mathbf{V}_{i} \tag{F15} $$ $$ \mathbf{V}''_{i+\frac{1}{2}} =\mathbf{V}_i-\frac{\zeta}{m}\frac{\Delta t}{2}\mathbf{V}'_{i+\frac{1}{2}} \tag{F16} $$ $$ \mathbf{V}'''_{i+1} =\mathbf{V}_i-\frac{\zeta}{m}{\Delta t}\mathbf{V}''_{i+\frac{1}{2}} \tag{F17} $$ $$ \mathbf{V}_{i+1} =\mathbf{V}_i-\frac{\zeta}{m}\frac{\Delta t}{6}\left(\mathbf{V}+\mathbf{V}'_{i+\frac{1}{2}}+\mathbf{V}''_{i+\frac{1}{2}}+\mathbf{V}'''_{i+1}\right) + \frac{1}{m} {\Delta \mathbf{W}_i} \tag{F18} $$ $$ \mathbf{R}_{i+1}=\mathbf{R}_i+ \frac{\Delta t}{6}\left(\mathbf{V}+\mathbf{V}'_{i+\frac{1}{2}}+\mathbf{V}''_{i+\frac{1}{2}}+\mathbf{V}'''_{i+1}\right) \hspace{15mm} \tag{F19} $$

1c5c3ebc46d1f53a3c42e0ef78db157173c0a84c

ipynb

Jupyter Notebook

edx-stochastic-data-analysis/downloaded_files/04/009x_43.ipynb

mirandagil/extra-courses

51858f5089b10b070de43ea3809697760aa261ec

edx-stochastic-data-analysis/downloaded_files/04/009x_43.ipynb

mirandagil/extra-courses

51858f5089b10b070de43ea3809697760aa261ec

edx-stochastic-data-analysis/downloaded_files/04/009x_43.ipynb

mirandagil/extra-courses

51858f5089b10b070de43ea3809697760aa261ec

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

###### Content under Creative Commons Attribution license CC-BY 4.0, code under MIT license (c)2014 L.A. Barba, G.F. Forsyth. # Relax and hold steady Ready for more relaxing? This is the third lesson of **Module 5** of the course, exploring solutions to elliptic PDEs. In [Lesson 1](http://nbviewer.ipython.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/05_relax/05_01_2D.Laplace.Equation.ipynb) and [Lesson 2](http://nbviewer.ipython.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/05_relax/05_02_2D.Poisson.Equation.ipynb) of this module we used the Jacobi method (a relaxation scheme) to iteratively find solutions to Laplace and Poisson equations. And it worked, so why are we still talking about it? Because the Jacobi method is slow, very slow to converge. It might not have seemed that way in the first two notebooks because we were using small grids, but we did need more than 3,000 iterations to reach the exit criterion while solving the Poisson equation on a $41\times 41$ grid. You can confirm this below: using `nx,ny=` $128$ on the Laplace problem of Lesson 1, the Jacobi method requires nearly *20,000* iterations before we reach $10^{-8}$ for the L2-norm of the difference between two iterates. That's a *lot* of iterations! Now, consider this application: an incompressible Navier-Stokes solver has to ensure that the velocity field is divergence-free at every timestep. One of the most common ways to ensure this is to solve a Poisson equation for the pressure field. In fact, the pressure Poisson equation is responsible for the majority of the computational expense of an incompressible Navier-Stokes solver. Imagine having to do 20,000 Jacobi iterations for *every* time step in a fluid-flow problem with many thousands or perhaps millions of grid points! The Jacobi method is the slowest of all relaxation schemes, so let's learn how to improve on it. In this lesson, we'll study the Gauss-Seidel method—twice as fast as Jacobi, in theory—and the successive over-relaxation (SOR) method. We also have some neat Python tricks lined up for you to get to the solution even faster. Let's go! ### Test problem Let's use the same example problem as in [Lesson 1](./05_01_2D.Laplace.Equation.ipynb): Laplace's equation with boundary conditions \begin{equation} \begin{gathered} p=0 \text{ at } x=0\\ \frac{\partial p}{\partial x} = 0 \text{ at } x = L\\ p = 0 \text{ at }y = 0 \\ p = \sin \left( \frac{\frac{3}{2}\pi x}{L} \right) \text{ at } y = H \end{gathered} \end{equation} We import our favorite Python libraries, and also some custom functions that we wrote in [Lesson 1](./05_01_2D.Laplace.Equation.ipynb), which we have saved in a 'helper' Python file for re-use. ```python import numpy from matplotlib import pyplot, cm from mpl_toolkits.mplot3d import Axes3D %matplotlib inline from matplotlib import rcParams rcParams['font.family'] = 'serif' rcParams['font.size'] = 16 ``` ```python from laplace_helper import p_analytical, plot_3D, L2_rel_error ``` We now have the analytical solution in the array `p_analytical`, and we have the functions `plot_3D` and `L2_rel_error` in our namespace. If you can't remember how they work, just use `help()` and take advantage of the docstrings. It's a good habit to always write docstrings in your functions, and now you see why! In this notebook, we are going to use larger grids than before, to better illustrate the speed increases we achieve with different iterative methods. Let's create a $128\times128$ grid and initialize. ```python nx = 128 ny = 128 L = 5 H = 5 x = numpy.linspace(0,L,nx) y = numpy.linspace(0,H,ny) dx = L/(nx-1) dy = H/(ny-1) p0 = numpy.zeros((ny, nx)) p0[-1,:] = numpy.sin(1.5*numpy.pi*x/x[-1]) ``` We said above that the Jacobi method takes nearly 20,000 iterations before it satisfies our exit criterion of $10^{-8}$ (L2-norm difference between two consecutive iterations). You'll just have to confirm that now. Have a seat! ```python def laplace2d(p, l2_target): '''Solves the Laplace equation using the Jacobi method with a 5-point stencil Parameters: ---------- p: 2D array of float Initial potential distribution l2_target: float Stopping criterion Returns: ------- p: 2D array of float Potential distribution after relaxation ''' l2norm = 1 pn = numpy.empty_like(p) iterations = 0 while l2norm > l2_target: pn = p.copy() p[1:-1,1:-1] = .25 * (pn[1:-1,2:] + pn[1:-1,:-2] +\ pn[2:,1:-1] + pn[:-2,1:-1]) ##Neumann B.C. along x = L p[1:-1,-1] = .25 * (2*pn[1:-1,-2] + pn[2:,-1] + pn[:-2, -1]) l2norm = numpy.sqrt(numpy.sum((p - pn)**2)/numpy.sum(pn**2)) iterations += 1 return p, iterations ``` ```python l2_target = 1e-8 p, iterations = laplace2d(p0.copy(), l2_target) print ("Jacobi method took {} iterations at tolerance {}".\ format(iterations, l2_target)) ``` Jacobi method took 19993 iterations at tolerance 1e-08 Would we lie to you? 19,993 iterations before we reach the exit criterion of $10^{-8}$. Yikes! We can also time how long the Jacobi method takes using the `%%timeit` cell-magic. Go make some tea, because this can take a while—the `%%timeit` magic runs the function a few times and then averages their runtimes to give a more accurate result. - - - ##### Notes 1. When using `%%timeit`, the return values of a function (`p` and `iterations` in this case) *won't* be saved. 2. We document our timings below, but your timings can vary quite a lot, depending on your hardware. In fact, you may not even see the same trends (some recent hardware can play some fancy tricks with optimizations that you have no control over). - - - With those caveats, let's give it a shot: ```python %%timeit laplace2d(p0.copy(), l2_target) ``` 1 loops, best of 3: 5.92 s per loop The printed result above (and others to come later) is from a mid-2007 Mac Pro, powered by two 3-GHz quad-core Intel Xeon X5364 (Clovertown). We tried also on more modern machines, and got conflicting results—like the Gauss-Seidel method being slightly slower than Jacobi, even though it required fewer iterations. Don't get too hung up on this: the hardware optimizations applied by more modern CPUs are varied and make a big difference sometimes. Meanwhile, let's check the overall accuracy of the numerical calculation by comparing it to the analytical solution. ```python pan = p_analytical(x,y) ``` ```python L2_rel_error(p,pan) ``` 6.1735513352884566e-05 That's a pretty small error. Let's assume it is good enough and focus on speeding up the process. ## Gauss-Seidel You will recall from [Lesson 1](./05_01_2D.Laplace_Equation.ipynb) that a single Jacobi iteration is written as: \begin{equation} p^{k+1}_{i,j} = \frac{1}{4} \left(p^{k}_{i,j-1} + p^k_{i,j+1} + p^{k}_{i-1,j} + p^k_{i+1,j} \right) \end{equation} The Gauss-Seidel method is a simple tweak to this idea: use updated values of the solution as soon as they are available, instead of waiting for the values in the whole grid to be updated. If you imagine that we progress through the grid points in the order shown by the arrow in Figure 1, then you can see that the updated values $p^{k+1}_{i-1,j}$ and $p^{k+1}_{i,j-1}$ can be used to calculate $p^{k+1}_{i,j}$. #### Figure 1. Assumed order of updates on a grid. The iteration formula for Gauss-Seidel is thus: \begin{equation} p^{k+1}_{i,j} = \frac{1}{4} \left(p^{k+1}_{i,j-1} + p^k_{i,j+1} + p^{k+1}_{i-1,j} + p^k_{i+1,j} \right) \end{equation} There's now a problem for the Python implementation. You can no longer use NumPy's array operations to evaluate the solution updates. Since Gauss-Seidel requires using values immediately after they're updated, we have to abandon our beloved array operations and return to nested `for` loops. Ugh. We don't like it, but if it saves us a bunch of time, then we can manage. But does it? Here's a function to compute the Gauss-Seidel updates using a double loop. ```python def laplace2d_gauss_seidel(p, nx, ny, l2_target): iterations = 0 iter_diff = l2_target+1 #init iter_diff to be larger than l2_target while iter_diff > l2_target: pn = p.copy() iter_diff = 0.0 for j in range(1,ny-1): for i in range(1,nx-1): p[j,i] = .25 * (p[j,i-1] + p[j,i+1] + p[j-1,i] + p[j+1,i]) iter_diff += (p[j,i] - pn[j,i])**2 #Neumann 2nd-order BC for j in range(1,ny-1): p[j,-1] = .25 * (2*p[j,-2] + p[j+1,-1] + p[j-1, -1]) iter_diff = numpy.sqrt(iter_diff/numpy.sum(pn**2)) iterations += 1 return p, iterations ``` We would then run this with the following function call: ```Python p, iterations = laplace2d_gauss_seidel(p,1e-8) ``` <br> But **don't do it**. We did it so that you don't have to! The solution of our test problem with the Gauss-Seidel method required several thousand fewer iterations than the Jacobi method, but it took nearly *10 minutes* to run on our machine. ##### What happened? If you think back to the far off days when you first learned about array operations, you might recall that we discovered that NumPy array operations could drastically improve code performance compared with nested `for` loops. NumPy operations are written in C and pre-compiled, so they are *much* faster than vanilla Python. But the Jacobi method is not algorithmically optimal, giving slow convergence. We want to take advantage of the faster-converging iterative methods, yet unpacking the array operations into nested loops destroys performance. *What can we do?* ## Use Numba! [Numba](http://numba.pydata.org) is an open-source optimizing compiler for Python. It works by reading Python functions that you give it, and generating a compiled version for you—also called Just-In-Time (JIT) compilation. You can then use the function at performance levels that are close to what you can get with compiled languages (like C, C++ and fortran). It can massively speed up performance, especially when dealing with loops. Plus, it's pretty easy to use. Like we overheard at a conference: [*Numba is a Big Deal.*](http://twitter.com/lorenaabarba/status/625383941453656065) ##### Caveat We encourage everyone following the course to use the [Anaconda Python](https://www.continuum.io/downloads) distribution because it's well put-together and simple to use. If you *haven't* been using Anaconda, that's fine, but let us **strongly** suggest that you take the plunge now. Numba is great and easy to use, but it is **not** easy to install without help. Those of you using Anaconda can install it by running <br><br> `conda install numba`<br><br> If you *really* don't want to use Anaconda, you will have to [compile all of Numba's dependencies](https://pypi.python.org/pypi/numba). - - - ### Intro to Numba Let's dive in! Numba is great and easy to use. We're going to first walk you through a simple example to give you a taste of Numba's abilities. After installing Numba (see above), we can use it by adding a line to `import numba` and another to `import autojit` (more on this in a bit). ```python import numba from numba import jit ``` You tell Numba which functions you want to accelerate by using a [Python decorator](http://www.learnpython.org/en/Decorators), a special type of command that tells the Python interpreter to modify a callable object (like a function). For example, let's write a quick function to calculate the $n^{\text{th}}$ number in the Fibonacci sequence: ```python def fib_it(n): a = 1 b = 1 for i in range(n-2): a, b = b, a+b return b ``` There are several faster ways to program the Fibonacci sequence, but that's not a concern right now (but if you're curious, [check them out](http://mathworld.wolfram.com/BinetsFibonacciNumberFormula.html)). Let's use `%%timeit` and see how long this simple function takes to find the 500,000-th Fibonacci number. ```python %%timeit fib_it(500000) ``` 1 loops, best of 3: 4.22 s per loop Now let's try Numba! Just add the `@jit` decorator above the function name and let's see what happens! ```python @jit def fib_it(n): a = 1 b = 1 for i in range(n-2): a, b = b, a+b return b ``` ```python %%timeit fib_it(500000) ``` The slowest run took 138.50 times longer than the fastest. This could mean that an intermediate result is being cached 1000 loops, best of 3: 499 µs per loop *Holy cow!* In our machine, that's more than 8,000 times faster! That warning from `%%timeit` is due to the compilation overhead for Numba. The very first time that it executes the function, it has to compile it, then it caches that code for reuse without extra compiling. That's the 'Just-In-Time' bit. You'll see it disappear if we run `%%timeit` again. ```python %%timeit fib_it(500000) ``` 1000 loops, best of 3: 499 µs per loop We would agree if you think that this is a rather artificial example, but the speed-up is very impressive indeed. Just adding the one-word decorator! ##### Running in `nopython` mode Numba is very clever, but it can't optimize everything. When it can't, rather than failing to run, it will fall back to the regular Python, resulting in poor performance again. This can be confusing and frustrating, since you might not know ahead of time which bits of code will speed up and which bits won't. To avoid this particular annoyance, you can tell Numba to use `nopython` mode. In this case, your code will simply fail if the "jitted" function can't be optimized. It's simply an option to give you "fast or nothing." Use `nopython` mode by adding the following line above the function that you want to JIT-compile: ```Python @jit(nopython=True) ``` - - - ##### Numba version check In these examples, we are using the latest (as of publication) version of Numba: 0.22.1. Make sure to upgrade or some of the code examples below may not run. - - - ```python print(numba.__version__) ``` 0.22.1 ## Back to Jacobi We want to compare the performance of different iterative methods under the same conditions. Because the Gauss-Seidel method forces us to unpack the array operations into nested loops (which are very slow in Python), we use Numba to get the code to perform well. Thus, we need to write a new Jacobi method using for-loops and Numba (instead of NumPy), so we can make meaningful comparisons. Let's write a "jitted" Jacobi with loops. ```python @jit(nopython=True) def laplace2d_jacobi(p, pn, l2_target): '''Solves the Laplace equation using the Jacobi method with a 5-point stencil Parameters: ---------- p: 2D array of float Initial potential distribution pn: 2D array of float Allocated array for previous potential distribution l2_target: float Stopping criterion Returns: ------- p: 2D array of float Potential distribution after relaxation ''' iterations = 0 iter_diff = l2_target+1 #init iter_diff to be larger than l2_target denominator = 0.0 ny, nx = p.shape l2_diff = numpy.zeros(20000) while iter_diff > l2_target: for j in range(ny): for i in range(nx): pn[j,i] = p[j,i] iter_diff = 0.0 denominator = 0.0 for j in range(1,ny-1): for i in range(1,nx-1): p[j,i] = .25 * (pn[j,i-1] + pn[j,i+1] + pn[j-1,i] + pn[j+1,i]) #Neumann 2nd-order BC for j in range(1,ny-1): p[j,-1] = .25 * (2*pn[j,-2] + pn[j+1,-1] + pn[j-1, -1]) for j in range(ny): for i in range(nx): iter_diff += (p[j,i] - pn[j,i])**2 denominator += (pn[j,i]*pn[j,i]) iter_diff /= denominator iter_diff = iter_diff**0.5 l2_diff[iterations] = iter_diff iterations += 1 return p, iterations, l2_diff ``` ```python p, iterations, l2_diffJ = laplace2d_jacobi(p0.copy(), p0.copy(), 1e-8) print("Numba Jacobi method took {} iterations at tolerance {}".format(iterations, l2_target)) ``` Numba Jacobi method took 19993 iterations at tolerance 1e-08 ```python %%timeit laplace2d_jacobi(p0.copy(), p0.copy(), 1e-8) ``` 1 loops, best of 3: 2.41 s per loop In our old machine, that's faster than the NumPy version of Jacobi, but on some newer machines it might not be. Don't obsess over this: there is much hardware black magic that we cannot control. Remember that NumPy is a highly optimized library. The fact that we can get competitive execution times with this JIT-compiled code is kind of amazing. Plus(!) now we get to try out those techniques that aren't possible with NumPy array operations. ##### Note We're also saving the history of the L2-norm of the difference between consecutive iterations. We'll take a look at that once we have a few more methods to compare. - - - ##### Another Note Why did we use ```Python l2_diff = numpy.zeros(20000) ``` Where did the `20000` come from? We cheated a little bit. Numba doesn't handle _mutable_ objects well in `nopython` mode, which means we can't use a *list* and append each iteration's value of the L2-norm. So we need to define an array big enough to hold all of them and we know from the first run that Jacobi converges in fewer than 20,000 iterations. - - - ##### Challenge task It is possible to get a good estimate of the number of iterations needed by the Jacobi method to reduce the initial error by a factor $10^{-m}$, for given $m$. The formula depends on the largest eigenvalue of the coefficient matrix, which is known for the discrete Poisson problem on a square domain. See Parviz Moin, *"Fundamentals of Engineering Numerical Analysis"* (2nd ed., pp.141–143). * Find the estimated number of iterations to reduce the initial error by $10^{-8}$ when using the grids listed below, in the section on grid convergence, with $11$, $21$, $41$ and $81$ grid points on each coordinate axis. ## Back to Gauss-Seidel If you recall, the reason we got into this Numba sidetrack was to try out Gauss-Seidel and compare the performance with Jacobi. Recall from above that the formula for Gauss-Seidel is as follows: \begin{equation} p^{k+1}_{i,j} = \frac{1}{4} \left(p^{k+1}_{i,j-1} + p^k_{i,j+1} + p^{k+1}_{i-1,j} + p^k_{i+1,j} \right) \end{equation} We only need to slightly tweak the Jacobi function to get one for Gauss-Seidel. Instead of updating `p` in terms of `pn`, we just update `p` using `p`! ```python @jit(nopython=True) def laplace2d_gauss_seidel(p, pn, l2_target): '''Solves the Laplace equation using Gauss-Seidel method with a 5-point stencil Parameters: ---------- p: 2D array of float Initial potential distribution pn: 2D array of float Allocated array for previous potential distribution l2_target: float Stopping criterion Returns: ------- p: 2D array of float Potential distribution after relaxation ''' iterations = 0 iter_diff = l2_target + 1 #initialize iter_diff to be larger than l2_target denominator = 0.0 ny, nx = p.shape l2_diff = numpy.zeros(20000) while iter_diff > l2_target: for j in range(ny): for i in range(nx): pn[j,i] = p[j,i] iter_diff = 0.0 denominator = 0.0 for j in range(1,ny-1): for i in range(1,nx-1): p[j,i] = .25 * (p[j,i-1] + p[j,i+1] + p[j-1,i] + p[j+1,i]) #Neumann 2nd-order BC for j in range(1,ny-1): p[j,-1] = .25 * (2*p[j,-2] + p[j+1,-1] + p[j-1, -1]) for j in range(ny): for i in range(nx): iter_diff += (p[j,i] - pn[j,i])**2 denominator += (pn[j,i]*pn[j,i]) iter_diff /= denominator iter_diff = iter_diff**0.5 l2_diff[iterations] = iter_diff iterations += 1 return p, iterations, l2_diff ``` ```python p, iterations, l2_diffGS = laplace2d_gauss_seidel(p0.copy(), p0.copy(), 1e-8) print("Numba Gauss-Seidel method took {} iterations at tolerance {}".format(iterations, l2_target)) ``` Numba Gauss-Seidel method took 13939 iterations at tolerance 1e-08 Cool! Using the most recently updated values of the solution in the Gauss-Seidel method saved 6,000 iterations! Now we can see how much faster than Jacobi this is, because both methods are implemented the same way: ```python %%timeit laplace2d_gauss_seidel(p0.copy(), p0.copy(), 1e-8) ``` 1 loops, best of 3: 2.09 s per loop We get some speed-up over the Numba version of Jacobi, but not a lot. And you may see quite different results—on some of the machines we tried, we could still not beat the NumPy version of Jacobi. This can be confusing, and hard to explain without getting into the nitty grity of hardware optimizations. Don't lose hope! We have another trick up our sleeve! ## Successive Over-Relaxation (SOR) Successive over-relaxation is able to improve on the Gauss-Seidel method by using in the update a linear combination of the previous and the current solution, as follows: \begin{equation} p^{k+1}_{i,j} = (1 - \omega)p^k_{i,j} + \frac{\omega}{4} \left(p^{k+1}_{i,j-1} + p^k_{i,j+1} + p^{k+1}_{i-1,j} + p^k_{i+1,j} \right) \end{equation} The relaxation parameter $\omega$ will determine how much faster SOR will be than Gauss-Seidel. SOR iterations are only stable for $0 < \omega < 2$. Note that for $\omega = 1$, SOR reduces to the Gauss-Seidel method. If $\omega < 1$, that is technically an "under-relaxation" and it will be slower than Gauss-Seidel. If $\omega > 1$, that's the over-relaxation and it should converge faster than Gauss-Seidel. Let's write a function for SOR iterations of the Laplace equation, using Numba to get high performance. ```python @jit(nopython=True) def laplace2d_SOR(p, pn, l2_target, omega): '''Solves the Laplace equation using SOR with a 5-point stencil Parameters: ---------- p: 2D array of float Initial potential distribution pn: 2D array of float Allocated array for previous potential distribution l2_target: float Stopping criterion omega: float Relaxation parameter Returns: ------- p: 2D array of float Potential distribution after relaxation ''' iterations = 0 iter_diff = l2_target + 1 #initialize iter_diff to be larger than l2_target denominator = 0.0 ny, nx = p.shape l2_diff = numpy.zeros(20000) while iter_diff > l2_target: for j in range(ny): for i in range(nx): pn[j,i] = p[j,i] iter_diff = 0.0 denominator = 0.0 for j in range(1,ny-1): for i in range(1,nx-1): p[j,i] = (1-omega)*p[j,i] + omega*.25 * (p[j,i-1] + p[j,i+1] + p[j-1,i] + p[j+1,i]) #Neumann 2nd-order BC for j in range(1,ny-1): p[j,-1] = .25 * (2*p[j,-2] + p[j+1,-1] + p[j-1, -1]) for j in range(ny): for i in range(nx): iter_diff += (p[j,i] - pn[j,i])**2 denominator += (pn[j,i]*pn[j,i]) iter_diff /= denominator iter_diff = iter_diff**0.5 l2_diff[iterations] = iter_diff iterations += 1 return p, iterations, l2_diff ``` That wasn't too bad at all. Let's try this out first with $\omega = 1$ and check that it matches the Gauss-Seidel results from above. ```python l2_target = 1e-8 omega = 1 p, iterations, l2_diffSOR = laplace2d_SOR(p0.copy(), p0.copy(), l2_target, omega) print("Numba SOR method took {} iterations\ at tolerance {} with omega = {}".format(iterations, l2_target, omega)) ``` Numba SOR method took 13939 iterations at tolerance 1e-08 with omega = 1 We have the exact same number of iterations as Gauss-Seidel. That's a good sign that things are working as expected. Now let's try to over-relax the solution and see what happens. To start, let's try $\omega = 1.5$. ```python l2_target = 1e-8 omega = 1.5 p, iterations, l2_diffSOR = laplace2d_SOR(p0.copy(), p0.copy(), l2_target, omega) print("Numba SOR method took {} iterations\ at tolerance {} with omega = {}".format(iterations, l2_target, omega)) ``` Numba SOR method took 7108 iterations at tolerance 1e-08 with omega = 1.5 Wow! That really did the trick! We dropped from 13939 iterations down to 7108. Now we're really cooking! Let's try `%%timeit` on SOR. ```python %%timeit laplace2d_SOR(p0.copy(), p0.copy(), l2_target, omega) ``` 1 loops, best of 3: 1.18 s per loop Things continue to speed up. But we can do even better! ### Tuned SOR Above, we picked $\omega=1.5$ arbitrarily, but we would like to over-relax the solution as much as possible without introducing instability, as that will result in the fewest number of iterations. For square domains, it turns out that the ideal factor $\omega$ can be computed as a function of the number of nodes in one direction, e.g., `nx`. \begin{equation} \omega \approx \frac{2}{1+\frac{\pi}{nx}} \end{equation} This is not some arbitrary formula, but its derivation lies outside the scope of this course. (If you're curious and have some serious math chops, you can check out Reference 3 for more information). For now, let's try it out and see how it works. ```python l2_target = 1e-8 omega = 2./(1 + numpy.pi/nx) p, iterations, l2_diffSORopt = laplace2d_SOR(p0.copy(), p0.copy(), l2_target, omega) print("Numba SOR method took {} iterations\ at tolerance {} with omega = {:.4f}".format(iterations, l2_target, omega)) ``` Numba SOR method took 1110 iterations at tolerance 1e-08 with omega = 1.9521 Wow! That's *very* fast. Also, $\omega$ is very close to the upper limit of 2. SOR tends to work fastest when $\omega$ approaches 2, but don't be tempted to push it. Set $\omega = 2$ and the walls will come crumbling down. Let's see what `%%timeit` has for us now. ```python %%timeit laplace2d_SOR(p0.copy(), p0.copy(), l2_target, omega) ``` 10 loops, best of 3: 184 ms per loop Regardless of the hardware in which we tried this, the tuned SOR gave *big* speed-ups, compared to the Jacobi method (whether implemented with NumPy or Numba). Now you know why we told you at the end of [Lesson 1](http://nbviewer.ipython.org/github/numerical-mooc/numerical-mooc/blob/master/lessons/05_relax/05_01_2D.Laplace.Equation.ipynb) that the Jacobi method is the *worst* iterative solver and almost never used. Just to convince ourselves that everything is OK, let's check the error after the 1,110 iterations of tuned SOR: ```python L2_rel_error(p,pan) ``` 7.7927433550683514e-05 Looking very good, indeed. We didn't explain it in any detail, but notice the very interesting implication of Equation $(6)$: the ideal relaxation factor is a function of the grid size. Also keep in mind that the formula only works for square domains with uniform grids. If your problem has an irregular geometry, you will need to find a good value of $\omega$ by numerical experiments. ## Decay of the difference between iterates In the [Poisson Equation notebook](./05_02_2D.Poisson.Equation.ipynb), we noticed how the norm of the difference between consecutive iterations first dropped quite fast, then settled for a more moderate decay rate. With Gauss-Seidel, SOR and tuned SOR, we reduced the number of iterations required to reach the stopping criterion. Let's see how that reflects on the time history of the difference between consecutive solutions. ```python pyplot.figure(figsize=(8,8)) pyplot.xlabel(r'iterations', fontsize=18) pyplot.ylabel(r'$L_2$-norm', fontsize=18) pyplot.semilogy(numpy.trim_zeros(l2_diffJ,'b'), 'k-', lw=2, label='Jacobi') pyplot.semilogy(numpy.trim_zeros(l2_diffGS,'b'), 'k--', lw=2, label='Gauss-Seidel') pyplot.semilogy(numpy.trim_zeros(l2_diffSOR,'b'), 'g-', lw=2, label='SOR') pyplot.semilogy(numpy.trim_zeros(l2_diffSORopt,'b'), 'g--', lw=2, label='Optimized SOR') pyplot.legend(fontsize=16); ``` The Jacobi method starts out with very fast convergence, but then it settles into a slower rate. Gauss-Seidel shows a faster rate in the first few thousand iterations, but it seems to be slowing down towards the end. SOR is a lot faster to converge, though, and optimized SOR just plunges down! ## References 1. [Gonsalves, Richard J. Computational Physics I. State University of New York, Buffalo: (2011): Section 3.1 ](http://www.physics.buffalo.edu/phy410-505/2011/index.html) 2. Moin, Parviz, "Fundamentals of Engineering Numerical Analysis," Cambridge University Press, 2nd edition (2010). 3. Young, David M. "A bound for the optimum relaxation factor for the successive overrelaxation method." Numerische Mathematik 16.5 (1971): 408-413. ```python from IPython.core.display import HTML css_file = '../../styles/numericalmoocstyle.css' HTML(open(css_file, "r").read()) ``` <link href='http://fonts.googleapis.com/css?family=Alegreya+Sans:100,300,400,500,700,800,900,100italic,300italic,400italic,500italic,700italic,800italic,900italic' rel='stylesheet' type='text/css'> <link href='http://fonts.googleapis.com/css?family=Arvo:400,700,400italic' rel='stylesheet' type='text/css'> <link href='http://fonts.googleapis.com/css?family=PT+Mono' rel='stylesheet' type='text/css'> <link href='http://fonts.googleapis.com/css?family=Shadows+Into+Light' rel='stylesheet' type='text/css'> <link href='http://fonts.googleapis.com/css?family=Nixie+One' rel='stylesheet' type='text/css'> <link href='https://fonts.googleapis.com/css?family=Source+Code+Pro' rel='stylesheet' type='text/css'> <style> @font-face { font-family: "Computer Modern"; src: url('http://mirrors.ctan.org/fonts/cm-unicode/fonts/otf/cmunss.otf'); } #notebook_panel { /* main background */ background: rgb(245,245,245); } div.cell { /* set cell width */ width: 750px; } div #notebook { /* centre the content */ background: #fff; /* white background for content */ width: 1000px; margin: auto; padding-left: 0em; } #notebook li { /* More space between bullet points */ margin-top:0.8em; } /* draw border around running cells */ div.cell.border-box-sizing.code_cell.running { border: 1px solid #111; } /* Put a solid color box around each cell and its output, visually linking them*/ div.cell.code_cell { background-color: rgb(256,256,256); border-radius: 0px; padding: 0.5em; margin-left:1em; margin-top: 1em; } div.text_cell_render{ font-family: 'Alegreya Sans' sans-serif; line-height: 140%; font-size: 125%; font-weight: 400; width:600px; margin-left:auto; margin-right:auto; } /* Formatting for header cells */ .text_cell_render h1 { font-family: 'Nixie One', serif; font-style:regular; font-weight: 400; font-size: 45pt; line-height: 100%; color: rgb(0,51,102); margin-bottom: 0.5em; margin-top: 0.5em; display: block; } .text_cell_render h2 { font-family: 'Nixie One', serif; font-weight: 400; font-size: 30pt; line-height: 100%; color: rgb(0,51,102); margin-bottom: 0.1em; margin-top: 0.3em; display: block; } .text_cell_render h3 { font-family: 'Nixie One', serif; margin-top:16px; font-size: 22pt; font-weight: 600; margin-bottom: 3px; font-style: regular; color: rgb(102,102,0); } .text_cell_render h4 { /*Use this for captions*/ font-family: 'Nixie One', serif; font-size: 14pt; text-align: center; margin-top: 0em; margin-bottom: 2em; font-style: regular; } .text_cell_render h5 { /*Use this for small titles*/ font-family: 'Nixie One', sans-serif; font-weight: 400; font-size: 16pt; color: rgb(163,0,0); font-style: italic; margin-bottom: .1em; margin-top: 0.8em; display: block; } .text_cell_render h6 { /*use this for copyright note*/ font-family: 'PT Mono', sans-serif; font-weight: 300; font-size: 9pt; line-height: 100%; color: grey; margin-bottom: 1px; margin-top: 1px; } .CodeMirror{ font-family: "Source Code Pro"; font-size: 90%; } .alert-box { padding:10px 10px 10px 36px; margin:5px; } .success { color:#666600; background:rgb(240,242,229); } </style>

4180c554be123d4a53ce2a397bd1fb65d4d0fa9d

ipynb

Jupyter Notebook

lessons/05_relax/05_03_Iterate.This.ipynb

sergiommr/numerical-mooc

b088e9d205f15dbc22f83e45c2181a2c5809365f

2018-04-12T08:05:58.000Z

2022-03-31T17:24:14.000Z

lessons/05_relax/05_03_Iterate.This.ipynb

sergiommr/numerical-mooc

b088e9d205f15dbc22f83e45c2181a2c5809365f

2017-01-16T20:53:59.000Z

2017-01-16T20:53:59.000Z

lessons/05_relax/05_03_Iterate.This.ipynb

sergiommr/numerical-mooc

b088e9d205f15dbc22f83e45c2181a2c5809365f

2016-05-02T16:47:17.000Z

2020-03-24T16:24:16.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

```python %matplotlib inline ``` 使用 PyTorch 进行 深度学习 ************************** 翻译者： http://www.studyai.com/antares 深度学习构建块: 仿射映射, 非线性单元 和 目标函数 ========================================================================== 深度学习包括以聪明的方式组合线性和非线性。非线性的引入使模型变得很强大。 在本节中，我们将使用这些核心组件，构造一个目标函数，并查看模型是如何训练的。 仿射映射 ~~~~~~~~~~~ 深度学习的核心工作之一是仿射映射(affine map)，它是一个函数 $f(x)$ ，其中 \begin{align}f(x) = Ax + b\end{align} 对矩阵 $A$ 和向量 $x, b$. 这里我们要学习的参数就是 $A$ 和 $b$. 通常, $b$ 被称之为 偏置项(the *bias* term)。 PyTorch和大多数其他深度学习框架所做的事情与传统的线性代数略有不同。它映射输入的行而不是列。 也就是说，下面第 $i$ 行的输出是输入的第 $i$ 行的映射，再加上偏置项。看下面的例子。 ```python # Author: Robert Guthrie import torch import torch.nn as nn import torch.nn.functional as F import torch.optim as optim torch.manual_seed(1) ``` ```python lin = nn.Linear(5, 3) # maps from R^5 to R^3, parameters A, b # data is 2x5. A maps from 5 to 3... can we map "data" under A? data = torch.randn(2, 5) print(lin(data)) # yes ``` 非线性单元 ~~~~~~~~~~~~~~~ 首先, 注意以下事实, 它告诉我们为什么需要非线性单元。假定 我们有两个仿射映射： $f(x) = Ax + b$ 和 $g(x) = Cx + d$ 。 那么 $f(g(x))$ 是什么呢？ \begin{align}f(g(x)) = A(Cx + d) + b = ACx + (Ad + b)\end{align} $AC$ 是一个矩阵 而 $Ad + b$ 是一个向量, 因此我们看到组合仿射映射之后的结果还是仿射映射。 从这里，你可以看到，如果你想要你的神经网络是很多仿射变换构成的长链条，这并没有为你的模型增加新的能力， 你的模型，最终只是做单个仿射映射而已。 如果我们在仿射层之间引入非线性，情况就不再是这样了，我们可以建立更强大的模型。 已经有一些核心的非线性单元: $\tanh(x), \sigma(x), \text{ReLU}(x)$ 是最常见的。 你或许会质疑: "为什么非得是这些非线性函数? 我可以想到的其他形式的非线性函数多如牛毛"。 这主要是因为它们的梯度非常容易计算，而且梯度计算在学习中有着至关重要的作用。 比如说： \begin{align}\frac{d\sigma}{dx} = \sigma(x)(1 - \sigma(x))\end{align} 注意：虽然你在AI类的介绍中学到了一些神经网络，其中 $\sigma(x)$ 是默认的非线性单元， 但在实践中人们通常回避它。这是因为梯度随着参数绝对值的增长而迅速消失。 小梯度意味着很难学习。大多数人默认为tanh或relu。 ```python # 在 pytorch 中, 大多数非线性单元是在 torch.nn.functional (我们将它导入为F) # 注意，非线性单元通常没有仿射映射那样的可学习参数。也就是说，他们没有在训练中更新的权重。 data = torch.randn(2, 2) print(data) print(F.relu(data)) ``` 软最大化 和 概率分布 ~~~~~~~~~~~~~~~~~~~~~~~~~ 函数 $\text{Softmax}(x)$ 也是一个非线性函数，但它的特殊之处在于它通常是网络中的最后一次运算。 这是因为它接受一个实数向量，并返回一个概率分布。 其定义如下。设 $x$ 是实数向量(正的，负的，随便什么，没有约束)。 那么 $\text{Softmax}(x)$ 的第 i 个分量是: \begin{align}\frac{\exp(x_i)}{\sum_j \exp(x_j)}\end{align} 应该清楚的是，输出是一个概率分布：每个元素都是非负的，所有分量之和等于 1。 你也可以认为它只是对输入向量进行按元素的指数运算，使一切非负，然后除以归一化常数。 ```python # Softmax 也在 torch.nn.functional 中 data = torch.randn(5) print(data) print(F.softmax(data, dim=0)) print(F.softmax(data, dim=0).sum()) # Sums to 1 because it is a distribution! print(F.log_softmax(data, dim=0)) # theres also log_softmax ``` 目标函数 ~~~~~~~~~~~~~~~~~~~ 目标函数是您的网络正在被训练以最小化的函数(在这种情况下，它通常被称为损失函数 *loss function* 或代价(成本)函数 *cost function*)。 首先选择一个训练实例，通过你的神经网络运行它，然后计算输出的损失。 然后利用损失函数的导数对模型的参数进行更新。直觉地说，如果你的模型对它的答案完全有信心， 而且它的答案是错误的，那么你的损失就会很大。如果它对它的答案很有信心， 而且它的答案是正确的，那么损失就会很小。 在你的训练样例上最小化损失函数的思想是，希望您的网络能够很好地泛化(generalize)， 并在开发集、测试集或生产中的未见过的样例中损失较小。 一个典型的损失函数是负对数似然损失(*negative log likelihood loss*)， 这是多类分类的一个非常常见的目标。对于有监督的多类分类， 这意味着训练网络最小化正确输出的负对数概率(或等效地，最大化正确输出的对数概率)。 优化和训练 ========================= 那么，我们能为一个实例计算一个损失函数吗？那我们该怎么办？我们早些时候看到张量知道如何计算该张量 相对于那些计算出它的变量的梯度。既然我们的损失是张量，我们就可以计算所有用于计算它的参数的梯度！ 然后我们可以执行标准梯度更新。设 $\theta$ 为我们的参数，$L(\theta)$ 为损失函数， $\eta$ 为正的学习速率.然后: \begin{align}\theta^{(t+1)} = \theta^{(t)} - \eta \nabla_\theta L(\theta)\end{align} 有大量的算法和积极的研究试图做的不仅仅是这个普通的梯度更新。许多人试图根据训练时段发生的情况来改变学习速度。 除非您真正感兴趣，否则您不需要担心这些算法具体做了什么。Torch在 Torch.optim 包中提供了许多学习速率调节策略，而且它们都是完全透明的。 使用最简单的梯度更新和更复杂的算法是一样的。尝试不同的更新算法和更新算法的不同参数 (比如不同的初始学习速率)对于优化网络的性能非常重要。 通常，用Adam或RMSProp这样的优化器代替普通的SGD会显着地提高性能。 在 PyTorch 中创建神经网络组件 ====================================== 在我们继续关注NLP之前，让我们做一个带注释的例子，在PyTorch中使用仿射映射和非线性来构建网络。 我们还将看到如何计算损失函数，使用PyTorch的负对数似然，并通过反向传播更新参数。 所有网络组件都应该继承nn.Module并覆盖forward()方法。嗯，没错，就是这样一个套路。 从nn.Module继承可以为组件提供很多功能。例如，它可以跟踪它的可训练参数， 您可以使用 ``.to(device)`` 方法在CPU和GPU之间交换它， 其中设备可以是CPU设备 ``torch.device("cpu")`` 或CUDA设备 ``torch.device("cuda:0")`` 。 让我们编写一个带标注的示例网络，它接受稀疏的词袋表示(sparse bag-of-words representation)， 并在两个标签上输出概率分布：“英语”和“西班牙语”。这个模型只是个Logistic回归模型。 案例: Logistic回归词袋分类器 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 我们的模型将把稀疏词袋(BoW)表示映射到标签上的概率。我们为词汇库(vocab)的单词分配一个索引(index)。 例如，假设我们的整个词汇是两个单词“hello”和“world”，索引分别为0和1。 "hello hello hello hello" 这个句子的BoW向量是 \begin{align}\left[ 4, 0 \right]\end{align} 对于句子 "hello world world hello" 的 BoW 向量是 \begin{align}\left[ 2, 2 \right]\end{align} etc. 通用意义上说, 它是 \begin{align}\left[ \text{Count}(\text{hello}), \text{Count}(\text{world}) \right]\end{align} 把这个BoW向量记为 $x$ 。 那么我们网络的输出是: \begin{align}\log \text{Softmax}(Ax + b)\end{align} 那就是说, 我们传递输入使其通过一个仿射映射，然后做对数软最大化(log softmax). ```python data = [("me gusta comer en la cafeteria".split(), "SPANISH"), ("Give it to me".split(), "ENGLISH"), ("No creo que sea una buena idea".split(), "SPANISH"), ("No it is not a good idea to get lost at sea".split(), "ENGLISH")] test_data = [("Yo creo que si".split(), "SPANISH"), ("it is lost on me".split(), "ENGLISH")] # word_to_ix maps each word in the vocab to a unique integer, which will be its # index into the Bag of words vector word_to_ix = {} for sent, _ in data + test_data: for word in sent: if word not in word_to_ix: word_to_ix[word] = len(word_to_ix) print(word_to_ix) VOCAB_SIZE = len(word_to_ix) NUM_LABELS = 2 class BoWClassifier(nn.Module): # inheriting from nn.Module! def __init__(self, num_labels, vocab_size): # calls the init function of nn.Module. Dont get confused by syntax, # just always do it in an nn.Module super(BoWClassifier, self).__init__() # Define the parameters that you will need. In this case, we need A and b, # the parameters of the affine mapping. # Torch defines nn.Linear(), which provides the affine map. # Make sure you understand why the input dimension is vocab_size # and the output is num_labels! self.linear = nn.Linear(vocab_size, num_labels) # NOTE! The non-linearity log softmax does not have parameters! So we don't need # to worry about that here def forward(self, bow_vec): # Pass the input through the linear layer, # then pass that through log_softmax. # Many non-linearities and other functions are in torch.nn.functional return F.log_softmax(self.linear(bow_vec), dim=1) def make_bow_vector(sentence, word_to_ix): vec = torch.zeros(len(word_to_ix)) for word in sentence: vec[word_to_ix[word]] += 1 return vec.view(1, -1) def make_target(label, label_to_ix): return torch.LongTensor([label_to_ix[label]]) model = BoWClassifier(NUM_LABELS, VOCAB_SIZE) # 模型知道它的参数. 下面的第一个输出是A, 第二个输出是 b。 # 不论何时，你给一个module的 __init__() 函数中的类变量分配一个组件 # 就像这一句做的这样：self.linear = nn.Linear(...) # 然后通过一些 Python的魔法函数，你的module(本例中的 BoWClassifier )将会存储关于 nn.Linear 的参数的知识 for param in model.parameters(): print(param) # 要运行这个模型, 传递一个 BoW vector # 这里我们先不考虑训练, 因此代码被封装在 torch.no_grad() 中： with torch.no_grad(): sample = data[0] bow_vector = make_bow_vector(sample[0], word_to_ix) log_probs = model(bow_vector) print(log_probs) ``` 以上哪个值对应于英语的对数概率(log probability)，哪个值对应于西班牙语？我们从来没有定义过它， 但是如果我们想训练它的话，我们就需要这样做。 ```python label_to_ix = {"SPANISH": 0, "ENGLISH": 1} ``` 所以让我们训练吧！为此，我们把样本实例传给网络获取输出的对数概率，计算损失函数的梯度，然后用梯度更新一步参数。 损失函数由PyTorch中的nn包提供。nn.nLLoss() 是我们想要的负对数似然损失(negative log likelihood loss)。 PyTorch中的torch.optim包中定义了优化函数。在这里，我们将只使用SGD。 注意，NLLoss的 *input* 是对数概率的向量还有目标标签向量。它不计算我们的对数概率(log probabilities)。 这就是为什么我们网络的最后一层是 log softmax。损失函数nn.CrossEntroyLoss()与NLLoss()相同， 只是它为您做了log softmax。 ```python # 在我们训练之前在测试数据上运行一下模型, 这么做是想把训练前后模型在测试数据上的输出做个对比 with torch.no_grad(): for instance, label in test_data: bow_vec = make_bow_vector(instance, word_to_ix) log_probs = model(bow_vec) print(log_probs) # Print the matrix column corresponding to "creo" print(next(model.parameters())[:, word_to_ix["creo"]]) loss_function = nn.NLLLoss() optimizer = optim.SGD(model.parameters(), lr=0.1) # 通常，您要传递好几次训练数据。100次epoch比在实际数据集上的epoch大得多， # 但实际数据集有两个以上的实例。通常，在5至30个epoch之间是合理的。 for epoch in range(100): for instance, label in data: # Step 1. 请记住，PyTorch累积了梯度。我们需要在每个样例(或batch)之前清除它们 model.zero_grad() # Step 2. 产生我们的BOW向量，同时，我们必须将目标装在一个整数张量中。 # 例如，如果目标是西班牙语，那么我们包装整数0。然后， # 损失函数知道对数概率向量的第0元素是与西班牙语对应的对数概率。 bow_vec = make_bow_vector(instance, word_to_ix) target = make_target(label, label_to_ix) # Step 3. 运行我们的前向传递过程. log_probs = model(bow_vec) # Step 4. 计算 loss, gradients, 并通过调用 optimizer.step() 更新参数 loss = loss_function(log_probs, target) loss.backward() optimizer.step() with torch.no_grad(): for instance, label in test_data: bow_vec = make_bow_vector(instance, word_to_ix) log_probs = model(bow_vec) print(log_probs) # Index corresponding to Spanish goes up, English goes down! print(next(model.parameters())[:, word_to_ix["creo"]]) ``` 我们得到了正确的答案！您可以看到，在第一个样例中西班牙语的对数概率要高得多， 而在第二个测试数据中英语的对数概率要高得多，这是应该的。 现在，您将看到如何制作PyTorch组件，通过它传递一些数据并进行梯度更新。 我们准备深入挖掘深度NLP所能提供的内容。

7afa85ed19e52ac2795c3f25b5a250923b348144

ipynb

Jupyter Notebook

build/_downloads/97d5fed33a2c5bb8f1875babdea02f4c/deep_learning_tutorial.ipynb

ScorpioDoctor/antares02

631b817d2e98f351d1173b620d15c4a5efed11da

build/_downloads/97d5fed33a2c5bb8f1875babdea02f4c/deep_learning_tutorial.ipynb

ScorpioDoctor/antares02

631b817d2e98f351d1173b620d15c4a5efed11da

build/_downloads/97d5fed33a2c5bb8f1875babdea02f4c/deep_learning_tutorial.ipynb

ScorpioDoctor/antares02

631b817d2e98f351d1173b620d15c4a5efed11da

Qwen/Qwen-72B

1. YES 2. YES

__label__yue_Hant

```python from IPython.display import HTML tag = HTML(''' Promijeni vidljivost <a href="javascript:code_toggle()">ovdje</a>.''') display(tag) ``` Promijeni vidljivost <a href="javascript:code_toggle()">ovdje</a>. ```python # Erasmus+ ICCT project (2018-1-SI01-KA203-047081) %matplotlib notebook import numpy as np import math import matplotlib.pyplot as plt from scipy import signal import ipywidgets as widgets import control as c import sympy as sym from IPython.display import Latex, display, Markdown # For displaying Markdown and LaTeX code from fractions import Fraction import matplotlib.patches as patches ``` ## Aproksimacija dominantnim polom Pri proučavanju ponašanja sustava, često ih se aproksimira dominantnim polom ili parom dominantnih kompleksnih polova. Ovaj primjer demonstrira navedeno svojstvo. Sustav drugog reda definiran je sljedećom prijenosnom funkcijom: \begin{equation} G(s)=\frac{\alpha\beta}{(s+\alpha)(s+\beta)}=\frac{1}{(\frac{1}{\alpha}s+1)(\frac{1}{\beta}s+1)}, \end{equation} gdje je $\beta=1$, a $\alpha$ je iterabilan. Sustav trećeg reda definiran je sljedećom prijenosnom funkcijom: \begin{equation} G(s)=\frac{\alpha{\omega_0}^2}{\big(s+\alpha\big)\big(s^2+2\zeta\omega_0s+\omega_0^2\big)}=\frac{1}{(\frac{1}{\alpha}s+1)(\frac{1}{\omega_0^2}s^2+\frac{2\zeta\alpha}{\omega_0}s+1)}, \end{equation} gdje je $\beta=1$, $\omega_0=4.1$, $\zeta=0.24$ i $\alpha$ je iterabilan. --- ### Kako koristiti ovaj interaktivni primjer? Odaberite između sustava drugog i trećeg reda te pomičite klizač za promjenu položaja pomičnog pola $a$. <sub>Ovaj interaktivni primjer zasnovan je na sljedećem [tutorijalu](https://lpsa.swarthmore.edu/PZXferStepBode/DomPole.html "The Dominant Pole Approximation") autora Prof. Erika Cheevera. ```python # System selector buttons style = {'description_width': 'initial'} typeSelect = widgets.ToggleButtons( options=[('sustav drugog reda', 0), ('sustav trećeg reda', 1),], description='Select: ',style=style) ``` ```python display(typeSelect) continuous_update=False # set up plot fig, ax = plt.subplots(2,1,figsize=[9.8,7],num='Aproksimacija dominantnim polom') plt.subplots_adjust(hspace=0.35) ax[0].grid(True) ax[1].grid(True) # ax[2].grid(which='both', axis='both', color='lightgray') ax[0].axhline(y=0,color='k',lw=.8) ax[1].axhline(y=0,color='k',lw=.8) ax[0].axvline(x=0,color='k',lw=.8) ax[1].axvline(x=0,color='k',lw=.8) ax[0].set_xlabel('Re') ax[0].set_ylabel('Im') ax[0].set_xlim([-10,0.5]) ax[1].set_xlim([-0.5,20]) ax[1].set_xlabel('$t$ [s]') ax[1].set_ylabel('ulaz, izlaz') ax[0].set_title('Dijagram polova i nula') ax[1].set_title('Vremenski odziv') plotzero, = ax[0].plot([], []) response, = ax[1].plot([], []) responseAdom, = ax[1].plot([], []) responseBdom, = ax[1].plot([], []) ax[1].step([0,50],[0,1],color='C0',label='ulaz') # generate x values def response_func(a,index): global plotzero, response, responseAdom, responseBdom # global bodePlot, bodePlotAdom, bodePlotBdom t = np.linspace(0, 50, 1000) if index==0: b=1 num=a*b den=([1,a+b,a*b]) tf_sys=c.TransferFunction(num,den) poles_sys,zeros_sys=c.pzmap(tf_sys, Plot=False) tout, yout = c.step_response(tf_sys,t) den1=([1,a]) tf_sys1=c.TransferFunction(a,den1) toutA, youtA = c.step_response(tf_sys1,t) den2=([1,b]) tf_sys2=c.TransferFunction(b,den2) toutB, youtB = c.step_response(tf_sys2,t) mag, phase, omega = c.bode_plot(tf_sys, Plot=False) # Bode-plot magA, phase, omegaA = c.bode_plot(tf_sys1, Plot=False) # Bode-plot magB, phase, omegaB = c.bode_plot(tf_sys2, Plot=False) # Bode-plot s=sym.Symbol('s') eq=(a*b/((s+a)*(s+b))) eq1=1/(((1/a)*s+1)*((1/b)*s+1)) display(Markdown('Pomični pol (ljubičasta krivulja) $\\alpha$ je jednak %.1f, fiksni pol (crvena krivulja) $b$ je jednak %i; Prijenosna funkcija je:'%(a,1))) display(eq),display(Markdown('or')),display(eq1) elif index==1: omega0=4.1 zeta=0.24 num=a*omega0**2 den=([1,2*zeta*omega0+a,omega0**2+2*zeta*omega0*a,a*omega0**2]) tf_sys=c.TransferFunction(num,den) poles_sys,zeros_sys=c.pzmap(tf_sys, Plot=False) tout, yout = c.step_response(tf_sys,t) den1=([1,a]) tf_sys1=c.TransferFunction(a,den1) toutA, youtA = c.step_response(tf_sys1,t) den2=([1,2*zeta*omega0,omega0**2]) tf_sys2=c.TransferFunction(omega0**2,den2) toutB, youtB = c.step_response(tf_sys2,t) mag, phase, omega = c.bode_plot(tf_sys, Plot=False) # Bode-plot magA, phase, omegaA = c.bode_plot(tf_sys1, Plot=False) # Bode-plot magB, phase, omegaB = c.bode_plot(tf_sys2, Plot=False) # Bode-plot s=sym.Symbol('s') eq=(a*omega0**2/((s+a)*(s**2+2*zeta*omega0*s+omega0*omega0))) eq1=1/(((1/a)*s+1)*((1/(omega0*omega0))*s*s+(2*zeta*a/omega0)*s+1)) display(Markdown('Pomični pol (ljubičasta krivulja) $\\alpha$ je jednak %.1f, fiksni pol (crvena krivulja) $\\beta$ je jednak $1\pm4j$ ($\omega_0$ je postavljen na 4.1, $\zeta$ je postavljen na 0.24). Prijenosna funkcija je:'%(a))) display(eq),display(Markdown('ili')),display(eq1) ax[0].lines.remove(plotzero) ax[1].lines.remove(response) ax[1].lines.remove(responseAdom) ax[1].lines.remove(responseBdom) plotzero, = ax[0].plot(np.real(poles_sys), np.imag(poles_sys), 'xg', markersize=10, label = 'pol') response, = ax[1].plot(tout,yout,color='C1',label='odziv sustava',lw=3) responseAdom, = ax[1].plot(toutA,youtA,color='C4',label='odziv zasnovan samo na pomičnom polu (paru polova)') responseBdom, = ax[1].plot(toutB,youtB,color='C3',label='odziv zasnovan samo na fiksnom polu') ax[0].legend() ax[1].legend() a_slider=widgets.FloatSlider(value=0.1, min=0.1, max=10, step=.1, description='$\\alpha$:',disabled=False,continuous_update=False, orientation='horizontal',readout=True,readout_format='.2f',) input_data=widgets.interactive_output(response_func,{'a':a_slider,'index':typeSelect}) def update_slider(index): global a_slider aval=[0.1,0.1] a_slider.value=aval[index] input_data2=widgets.interactive_output(update_slider,{'index':typeSelect}) display(a_slider,input_data) ``` ToggleButtons(description='Select: ', options=(('sustav drugog reda', 0), ('sustav trećeg reda', 1)), style=To… <IPython.core.display.Javascript object> FloatSlider(value=0.1, continuous_update=False, description='$\\alpha$:', max=10.0, min=0.1) Output() ```python ```

e1970d321f3e7c1d3aa28440562909c8832dc37b

ipynb

Jupyter Notebook

ICCT_hr/examples/02/TD-12-Aproksimacija_dominantnim_polom.ipynb

ICCTerasmus/ICCT

fcd56ab6b5fddc00f72521cc87accfdbec6068f6

2021-05-22T18:42:14.000Z

2021-10-03T14:10:22.000Z

ICCT_hr/examples/02/.ipynb_checkpoints/TD-12-Aproksimacija_dominantnim_polom-checkpoint.ipynb

ICCTerasmus/ICCT

fcd56ab6b5fddc00f72521cc87accfdbec6068f6

ICCT_hr/examples/02/.ipynb_checkpoints/TD-12-Aproksimacija_dominantnim_polom-checkpoint.ipynb

ICCTerasmus/ICCT

fcd56ab6b5fddc00f72521cc87accfdbec6068f6

2021-05-24T11:40:09.000Z

2021-08-29T16:36:18.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__hrv_Latn

# Using DQN to cross a bridge in World of Warcraft ## The bridge The bridge can be found at coordinates X:1669.62, Y:-3731.47, Z:148.3 in the zone Howling Fjord. The bridge have no rails thus the agent can easily fall off. The goal is to cross the bridge without falling down with the help of DQN. A trained agent should be able to cross. The bridge is also slightly tilted from the north. For this task, Keras will be used for modeling the network. <table width="100%" border="0"> <tr> <td></td> <td></td> </tr> </table> ```python from keras.models import Sequential, load_model from keras.optimizers import Adam, RMSprop from keras.layers import Dense, Flatten, Dropout from keras.callbacks import TensorBoard, EarlyStopping from keras.initializers import RandomUniform from collections import deque import random import numpy as np import matplotlib.pyplot as plt from shapely.geometry import Point from shapely.geometry.polygon import Polygon from ctypes import cdll, POINTER, c_float, c_int from random import randint from time import sleep from IPython.display import clear_output ``` ## Measured constants The first step was to measure the bridge as a polygon concealed within four points. These four points are initalized below and were measured from the World of Warcraft client. The inital start position x and y is between the eastern and western starting point. The variables k and m are the linear equation between the end points on the other side of the bridge. This linear equation is useful to determine if the agent passed the end of the bridge or not. The step size is equal to half the width of the bridge. This will determine how many units the agent will move in every step. The bridge is contained within a polygon that will use the raycasting algorithm to decide if the agent is in or outside the polygon aka the bridge. The image visualize the polygon that surrounds the bridge in the simulation. ```python bridge_start_west = np.array([-3728.34, 1668.16]) bridge_start_east = np.array([-3734.89, 1668.64]) bridge_end_west = np.array([-3735.31, 1580.07]) bridge_end_east = np.array([-3741.63, 1580.53]) init_pos = np.sum([bridge_start_west, bridge_start_east], axis=0) / 2 k = (bridge_end_west[1] - bridge_end_east[1]) / (bridge_end_west[0] - bridge_end_east[0]) m = bridge_end_west[1] -(k * bridge_end_west[0]) step_size = np.abs((bridge_start_west[0] - bridge_start_east[0]) / 2) current_angle = 0 polygon = Polygon([bridge_start_west, bridge_start_east, bridge_end_east, bridge_end_west]) ``` ## Determine goal The goal line can be defined as: \begin{align} y = kx + m \end{align} If the agents current y position is less than the goals y, the agent crossed the bridge. The reason why the agent y have to be lesser is beacuse it move in a north to south direction. ```python def is_goal(x, y): goal_y = (k*x) + m return y < goal_y ``` ## Is within bridge This is calculated with the Shapley library that implement the raycasting algorithm. ```python def is_within_bridge(x, y): point = Point(x, y) return polygon.contains(point) ``` ## Calculate distance from the right edge To determine the distance to the right edge, the linear equation is calculated for the right sided line. This will be used to later calculate the perpendicular line. The x position in realtion to the edge can then be solved by finding what x is intersection both lines. The euclidean distance can then be used once we have the x and y on the right edge line compared to the agents current position. The first two methods are only used to plot how far the agent reach after each episode. ```python def get_start_edge(): k_s = (bridge_start_west[1] - bridge_start_east[1]) / (bridge_start_west[0] - bridge_start_east[0]) m_s = bridge_start_west[1] -(k_s * bridge_start_west[0]) return k_s, m_s k_s, m_s = get_start_edge() ``` ```python def get_start_edge_dist(x, y): k_p = -1 / k_s m_p = y - (k_p * x); x_new = (m_p - m_s) / (k_s - k_p); y_new = (k_s*x_new) + m_s; a = (x_new - x); b = (y_new - y); d = np.sqrt(a**2 + b**2); return d ``` ```python def get_right_edge(): k_r = (bridge_start_west[1] - bridge_end_west[1]) / (bridge_start_west[0] - bridge_end_west[0]) m_r = bridge_end_west[1] -(k_r * bridge_end_west[0]) return k_r, m_r k_r, m_r = get_right_edge() ``` ```python def get_edge_dist(x, y): k_p = -1 / k_r m_p = y - (k_p * x); x_new = (m_p - m_r) / (k_r - k_p); y_new = (k_r*x_new) + m_r; a = (x_new - x); b = (y_new - y); d = np.sqrt(a**2 + b**2); return d ``` ## Avaliable actions The agent have four avaliable actions that follows: <ol> <li>Adjust angle $+\frac{\pi}{8}$ radians</li> <li>Adjust angle $+\frac{\pi}{4}$ radians</li> <li>Adjust angle 0 radians</li> <li>Adjust angle $-\frac{\pi}{8}$ radians</li> <li>Adjust angle $-\frac{\pi}{4}$ radians</li> </ol> ```python def get_new_angle(action): v = np.pi / 8 return{ 0 : current_angle + v, 1 : current_angle + v*2, 2 : current_angle, 3 : current_angle - v, 4 : current_angle - v*2, }[action] ``` ## New position from predicted angle Once the new angle is predicted, the new position can be determined from the current position. The figure below visualizes how the triangle can look before a step where the current angle is equal to $\alpha$. Since $sin(\alpha) = \frac{a}{c}$ and $cos(\alpha) = \frac{b}{c}$, $a$ and $b$ can be calculated from this. The new position $x'$ and $y'$ ten evaluates to: $x' = x + a$, $y' = y + b$. ```python def do_action(action, x, y): v = get_new_angle(action) current_angle = v a = step_size * np.sin(v); b = step_size * np.cos(v); x_new = x - a; y_new = y - b; return x_new, y_new ``` ## Rewards These are the rewards that will determine how the agent perform. ```python terminate_reward = 100 step_reward = -1 stuck_reward = -100 state_size = 2 action_size = 5 ``` ## Step The state contain two variables, the curent angle and the distance to the right edge in realtion to the agent. ```python def step(action, p_x, p_y): tmp_player_x = p_x tmp_player_y = p_y new_pos = do_action(action, p_x, p_y) p_x = new_pos[0] p_y = new_pos[1] reward = 0 done = False if is_goal(p_x, p_y): done = True reward = terminate_reward elif is_within_bridge(p_x, p_y): reward = step_reward else: p_x = tmp_player_x p_y = tmp_player_y reward = stuck_reward; done = True state = np.reshape([current_angle, get_edge_dist(p_x, p_y)], [1, state_size]) return state, reward, done, p_x, p_y ``` ```python def reset(): p_x = init_pos[0] p_y = init_pos[1] current_angle = 0 state = np.reshape([current_angle, get_edge_dist(p_x, p_y)], [1, state_size]) return state, p_x, p_y ``` ## The DQN The agent class contain the logic for the DQN. The netowrk consist of two hidden layers with 40 neurons each. The neural net is visualized below. ```python model_path = "my_model.h5" class Agent: def __init__(self, state_size, action_size, discount, eps, eps_decay, eps_min, l_rate, decay_linear): self.path = model_path self.state_size = state_size self.action_size = action_size self.mem = deque(maxlen=2000) self.discount = discount self.eps = eps self.eps_decay = eps_decay self.decay_linear = decay_linear self.eps_min = eps_min self.l_rate = l_rate self.model = self.init_model() def load_model(self): return load_model(self.path) def save_model(self): self.model.save(self.path) def init_model(self): model = Sequential() model.add(Dense(40, input_dim=self.state_size, activation='relu')) model.add(Dense(40, activation='relu')) model.add(Dense(self.action_size, activation='linear')) model.compile(loss='mse', optimizer=Adam(lr=self.l_rate)) return model def action(self, state): if np.random.rand() <= self.eps: return random.randrange(self.action_size) actions = self.model.predict(state) return np.argmax(actions[0]) def remember(self, state, action, reward, next_state, terminal): self.mem.append((state, action, reward, next_state, terminal)) def replay(self, batch_size): if len(self.mem) < batch_size: batch = self.mem else: batch = random.sample(self.mem, batch_size) for state, action, reward, next_state, terminal in batch: target = reward if not terminal: target += self.discount * np.amax(self.model.predict(next_state)[0]) target_f = self.model.predict(state) target_f[0][action] = target self.model.fit(state, target_f, epochs=1, verbose=0) self.decay() def decay(self): if self.eps > self.eps_min: if self.decay_linear: self.eps -= self.eps_decay else: self.eps *= self.eps_decay ``` ```python agent = Agent( state_size = state_size, action_size = action_size, discount = 0.98, eps = 1, eps_decay = 0.001, eps_min = 0.001, l_rate = 0.001, decay_linear = True ) #Train agent episodes = 2000 steps = 100 print_freq = 100 goalCounter = 0 goalAvg = -1 stepCounter = 0 epGoalCounter = 0 epGoalAvg = -1 epStepCounter = 0 total_ep = [] total_rewards = [] total_distance = [] for ep in range(1, episodes + 1): state, p_x, p_y = reset() player_x = p_x player_y = p_y total_reward = 0 for st in range(1, steps): action = agent.action(state) next_state, reward, done, p_x, p_y = step(action, player_x, player_y) total_reward += reward player_x = p_x player_y = p_y agent.remember(state, action, reward, next_state, done) state = next_state if done: if reward > 1: goalCounter += 1 epGoalCounter += 1 epStepCounter += st epGoalAvg = epStepCounter / epGoalCounter break agent.replay(32) if ep % print_freq == 0 or ep == 1: total_ep.append(ep) total_rewards.append(total_reward) total_distance.append(get_start_edge_dist(player_x, player_y)) print("episode {} done, found goal {} times with and avg step of {}, total goals: {}".format(ep, epGoalCounter, epGoalAvg, goalCounter)) epGoalCounter = 0 epGoalAvg = -1 epStepCounter = 0 agent.save_model() print("summary: total goals found: {}, an avg of {} episodes reached the goal".format(goalCounter, goalCounter/episodes)) ``` episode 1 done, found goal 0 times with and avg step of -1, total goals: 0 episode 100 done, found goal 0 times with and avg step of -1, total goals: 0 episode 200 done, found goal 0 times with and avg step of -1, total goals: 0 episode 300 done, found goal 2 times with and avg step of 30.5, total goals: 2 episode 400 done, found goal 8 times with and avg step of 30.375, total goals: 10 episode 500 done, found goal 13 times with and avg step of 30.53846153846154, total goals: 23 episode 600 done, found goal 25 times with and avg step of 30.96, total goals: 48 episode 700 done, found goal 28 times with and avg step of 30.392857142857142, total goals: 76 episode 800 done, found goal 33 times with and avg step of 30.393939393939394, total goals: 109 episode 900 done, found goal 71 times with and avg step of 30.718309859154928, total goals: 180 episode 1000 done, found goal 90 times with and avg step of 30.68888888888889, total goals: 270 episode 1100 done, found goal 100 times with and avg step of 29.45, total goals: 370 episode 1200 done, found goal 100 times with and avg step of 29.06, total goals: 470 episode 1300 done, found goal 100 times with and avg step of 28.42, total goals: 570 episode 1400 done, found goal 100 times with and avg step of 28.85, total goals: 670 episode 1500 done, found goal 100 times with and avg step of 28.69, total goals: 770 episode 1600 done, found goal 100 times with and avg step of 30.03, total goals: 870 episode 1700 done, found goal 100 times with and avg step of 29.4, total goals: 970 episode 1800 done, found goal 100 times with and avg step of 29.81, total goals: 1070 episode 1900 done, found goal 100 times with and avg step of 29.14, total goals: 1170 episode 2000 done, found goal 100 times with and avg step of 29.25, total goals: 1270 summary: total goals found: 1270, an avg of 0.635 episodes reached the goal ```python plt.plot(total_ep, total_rewards) plt.title('Total reward from start') plt.ylabel('Reward') plt.xlabel('Episode') plt.legend(['Reward'], loc='upper left') plt.show() ``` ```python plt.plot(total_ep, total_distance, color='orange') plt.title('Distance from start over time') plt.ylabel('Distance') plt.xlabel('Episode') plt.legend(['Distance'], loc='upper left') plt.show() ``` ## Testing the trained network in the client The last step is to confirm that the trained network works in the World of Warcraft client. To do this Click to move was used to walk towards a given x and y. This is an built in function for World of Warcraft. This can be accsed by manipulating memory variables with a language such as C++. The python class ctypes allow for calls to compiled C++ classes. The libenv.so were compiled with MinGW and the source code for this library can be found at: https://github.com/Jacobth/wow_rl_environment. ```python lib = cdll.LoadLibrary('libenv.so') class Env(object): def __init__(self): self.obj = lib.Env() def reset(self, init_x, init_y): lib.ResetTest.argtypes = [c_float, c_float] lib.ResetTest(self.obj, init_x, init_y) def step(self, new_x, new_y): lib.StepTest.argtypes = [c_float, c_float] lib.StepTest(self.obj, new_x, new_y) def get_pos(self): lib.GetPos.restype = POINTER(c_float * 2) values = lib.GetPos(self.obj).contents x = values[0] y = values[1] return x, y ``` ```python def test_model() : env = Env() model = load_model(model_path) state, p_x, p_y = reset() env.reset(c_float(p_x), c_float(p_y)) pl_x = p_x pl_y = p_y total_reward = 0 total_steps = 0 while True: action = np.argmax(model.predict(state)[0]) next_state, reward, done, p_x, p_y = step(action, pl_x, pl_y) env.step(c_float(p_x), c_float(p_y)) state = next_state pl_x = p_x pl_y = p_y total_reward += reward total_steps += 1 if done: print("completed with reward: {} and {} steps.".format(total_reward, total_steps)) break; test_model() ``` completed with reward: 72 and 29 steps. This method can be used to test if the right distance behave correctly in the client. ```python def test_dist() : env = Env() while True: x, y = env.get_pos() print(get_edge_dist(x, y)) sleep(0.5) clear_output() #test_dist() ```

2bbd43c3db81ee7eefdd67a20d59d7f62052634d

ipynb

Jupyter Notebook

wow_rl_sim.ipynb

Jacobth/wow_sim_notebook

bf398442e2f6d9ddf7ea8ae02ebe563252db4c2d

wow_rl_sim.ipynb

Jacobth/wow_sim_notebook

bf398442e2f6d9ddf7ea8ae02ebe563252db4c2d

wow_rl_sim.ipynb

Jacobth/wow_sim_notebook

bf398442e2f6d9ddf7ea8ae02ebe563252db4c2d

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# Data Fitting Exercises # 2. Linear Least-Squares ### How to define a line of &ldquo;best fit&rdquo; In the previous exercise, you used the `linregress` function to calculate a line of best fit to your experimental data. But what is this function actually doing, and how do we define the quality of fit for a particular straight line? In this exercise, you will work through the maths behind linear regression, and then learn how to implement this using functions in Python as a more general optimisation problem. ### The maths Linear regression addresses the problem of how to find a line of &ldquo;best fit&rdquo; for some data that is appriximately described by a straight line. For example. we might have the data shown in the figure below: and we want to find the straight line that best describes the relationship between $x$ and $y$: How do we find the &ldquo;best&rdquo; line for this particular data set? The equation of a straight line is \begin{equation} y=mx+c. \end{equation} This is a mathematical function that defines a set of $y$ values from a set of $x$ values, for any pair or parameters, $m$ and $c$. More generally, we can say that $y$ is a function of some model parameters, $P$, and the input $x$: \begin{equation} y = f(P,x). \end{equation} In our example of a straight line, the parameter set $P$ contains the slope and intercept of the line: \begin{equation} P=\left\{m,c\right\}, \end{equation} and the function $f$ is \begin{equation} f(P,x) = P_0 x + P_1. \end{equation} Now $P_0$ is the slope, and $P_1$ is the intercept. In principle, we could choose any combination of $P_0$ and $P_1$ for our model parameters. Every combination gives a different straight line, which might be a better, or worse, fit to our experimental data. To decide which set of model parameters best describes our real data, we need a way to score the agreement between the model $f(P,x)$ and the data. A common way to quantify the error between the model and the real data is to calculate the **sum of squared errors**. For every $x$ value in our input data set, we can calculate the $y_\mathrm{predicted}$ value predicted by the model. The difference between this predicted value and the real $y$ value for this data point is the **error** for that data point. To quantify the overall error of this particular model, we can add up the *squares* of all the error terms: \begin{equation} \mathrm{error} = \sum_i\left[y_i - f(P,x_i)\right]^2 \end{equation} Adding *squares* means that positive and negative errors contribute equally to the total error. We can now determine mathematically whether one model is a better &ldquo;fit&rdquo; to the data than another. A better quality of fit will give us a smaller error. The **best** fit to the data (for this particular model function) is given by the set of parameters that **minimises** the error. The procedure of finding a set of model parameters that minimises the sum of squared errors is often called **least-squares** fitting. ### The code In Python the model straight-line function can be expressed using the following function: >```python def model_function( P, x ): m = P[0] c = P[1] y = m * x + c return y ``` If you compare this to the mathematical function definition above, you should see the same structure in both the mathematical description and the Python representation. The function `model_function()` also looks similar to the `line()` function you used in Exercise 1. ```python def line( m, c, x ): y = m * x + c return y ``` The only difference is that in `model_function()` we pass in the model **parameters** as a **list**. This is then unpacked inside the function, instead of passing in $m$ and $c$ separately. <div class="alert alert-success"> In the code cell below, define the functions <span style='font-family:monospace'>model_function()</span> and <span style='font-family:monospace'>line()</span>. Using <span style='font-family:monospace'>x = 2</span>, check that both these functions return the same $y$ values for pairs of parameters, $m$ and $c$. For the <span style='font-family:monospace'>model_function()</span> function, remember that the parameters need to be passed in as a **list**. </div> ```python ``` We can also write a Python function that calculates the error between the predictions of our model function and the real $y$ values: >```python def error_function( P, x, y ): y_predicted = model_function( P, x ) error_terms = y - y_predicted total_error = np.sum( error_terms**2 ) return total_error ``` * The first line calls the `model_function()` function with the list of model parameters, $P$, and the input $x$ values. This returns a set of *predicted* $y$ values for this particular model. * The second line calculates the error terms, i.e. the differences between the predicted and actual $y$ values. * The third line calculates the sum of squared errors. * The fourth line returns the error. <div class="alert alert-success"> By copying the appropriate code from Exercise 1, or writing it from scratch, read in the experimental data from <span style='font-family:monospace'>'data/equilibrium_constant.dat'</span> and plot it as points. <br/><br/> Using the <span style='font-family:monospace'>model_function()</span> function, generate a series of lines with different parameters, and plot these against the experimental data. <br/><br/> Define the function <span style='font-family:monospace'>error_function()</span>. For each of your guessed model parameter sets, calculate the error. You should see that models that appear closer to the experimental data give you lower errors. </div> ```python ``` You should have seen how changing the parameters for your model lets you generate different lines, that each do better or worse jobs of describing the experimental data. In each case, the quality of fit between your model and the data is given by the error, calculated with your error function. The final step in the problem is to find the **least-squares** solution. This corresponds to the set of model parameters that **minimise** the result from your error function. Finding the minimum or maximum of a function is a common mathematical problem, and there are a large number of algorithms for doing this numerically, using computers. The `scipy` module contains functions for doing exactly this, in `scipy.optimize`. For this exercise, you will import the `minimize()` function, and use this to find the parameters that minimise the output of your error function. You can import the `minimize()` function as follows: >```python from scipy.optimize import minimize ``` The `minimize()` function can be given a [large number of options](https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize.html), but the simplest usage requires three arguments: >```python minimize( function_to_minimise, initial_guess, other_arguments ) ``` - The first argument, `function_to_minimise`, is the name of the function to minimise. For this exercise, this is `error_function`. - The second argument, `initial_guess`, is a starting guess for the parameters that you want to fit. e.g. you might guess that `P=[1.0,1.0]`. - The third argument is a list of any other arguments that need to be passed into the function you are minimising. In this exercise, your function `error_function` takes three arguments: `error_function( P, x, y )`: The first is the set of model parameters, which you want to change during the fitting. The second and third are the **observed** $x$ and $y$ values (here these are $1/T$ and $\ln{K}$) for each data point. These do not change during the fit, and get passed into `minimize()` as a list in the `other_arguments` position. e.g. if you have stored the $1/T$ ($x$ values) and $\ln{K}$ ($y$ values) for the experimental data in numpy arrays called, respectively, `inverse_temperature` and `ln_K` then you could write >```python P_initial = [ 1.0, 1.0 ] other_args = inverse_temperature, ln_K minimize( error_function, P_initial, other_args ) ``` The `other_arg = inverse_temperature, ln_K` command stores the $x$ and $y$ data values in a data type called a **tuple**. From the perspective of this exercise, a tuple is like a list, in that it can store multiple values (here you store two `numpy` arrays). <div class="alert alert-success"> In the following code cell, import the <span style='font-family:monospace'>minimize</span> function, and use it to minimise your error function, with the experimental data you loaded previously. </div> ```python ``` Your output should look like: ``` fun: 0.026018593683863903 hess_inv: array([[ 1.53892987e+06, -4.95784961e+03], [ -4.95784961e+03, 1.60346929e+01]]) jac: array([ 1.53901055e-07, -1.45286322e-07]) message: 'Optimization terminated successfully.' nfev: 60 nit: 4 njev: 15 status: 0 success: True x: array([ 6917.390252 , -21.05540855]) ``` You will see that a lot of information about the fit is produced. For this exercise, the important parts of the output are the `message`, which tells you whether the optimisation was successful, and the result labelled `x`, which gives the input parameters that minimise your error function. The value of the error function with these optimised model parameters is given by the `fun` result. You can access specific parts of the output by appending the variable names to the end of your `minimize()` call, e.g. to get the optimal parameters you can write >```python minimize( error_function, P_initial, other_args ).x ``` <div class="alert alert-success"> Repeat your optimisation, and store the optimised model parameters in a variable <span style='font-family:monospace'>P_opt</span>. Check these values against the fitted slope and intercept you found in Exercise 1. </div>

21e4f0482649d0a6c83292947cdc588e651fc1b3

ipynb

Jupyter Notebook

Data_Fitting_Exercise_S2_2.ipynb

pythoninchemistry/chem_data_analysis_jupyter

4af545f1a8acdded28d96508bb5adc8929da92cc

2019-05-05T00:21:55.000Z

2021-09-16T14:15:15.000Z

Data_Fitting_Exercise_S2_2.ipynb

pythoninchemistry/chem_data_analysis_jupyter

4af545f1a8acdded28d96508bb5adc8929da92cc

Data_Fitting_Exercise_S2_2.ipynb

pythoninchemistry/chem_data_analysis_jupyter

4af545f1a8acdded28d96508bb5adc8929da92cc

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# Entscheidungsbäume Alice beobachtet die Tennisspieler auf dem Tennisplatz vor ihrem Haus. Sie möchte herausfinden, wie die Spieler entscheiden, bei welchem Wetter die Spieler Tennis spielen und wann nicht. Sie macht die folgenden Beobachtungen: Erstellen Sie einen Entscheidungsbaum auf Basis dieser Trainingsdaten. Notieren Sie an jedem Knoten die Anzahl der yes- und no-Instanzen. Benutzen Sie die Informationsentropie als Maß für Knotenreinheit. # K-Nearest-Neighbor-Klassifikator Betrachten sie folgende Teilmenge des Iris-Datensatzes: | Sepal.Length | Sepal.Width | Petal.Length | Petal.Width | Species| | ------------- |-------------| -----|------|------| | 5.1 | 3.5 | 1.4 | 0.2 | setosa | 4.9 | 3.0 | 1.4 | 0.2 | setosa | 7.0 | 3.2 | 4.7 | 1.4 | versicolor | 6.4 | 3.2 | 4.5 | 1.5 | versicolor Klassifizieren Sie das Sample | 6.9 | 3.0 | 3.5 | 1 | |-|-|-|-| mit einem k-nearest-Neighbor-Klassifikator. Verwenden Sie k=1 und die euklidische Distanz. # Kerndichteschätzung In der Vorlesung haben Sie Kerndichteschätzer als eine nichtparametrische Methode zum Darstellen einer Verteilung kennen gelernt. Dabei wird eine Verteilung an einem Punkt $t$ wie folgt dargestellt: \begin{equation} p(t) = \frac{1}{n \, h} \sum_{i=1}^n \varphi\left(\frac{t-x_i}{h}\right) \end{equation} Hierbei ist $\varphi$ eine Fenster-Funktion, z.B. das Gauß-Fenster \begin{equation} \varphi(u) = \frac{1}{\sqrt{2\pi}} e^{-u^2/2} \end{equation} ## Aufgabe 1 Implementieren Sie die Funktion `kde(t,h,x)`, die für einen Punkt $t$, eine Fenster-Breite $h$ und ein Array von Trainings-Pukten $x$, die Kerndichteschätzung für $p(t)$ berechnet. ```python import math import numpy as np import matplotlib.pyplot as plt def kde(t,h,x): #TODO return None def k1(t): return 1/math.sqrt(2*math.pi) * math.exp(-1/2 * t**2) example = np.concatenate((np.random.normal(0,1,100),np.random.normal(5,1,100))) dens = [kde(t,0.5,example) for t in np.arange(-2,8,0.05)] plt.plot(dens) ``` ## Aufgabe 2 Implementieren Sie die Funktion `classify_kde(xnew,x,classes)`, die eine Klassifikation mit dem Kerndichteschätzer durchführt. Das bedeutet, es handelt sich um einen Bayes-Klassifikator, bei dem die Likelihood mit dem Kerndichteschätzer geschätzt wird. ```python import pandas as pd from scipy.io import arff def classify_kde(xnew,x,classes): #TODO return None data = arff.loadarff('features1.arff') df = pd.DataFrame(data[0]) feat = df["AccX_mean"] cl = df["class"] p = [classify_kde(x,feat,cl) for x in feat] np.mean(p == cl) ```

096a43efe076eb1af87aa754c3eaf94665f43ae3

ipynb

Jupyter Notebook

05-Weitere-Klassifikatoren.ipynb

stefanluedtke/AI-II-Exercises

a1e816375c58f52609c3f7683b17a35fed64bc1d

05-Weitere-Klassifikatoren.ipynb

stefanluedtke/AI-II-Exercises

a1e816375c58f52609c3f7683b17a35fed64bc1d

05-Weitere-Klassifikatoren.ipynb

stefanluedtke/AI-II-Exercises

a1e816375c58f52609c3f7683b17a35fed64bc1d

Qwen/Qwen-72B

1. YES 2. YES

__label__deu_Latn

<div style='background-image: url("title01.png") ; padding: 0px ; background-size: cover ; border-radius: 5px ; height: 200px'> <div style="float: right ; margin: 50px ; padding: 20px ; background: rgba(255 , 255 , 255 , 0.7) ; width: 50% ; height: 150px"> <div style="position: relative ; top: 50% ; transform: translatey(-50%)"> <div style="font-size: xx-large ; font-weight: 900 ; color: rgba(0 , 0 , 0 , 0.8) ; line-height: 100%">Computers, Waves, Simulations</div> <div style="font-size: large ; padding-top: 20px ; color: rgba(0 , 0 , 0 , 0.5)">Finite-Difference Method - High-Order Taylor Operators</div> </div> </div> </div> #### This exercise covers the following aspects * Learn how to define high-order central finite-difference operators * Investigate the behaviour of the operators with increasing length #### Basic Equations The Taylor expansion of $f(x + dx)$ around $x$ is defined as $$ f(x+dx)=\sum_{n=0}^\infty \frac{f^{(n)}(x)}{n!}dx^{n} $$ Finite-difference operators can be calculated by seeking weights (here: $a$, $b$, $c$) with which function values have to be multiplied to obtain an interpolation or a derivative. Example: $$ \begin{align} a ~ f(x + dx) & \ = \ a ~ \left[ ~ f(x) + f^{'} (x) dx + \frac{1}{2!} f^{''} (x) dx^2 + \dotsc ~ \right] \\ b ~ f(x) & \ = \ b ~ \left[ ~ f(x) ~ \right] \\ c ~ f(x - dx) & \ = \ c ~ \left[ ~ f(x) - f^{'} (x) dx + \frac{1}{2!} f^{''} (x) dx^2 - \dotsc ~ \right] \end{align} $$ This can be expressed in matrix form by comparing coefficients, here seeking a 2nd derivative $$ \begin{align} &a ~~+~~ ~~~~b &+~~ c & = & 0 \\ &a ~~\phantom{+}~~ \phantom{b} &-~~ c & = & 0 \\ &a ~~\phantom{+}~~ \phantom{b} &+~~ c & = & \frac{2!}{\mathrm{d}x^2} \end{align} $$ which leads to $$ \begin{pmatrix} 1 & 1 & 1 \\ 1 & 0 & -1 \\ 1 & 0 & 1 \end{pmatrix} \begin{pmatrix} a\\ b \\ c \end{pmatrix} = \begin{pmatrix} 0\\ 0 \\ \frac{2!}{dx^2} \end{pmatrix} $$ and using matrix inversion we obtain $$ \begin{pmatrix} a \\ b\\ c \end{pmatrix} = \begin{pmatrix} \frac{1}{2 \mathrm{d}x^2} \\ - \frac{2}{2 \mathrm{d}x^2} \\ \frac{1}{2 \mathrm{d}x^2} \end{pmatrix} $$ This is the the well known 3-point operator for the 2nd derivative. This can easily be generalized to higher point operators and higher order derivatives. Below you will find a routine that initializes the system matrix and solves for the Taylor operator. #### Calculating the Taylor operator The subroutine `central_difference_coefficients()` initializes the system matrix and solves for the difference weights assuming $dx=1$. It calculates the centered differences using an arbitrary number of coefficients, also for higher derivatives. The weights are defined at $x\pm i dx$ and $i=0,..,(nop-1)/2$, where $nop$ is the length of the operator. Careful! Because it is centered $nop$ has to be an odd number (3,5,...)! It returns a central finite difference stencil (a vector of length $nop$) for the `n`th derivative. ```python # Import libaries import math import numpy as np import matplotlib.pyplot as plt ``` ```python # Define function to calculate Taylor operators def central_difference_coefficients(nop, n): """ Calculate the central finite difference stencil for an arbitrary number of points and an arbitrary order derivative. :param nop: The number of points for the stencil. Must be an odd number. :param n: The derivative order. Must be a positive number. """ m = np.zeros((nop, nop)) for i in range(nop): for j in range(nop): dx = j - nop // 2 m[i, j] = dx ** i s = np.zeros(nop) s[n] = math.factorial(n) # The following statement return oper = inv(m) s oper = np.linalg.solve(m, s) # Calculate operator return oper ``` #### Plot Taylor operators Investigate graphically the Taylor operators. Increase $nop$ for the first $n=1$ or higher order derivatives. Discuss the results and try to understand the interpolation operator (derivative order $n=0$). ```python # Calculate and plot Taylor operator # Give length of operator (odd) nop = 25 # Give order of derivative (0 - interpolation, 1 - first derivative, 2 - second derivative) n = 1 # Get operator from routine 'central_difference_coefficients' oper = central_difference_coefficients(nop, n) ``` ```python # Plot operator x = np.linspace(-(nop - 1) / 2, (nop - 1) / 2, nop) # Simple plot with operator plt.figure(figsize=(10, 4)) plt.plot(x, oper,lw=2,color='blue') plt.plot(x, oper,lw=2,marker='o',color='blue') plt.plot(0, 0,lw=2,marker='o',color='red') #plt.plot (x, nder5-ader, label="Difference", lw=2, ls=":") plt.title("Taylor Operator with nop = %i " % nop ) plt.xlabel('x') plt.ylabel('Operator') plt.grid() plt.show() ``` #### Conclusions * The Taylor operator weights decrease rapidly with distance from the central point * In practice often 4th order operators are used to calculate space derivatives

ea6fc4c8cf9813f58ddace380cb6266864a22b93

ipynb

Jupyter Notebook

PDE's/Using Taylor.ipynb

MonitSharma/Computational-Methods-in-Physics

e3b2db36c37dd5f64b9a37ba39e9bb267ba27d85

PDE's/Using Taylor.ipynb

MonitSharma/Computational-Methods-in-Physics

e3b2db36c37dd5f64b9a37ba39e9bb267ba27d85

PDE's/Using Taylor.ipynb

MonitSharma/Computational-Methods-in-Physics

e3b2db36c37dd5f64b9a37ba39e9bb267ba27d85

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

<a href="https://colab.research.google.com/github/anathnath/EDA/blob/master/CBCS_V_SchrodingerEquationPartI.ipynb" target="_parent"></a> # $ \color{green}{ CoreP11-Quantum~ Mechanics~ and~ Application ~lab} $ ## $ \color{green}{West~Bengal ~ State~ University} $ # Quantum Mechanics and Application: 60 class Hours 2 credits # Dr. Anathnath Ghosh # Dum dum Motijheel College # email: anathnath.rivu@gmail.com # References: 1. Physcis in Laboratory including Python # by # Dr. Pradipta Kumar Mandal # 2. Google master ## Elementary Mathematical idea: ## Curve Fitting ```python import numpy as np from scipy.optimize import curve_fit import matplotlib.pyplot as plt plt.style.use('fivethirtyeight') x=np.array([0,10,20,30,40,50,60,70,80,90]) y=np.array([76,92,106,123,132,151,179,203,227,249]) def f(x,a,b,c): return a+b*x+c*x**2 par,var=curve_fit(f,x,y) a,b,c=par plt.plot(x,f(x,a,b,c),'r',label='Fitted Function') plt.scatter(x,y,label='Data Points') plt.xlabel('x') plt.ylabel('f(x)') plt.title("Curve Fitting") plt.legend() plt.show ``` ```python import numpy as np import matplotlib.pyplot as plt plt.style.use('fivethirtyeight') x=2*np.random.randint(0,2,size=1000)-1 x np.cumsum(x) plt.plot(np.cumsum(x)) plt.show() ``` ```python import numpy as np import matplotlib.pyplot as plt import numpy.polynomial.polynomial as poly plt.style.use('fivethirtyeight') x=np.array([0,10,20,30,40,50,60,70,80,90]) y=np.array([76,92,106,123,132,151,179,203,227,249]) coeffs=poly.polyfit(x,y,2) yfit=poly.polyval(x,coeffs) plt.plot(x,y,'o',x,yfit) ``` ```python import numpy as np from scipy import constants as const from scipy import sparse from scipy.sparse.linalg import eigs import matplotlib.pyplot as plt plt.style.use('fivethirtyeight') hbar=const.hbar e=const.e m_e=_e=const.m_e pi=const.pi epsilon_0=const.epsilon_0 l=0 n=1000 r,h=np.linspace(1.0e-9,0.0,n,endpoint=False,retstep=True) coef1=-hbar**2/(2*m_e*h**2) coef2=lambda r: -e**2/(4*pi*epsilon_0*r)+hbar**2/(2*m_e)*l*(l+1)/r**2 D=-2*np.ones(n) D_off=np.ones(n-1) M1=coef1*sparse.diags([D,D_off,D_off],(0,-1,1)) M2=coef2(r)*np.diag(np.ones(n)) H=M1+M2 n_eig=20 eig_val,eig_vec=eigs(H,k=n_eig,which='SM') indx=np.argsort(eig_val) eig_val=eig_val[indx] eig_vec=eig_vec[:,indx] ``` ```python eig_val ``` ```python v=eig_vec.T P=[np.abs(v[i])**2 for i in range(n_eig)] plt.figure(figsize=(12,8)) r=r*1e+10 engy=['E={:5.2f} eV'.format(eig_val[i].real/e) for i in range(3)] engy plt.plot(r,P[0],'-',lw=2,label=engy[0]) plt.plot(r,P[1],'--',lw=2,label=engy[1]) plt.plot(r,P[2],'-.',lw=2,label=engy[2]) plt.legend() plt.xlabel('r $\AA$',size=18) plt.ylabel('Probability density($\AA^{-1})$',size=18) plt.show() ``` # NUMERICAL SOLUTION OF SCHRODINGER WAVE EQUATION 1D ## Method The method we will use here is called the ["Finite Difference Method"](https://en.wikipedia.org/wiki/Finite_difference_method) (see the linked Wikipedia article). In this method we will turn the function $\psi(x)$ into a vector, which is a list in Python, and the operator of the differential equation into a *matrix*. We then end up with a matrix eigenequation, which we can diagonalize to get our answer. ### Discretization The process of discretization is simply turning our continuous space $x$, into a discrete number of steps, $N$, and our function $\psi(x)$ into an array of size $N$. We thus have $N$ values $x_i$, which have a stepsize $h = \Delta x = x_{i+1} - x_i$. Our choice of the *size* of our space, $N$, turns out to be important. Too large a number will slow down our computation and require too much computer memory, too small a number and the answers we compute will not be sufficiently accurate. A common practice is to start with a small number $N$ and then increase it until the accuracy is acceptable. The actual value you obtain in the end will depend on the problem you are studying. ### Forward and Backward first order differential We first need to develop how we will take the derivative of our function. Going back to our introduction to calculus, we remember that the derivative was defined as: $$ \frac{d}{dx} f(x) = \lim_{\Delta x \rightarrow 0} \frac{f(x+\Delta x) - f(x)}{\Delta x} \approx \frac{f(x+h) - f(x)}{h} + \mathrm{O}(h) $$ When we take a *finite difference*, we simply not take the limit all the way down to 0, but stop at $\Delta x = h$. Note that for this equation we evaluate the point just *after* $x$, which we call the *forward difference*. If you actually let $\Delta x \rightarrow 0$, then this does not matter, but if you do a finite difference, you can also do: $$ \frac{d}{dx} f(x) = \lim_{\Delta x \rightarrow 0} \frac{f(x) - f(x-\Delta x)}{\Delta x} \approx \frac{f(x) - f(x-h)}{h} + \mathrm{O}(h) $$ which is known as the *backward difference*. You can also comput a *central difference*, but cannot use steps of $\frac{1}{2}\Delta x$, since that does not exist in our space. The central difference is then a combination of the previous two: $$ \frac{d}{dx} f(x) = \lim_{\Delta x \rightarrow 0} \frac{f(x+\Delta x) - f(x-\Delta x)}{2\Delta x}\approx \frac{f(x+h) - f(x-h)}{2h} + \mathrm{O}(h^2) $$ This last one is a little more accurate than the first two. Note that for any of these approximations to a derivative, we have a problem at the edges of our space. (In Python, C and Java, our space goes from $n=0$ to $n=N-1$, in Fortran $n=1$ to $N$.) Either on one end or the other, there is no $x-\Delta x$ or $x+\Delta x$. Here, we are just not going to worry about this detail. ## Time dependent Schrodinger Equation: ## $i\hbar \frac{\partial \psi(x,t)}{\partial t}=-\frac{\hbar^2}{2m}\frac{\partial^2\psi(x,t)}{\partial t^2}+V(x)\psi(x,t)$ ```python import numpy as np import matplotlib.pyplot as plt plt.style.use('fivethirtyeight') def step(N,v0): v=np.zeros(N) v[int(N/2):]=v0 return v m=1.0 hbar=1.0 N=1000 T=5000 X,dx=np.linspace(0,N-1,N,retstep=True) v0=.019 V=step(N,v0) plt.plot(X,V) Vmax=V.max() dt=hbar/(2*hbar**2/(m*dx**2)+Vmax) c1=hbar*dt/(m*dx**2) c2=2*dt/hbar sigma=40 x0=round(N/2)-5*sigma k0=np.pi/20 E=(hbar**2/2.0/m)*(k0**2+.5/sigma**2) print('Wavepacket energy',E) def gauss(x,x0,sigma): return np.exp(-(x-x0)**2/(2*sigma**2)) n=int(N/2) x=X[:n] gg=gauss(x,x0,sigma) cx=np.cos(k0*x) sx=np.sin(k0*x) R=np.zeros((3,N)) I=np.zeros((3,N)) R[1,:n]=gg*cx I[1,:n]=gg*sx R[0,:n]=gg*cx I[0,:n]=gg*sx P=dx*np.sum(R[1]**2+I[1]**2) nrm=np.sqrt(P) R=R/nrm ``` ```python for t in range(T+1): R0=R[1] I0=I[1] I[2,1:-1]=I[0,1:-1]+c1*(R0[2:]-2*R0[1:-1]+R0[:-2])-c2*V[1:-1]*R0[1:-1] R[2,1:-1]=R[0,1:-1]-c1*(I0[2:]-2*I0[1:-1]+I0[:-2])+c2*V[1:-1]*I0[1:-1] R[0]=R0 R[1]=R[2] I[0]=I0 I[1]=I[2] plt.figure(figsize=(10,8)) prob=R[1]**2+I[1]**2 plt.plot(X,R[1],'-',label='Real') plt.plot(X,I[1],'--',label='Img') plt.plot(X,6*prob,lw=2,label='Prob') plt.plot(X,19*V,'k',lw=3) plt.legend() plt.show() ``` ```python import numpy as np import matplotlib.pyplot as plt plt.style.use('fivethirtyeight') # Define the number of points in our space, N N = 128 a = 2*np.pi # Define the x space from 0 to a with N-1 divisions. x = np.linspace(0,2*np.pi,N) # We want to store step size, this is the reliable way: h = x[1]-x[0] # Should be equal to 2*np.pi/(N-1) # Compute the function, y = sin(x). With numpy this is easy: y = np.sin(x) # We compute the matrix using the np.diag(np.ones(N),0) which creates a # diagonal matrix of 1 of NxN size. Multiply by -1 to get -1 diagonal array. # You get an +1 off-diagonal array of ones, with np.diag(np.ones(N-1),1) # Note that you need N-1 for an NxN array, since the off diagonal is one smaller. # Add the two together and normalize by 1/h Md = 1./h*(np.diag( -1.*np.ones(N),0) + np.diag(np.ones(N-1),1)) # Compute the derivative of y into yp by matrix multiplication: yp = Md.dot(y) # Plot the results. plt.figure(figsize=(10,7)) plt.plot(x,y,label='f(x)') plt.plot(x[:-1],yp[:-1],label='Derivative of f(x)') # Don't plot last value, which is invalid plt.xlabel('x',size=20) plt.ylabel('f(x),df(x)/dx',size=30) plt.legend() plt.show() ``` ```python import numpy as np import matplotlib.pyplot as plt plt.style.use('fivethirtyeight') # Define the number of points in our space, N N = 128 #a = 2*np.pi a=5 # Define the x space from 0 to a with N-1 divisions. x = np.linspace(-5,5,N) # We want to store step size, this is the reliable way: h = x[1]-x[0] # Should be equal to 2*np.pi/(N-1) # Compute the function, y = sin(x). With numpy this is easy: y = x**2*np.exp(-x**2/2) # We compute the matrix using the np.diag(np.ones(N),0) which creates a # diagonal matrix of 1 of NxN size. Multiply by -1 to get -1 diagonal array. # You get an +1 off-diagonal array of ones, with np.diag(np.ones(N-1),1) # Note that you need N-1 for an NxN array, since the off diagonal is one smaller. # Add the two together and normalize by 1/h Md = 1./h*(np.diag( -1.*np.ones(N),0) + np.diag(np.ones(N-1),1)) # Compute the derivative of y into yp by matrix multiplication: yp = Md.dot(y) # Plot the results. plt.figure(figsize=(10,7)) plt.plot(x,y,label='f(x)') plt.plot(x[:-1],yp[:-1],label='Derivative of f(x)') # Don't plot last value, which is invalid plt.xlabel('x',size=20) plt.ylabel('f(x),df/dx',size=20) plt.legend() plt.show() ``` ## Second order Differential We can now extend this method to the second order differential. If we take the backward differential of the result of a forward differential, we get: $$ \frac{d^2}{dx^2}f(x) = \lim_{\Delta x \rightarrow 0} \frac{f'(x)-f'(x-\Delta x)}{\Delta x} = \lim_{\Delta x \rightarrow 0} \frac{f(x+\Delta x) - f(x) - (f(x) - f(x-\Delta x))}{\Delta x^2} \\ \frac{d^2}{dx^2}f(x) = \lim_{\Delta x \rightarrow 0} \frac{f(x+\Delta x) - 2f(x) + f(x-\Delta x))}{\Delta x^2} \approx \frac{f(x+h) - 2f(x) + f(x-h))}{h^2} $$ So in the discrete space we can write this as: $$ f''_i = (f_{i+1} - 2f_i + f_{i-1})/h^2 $$ And finally, as a matrix equation, the second derivative is then: $$ \begin{pmatrix}f''_0 \\ f''_1 \\ f''_2 \\\vdots \\ f''_{N-1}\end{pmatrix} = \frac{1}{h^2} \begin{pmatrix} -2 & 1 & 0 & 0 & \\ 1 & -2 & 1 & 0 & \\ 0& 1 & -2 & 1 & \\ & & \ddots & \ddots & \ddots &\\ & & & 1 & -2 \end{pmatrix}\begin{pmatrix}f_0 \\ f_1 \\ f_2 \\\vdots \\ f_{N-1}\end{pmatrix} $$ Where now we note that at both ends of our array we will get an inaccurate answer unless we do some fixup. The fixup in this case is to use the same elements as the row below (at the start) or the row above (at the end), so we get $f''_0 = f''_1$ and $f''_{N-1} = f''_{N-2}$, which is not great but better than the alternative. We can now try this matrix in Python and compute the second derivative of our $y(x)$ array. ```python Mdd = 1./(h*h)*(np.diag(np.ones(N-1),-1) + np.diag( -2.*np.ones(N),0) + np.diag(np.ones(N-1),1)) print(Mdd) ypp = Mdd.dot(y) plt.figure(figsize=(10,7)) plt.plot(x,y,label='y=f(x)') plt.plot(x[:-1],yp[:-1],label='Derivative of f(x)') # Last value is invalid, don't plot plt.plot(x[1:-1],ypp[1:-1],label='Exclude 1st,last value') # First and last value is invalid. plt.xlabel('x',size=24) plt.ylabel('f(x),df/dx',size=25) plt.legend() plt.show() ``` ## Solving the Schrödinger Equation We can now setup the Schrodinger Equation as a matrix equation: $$ \hat H = \frac{\hbar^2}{2m}\frac{d^2}{d x^2} + V \\ \hat H \psi(x) = E \psi(x) $$ We now know the matrix for taking the second order derivative. The matrix for the potential is simply the values of the potential on the diagonal of the matrix: $\mathbf{V}_{i=j} = V_i$. Writing out the matrix for $\mathbf{H}$ we get: $$ \mathbf{H} = \frac{-\hbar^2}{2 m h^2} \begin{pmatrix} -2 & 1 & 0 & 0 & \\ 1 & -2 & 1 & 0 & \\ 0& 1 & -2 & 1 & \\ & & \ddots & \ddots & \ddots &\\ & & & 1 & -2 \end{pmatrix} + \begin{pmatrix} V_0 & 0 & 0 & & \\ 0 & V_1 & 0 & & \\ 0 & 0 & V_2 & & \\ & & &\ddots & \\ &&&&V_{N-1}\end{pmatrix} $$ It is worth looking at the matrix of the Hamiltonian and notice the symmetry: $\mathbf{H}^T = \mathbf{H}$, so the transpose of the matrix is identical to the matrix. Since the matrix is *real* everywhere, the complex conjugate is also the same: $\mathbf{H}^*=\mathbf{H}$. Combining these two statements, we can say that the Hamiltonian is Hermetian: $\mathbf{H}^\dagger = \mathbf{H}$. We will come back to this later in the course. ### Infinite Square Well The very simplest system to solve for is the infinite square well, for which $V=0$. We will readily recognize the results as alternating $\cos(x)$ and $\sin(x)$ functions, and the energy levels are: $$ E_i = \frac{n^2\pi^2\hbar^2}{2ma^2} $$ First, we need to discuss a subtlety. The Infinite Square Well from $-a/2$ to $a/2$ has $V=\infty$ *at* these points. We get into trouble trying to entery $\infty$ in our potential, so what we need to do is just limit the coputational space from $-a/2+h$ to $a/2-h$, where $h$ is our step size. That way we force the wavefunction to zero at the end points. We compute this in the next box. I create $x_{full}$ as the full x-axis from $-a/2$ to $a/2$, but take $N+2$ steps. I then leave out the first and last point when calculating the wavefunctions. At the end, before plotting, I add a zero to the beginning and end of the wavefunctions, so that we get the expected result for plotting. Note I again import everything and setup all the definitions, so this block is stand-alone, and can be copy-pasted into another notebook. ```python # Infinite square well 16/02/2021 import numpy as np import matplotlib.pyplot as plt import scipy.linalg as scl plt.style.use('fivethirtyeight') hbar=1 m=1 N = 512 a = 1.0 x = np.linspace(-a/2.,a/2.,N) # We want to store step size, this is the reliable way: h = x[1]-x[0] # Should be equal to 2*np.pi/(N-1) V = 0.*x Mdd = 1./(h*h)*(np.diag(np.ones(N-1),-1) -2* np.diag(np.ones(N),0) + np.diag(np.ones(N-1),1)) H = -(hbar*hbar)/(2.0*m)*Mdd + np.diag(V) E,psiT = np.linalg.eigh(H) # This computes the eigen values and eigenvectors psi = np.transpose(psiT) # We take the transpose of psiT to the wavefunction vectors can accessed as psi[n] ``` ```python plt.figure(figsize=(10,7)) for i in range(5): if psi[i][N-10] < 0: # Flip the wavefunctions if it is negative at large x, so plots are more consistent. plt.plot(x,-psi[i]/np.sqrt(h),label="$E_{}$={:>8.3f}".format(i,E[i])) else: plt.plot(x,psi[i]/np.sqrt(h),label="$E_{}$={:>8.3f}".format(i,E[i])) plt.title("Wavefunctions for the Infinite Square Well") plt.xlabel('x',size=25) plt.ylabel('$\psi_n(x)$',size=30) plt.legend() plt.savefig("Infinite_Square_Well_WaveFunctions.pdf") plt.show() ``` ```python for i in range(7): n = i+1 print("E[{}] = {:9.4f}, E_{} ={:9.4f}".format(n,E[i],n, n*n*np.pi**2*hbar*hbar/(2*m*a*a))) ``` ```python # Accuracy check for j in range(5): for i in range(5): print("{:16.9e}".format(np.sum(psi[j]*psi[i]))) ``` # For Radial equation of Hydrogen atom ## $\frac{d}{dr}(r^2\frac{dR}{dr})-\frac{2mr^2}{\hbar^2}(V(r)-E)R=l(l+1) R$ ## If we put $ u(r)=r R(r) $ ## We get $-\frac{\hbar^2}{2m}\frac{d^2u}{dr^2}+(-\frac{e^2}{4\pi \epsilon_0 r}+\frac{\hbar^2}{2m r^2}l(l+1))u=E u$ ## ${\psi }_{ n,l,m }\left( r,\theta ,\phi \right) =\sqrt { { \left( \frac { 2 }{ n{ a }_{ 0 } } \right) }^{ 3 }\frac { \left( n-l-1 \right) ! }{ { 2n[(n+l)! ] }^{ 3 } } } { e }^{ { -r }/{ { na }_{ 0 } } }{ (\frac { 2r }{ n{ a }_{ 0 } } ) }^{ l }{ L }_{ n-l-1 }^{ 2l+1 }(\frac { 2r }{ n{ a }_{ 0 } } )\cdot { Y }_{ l }^{ m }(\theta ,\phi ) $ where $a_0$ is the Bohr radius, L are the generalized Laguerre polynomials, and n, l, and m are the principal, azimuthal, and magnetic. ```python # Check the result # This is more or less accurate at lower l value # Hydrogen atom 16/02/2021 # hbar=1, m=1,e^2/4 pi epsilon=1 # Based on our taken parameter values # Theoretical value of ground state E0=-.5, but here it comes -.407 import numpy as np import matplotlib.pyplot as plt import scipy.linalg as scl plt.style.use('fivethirtyeight') hbar=1 m=1 N = 1001 a = 25.0 l=0 x = np.linspace(0.1,a,N) # We want to store step size, this is the reliable way: h = x[1]-x[0] # Should be equal to 2*np.pi/(N-1) V = -1/x+l*(l+1)/(x**2) Mdd = 1./(h*h)*(np.diag(np.ones(N-1),-1) -2* np.diag(np.ones(N),0) + np.diag(np.ones(N-1),1)) H = -(hbar*hbar)/(2.0*m)*Mdd + np.diag(V) E,psiT = np.linalg.eigh(H) # This computes the eigen values and eigenvectors psi = np.transpose(psiT)/x # We take the transpose of psiT to the wavefunction vectors can accessed as psi[n] plt.figure(figsize=(12,6)) for i in range(3): plt.plot(x,psi[i]/np.sqrt(h),label="$E_{}$={:>8.3f}".format(i,E[i])) plt.title("Wavefunctions for Hydrogen Atom: Radial Part") plt.xlim(0,25) plt.ylim(-.1,.1) plt.xlabel('r') plt.ylabel('$R_{nl}$') plt.legend() plt.savefig("HydrogenAtom.pdf") plt.show() ``` ```python E ``` ```python # BETTER CODE TO PLOT THE HYDROGEN RADIAL WAVE FUNCTIONs import numpy as np from scipy import constants as const from scipy import sparse as sparse from scipy.sparse.linalg import eigs from matplotlib import pyplot as plt plt.style.use('fivethirtyeight') hbar = const.hbar e = const.e m_e = const.m_e pi = const.pi epsilon_0 = const.epsilon_0 joul_to_eV = e def calculate_potential_term(r): potential = e**2 / (4.0 * pi * epsilon_0) / r potential_term = sparse.diags((potential)) return potential_term def calculate_angular_term(r): angular = l * (l + 1) / r**2 angular_term = sparse.diags((angular)) return angular_term def calculate_laplace_three_point(r): h = r[1] - r[0] main_diag = -2.0 / h**2 * np.ones(N) off_diag = 1.0 / h**2 * np.ones(N - 1) laplace_term = sparse.diags([main_diag, off_diag, off_diag], (0, -1, 1)) return laplace_term def build_hamiltonian(r): laplace_term = calculate_laplace_three_point(r) angular_term = calculate_angular_term(r) potential_term = calculate_potential_term(r) hamiltonian = -hbar**2 / (2.0 * m_e) * (laplace_term - angular_term) - potential_term return hamiltonian N = 2000 l = 0 r = np.linspace(2e-9, 0.0, N, endpoint=False) hamiltonian = build_hamiltonian(r) """ solve eigenproblem """ number_of_eigenvalues = 30 eigenvalues, eigenvectors = eigs(hamiltonian, k=number_of_eigenvalues, which='SM') """ sort eigenvalue and eigenvectors """ eigenvectors = np.array([x for _, x in sorted(zip(eigenvalues, eigenvectors.T), key=lambda pair: pair[0])]) eigenvalues = np.sort(eigenvalues) """ compute probability density for each eigenvector """ densities = [np.absolute(eigenvectors[i, :])**2 for i in range(len(eigenvalues))] plt.figure(figsize=(12,6)) def plot(r, densities, eigenvalues): plt.xlabel('r ($\\mathrm{\AA}$)') plt.ylabel('probability density ($\\mathrm{\AA}^{-1}$)') energies = ['E = {: >5.2f} eV'.format(eigenvalues[i].real / e) for i in range(3)] plt.plot(r * 1e+10, densities[0], color='blue', label=energies[0]) plt.plot(r * 1e+10, densities[1], color='green', label=energies[1]) plt.plot(r * 1e+10, densities[2], color='red', label=energies[2]) plt.legend() plt.show() return """ plot results """ plot(r, densities, eigenvalues) ``` ```python # BETTER CODE TO PLOT THE HYDROGEN RADIAL WAVE FUNCTIONs # 21/03/2021 import numpy as np from scipy import constants as const from scipy import sparse as sparse from scipy.sparse.linalg import eigs from matplotlib import pyplot as plt plt.style.use('fivethirtyeight') hbar = const.hbar e = const.e m_e = const.m_e pi = const.pi epsilon_0 = const.epsilon_0 joul_to_eV = e def calculate_potential_term(r): a=1e-8 potential = np.exp(-a*r)*e**2 / (4.0 * pi * epsilon_0) / r potential_term = sparse.diags((potential)) return potential_term def calculate_angular_term(r): angular = l * (l + 1) / r**2 angular_term = sparse.diags((angular)) return angular_term def calculate_laplace_three_point(r): h = r[1] - r[0] main_diag = -2.0 / h**2 * np.ones(N) off_diag = 1.0 / h**2 * np.ones(N - 1) laplace_term = sparse.diags([main_diag, off_diag, off_diag], (0, -1, 1)) return laplace_term def build_hamiltonian(r): laplace_term = calculate_laplace_three_point(r) angular_term = calculate_angular_term(r) potential_term = calculate_potential_term(r) hamiltonian = -hbar**2 / (2.0 * m_e) * (laplace_term - angular_term) - potential_term return hamiltonian N = 2000 l = 0 r = np.linspace(2e-9, 0.0, N, endpoint=False) hamiltonian = build_hamiltonian(r) """ solve eigenproblem """ number_of_eigenvalues = 30 eigenvalues, eigenvectors = eigs(hamiltonian, k=number_of_eigenvalues, which='SM') """ sort eigenvalue and eigenvectors """ eigenvectors = np.array([x for _, x in sorted(zip(eigenvalues, eigenvectors.T), key=lambda pair: pair[0])]) eigenvalues = np.sort(eigenvalues) """ compute probability density for each eigenvector """ densities = [np.absolute(eigenvectors[i, :])**2 for i in range(len(eigenvalues))] plt.figure(figsize=(12,6)) def plot(r, densities, eigenvalues): plt.xlabel('r ($\\mathrm{\AA}$)') plt.ylabel('probability density ($\\mathrm{\AA}^{-1}$)') energies = ['E = {: >5.2f} eV'.format(eigenvalues[i].real / e) for i in range(3)] plt.plot(r * 1e+10, densities[0], color='blue', label=energies[0]) plt.plot(r * 1e+10, densities[1], color='green', label=energies[1]) plt.plot(r * 1e+10, densities[2], color='red', label=energies[2]) plt.legend() plt.show() return """ plot results """ plot(r, densities, eigenvalues) ``` ```python import matplotlib as mpl # matplotlib library for plotting and visualization import matplotlib.pylab as plt # matplotlib library for plotting and visualization import numpy as np #numpy library for numerical manipulation, especially suited for data arrays import warnings warnings.filterwarnings('ignore') import sys # checking the version of Python import IPython # checking the version of IPython print("Python version = {}".format(sys.version)) print("IPython version = {}".format(IPython.__version__)) print("Matplotlib version = {}".format(plt.__version__)) print("Numpy version = {}".format(np.__version__)) import numpy as np import matplotlib.pyplot as plt plt.style.use('fivethirtyeight') def wavefn(mhdx2,psi,vi,E): N=len(psi) psiE=[psi[i] for i in rannge(N)] for i in range(2,N): psiE[i]=2*(mhdx2*(vi[i]-E)+1)*psiE[i-1]-psiE[i-2] return psiE def Sch(mhdx2,vi,psi0,psi1,psiN,nodes,mxItr): N=len(vi)-1 Emx=max(vi) Emn=min(vi) psiIn=[0 for i in range(N+1)] psiIn[0],psiIn[1],psiIn[N]=psi0,psi1,psiN itr=0 while abs(Emx-Emn)>1e-6 and itr<mxItr: E=.5*(Emx+Emn) psi=wavefn(mhdx2,psiIn,vi,E) cnt=0 for i in range(1,N-2): if psi[i]*psi[i+1]<0: cnt+=1 if cnt>nodes: Emx=E elif cnt<nodes: Emn=E else: if psi[N-1]>psi[N]: Emn=E elif psi[N-1]<psi[N]: Emx=E itr+=1 if itr<mxItr: return E,psi else: return None,None # Simpson 1/3 rule for discrete function def simp13dis(h,fx): n=len(fx) I=0 for i in range(n): if i==0 or i==n: I+=fx[i] elif i%2!=0: I+=4*fx[i] else: I+=2*fx[i] I=I*h/3 return I # Normalisation of discrete wavefunction def norm(psi,dx): N=len(psi) psi2=[psi[i]**2 for i in range(N)] psimod2=simp13dis(dx,psi2) normpsi=[psi[i]/psimod2**0.5 for i in range(N)] return normpsi ``` ## Matrix Method ## 1D Harmonic Oscillator ```python import numpy as np import matplotlib.pyplot as plt plt.style.use('fivethirtyeight') x=np.linspace(3,4.5,100) y=(2*x+7)/(x-4) plt.figure(figsize=(12,6)) plt.plot(x,y) ``` ```python # Matrix method to solve 1D Harmonic Oscillator schrodinger equation # units used here m (mas)=1,hbar=1 # Date 15/02/2021 import matplotlib.pyplot as plt plt.style.use('fivethirtyeight') def Vpot(x): return x**2 a = float(input('enter lower limit of the domain: ')) b = float(input('enter upper limit of the domain: ')) N = int(input('enter number of grid points: ')) x = np.linspace(a,b,N) h = x[1]-x[0] T = np.zeros((N-2)**2).reshape(N-2,N-2) for i in range(N-2): for j in range(N-2): if i==j: T[i,j]= -2 elif np.abs(i-j)==1: T[i,j]=1 else: T[i,j]=0 V = np.zeros((N-2)**2).reshape(N-2,N-2) for i in range(N-2): for j in range(N-2): if i==j: V[i,j]= Vpot(x[i+1]) else: V[i,j]=0 # To create hamiltonian matrix H = -T/(2*h**2) + V # To find eigenvalues val,vec=np.linalg.eig(H) z = np.argsort(val) z = z[0:4] energies=(val[z]/val[z][0]) print(energies) plt.figure(figsize=(12,10)) for i in range(len(z)): y = [] y = np.append(y,vec[:,z[i]]) y = np.append(y,0) y = np.insert(y,0,0) plt.plot(x,y,lw=3, label="$E_{}={} $".format(i,energies[i])) plt.xlabel('x', size=24) plt.ylabel('$\psi$(x)',size=24) plt.legend() plt.title('Normalized Wavefunctions for a harmonic oscillator',size=14) plt.show() ``` ```python plt.figure(figsize=(12,10)) for i in range(len(z)): y = [] y = np.append(y,vec[:,z[i]]) y = np.append(y,0) y = np.insert(y,0,0) plt.plot(x,y,lw=3, label="$E_{}={} $".format(i,energies[i])) plt.xlabel('x', size=24) plt.ylabel('$\psi_n$(x)',size=24) plt.legend() plt.title('Normalized Wavefunctions for a harmonic oscillator',size=14) plt.show() ``` ```python ``` ```python # Matrix method to solve finite potential well schrodinger equation # units used here m (mas)=1,hbar=1 # Date 15/02/2021 import matplotlib.pyplot as plt plt.style.use('fivethirtyeight') def Vpot(pr,x): L0,L1,V0=pr pr=[-1,1,-1] if x>L0 and x<L1: pot=V0 else: pot=0 return pot a = float(input('enter lower limit of the domain: ')) b = float(input('enter upper limit of the domain: ')) N = int(input('enter number of grid points: ')) x = np.linspace(a,b,N) h = x[1]-x[0] T = np.zeros((N-2)**2).reshape(N-2,N-2) for i in range(N-2): for j in range(N-2): if i==j: T[i,j]= -2 elif np.abs(i-j)==1: T[i,j]=1 else: T[i,j]=0 V = np.zeros((N-2)**2).reshape(N-2,N-2) pr=[-1,1,-1] for i in range(N-2): for j in range(N-2): if i==j: V[i,j]= Vpot(pr,x[i+1]) else: V[i,j]=0 # To create hamiltonian matrix H = -T/(2*h**2) + V # To find eigenvalues val,vec=np.linalg.eig(H) z = np.argsort(val) z = z[0:4] energies=(val[z]/val[z][0]) print(energies) plt.figure(figsize=(12,10)) for i in range(len(z)): y = [] y = np.append(y,vec[:,z[i]]) y = np.append(y,0) y = np.insert(y,0,0) plt.plot(x,y,lw=3, label="$E_{} ={}$".format(i,energies[i])) plt.xlabel('x', size=24) plt.ylabel('$\psi$(x)',size=24) plt.legend() plt.title('Normalized WaveFunctions for a finite well potential',size=14) plt.show() ``` ```python # Anharmonic Oscilator # units used here m (mas)=1,hbar=1 # Date 15/02/2021 import matplotlib.pyplot as plt plt.style.use('seaborn-dark') def Vpot(x): return x**2+(1/4)*x**4 a = float(input('enter lower limit of the domain: ')) b = float(input('enter upper limit of the domain: ')) N = int(input('enter number of grid points: ')) x = np.linspace(a,b,N) h = x[1]-x[0] T = np.zeros((N-2)**2).reshape(N-2,N-2) for i in range(N-2): for j in range(N-2): if i==j: T[i,j]= -2 elif np.abs(i-j)==1: T[i,j]=1 else: T[i,j]=0 V = np.zeros((N-2)**2).reshape(N-2,N-2) for i in range(N-2): for j in range(N-2): if i==j: V[i,j]= Vpot(x[i+1]) else: V[i,j]=0 # To create hamiltonian matrix H = -T/(2*h**2) + V # To find eigenvalues val,vec=np.linalg.eig(H) z = np.argsort(val) z = z[0:4] energies=(val[z]/val[z][0]) print(energies) plt.figure(figsize=(12,10)) for i in range(len(z)): y = [] y = np.append(y,vec[:,z[i]]) y = np.append(y,0) y = np.insert(y,0,0) plt.plot(x,y,lw=3, label="$E_{}={} $".format(i,energies[i])) plt.xlabel('x', size=24) plt.ylabel('$\psi_n$(x)',size=24) plt.legend() plt.title('Normalized Wavefunctions for a anharmonic oscillator',size=14) plt.show() ``` ### Linear Potential #### Symmetric Case For the symmetric case, we have the potential: $$ V(x) = \lambda \left| x \right| = \left\{\begin{matrix} \lambda x,& \mathrm{if\ }& x\ge 0 \\ -\lambda x,& \mathrm{if\ }& x<0 \end{matrix} \right. $$ For the one-sided case, we have the potential: $$ V(x) = \left\{\begin{matrix} \lambda x,& \mathrm{if\ }& x\ge 0 \\ \infty,& \mathrm{if\ }& x<0 \end{matrix} \right. $$ We set $\lambda = 1$ when we do the calculations. Note that to get the potential to go to $\infty$, we need to set the $x$-axis to go from 0. to $a/2$ with $N/2$ points, instead of from $-a/2$ to $a/2$ with $N$ points. ```python # Application to linear potential import numpy as np import matplotlib.pyplot as plt import scipy.linalg as scl plt.style.use('fivethirtyeight') hbar=1 m=1 N = 4096 a = 15.0 ``` ```python # This is for the symmetric linear potential xs = np.linspace(-a/2.,a/2.,N) Vs = np.abs(xs) # This is for the one-sided linear potential xo = np.linspace(0.,a/2.,int(N/2)) Vo = np.abs(xo) # Make Plots fig1 = plt.figure(figsize=(8,6)) # plt.xkcd() # Set hand drawn looking style #plt.xticks([]) # And remove x and y ticks. #plt.yticks([]) # For plotting. plt.plot([0,0],[-2,a/2.],color="blue") # Draw the axes in blue. plt.plot([-a/2.,a/2.],[0,0],color="blue") plt.plot(xs,Vs,color="green") # Plot the potential in green plt.title("Symmetric Linear Potential") plt.savefig("Symmetric_Linear_potential.pdf") plt.xlabel('x',size=24) plt.ylabel('V(x)',size=24) plt.show() # # Now plot the one-sided case # fig1 = plt.figure(figsize=(8,6)) #plt.xticks([]) #plt.yticks([]) plt.plot([0,0],[-2,a/2.],color="blue") plt.plot([0,a/2.],[0,0],color="blue") plt.plot([0,0],[0,a/2.],color="green") # Plot the infinity side. plt.plot(xo,Vo,color="green") plt.title("One Sided Linear Potential") plt.savefig("Onesided_Linear_potential.pdf") plt.xlabel('x',size=24) plt.ylabel('V(x)',size=24) plt.show() ``` ```python # This is for the Symmetric linear potential case. hs = xs[1]-xs[0] # Should be equal to 2*np.pi/(N-1) Mdds = 1./(hs*hs)*(np.diag(np.ones(N-1),-1) -2* np.diag(np.ones(N),0) + np.diag(np.ones(N-1),1)) Hs = -(hbar*hbar)/(2.0*m)*Mdds + np.diag(Vs) Es,psiTs = np.linalg.eigh(Hs) # This computes the eigen values and eigenvectors psis = np.transpose(psiTs) # We now have the eigen vectors as psi(i), where i is the energy level. print(np.sum(psis[0]*psis[0])) # Check. Yes these are normalized already. ``` ```python # This is for the One sided case. ho = xo[1]-xo[0] # Should be equal to 2*np.pi/(N-1) Mddo = 1./(ho*ho)*(np.diag(np.ones(int(N/2)-1),-1) -2* np.diag(np.ones(int(N/2)),0) + np.diag(np.ones(int(N/2)-1),1)) Ho = -(hbar*hbar)/(2.0*m)*Mddo + np.diag(Vo) Eo,psiTo = np.linalg.eigh(Ho) # This computes the eigen values and eigenvectors psio = np.transpose(psiTo) # We now have the eigen vectors as psi(i), where i is the energy level. print(np.sum(psio[0]*psio[0])) # Check. Yes these are normalized already. # print psiT[0] # Uncomment to see the values printed for Psi_0 ``` ```python plt.figure(figsize=(10,6)) plt.plot(xs,0.1*Vs,color="grey",label="Potential: 0.1V(x)") plt.ylim((-0.9,0.9)) for i in range(6): if psis[i,N-10]<0: plt.plot(xs,-np.real(psis[i])/np.sqrt(hs),label="$E_{}={:8.4f}$".format(i,Es[i])) else: plt.plot(xs,np.real(psis[i])/np.sqrt(hs),label="$E_{}={:8.4f}$".format(i,Es[i])) plt.legend() plt.title("Wavefunctions for the Symmetric Linear Potential") plt.xlabel("x",size=24) plt.ylabel("$\psi_n(x)$",size=24) plt.savefig("Linear_Potential_Wavefunctions.pdf") plt.show() ``` ```python print("Symmetric Case \t One-sided Case") for n in range(12): if n%2==1: no = int((n-1)/2) print("Es[{}] = {:9.4f}\t Eo[{}] ={:9.4f}".format(n,Es[n],no, Eo[no])) else: print("Es[{}] = {:9.4f} ".format(n,Es[n])) ``` ```python # First six wavefunctions plt.figure(figsize=(10,6)) plt.plot(xo,0.1*Vo,color="grey",label="Potential: 0.1V(x)") plt.ylim((-0.9,0.9)) for i in range(6): if psio[i,int(N/2)-10]<0: plt.plot(xo,-psio[i]/np.sqrt(ho),label="$E_{}={}$".format(i,Eo[i])) else: plt.plot(xo,psio[i]/np.sqrt(ho),label="$E_{}={}$".format(i,Eo[i])) plt.legend() plt.title("Wavefunctions for the One Sided Linear Potential") plt.xlabel("x") plt.ylabel("$\psi_n(x)$") plt.savefig("One sided Wavefunctions.pdf") plt.show() ``` ```python # v(r)=-e^2/r*(exp(-r/a)) ``` ```python # Matrix method to solve 1D schrodinger equation # units used here m (mas)=1,hbar=1 # v(r)=-e^2/r*(exp(-r/a)) # Date 15/02/2021 import matplotlib.pyplot as plt import numpy as np plt.style.use('fivethirtyeight') def Vpot(x): a=7.5 e2=1 return (-e2/x)*(np.exp(-x/a)) a = float(input('enter lower limit of the domain: ')) b = float(input('enter upper limit of the domain: ')) N = int(input('enter number of grid points: ')) x = np.linspace(a,b,N) h = x[1]-x[0] T = np.zeros((N-2)**2).reshape(N-2,N-2) for i in range(N-2): for j in range(N-2): if i==j: T[i,j]= -2 elif np.abs(i-j)==1: T[i,j]=1 else: T[i,j]=0 V = np.zeros((N-2)**2).reshape(N-2,N-2) for i in range(N-2): for j in range(N-2): if i==j: V[i,j]= Vpot(x[i+1]) else: V[i,j]=0 # To create hamiltonian matrix H = -T/(2*h**2) + V # To find eigenvalues val,vec=np.linalg.eig(H) z = np.argsort(val) z = z[0:4] energies=(val[z]/val[z][0]) print(energies) plt.figure(figsize=(12,10)) for i in range(len(z)): y = [] y = np.append(y,vec[:,z[i]]) y = np.append(y,0) y = np.insert(y,0,0) plt.plot(x,y,lw=3, label="$E_{}={} $".format(i,energies[i])) plt.xlabel('x', size=24) plt.ylabel('$\psi$(x)',size=24) plt.legend() plt.title('Wavefunctions for Spherically Symmetric Potential',size=14) plt.show() ``` ```python # Matrix method to solve 1D spherically symmetric potential # units used here m (mas)=1,hbar=1 # Date 15/02/2021 import matplotlib.pyplot as plt import numpy as np plt.style.use('fivethirtyeight') def Vpot(x): a=7.5 e2=1 return (-e2/x)*(np.exp(-x/a)) a = float(input('enter lower limit of the domain: ')) b = float(input('enter upper limit of the domain: ')) N = int(input('enter number of grid points: ')) x = np.linspace(a,b,N) h = x[1]-x[0] T = np.zeros((N-2)**2).reshape(N-2,N-2) for i in range(N-2): for j in range(N-2): if i==j: T[i,j]= -2 elif np.abs(i-j)==1: T[i,j]=1 else: T[i,j]=0 V = np.zeros((N-2)**2).reshape(N-2,N-2) for i in range(N-2): for j in range(N-2): if i==j: V[i,j]= Vpot(x[i+1]) else: V[i,j]=0 # To create hamiltonian matrix H = -T/(2*h**2) + V # To find eigenvalues val,vec=np.linalg.eig(H) z = np.argsort(val) z = z[0:4] energies=(val[z]/val[z][0]) print(energies) plt.figure(figsize=(12,10)) for i in range(len(z)): y = [] y = np.append(y,vec[:,z[i]]) y = np.append(y,0) y = np.insert(y,0,0) plt.plot(x,y,lw=3, label="{} ".format(i)) plt.xlabel('x', size=14) plt.ylabel('$\psi$(x)',size=14) plt.legend() plt.title('Normalized Wavefunctions for spherically symmetric potential',size=14) plt.show() ``` ```python # Single codes for solving many problems import numpy as np import matplotlib.pyplot as plt from scipy import sparse from scipy.sparse import linalg as sla plt.style.use('fivethirtyeight') def schrodinger1D(xmin, xmax, Nx, Vfun, params, neigs=20, findpsi=False): # for this code we are using Dirichlet Boundary Conditions x = np.linspace(xmin, xmax, Nx) # x axis grid dx = x[1] - x[0] # x axis step size # Obtain the potential function values: V = Vfun(x, params) # create the Hamiltonian Operator matrix: H = sparse.eye(Nx, Nx, format='lil') * 2 for i in range(Nx - 1): #H[i, i] = 2 H[i, i + 1] = -1 H[i + 1, i] = -1 #H[-1, -1] = 2 H = H / (dx ** 2) # Add the potential into the Hamiltonian for i in range(Nx): H[i, i] = H[i, i] + V[i] # convert to csc matrix format H = H.tocsc() # obtain neigs solutions from the sparse matrix [evl, evt] = sla.eigs(H, k=neigs, which='SM') for i in range(neigs): # normalize the eigen vectors evt[:, i] = evt[:, i] / np.sqrt( np.trapz(np.conj( evt[:, i]) * evt[:, i], x)) # eigen values MUST be real: evl = np.real(evl) if findpsi == False: return evl else: return evl, evt, x def eval_wavefunctions(xmin,xmax,Nx,Vfun,params,neigs,findpsi=True): """ Evaluates the wavefunctions given a particular potential energy function Vfun Inputs ------ xmin: float minimum value of the x axis xmax: float maximum value of the x axis Nx: int number of finite elements in the x axis Vfun: function potential energy function params: list list containing the parameters of Vfun neigs: int number of eigenvalues to find findpsi: bool If True, the eigen wavefunctions will be calculated and returned. If False, only the eigen energies will be found. """ H = schrodinger1D(xmin, xmax, Nx, Vfun, params, neigs, findpsi) evl = H[0] # energy eigen values indices = np.argsort(evl) print("Energy eigenvalues in units of E0:") for i,j in enumerate(evl[indices]): print("{}: {:.2f}".format(i+1,j)) evt = H[1] # eigen vectors x = H[2] # x dimensions i = 0 plt.figure(figsize=(8,8)) while i < neigs: n = indices[i] y = np.real(np.conj(evt[:, n]) * evt[:, n]) plt.subplot(neigs, 1, i+1) plt.plot(x, y) plt.axis('off') i = i + 1 plt.show() def sho_wavefunctions_plot(xmin=-10, xmax=10, Nx=500, neigs=20, params=[1]): """ Plots the 1D quantum harmonic oscillator wavefunctions. Inputs ------ xmin: float minimum value of the x axis xmax: float maximum value of the x axis Nx: int number of finite elements in the x axis neigs: int number of eigenvalues to find params: list list containing the parameters of Vfun """ def Vfun(x, params): V = params[0] * x**2 return V eval_wavefunctions(xmin,xmax,Nx,Vfun,params,neigs,True) def infinite_well_wavefunctions_plot(xmin=-10, xmax=10, Nx=500, neigs=20, params=1e10): """ Plots the 1D infinite well wavefunctions. Inputs ------ xmin: float minimum value of the x axis xmax: float maximum value of the x axis Nx: int number of finite elements in the x axis neigs: int number of eigenvalues to find params: float parameter of Vfun """ def Vfun(x, params): V = x*0 V[:100]=params V[-100:]=params return V eval_wavefunctions(xmin,xmax,Nx,Vfun,params,neigs,True) def double_well_wavefunctions_plot(xmin=-10, xmax=10, Nx=500, neigs=20, params=[-0.5,0.01]): """ Plots the 1D double well wavefunctions. Inputs ------ xmin: float minimum value of the x axis xmax: float maximum value of the x axis Nx: int number of finite elements in the x axis neigs: int number of eigenvalues to find params: list list of parameters of Vfun """ def Vfun(x, params): A = params[0] B = params[1] V = A * x ** 2 + B * x ** 4 return V eval_wavefunctions(xmin,xmax,Nx,Vfun,params,neigs,True) plt.style.use('fivethirtyeight') infinite_well_wavefunctions_plot(xmin=-10, xmax=10, Nx=500, neigs=2, params=1e10) ``` ```python plt.style.use('fivethirtyeight') infinite_well_wavefunctions_plot(xmin=-10, xmax=10, Nx=500, neigs=3, params=1e10) ``` ```python double_well_wavefunctions_plot(xmin=-10, xmax=10, Nx=500, neigs=3, params=[-0.5,0.01]) ``` ```python # Harmonic Oscillator sho_wavefunctions_plot(xmin=-10, xmax=10, Nx=500, neigs=5, params=[1]) ``` # NUMERICAL SOLUTION OF SCHRODINGER WAVE EQUATION 1D # $-\frac{\hbar^2}{2m} \frac{d^2\psi}{dx^2}+V(x)\psi =E\psi $ ## Finite Potential well ```python # Normalisation of discrete wavefunction # Finite Potential well def norm(psi,dx): N=len(psi) psi2=[psi[i]**2 for i in range(N)] psimod2=simp13dis(dx,psi2) normpsi=[psi[i]/psimod2**0.5 for i in range(N)] return normpsi import matplotlib.pyplot as plt # Solution of Schrodinger equation: def wavefn(mhdx2,psi,vi,E): N=len(psi) psiE=[psi[i] for i in range(N)] for i in range(2,N): psiE[i]=2*(mhdx2*(vi[i]-E)+1)*psiE[i-1]-psiE[i-2] return psiE def Sch(mhdx2,vi,psi0,psi1,psiN,nodes,mxItr): N=len(vi)-1 Emx=max(vi) Emn=min(vi) psiIn=[0 for i in range(N+1)] psiIn[0],psiIn[1],psiIn[N]=psi0,psi1,psiN itr=0 while abs(Emx-Emn)>1e-6 and itr<mxItr: E=.5*(Emx+Emn) psi=wavefn(mhdx2,psiIn,vi,E) #For Plotting plt.title(r'$E_{mx}=%.3f,E_{mn}=%.3f$'%(Emx,Emn)) plt.ylim(-1.02,0.7) plt.plot(x,psi,'k',label=r'$\psi(x)$ for E=%.4f'%E) plt.plot(x,vi,'k:',label='Potential') plt.plot(x[-1],psiN,'k.',label='Far end boundary Point') plt.xlabel('x') plt.legend(loc='upper left') plt.pause(1.0) plt.clf() # Node counting cnt=0 for i in range(1,N-2): if psi[i]*psi[i+1]<0: cnt+=1 if cnt>nodes: Emx=E elif cnt<nodes: Emn=E else: if psi[N-1]>psi[N]: Emn=E elif psi[N-1]<psi[N]: Emx=E itr+=1 if itr<mxItr: return E,psi else: return None,None # Define Square wave potential def V(pr,x): L0,L1,V0=pr if x>L0 and x<L1: pot=V0 else: pot=0 return pot hbar,m=.1,1 x0,xN=-1.4,1.4 dx=.01 mxItr=100 psi0,psiN=0,0 L0,L1,V0=-1,1,-1 prV=[L0,L1,V0] mhdx2=m*dx**2/hbar**2 N=int((xN-x0)/dx) dx=(xN-x0)/N x=[x0+i*dx for i in range(N+1)] Vi=[V(prV,x[i]) for i in range(N+1)] nodes=2 psi1=(-1)**nodes*1e-4 E,psi=Sch(mhdx2,Vi,psi0,psi1,psiN,nodes,mxItr) ``` ```python # Finite Well potential # Simpson 1/3 rule for discrete function import numpy as np import matplotlib.pyplot as plt plt.style.use('fivethirtyeight') def simp13dis(h,fx): n=len(fx) I=0 for i in range(n): if i==0 or i==n: I+=fx[i] elif i%2!=0: I+=4*fx[i] else: I+=2*fx[i] I=I*h/3 return I # Normalisation of discrete wavefunction def norm(psi,dx): N=len(psi) psi2=[psi[i]**2 for i in range(N)] psimod2=simp13dis(dx,psi2) normpsi=[psi[i]/psimod2**0.5 for i in range(N)] return normpsi import matplotlib.pyplot as plt # Solution of Schrodinger equation: def wavefn(mhdx2,psi,vi,E): N=len(psi) psiE=[psi[i] for i in range(N)] for i in range(2,N): psiE[i]=2*(mhdx2*(vi[i]-E)+1)*psiE[i-1]-psiE[i-2] return psiE def Sch(mhdx2,vi,psi0,psi1,psiN,nodes,mxItr): N=len(vi)-1 Emx=max(vi) Emn=min(vi) psiIn=[0 for i in range(N+1)] psiIn[0],psiIn[1],psiIn[N]=psi0,psi1,psiN itr=0 while abs(Emx-Emn)>1e-6 and itr<mxItr: E=.5*(Emx+Emn) psi=wavefn(mhdx2,psiIn,vi,E) # Node counting cnt=0 for i in range(1,N-2): if psi[i]*psi[i+1]<0: cnt+=1 if cnt>nodes: Emx=E elif cnt<nodes: Emn=E else: if psi[N-1]>psi[N]: Emn=E elif psi[N-1]<psi[N]: Emx=E itr+=1 if itr<mxItr: return E,psi else: return None,None # Define Square wave potential def V(pr,x): L0,L1,V0=pr if x>L0 and x<L1: pot=V0 else: pot=0 return pot hbar,m=.1,1 x0,xN=-1.4,1.4 dx=.01 mxItr=100 psi0,psiN=0,0 L0,L1,V0=-1,1,-1 prV=[L0,L1,V0] mhdx2=m*dx**2/hbar**2 N=int((xN-x0)/dx) dx=(xN-x0)/N x=[x0+i*dx for i in range(N+1)] Vi=[V(prV,x[i]) for i in range(N+1)] stln=['k','k--','k:','k.-'] for nodes in range(4): psi1=(-1)**nodes*1e-4 E,psi=Sch(mhdx2,Vi,psi0,psi1,psiN,nodes,mxItr) if E!=None: psi=norm(psi,dx) #for Plot #plt.figure(figsize=(12,6)) plt.plot(x,psi,stln[nodes],label=r'E=%.3f $\psi_%d(x)$'%(E,nodes)) #plt.figure(figsize=(12,6)) plt.plot(x,Vi,'k',label='Potential') plt.legend() plt.xlabel('x',size=24) plt.ylabel('$\psi(x)$',size=24) plt.show() ``` ## Theory of Finite Potential Well: ## $\dfrac{d^2\psi(x)}{d x^2} = -\dfrac{2mE}{\hbar^2} \psi(x) =-k^2 \psi(x) \nonumber$ ## Behaviour in side box ## $\psi(x) = e^{\pm ikx} \nonumber$ ## $\psi(x) = q_1 \cos(kx) + q_2 \sin(kx) \nonumber$ ## Behavior outside the Box $\dfrac{d^2\psi(x)}{d x^2} = -\dfrac{2m(E-V_o)}{\hbar^2}\psi(x) \nonumber$ Connecting the two Behaviors For $ E<V_o $, it is really interesting to look at what happens outside the walls. When E<V_o, the Schrödinger equation becomes $\large{\frac{\partial^2\psi(x)}{\partial x^2}} = \alpha_o^2\cdot \psi(x) \nonumber $ since $\alpha_o^2 = \frac{2m(V_o-E)}{\hbar^2} >0.$ The solutions to this equation have the general form of $\psi(x) =e^{\pm\alpha_o x}. \nonumber $ Note that the exponential function does not require an imaginary component, thus it is not oscillatory. Before we move on, here are some questions to consider: ```python # Finite Potential well import matplotlib.pyplot as plt import numpy as np plt.style.use('fivethirtyeight') # Reading the input variables from the user Vo = float(input("Enter the value for Vo (in eV) = ")) L = float(input("Enter the value for L (in Angstroms) = ")) val = np.sqrt(2.0*9.10938356e-31*1.60217662e-19)*1e-10/(2.0*1.05457180013e-34) # equal to sqrt(2m*1eV)*1A/(2*hbar) # Generating the graph plt.rcParams.update({'font.size': 18, 'font.family': 'STIXGeneral', 'mathtext.fontset': 'stix'}) fig, axes = plt.subplots(1, 2, figsize=(13,4)) axes[0].axis([0.0,Vo,0.0,np.sqrt(Vo)*1.8]) axes[0].set_xlabel(r'$E$ (eV)') axes[0].set_ylabel(r'(eV$^{-1}$)') axes[0].set_title('Even solutions') axes[1].axis([0.0,Vo,0.0,np.sqrt(Vo)*1.8]) axes[1].set_xlabel(r'$E$ (eV)') axes[1].set_ylabel(r'') axes[1].set_title('Odd solutions') E = np.linspace(0.0, Vo, 10000) num = int(round((L*np.sqrt(Vo)*val-np.pi/2.0)/np.pi)) # Removing discontinuity points for n in range(10000): for m in range(num+2): if abs(E[n]-((2.0*float(m)+1.0)*np.pi/(2.0*L*val))**2)<0.01: E[n] = np.nan if abs(E[n]-(float(m)*np.pi/(L*val))**2)<0.01: E[n] = np.nan # Plotting the curves and setting the labels axes[0].plot(E, np.sqrt(Vo-E), label=r"$\sqrt{V_o-E}$", color="blue", linewidth=1.8) axes[0].plot(E, np.sqrt(E)*np.tan(L*np.sqrt(E)*val), label=r"$\sqrt{E}\tan(\frac{L\sqrt{2mE}}{2\hbar})$", color="red", linewidth=1.8) axes[1].plot(E, np.sqrt(Vo-E), label=r"$\sqrt{V_o-E}$", color="blue", linewidth=1.8) axes[1].plot(E, -np.sqrt(E)/np.tan(L*np.sqrt(E)*val), label=r"$-\frac{\sqrt{E}}{\tan(\frac{L\sqrt{2mE}}{2\hbar})}$", color="red", linewidth=1.8) # Chosing the positions of the legends axes[0].legend(bbox_to_anchor=(0.05, -0.2), loc=2, borderaxespad=0.0) axes[1].legend(bbox_to_anchor=(0.05, -0.2), loc=2, borderaxespad=0.0) # Show the plots on the screen once the code reaches this point plt.show() ``` ```python # Finding eigenvalues import numpy as np print ("The allowed bounded energies are:") # We want to find the values of E in which f_even and f_odd are zero f_even = lambda E : np.sqrt(Vo-E)-np.sqrt(E)*np.tan(L*np.sqrt(E)*val) f_odd = lambda E : np.sqrt(Vo-E)+np.sqrt(E)/np.tan(L*np.sqrt(E)*val) E_old = 0.0 f_even_old = f_even(0.0) f_odd_old = f_odd(0.0) n = 1 E_vals = np.zeros(999) # Here we loop from E = 0 to E = Vo seeking roots for E in np.linspace(0.0, Vo, 200000): f_even_now = f_even(E) # If the difference is zero or if it changes sign then we might have passed through a root if f_even_now == 0.0 or f_even_now/f_even_old < 0.0: # If the old values of f are not close to zero, this means we didn't pass through a root but # through a discontinuity point if (abs(f_even_now)<1.0 and abs(f_even_old)<1.0): E_vals[n-1] = (E+E_old)/2.0 print (" State #%3d (Even wavefunction): %9.4f eV, %13.6g J" % (n,E_vals[n-1],E_vals[n-1]*1.60217662e-19)) n += 1 f_odd_now = f_odd(E) # If the difference is zero or if it changes sign then we might have passed through a root if f_odd_now == 0.0 or f_odd_now/f_odd_old < 0.0: # If the old values of f are not close to zero, this means we didn't pass through a root but # through a discontinuity point if (abs(f_odd_now)<1.0 and abs(f_odd_old)<1.0): E_vals[n-1] = (E+E_old)/2.0 print ("State #%3d (Odd wavefunction): %9.4f eV, %13.6g J" % (n,E_vals[n-1],E_vals[n-1]*1.60217662e-19)) n += 1 E_old = E f_even_old = f_even_now f_odd_old = f_odd_now nstates = n-1 print ("\nTHERE ARE %3d POSSIBLE BOUNDED ENERGIES" % nstates) ``` ```python # Energy diagram import matplotlib.pyplot as plt # Generating the energy diagram fig, ax = plt.subplots(figsize=(8,12)) ax.spines['right'].set_color('none') ax.yaxis.tick_left() ax.spines['bottom'].set_color('none') ax.axes.get_xaxis().set_visible(False) ax.spines['top'].set_color('none') ax.axis([0.0,10.0,0.0,1.1*Vo]) ax.set_ylabel(r'$E_n$ (eV)') for n in range(1,nstates+1): str1="$n = "+str(n)+r"$, $E_"+str(n)+r" = %.3f$ eV"%(E_vals[n-1]) ax.text(6.5, E_vals[n-1]-0.005*Vo, str1, fontsize=16, color="red") ax.hlines(E_vals[n-1], 0.0, 6.3, linewidth=1.8, linestyle='--', color="red") str1="$V_o = %.3f$ eV"%(Vo) ax.text(6.5, Vo-0.01*Vo, str1, fontsize=16, color="blue") ax.hlines(Vo, 0.0, 6.3, linewidth=3.8, linestyle='-', color="blue") ax.hlines(0.0, 0.0, 10.3, linewidth=1.8, linestyle='-', color="black") plt.title("Energy Levels", fontsize=30) plt.show() ``` ```python # Wavefn import matplotlib.pyplot as plt import numpy as np print ("\nThe bound wavefunctions are:") fig, ax = plt.subplots(figsize=(12,9)) ax.spines['right'].set_color('none') ax.xaxis.tick_bottom() ax.spines['left'].set_color('none') ax.axes.get_yaxis().set_visible(False) ax.spines['top'].set_color('none') X_lef = np.linspace(-L, -L/2.0, 900,endpoint=True) X_mid = np.linspace(-L/2.0, L/2.0, 900,endpoint=True) X_rig = np.linspace(L/2.0, L, 900,endpoint=True) ax.axis([-L,L,0.0,1.1*Vo]) ax.set_xlabel(r'$X$ (Angstroms)') str1="$V_o = %.3f$ eV"%(Vo) ax.text(2.0*L/2.0, 1.02*Vo, str1, fontsize=24, color="blue") # Defining the maximum amplitude of the wavefunction if (nstates > 1): amp = np.sqrt((E_vals[1]-E_vals[0])/1.5) else: amp = np.sqrt((Vo-E_vals[0])/1.5) # Plotting the wavefunctions for n in range(1,nstates+1): ax.hlines(E_vals[n-1], -L, L, linewidth=1.8, linestyle='--', color="black") str1="$n = "+str(n)+r"$, $E_"+str(n)+r" = %.3f$ eV"%(E_vals[n-1]) ax.text(2.0*L/2.0, E_vals[n-1]+0.01*Vo, str1, fontsize=16, color="red") k = 2.0*np.sqrt(E_vals[n-1])*val a0 = 2.0*np.sqrt(Vo-E_vals[n-1])*val # Plotting odd wavefunction if (n%2==0): ax.plot(X_lef,E_vals[n-1]-amp*np.exp(a0*L/2.0)*np.sin(k*L/2.0)*np.exp(a0*X_lef), color="red", label="", linewidth=2.8) ax.plot(X_mid,E_vals[n-1]+amp*np.sin(k*X_mid), color="red", label="", linewidth=2.8) ax.plot(X_rig,E_vals[n-1]+amp*np.exp(a0*L/2.0)*np.sin(k*L/2.0)*np.exp(-a0*X_rig), color="red", label="", linewidth=2.8) # Plotting even wavefunction else: ax.plot(X_lef,E_vals[n-1]+amp*np.exp(a0*L/2.0)*np.cos(k*L/2.0)*np.exp(a0*X_lef), color="red", label="", linewidth=2.8) ax.plot(X_mid,E_vals[n-1]+amp*np.cos(k*X_mid), color="red", label="", linewidth=2.8) ax.plot(X_rig,E_vals[n-1]+amp*np.exp(a0*L/2.0)*np.cos(k*L/2.0)*np.exp(-a0*X_rig), color="red", label="", linewidth=2.8) ax.margins(0.00) ax.vlines(-L/2.0, 0.0, Vo, linewidth=4.8, color="blue") ax.vlines(L/2.0, 0.0, Vo, linewidth=4.8, color="blue") ax.hlines(0.0, -L/2.0, L/2.0, linewidth=4.8, color="blue") ax.hlines(Vo, -L, -L/2.0, linewidth=4.8, color="blue") ax.hlines(Vo, L/2.0, L, linewidth=4.8, color="blue") plt.title('Wavefunctions', fontsize=30) plt.legend(bbox_to_anchor=(0.8, 1), loc=2, borderaxespad=0.) plt.show() ``` ```python # Bound Wavefunctions import matplotlib.pyplot as plt import numpy as np print ("\nThe bound Probability Densities are shown below \nwith the areas shaded in green showing the regions where the particle can tunnel outside the box") fig, ax = plt.subplots(figsize=(12,9)) ax.spines['right'].set_color('none') ax.xaxis.tick_bottom() ax.spines['left'].set_color('none') ax.axes.get_yaxis().set_visible(False) ax.spines['top'].set_color('none') X_lef = np.linspace(-L, -L/2.0, 900,endpoint=True) X_mid = np.linspace(-L/2.0, L/2.0, 900,endpoint=True) X_rig = np.linspace(L/2.0, L, 900,endpoint=True) ax.axis([-L,L,0.0,1.1*Vo]) ax.set_xlabel(r'$X$ (Angstroms)') str1="$V_o = %.3f$ eV"%(Vo) ax.text(2.05*L/2.0, 1.02*Vo, str1, fontsize=24, color="blue") # Defining the maximum amplitude of the probability density if (nstates > 1): amp = (E_vals[1]-E_vals[0])/1.5 else: amp = (Vo-E_vals[0])/1.5 # Plotting the probability densities for n in range(1,nstates+1): ax.hlines(E_vals[n-1], -L, L, linewidth=1.8, linestyle='--', color="black") str1="$n = "+str(n)+r"$, $E_"+str(n)+r" = %.3f$ eV"%(E_vals[n-1]) ax.text(2.0*L/2.0, E_vals[n-1]+0.01*Vo, str1, fontsize=16, color="red") k = 2.0*np.sqrt(E_vals[n-1])*val a0 = 2.0*np.sqrt(Vo-E_vals[n-1])*val # Plotting odd probability densities if (n%2==0): Y_lef = E_vals[n-1]+amp*(np.exp(a0*L/2.0)*np.sin(k*L/2.0)*np.exp(a0*X_lef))**2 ax.plot(X_lef,Y_lef, color="red", label="", linewidth=2.8) ax.fill_between(X_lef, E_vals[n-1], Y_lef, color="#3dbb2a") ax.plot(X_mid,E_vals[n-1]+amp*(np.sin(k*X_mid))**2, color="red", label="", linewidth=2.8) Y_rig = E_vals[n-1]+amp*(np.exp(a0*L/2.0)*np.sin(k*L/2.0)*np.exp(-a0*X_rig))**2 ax.plot(X_rig,Y_rig, color="red", label="", linewidth=2.8) ax.fill_between(X_rig, E_vals[n-1], Y_rig, color="#3dbb2a") # Plotting even probability densities else: Y_lef = E_vals[n-1]+amp*(np.exp(a0*L/2.0)*np.cos(k*L/2.0)*np.exp(a0*X_lef))**2 ax.plot(X_lef,Y_lef, color="red", label="", linewidth=2.8) ax.fill_between(X_lef, E_vals[n-1], Y_lef, color="#3dbb2a") ax.plot(X_mid,E_vals[n-1]+amp*(np.cos(k*X_mid))**2, color="red", label="", linewidth=2.8) Y_rig = E_vals[n-1]+amp*(np.exp(a0*L/2.0)*np.cos(k*L/2.0)*np.exp(-a0*X_rig))**2 ax.plot(X_rig,Y_rig, color="red", label="", linewidth=2.8) ax.fill_between(X_rig, E_vals[n-1], Y_rig, color="#3dbb2a") ax.margins(0.00) ax.vlines(-L/2.0, 0.0, Vo, linewidth=4.8, color="blue") ax.vlines(L/2.0, 0.0, Vo, linewidth=4.8, color="blue") ax.hlines(0.0, -L/2.0, L/2.0, linewidth=4.8, color="blue") ax.hlines(Vo, -L, -L/2.0, linewidth=4.8, color="blue") ax.hlines(Vo, L/2.0, L, linewidth=4.8, color="blue") plt.title('Probability Densities', fontsize=30) plt.legend(bbox_to_anchor=(0.8, 1), loc=2, borderaxespad=0.) plt.show() ``` ```python # Tunneling import numpy as np print ("\nThe tunneling probabilities are:") for n in range(1,nstates+1): k = 2.0*np.sqrt(E_vals[n-1])*val a0 = 2.0*np.sqrt(Vo-E_vals[n-1])*val # For odd solution if (n%2==0): C = 1.0 D = np.exp(a0*L/2.0)*np.sin(k*L/2.0)*C prob = D*D*2.0*k*np.exp(-a0*L)/(B*B*a0*(k*L-np.sin(k*L))+D*D*2.0*k*np.exp(-a0*L)) # For even solution else: B = 1.0 D = np.exp(a0*L/2.0)*np.cos(k*L/2.0)*B prob = D*D*2.0*k*np.exp(-a0*L)/(B*B*a0*(k*L+np.sin(k*L))+D*D*2.0*k*np.exp(-a0*L)) print (" State #%3d tunneling probability = %5.2f%%" % (n,100*prob)) ``` ## $\large{\dfrac{\displaystyle \int^{\frac{-L}{2}}_{-\infty} |\psi(x)|^2\ dx + \displaystyle \int^{+\infty}_{\frac{L}{2}} |\psi(x)|^2\ dx }{\displaystyle \int_{-\infty}^{+\infty} |\psi(x)|^2\ dx }}$ ## where the denominator is 1 for a normalized wavefunction. # INFINITE POTENTIAL WELL ```python # InFinite Well potential # Simpson 1/3 rule for discrete function def simp13dis(h,fx): n=len(fx) I=0 for i in range(n): if i==0 or i==n: I+=fx[i] elif i%2!=0: I+=4*fx[i] else: I+=2*fx[i] I=I*h/3 return I # Normalisation of discrete wavefunction def norm(psi,dx): N=len(psi) psi2=[psi[i]**2 for i in range(N)] psimod2=simp13dis(dx,psi2) normpsi=[psi[i]/psimod2**0.5 for i in range(N)] return normpsi import matplotlib.pyplot as plt # Solution of Schrodinger equation: def wavefn(mhdx2,psi,vi,E): N=len(psi) psiE=[psi[i] for i in range(N)] for i in range(2,N): psiE[i]=2*(mhdx2*(vi[i]-E)+1)*psiE[i-1]-psiE[i-2] return psiE def Sch(mhdx2,vi,psi0,psi1,psiN,nodes,mxItr): N=len(vi)-1 Emx=max(vi) Emn=min(vi) psiIn=[0 for i in range(N+1)] psiIn[0],psiIn[1],psiIn[N]=psi0,psi1,psiN itr=0 while abs(Emx-Emn)>1e-6 and itr<mxItr: E=.5*(Emx+Emn) psi=wavefn(mhdx2,psiIn,vi,E) # Node counting cnt=0 for i in range(1,N-2): if psi[i]*psi[i+1]<0: cnt+=1 if cnt>nodes: Emx=E elif cnt<nodes: Emn=E else: if psi[N-1]>psi[N]: Emn=E elif psi[N-1]<psi[N]: Emx=E itr+=1 if itr<mxItr: return E,psi else: return None,None # Define Square wave potential def V(pr,x): L0,L1,V0=pr if x>L0 and x<L1: pot=0 else: pot=V0 return pot hbar,m=.1,1 x0,xN=-1.0,1.0 dx=.01 mxItr=100 psi0,psiN=0,0 L0,L1,V0=-1,1,5000 prV=[L0,L1,V0] mhdx2=m*dx**2/hbar**2 N=int((xN-x0)/dx) dx=(xN-x0)/N x=[x0+i*dx for i in range(N+1)] Vi=[V(prV,x[i]) for i in range(N+1)] stln=['k','k--','k:','k.-'] for nodes in range(4): psi1=(-1)**(nodes)*1e-4 E,psi=Sch(mhdx2,Vi,psi0,psi1,psiN,nodes,mxItr) if E!=None: psi=norm(psi,dx) #for Plot #plt.figure(figsize=(12,6)) plt.ylim(-5.0,5.0) plt.plot(x,psi,stln[nodes],label=r'E=%.3f $\psi_%d(x)$'%(E,nodes)) #plt.figure(figsize=(12,6)) #plt.plot(x,Vi,'k',label='Potential') plt.legend() plt.xlabel('x') plt.ylabel('$\psi(x)$') plt.grid() plt.show() ``` ```python import matplotlib as mpl # matplotlib library for plotting and visualization import matplotlib.pylab as plt # matplotlib library for plotting and visualization import numpy as np #numpy library for numerical manipulation, especially suited for data arrays import warnings warnings.filterwarnings('ignore') import sys # checking the version of Python import IPython # checking the version of IPython print("Python version = {}".format(sys.version)) print("IPython version = {}".format(IPython.__version__)) print("Matplotlib version = {}".format(plt.__version__)) print("Numpy version = {}".format(np.__version__)) ``` ```python # Wave function and probability import matplotlib.pyplot as plt import numpy as np plt.style.use('fivethirtyeight') # Defining the wavefunction def psi(x,n,L): return np.sqrt(2.0/L)*np.sin(float(n)*np.pi*x/L) # Reading the input variables from the user n = int(input("Enter the value for the quantum number n = ")) L = float(input("Enter the size of the box in Angstroms = ")) # Generating the wavefunction graph plt.rcParams.update({'font.size': 18, 'font.family': 'STIXGeneral', 'mathtext.fontset': 'stix'}) x = np.linspace(0, L, 900) fig, ax = plt.subplots() lim1=np.sqrt(2.0/L) # Maximum value of the wavefunction ax.axis([0.0,L,-1.1*lim1,1.1*lim1]) # Defining the limits to be plot in the graph str1=r"$n = "+str(n)+r"$" ax.plot(x, psi(x,n,L), linestyle='--', label=str1, color="orange", linewidth=2.8) # Plotting the wavefunction ax.hlines(0.0, 0.0, L, linewidth=1.8, linestyle='--', color="black") # Adding a horizontal line at 0 # Now we define labels, legend, etc ax.legend(loc=2); ax.set_xlabel(r'$L$') ax.set_ylabel(r'$\psi_n(x)$') plt.title('Wavefunction') plt.legend(bbox_to_anchor=(1.1, 1), loc=2, borderaxespad=0.0) # Generating the probability density graph fig, ax = plt.subplots() ax.axis([0.0,L,0.0,lim1*lim1*1.1]) str1=r"$n = "+str(n)+r"$" ax.plot(x, psi(x,n,L)*psi(x,n,L), label=str1, linewidth=2.8) ax.legend(loc=2); ax.set_xlabel(r'$L$') ax.set_ylabel(r'$|\psi_n|^2(x)$') plt.title('Probability Density') plt.legend(bbox_to_anchor=(1.1, 1), loc=2, borderaxespad=0.0) # Show the plots on the screen once the code reaches this point plt.show() ``` ```python # Length Dependence on Wavefunctions import matplotlib.pyplot as plt import numpy as np # Reading the input boxes sizes from the user, and making sure the values are not larger than 20 A L = 100.0 while(L>20.0): L1 = float(input(" To compare wavefunctions for boxes of different lengths \nenter the value of L for the first box (in Angstroms and not larger then 20 A) = ")) L2 = float(input("Enter the value of L for the second box (in Angstroms and not larger then 20) = ")) L = max(L1,L2) if(L>20.0): print ("The sizes of the boxes cannot be larger than 20 A. Please enter the values again.\n") # Generating the wavefunction and probability density graphs plt.rcParams.update({'font.size': 18, 'font.family': 'STIXGeneral', 'mathtext.fontset': 'stix'}) fig, ax = plt.subplots(figsize=(12,6)) ax.spines['right'].set_color('none') ax.xaxis.tick_bottom() ax.spines['left'].set_color('none') ax.axes.get_yaxis().set_visible(False) ax.spines['top'].set_color('none') val = 1.1*max(L1,L2) X1 = np.linspace(0.0, L1, 900,endpoint=True) X2 = np.linspace(0.0, L2, 900,endpoint=True) ax.axis([-0.5*val,1.5*val,-np.sqrt(2.0/L),3*np.sqrt(2.0/L)]) ax.set_xlabel(r'$X$ (Angstroms)') strA="$\psi_n$" strB="$|\psi_n|^2$" ax.text(-0.12*val, 0.0, strA, rotation='vertical', fontsize=30, color="black") ax.text(-0.12*val, np.sqrt(4.0/L), strB, rotation='vertical', fontsize=30, color="black") str1=r"$L = "+str(L1)+r"$ A" str2=r"$L = "+str(L2)+r"$ A" ax.plot(X1,psi(X1,n,L1)*np.sqrt(L1/L), color="red", label=str1, linewidth=2.8) ax.plot(X2,psi(X2,n,L2)*np.sqrt(L2/L), color="blue", label=str2, linewidth=2.8) ax.plot(X1,psi(X1,n,L1)*psi(X1,n,L1)*(L1/L) + np.sqrt(4.0/L), color="red", linewidth=2.8) ax.plot(X2,psi(X2,n,L2)*psi(X2,n,L2)*(L2/L) + np.sqrt(4.0/L), color="blue", linewidth=2.8) ax.margins(0.00) ax.legend(loc=9) str2="$V = +\infty$" ax.text(-0.3*val, 0.5*np.sqrt(2.0/L), str2, rotation='vertical', fontsize=40, color="black") ax.vlines(0.0, -np.sqrt(2.0/L), 2.5*np.sqrt(2.0/L), linewidth=4.8, color="red") ax.vlines(L1, -np.sqrt(2.0/L), 2.5*np.sqrt(2.0/L), linewidth=4.8, color="red") ax.vlines(0.0, -np.sqrt(2.0/L), 2.5*np.sqrt(2.0/L), linewidth=4.8, color="blue") ax.vlines(L2, -np.sqrt(2.0/L), 2.5*np.sqrt(2.0/L), linewidth=4.8, color="blue") ax.hlines(0.0, 0.0, L, linewidth=1.8, linestyle='--', color="black") ax.hlines(np.sqrt(4.0/L), 0.0, L, linewidth=1.8, linestyle='--', color="black") plt.title('Wavefunction and Probability Density', fontsize=30) str3=r"$n = "+str(n)+r"$" ax.text(1.1*L,np.sqrt(4.0/L), r"$n = "+str(n)+r"$", fontsize=25, color="black") plt.legend(bbox_to_anchor=(0.73, 0.95), loc=2, borderaxespad=0.) # Show the plots on the screen once the code reaches this point plt.show() ``` ```python # Length Dependence on Wavefunctions import matplotlib.pyplot as plt import numpy as np # Reading the input boxes sizes from the user, and making sure the values are not larger than 20 A L = 100.0 while(L>20.0): L1 = float(input(" To compare wavefunctions for boxes of different lengths \nenter the value of L for the first box (in Angstroms and not larger then 20 A) = ")) L2 = float(input("Enter the value of L for the second box (in Angstroms and not larger then 20) = ")) L = max(L1,L2) if(L>20.0): print ("The sizes of the boxes cannot be larger than 20 A. Please enter the values again.\n") # Generating the wavefunction and probability density graphs plt.rcParams.update({'font.size': 18, 'font.family': 'STIXGeneral', 'mathtext.fontset': 'stix'}) fig, ax = plt.subplots(figsize=(12,6)) ax.spines['right'].set_color('none') ax.xaxis.tick_bottom() ax.spines['left'].set_color('none') ax.axes.get_yaxis().set_visible(False) ax.spines['top'].set_color('none') val = 1.1*max(L1,L2) X1 = np.linspace(0.0, L1, 900,endpoint=True) X2 = np.linspace(0.0, L2, 900,endpoint=True) ax.axis([-0.5*val,1.5*val,-np.sqrt(2.0/L),3*np.sqrt(2.0/L)]) ax.set_xlabel(r'$X$ (Angstroms)') strA="$\psi_n$" strB="$|\psi_n|^2$" ax.text(-0.12*val, 0.0, strA, rotation='vertical', fontsize=30, color="black") ax.text(-0.12*val, np.sqrt(4.0/L), strB, rotation='vertical', fontsize=30, color="black") str1=r"$L = "+str(L1)+r"$ A" str2=r"$L = "+str(L2)+r"$ A" ax.plot(X1,psi(X1,n,L1)*np.sqrt(L1/L), color="red", label=str1, linewidth=2.8) ax.plot(X2,psi(X2,n,L2)*np.sqrt(L2/L), color="blue", label=str2, linewidth=2.8) ax.plot(X1,psi(X1,n,L1)*psi(X1,n,L1)*(L1/L) + np.sqrt(4.0/L), color="red", linewidth=2.8) ax.plot(X2,psi(X2,n,L2)*psi(X2,n,L2)*(L2/L) + np.sqrt(4.0/L), color="blue", linewidth=2.8) ax.margins(0.00) ax.legend(loc=9) str2="$V = +\infty$" ax.text(-0.3*val, 0.5*np.sqrt(2.0/L), str2, rotation='vertical', fontsize=40, color="black") ax.vlines(0.0, -np.sqrt(2.0/L), 2.5*np.sqrt(2.0/L), linewidth=4.8, color="red") ax.vlines(L1, -np.sqrt(2.0/L), 2.5*np.sqrt(2.0/L), linewidth=4.8, color="red") ax.vlines(0.0, -np.sqrt(2.0/L), 2.5*np.sqrt(2.0/L), linewidth=4.8, color="blue") ax.vlines(L2, -np.sqrt(2.0/L), 2.5*np.sqrt(2.0/L), linewidth=4.8, color="blue") ax.hlines(0.0, 0.0, L, linewidth=1.8, linestyle='--', color="black") ax.hlines(np.sqrt(4.0/L), 0.0, L, linewidth=1.8, linestyle='--', color="black") plt.title('Wavefunction and Probability Density', fontsize=30) str3=r"$n = "+str(n)+r"$" ax.text(1.1*L,np.sqrt(4.0/L), r"$n = "+str(n)+r"$", fontsize=25, color="black") plt.legend(bbox_to_anchor=(0.73, 0.95), loc=2, borderaxespad=0.) # Show the plots on the screen once the code reaches this point plt.show() ``` ```python # Energy levels import matplotlib.pyplot as plt plt.style.use('fivethirtyeight') #Given the following parameters h=6.62607e-34 #planck's constant in joules me=9.1093837e-31 # mass of an electron in kg # (h**2 / (me*8))* (1e10)**2 *6.242e+18 #is the prefactor using length units is Angstroms and then converted into electron volts # Defining a function to compute the energy def En(n,L,m): return (h**2 / (m*8))* (1e10)**2 *6.242e+18*((float(n)/L)**2) # Reading the input variables from the user L1 = float(input(" To see how the energy levels change for boxes of different lengths, \nenter the value for L for the first box (in Angstroms) = ")) nmax1 = int(input("Enter the number of levels you want to plot for the first box = ")) L2 = float(input("Enter the value for L for the second box (in Angstroms) = ")) nmax2 = int(input("Enter the number of levels you want to plot for the second box = ")) # Generating the graph plt.rcParams.update({'font.size': 18, 'font.family': 'STIXGeneral', 'mathtext.fontset': 'stix'}) fig, ax = plt.subplots(figsize=(8,12)) ax.spines['right'].set_color('none') ax.yaxis.tick_left() ax.spines['bottom'].set_color('none') ax.axes.get_xaxis().set_visible(False) ax.spines['top'].set_color('none') val = 1.1*max(En(nmax1,L1,me),En(nmax2,L2,me)) val2= 1.1*max(L1,L2) ax.axis([0.0,10.0,0.0,val]) ax.set_ylabel(r'$E_n$ (eV)') for n in range(1,nmax1+1): str1="$n = "+str(n)+r"$, $E_{"+str(n)+r"} = %.3f$ eV"%(En(n,L1,me)) ax.text(0.6, En(n,L1,me)+0.01*val, str1, fontsize=16, color="red") ax.hlines(En(n,L1,me), 0.0, 4.5, linewidth=1.8, linestyle='--', color="red") for n in range(1,nmax2+1): str1="$n = "+str(n)+r"$, $E_{"+str(n)+r"} = %.3f$ eV"%(En(n,L2,me)) ax.text(6.2, En(n,L2,me)+0.01*val, str1, fontsize=16, color="blue") ax.hlines(En(n,L2,me), 5.5, 10.0, linewidth=1.8, linestyle='--', color="blue") str1=r"$L = "+str(L1)+r"$ A" plt.title("Energy Levels for a particle of mass = $m_{electron}$ \n ", fontsize=30) str1=r"$L = "+str(L1)+r"$ A" str2=r"$L = "+str(L2)+r"$ A" ax.text(1.5,val, str1, fontsize=25, color="red") ax.text(6,val, str2, fontsize=25, color="blue") # Show the plots on the screen once the code reaches this point plt.show() ``` ```python # Energy mass dependence import matplotlib.pyplot as plt # Reading the input variables from the user L = float(input(" Enter the value for L for both boxes (in Angstroms) = ")) m1 = float(input(" To see how the energy levels change for particles of different mass, \nEnter the value of the mass for the first particle (in units of the mass of 1 electron) = ")) nmax1 = int(input("Enter the number of levels you want to plot for the first box = ")) m2 = float(input("Enter the value of the mass for the second particle (in units of the mass of 1 electron) = ")) nmax2 = int(input("Enter the number of levels you want to plot for the second box = ")) # Generating the graph plt.rcParams.update({'font.size': 18, 'font.family': 'STIXGeneral', 'mathtext.fontset': 'stix'}) fig, ax = plt.subplots(figsize=(8,12)) ax.spines['right'].set_color('none') ax.yaxis.tick_left() ax.spines['bottom'].set_color('none') ax.axes.get_xaxis().set_visible(False) ax.spines['top'].set_color('none') val = 1.1*max(En(nmax1,L,m1*me),En(nmax2,L,m2*me)) val2= 1.1*max(m1,m2) ax.axis([0.0,10.0,0.0,val]) ax.set_ylabel(r'$E_n$ (eV)') for n in range(1,nmax1+1): str1="$n = "+str(n)+r"$, $E_{"+str(n)+r"} = %.3f$ eV"%(En(n,L,m1*me)) ax.text(0.6, En(n,L,m1*me)+0.01*val, str1, fontsize=16, color="green") ax.hlines(En(n,L,m1*me), 0.0, 4.5, linewidth=1.8, linestyle='--', color="green") for n in range(1,nmax2+1): str1="$n = "+str(n)+r"$, $E_{"+str(n)+r"} = %.3f$ eV"%(En(n,L,m2*me)) ax.text(6.2, En(n,L,m2*me)+0.01*val, str1, fontsize=16, color="magenta") ax.hlines(En(n,L,m2*me), 5.5, 10.0, linewidth=1.8, linestyle='--', color="magenta") str1=r"$m = "+str(m1)+r"$ A" plt.title("Energy Levels for two particles with different masses\n ", fontsize=30) str1=r"$m_1 = "+str(m1)+r"$ $m_e$ " str2=r"$m_2 = "+str(m2)+r"$ $m_e$ " ax.text(1.1,val, str1, fontsize=25, color="green") ax.text(6.5,val, str2, fontsize=25, color="magenta") # Show the plots on the screen once the code reaches this point plt.show() ``` ```python # Combined plot import matplotlib.pyplot as plt import numpy as np # Here the users inputs the value of L L = float(input("Enter the value of L (in Angstroms) = ")) nmax = int(input("Enter the maximum value of n you want to plot = ")) # Generating the wavefunction graph fig, ax = plt.subplots(figsize=(12,9)) ax.spines['right'].set_color('none') ax.xaxis.tick_bottom() ax.spines['left'].set_color('none') ax.axes.get_yaxis().set_visible(False) ax.spines['top'].set_color('none') X3 = np.linspace(0.0, L, 900,endpoint=True) Emax = En(nmax,L,me) amp = (En(2,L,me)-En(1,L,me)) *0.9 Etop = (Emax+amp)*1.1 ax.axis([-0.5*L,1.5*L,0.0,Etop]) ax.set_xlabel(r'$X$ (Angstroms)') for n in range(1,nmax+1): ax.hlines(En(n,L,me), 0.0, L, linewidth=1.8, linestyle='--', color="black") str1="$n = "+str(n)+r"$, $E_{"+str(n)+r"} = %.3f$ eV"%(En(n,L,me)) ax.text(1.03*L, En(n,L,me), str1, fontsize=16, color="black") ax.plot(X3,En(n,L,me)+amp*np.sqrt(L/2.0)*psi(X3,n,L), color="red", label="", linewidth=2.8) ax.margins(0.00) ax.vlines(0.0, 0.0, Etop, linewidth=4.8, color="blue") ax.vlines(L, 0.0, Etop, linewidth=4.8, color="blue") ax.hlines(0.0, 0.0, L, linewidth=4.8, color="blue") plt.title('Wavefunctions', fontsize=30) plt.legend(bbox_to_anchor=(0.8, 1), loc=2, borderaxespad=0.) str2="$V = +\infty$" ax.text(-0.15*L, 0.6*Emax, str2, rotation='vertical', fontsize=40, color="black") # Generating the probability density graph fig, ax = plt.subplots(figsize=(12,9)) ax.spines['right'].set_color('none') ax.xaxis.tick_bottom() ax.spines['left'].set_color('none') ax.axes.get_yaxis().set_visible(False) ax.spines['top'].set_color('none') X3 = np.linspace(0.0, L, 900,endpoint=True) Emax = En(nmax,L,me) ax.axis([-0.5*L,1.5*L,0.0,Etop]) ax.set_xlabel(r'$X$ (Angstroms)') for n in range(1,nmax+1): ax.hlines(En(n,L,me), 0.0, L, linewidth=1.8, linestyle='--', color="black") str1="$n = "+str(n)+r"$, $E_{"+str(n)+r"} = %.3f$ eV"%(En(n,L,me)) ax.text(1.03*L, En(n,L,me), str1, fontsize=16, color="black") ax.plot(X3,En(n,L,me)+ amp*(np.sqrt(L/2.0)*psi(X3,n,L))**2, color="red", label="", linewidth=2.8) ax.margins(0.00) ax.vlines(0.0, 0.0, Etop, linewidth=4.8, color="blue") ax.vlines(L, 0.0, Etop, linewidth=4.8, color="blue") ax.hlines(0.0, 0.0, L, linewidth=4.8, color="blue") plt.title('Probability Density', fontsize=30) plt.legend(bbox_to_anchor=(0.8, 1), loc=2, borderaxespad=0.) str2="$V = +\infty$" ax.text(-0.15*L, 0.6*Emax, str2, rotation='vertical', fontsize=40, color="black") # Show the plots on the screen once the code reaches this point plt.show() ``` ```python # 2D Box import matplotlib.pyplot as plt import numpy as np # Defining the wavefunction def psi2D(x,y): return 2.0*np.sin(n*np.pi*x)*np.sin(m*np.pi*y) # Here the users inputs the values of n and m n = int(input("Let's look at the Wavefunction for a 2D box \nEnter the value for n = ")) m = int(input("Enter the value for m = ")) # Generating the wavefunction graph x = np.linspace(0, 1, 100) y = np.linspace(0, 1, 100) X, Y = np.meshgrid(x, y) fig, axes = plt.subplots(1, 1, figsize=(8,8)) axes.imshow(psi2D(X,Y), origin='lower', extent=[0.0, 1.0, 0.0, 1.0]) axes.set_title(r'Heat plot of $\sqrt{L_xL_y}\Psi_{n,m}(x,y)$ for $n='+str(n)+r'$ and $m='+str(m)+r'$') axes.set_ylabel(r'$y/L_y$') axes.set_xlabel(r'$x/L_x$') # Plotting the colorbar for the density plots fig = plt.figure(figsize=(10,3)) colbar = fig.add_axes([0.05, 0.80, 0.7, 0.10]) norm = mpl.colors.Normalize(vmin=-2.0, vmax=2.0) mpl.colorbar.ColorbarBase(colbar, norm=norm, orientation='horizontal') # Show the plots on the screen once the code reaches this point plt.show() ``` ```python import matplotlib.pyplot as plt import numpy as np # Here the users inputs the values of n and m yo = float(input("Enter the value of y/L_y for the x-axes slice =")) xo = float(input("Enter the value of x/L_x for the y-axes slice =")) # Generating the wavefunction graph plt.rcParams.update({'font.size': 18, 'font.family': 'STIXGeneral', 'mathtext.fontset': 'stix'}) x = np.linspace(0, 1.0, 900) fig, ax = plt.subplots() lim1=2.0 # Maximum value of the wavefunction ax.axis([0.0,1.0,-1.1*lim1,1.1*lim1]) # Defining the limits to be plot in the graph str1=r"$n = "+str(n)+r", m = "+str(m)+r", y_o = "+str(yo)+r"\times L_y$" ax.plot(x, psi2D(x,yo), linestyle='--', label=str1, color="orange", linewidth=2.8) # Plotting the wavefunction ax.hlines(0.0, 0.0, 1.0, linewidth=1.8, linestyle='--', color="black") # Adding a horizontal line at 0 # Now we define labels, legend, etc ax.legend(loc=2); ax.set_xlabel(r'$x/L_x$') ax.set_ylabel(r'$\sqrt{L_xL_y}\Psi_{n,m}(x,y_o)$') plt.legend(bbox_to_anchor=(1.1, 1), loc=2, borderaxespad=0.0) # Generating the wavefunction graph plt.rcParams.update({'font.size': 18, 'font.family': 'STIXGeneral', 'mathtext.fontset': 'stix'}) y = np.linspace(0, 1.0, 900) fig, ax = plt.subplots() lim1=2.0 # Maximum value of the wavefunction ax.axis([0.0,1.0,-1.1*lim1,1.1*lim1]) # Defining the limits to be plot in the graph str1=r"$n = "+str(n)+r", m = "+str(m)+r", x_o = "+str(xo)+r"\times L_x$" ax.plot(y, psi2D(xo,y), linestyle='--', label=str1, color="blue", linewidth=2.8) # Plotting the wavefunction ax.hlines(0.0, 0.0, 1.0, linewidth=1.8, linestyle='--', color="black") # Adding a horizontal line at 0 # Now we define labels, legend, etc ax.legend(loc=2); ax.set_xlabel(r'$y/L_y$') ax.set_ylabel(r'$\sqrt{L_xL_y}\Psi_{n,m}(x_o,y)$') plt.legend(bbox_to_anchor=(1.1, 1), loc=2, borderaxespad=0.0) # Show the plots on the screen once the code reaches this point plt.show() ``` ```python import matplotlib.pyplot as plt # Defining the energy as a function def En2D(n,m,L1,L2): return 37.60597*((float(n)/L1)**2+ (float(m)/L2)**2) # Reading data from the user L1 = float(input("Can we count DEGENERATE states?\nEnter the value for Lx (in Angstroms) = ")) nmax1 = int(input("Enter the maximum value of n to consider = ")) L2 = float(input("Enter the value for Ly (in Angstroms) = ")) mmax2 = int(input("Enter the maximum value of m to consider = ")) # Plotting the energy levels plt.rcParams.update({'font.size': 18, 'font.family': 'STIXGeneral', 'mathtext.fontset': 'stix'}) fig, ax = plt.subplots(figsize=(nmax1*2+2,nmax1*3)) ax.spines['right'].set_color('none') ax.yaxis.tick_left() ax.spines['bottom'].set_color('none') ax.axes.get_xaxis().set_visible(False) ax.spines['top'].set_color('none') val = 1.1*(En2D(nmax1,mmax2,L1,L2)) val2= 1.1*max(L1,L2) ax.axis([0.0,3*nmax1,0.0,val]) ax.set_ylabel(r'$E_n$ (eV)') for n in range(1,nmax1+1): for m in range(1, mmax2+1): str1="$"+str(n)+r","+str(m)+r"$" str2=" $E = %.3f$ eV"%(En2D(n,m,L1,L2)) ax.text(n*2-1.8, En2D(n,m,L1,L2)+ 0.005*val, str1, fontsize=20, color="blue") ax.hlines(En2D(n,m,L1,L2), n*2-2, n*2-1, linewidth=3.8, color="red") ax.hlines(En2D(n,m,L1,L2), 0.0, nmax1*2+1, linewidth=1., linestyle='--', color="black") ax.text(nmax1*2+1, En2D(n,m,L1,L2)+ 0.005*val, str2, fontsize=16, color="blue") plt.title("Energy Levels for \n ", fontsize=30) str1=r"$L_x = "+str(L1)+r"$ A, $n_{max} = "+str(nmax1)+r"$ $L_y = "+str(L2)+r"$ A, $m_{max}="+str(mmax2)+r"$" ax.text(0.1,val, str1, fontsize=25, color="black") # Show the plots on the screen once the code reaches this point plt.show() ``` https://scipython.com/blog/the-harmonic-oscillator-wavefunctions/ ```python import numpy as np from matplotlib import rc from scipy.special import factorial import matplotlib.pyplot as plt rc('font', **{'family': 'serif', 'serif': ['Computer Modern'], 'size': 14}) #rc('text', usetex=True) # PLOT_PROB=False plots the wavefunction, psi; PLOT_PROB=True plots |psi|^2 PLOT_PROB = False # Maximum vibrational quantum number to calculate wavefunction for VMAX = 6 # Some appearance settings # Pad the q-axis on each side of the maximum turning points by this fraction QPAD_FRAC = 1.3 # Scale the wavefunctions by this much so they don't overlap SCALING = 0.7 # Colours of the positive and negative parts of the wavefunction COLOUR1 = (0.6196, 0.0039, 0.2588, 1.0) COLOUR2 = (0.3686, 0.3098, 0.6353, 1.0) # Normalization constant and energy for vibrational state v N = lambda v: 1./np.sqrt(np.sqrt(np.pi)*2**v*factorial(v)) get_E = lambda v: v + 0.5 def make_Hr(): """Return a list of np.poly1d objects representing Hermite polynomials.""" # Define the Hermite polynomials up to order VMAX by recursion: # H_[v] = 2qH_[v-1] - 2(v-1)H_[v-2] Hr = [None] * (VMAX + 1) Hr[0] = np.poly1d([1.,]) Hr[1] = np.poly1d([2., 0.]) for v in range(2, VMAX+1): Hr[v] = Hr[1]*Hr[v-1] - 2*(v-1)*Hr[v-2] return Hr Hr = make_Hr() def get_psi(v, q): """Return the harmonic oscillator wavefunction for level v on grid q.""" return N(v)*Hr[v](q)*np.exp(-q*q/2.) def get_turning_points(v): """Return the classical turning points for state v.""" qmax = np.sqrt(2. * get_E(v + 0.5)) return -qmax, qmax def get_potential(q): """Return potential energy on scaled oscillator displacement grid q.""" return q**2 / 2 fig, ax = plt.subplots(figsize=(10,8)) qmin, qmax = get_turning_points(VMAX) xmin, xmax = QPAD_FRAC * qmin, QPAD_FRAC * qmax q = np.linspace(qmin, qmax, 500) V = get_potential(q) def plot_func(ax, f, scaling=1, yoffset=0): """Plot f*scaling with offset yoffset. The curve above the offset is filled with COLOUR1; the curve below is filled with COLOUR2. """ ax.plot(q, f*scaling + yoffset, color=COLOUR1) ax.fill_between(q, f*scaling + yoffset, yoffset, f > 0., color=COLOUR1, alpha=0.5) ax.fill_between(q, f*scaling + yoffset, yoffset, f < 0., color=COLOUR2, alpha=0.5) # Plot the potential, V(q). ax.plot(q, V, color='k', linewidth=1.5) # Plot each of the wavefunctions (or probability distributions) up to VMAX. for v in range(VMAX+1): psi_v = get_psi(v, q) E_v = get_E(v) if PLOT_PROB: plot_func(ax, psi_v**2, scaling=SCALING*1.5, yoffset=E_v) else: plot_func(ax, psi_v, scaling=SCALING, yoffset=E_v) # The energy, E = (v+0.5).hbar.omega. ax.text(s=r'$\frac{{{}}}{{2}}\hbar\omega$'.format(2*v+1), x=qmax+0.2, y=E_v, va='center') # Label the vibrational levels. ax.text(s=r'$v={}$'.format(v), x=qmin-0.2, y=E_v, va='center', ha='right') # The top of the plot, plus a bit. ymax = E_v+0.5 if PLOT_PROB: ylabel = r'$|\psi(q)|^2$' else: ylabel = r'$\psi(q)$' ax.text(s=ylabel, x=0, y=ymax, va='bottom', ha='center') ax.set_xlabel('$q$') ax.set_xlim(xmin, xmax) ax.set_ylim(0, ymax) ax.spines['left'].set_position('center') ax.set_yticks([]) ax.spines['top'].set_visible(False) ax.spines['right'].set_visible(False) plt.savefig('sho-psi{}-{}.png'.format(PLOT_PROB+1, VMAX)) plt.show() ``` ```python ``` ```python # Visualizing the solutions of harmonic oscillator problem. # First load the numpy/scipy/matplotlib import numpy as np import matplotlib.pyplot as plt %matplotlib inline #load interactive widgets import ipywidgets as widgets from IPython.display import display #If your screen has retina display this will increase resolution of plots %config InlineBackend.figure_format = 'retina' # Import hermite polynomials and factorial to use in normalization factor from scipy.special import hermite from math import factorial #Check to see if they match the table H=hermite(4) print(H) ``` ```python ``` ```python x=np.linspace(-2,2,1000) # Range needs to be specified for plotting functions of x for v in range(0,3): H=hermite(v) f=H(x) plt.plot(x,f) plt.xlabel('x') plt.ylabel(r'$H_n(x)$') ``` ```python def N(v): '''Normalization constant ''' return 1./np.sqrt(np.sqrt(np.pi)*2**v*factorial(v)) def psi(v, x): """Harmonic oscillator wavefunction for level v computed on grid of points x""" Hr=hermite(v) Psix = N(v)*Hr(x)*np.exp(-0.5*x**2) return Psix # Normalization is computed by using numerical integration with trapezoidal method: from scipy.integrate import trapz # remember that x runs form -inf to +inf so lets use large xmin and xmax x=np.linspace(-10,10,1000) psi2=psi(5,x)**2 Integral = trapz(psi2,x) print(Integral) @widgets.interact(v=(0,50)) def plot_psi(v=0): x=np.linspace(-10,10,1000) y= psi(v,x)**2 plt.plot(x,y,lw=2) plt.grid('on') plt.xlabel('x',fontsize=16) plt.ylabel('$\psi_n(x)$',fontsize=16) ``` ```python ``` ```python def E(v): '''Eigenvalues in units of h''' return (v + 0.5) def V(x): """Potential energy function""" return 0.5*x**2 # plot up to level vmax VMAX=8 # Range of x determine by classical tunring points: xmin, xmax = -np.sqrt(2*E(VMAX)), np.sqrt(2*E(VMAX)) x = np.linspace(xmin, xmax, 1000) fig, ax = plt.subplots(figsize=(8,8)) for v in range(8): # plot potential V(x) ax.plot(x,V(x),color='black') # plot psi squared which we shift up by values of energy ax.plot(x,psi(v,x)**2 + E(v), lw=2) # add lines and labels ax.axhline(E(v), color='gray', linestyle='--') ax.text(xmax, 1.2*E(v), f"v={v}") ax.set_xlabel('x') ax.set_ylabel('$\psi^2_n(x)$') ``` ```python ``` ```python # First load the libs import numpy as np import matplotlib.pyplot as plt from mpl_toolkits import mplot3d %matplotlib inline # a and load interactive widgets import ipywidgets as widgets from IPython.display import display L=0.3 # Try different wavelengths x = np.linspace(0.0, 1.0, 1000) y = np.sin(2 * np.pi * x/L) plt.plot(x, y) ``` ```python ``` ```python def wave(L): x = np.linspace(0.0, 1.0, 1000) y = np.sin(2*np.pi * x/L) plt.plot(x, y) # Now try comparing three different wavelengths wave(0.5) wave(1.0) wave(2.0) ``` ```python # Interactive Plot ``` ```python @widgets.interact(L=(0.1,1)) def wavef(L=.1): # By writing wavef(L=0.1) inside function you can specify initial value x = np.linspace(0, +1., 1000) y = np.sin(np.pi * x/L) plt.plot(x, y) ``` ```python ``` ```python @widgets.interact(k=(2,20),t=(0,50.0,0.1)) def wavef2(k=10,t=0): v=1 #velocity of waves phi = 0.5 # vary initial phase between -2*np.pi and 2*np.pi x = np.linspace(0, 1., 1000) wave1 = np.sin(k*(x-v*t)) wave2= np.sin(k*(x-v*t)+phi) #try flipping the direction ofvelocity to get standing wave plt.figure(figsize=(12,6)) plt.plot(x, wave1,'--', color='blue') plt.plot(x,wave2,'--', color='green') plt.plot(x, wave1+wave2,color='red') plt.ylim([-2.5,2.5]) plt.legend(['Wave1','Wave2','Wave1+Wave2']) plt.grid('on') ``` ```python ``` ```python @widgets.interact(n=(1,10)) def wavef(n=1): L=1 x = np.linspace(0, +1., 1000) y = np.sin(n*np.pi * x/L) plt.plot(x, y, lw=3, color='red') plt.grid('on') ``` ```python @widgets.interact(n1=(1,5),n2=(1,5),phi=(0,2*np.pi),t=(0,20,0.2)) def wavef(n1=1,n2=1,phi=0,t=0): L=1 omega=1 x = np.linspace(0, +1., 50) mode1 = np.cos(omega*t) * np.sin(n1*np.pi * x/L) mode2 = np.cos(omega*t + phi) * np.sin(n2*np.pi * x/L) plt.plot(x, mode1+mode2, lw=5, color='orange') plt.ylim([-2.5,2.5]) plt.grid('on') ``` ```python ``` ```python @widgets.interact(n1=(1,10),m1=(1,10)) def membrane(n1=1, m1=1): t=0 omega=1 Lx,Ly = 1,1 # size of memrbante N=40 # number of grid points along X and Y xs = np.linspace(0,Lx,N) ys = np.linspace(0,Ly,N) X,Y = np.meshgrid(xs,ys) # create 2D mesh of points along X and Y mode1 = np.sin(n1*np.pi*X/Lx)*np.sin(m1*np.pi*Y/Ly) fig, ax =plt.subplots() ax.contourf(X,Y,mode1,40,cmap='RdBu') ``` ```python ``` ```python # Vibrations of square 2D membrane as a linear combination of normal modes @widgets.interact(n1=(1,10),m1=(1,10),n2=(1,10),m2=(1,10),phi=(0,2*np.pi),t=(0,100)) def membrane(n1=1, m1=1, n2=1, m2=1, phi=0, t=0): omega=1 L=1 # size of memrbante N=40 # number of grid points along X and Y x = np.linspace(0,L,N) y = np.linspace(0,L,N) X,Y = np.meshgrid(x,y) # create 2D mesh of points along X and Y mode1 = np.cos(omega*t) * np.sin(n1*np.pi*X/L) * np.sin(m1*np.pi*Y/L) mode2 = np.cos(omega*t+phi) * np.sin(n2*np.pi*X/L) * np.sin(m2*np.pi*Y/L) fig, ax = plt.subplots(figsize=(9,6)) ax = plt.axes(projection='3d') # Making a 3D plot ax.set_zlim([-2.0,2.0]) ax.plot_surface(X,Y,mode1+mode2,cmap='RdYlBu') #Do the Plot ``` # Solving Time Independent Schrodinger Equation by # Numerov Method # SHO ( 1D Harmonic Quantum Oscillator) # $ -\frac{\hbar^2}{2m}\frac{d^2\psi(x)}{dx^2}-\frac{1}{2}kx^2\psi(x)=E\psi(x)$ ```python # Hamiltonian matrix method to solve harmonic oscillator 15/02/2021 from matplotlib import pyplot as plt import numpy as np plt.style.use('fivethirtyeight') hbar=1 m=1 omega=1 N = 2014 a = 20.0 x = np.linspace(-a/2.,a/2.,N) h = x[1]-x[0] # Should be equal to 2*np.pi/(N-1) V = .5*m*omega*x*x # V[N/2]=2/h # This would add a "delta" spike in the center. Mdd = 1./(h*h)*(np.diag(np.ones(N-1),-1) -2* np.diag(np.ones(N),0) + np.diag(np.ones(N-1),1)) H = -(hbar*hbar)/(2.0*m)*Mdd + np.diag(V) En,psiT = np.linalg.eigh(H) # This computes the eigen values and eigenvectors psi = np.transpose(psiT) # The psi now contain the wave functions ordered so that psi[n] if the n-th eigen state. plt.figure(figsize=(12,6)) plt.plot(x,psi[1],label='$\psi_1(x)$') plt.plot(x,psi[2],label='$\psi_2(x)$') plt.xlabel('x') plt.ylabel('$\psi_n(x)$') plt.legend(loc='upper left') plt.show() ``` ```python ``` ```python # Check the normalization of the wave function arrays. notok=False for n in range(len(psi)): # s = np.sum(psi[n]*psi[n]) s = np.linalg.norm(psi[n]) # This does the same as the line above. if np.abs(s - 1) > 0.00001: # Check if it is different from one. print("Wave function {} is not normalized to 1 but {}".format(n,s)) notok=True if not notok: print("All the $\psi_n(x)$ are normalized.") fig2 = plt.figure(figsize=[12,7]) plt.title('Harmonic Oscillator') plt.ylabel('$\psi(x)$') plt.xlabel('$x$') plt.plot([0,0],[-6,V[0]],color="blue") plt.plot([-a/2.,a/2.],[0,0],color="blue") plt.plot(x,0.1*V,color="grey",label="V(x) scaled by 0.1") plt.ylim((-.8,1.)) plt.xlim((-6.,6.)) for i in range(0,5): if psi[i][int(N/8)] < 0: plt.plot(x,-psi[i]/np.sqrt(h),label="$E_{}$={:3.1f}".format(i,En[i])) else: plt.plot(x,psi[i]/np.sqrt(h),label="$E_{}$={:3.1f}".format(i,En[i])) plt.title("Solution to harmonic oscillator") plt.legend() plt.savefig("Harmonic_Oscillator_WaveFunctions.pdf") plt.show() ``` ```python ``` We want to now plot the initial wave function. We could try to shift the already calculated $\psi_0(x)$ array, but it is better to compute the function from a formula. The *main reason* for making this plot is to make sure the *normalization* of the function is correct. We would want the *same normalization* as our $\psi_n(x)$ arrays, so we need to muliply the function by $\sqrt{\Delta x}$, which we then divide out again when we plot. Doing this makes sure that the $c_n$ factors we compute later are correct and with the same normalization. ```python fig2 = plt.figure(figsize=[10,7]) plt.title('Harmonic Oscillator and displaced ground state.') plt.ylabel('$\psi(x)$') plt.xlabel('$x$') plt.plot([0,0],[-6,V[0]],color="blue") plt.plot([-a/2.,a/2.],[0,0],color="blue") plt.plot(x,0.1*V,color="grey",label="V(x) scaled by 0.1") plt.ylim((-.1,1.)) plt.xlim((-5.,8.)) a0=5. alpha = (m*omega/(np.pi*hbar))**0.25 psi0 = np.sqrt(h)*alpha*np.exp(-(x-a0)**2*m*omega/(2*hbar)) # This is the formula for the displaced state. n0 = np.linalg.norm(psi0) print("Check the normalization of psi0: ",n0) plt.plot(x,psi0/np.sqrt(h),label="Displaced state $\Psi(x,0)$") plt.plot(x,-psi[0]/np.sqrt(h),label="Ground state $\psi_0(x)$") plt.legend() plt.savefig("Displaced_state.pdf") plt.show() ``` We can now compute the $c_n$ factors as a simple sum of the product of the initial wave and the $\psi_n(x)$ eigen states. There are many ways to accomplish this, looping over the $N$ eigen states. The way I do this below is particularly efficient, creating a new Numpy array of the $c_n$ factors. The line commented out does the calculation using list comprehension. The second line does this as a matrix multiplication. We now compute the energy of this initial state, so we can plot the line on our graph. This was not part of the homework assignment, but it is nice to be able to draw this. We compute the energy as: . We also compute the energy as $E=\int \Psi^*(x,t=0) \hat{\mathrm{H}} \Psi(x,t-0)$, and compare. Once we have the $c_n$ we can sum them to make sure the normalization is indeed correct: $\sum |c_n|^2 =1$. We can also use them to calculate the expactation value of the energy of the state: $<E>=\sum |c_n|^2 E_n$, which we can check against an algebraic computation: $$ <E> = <T> + <V> = \frac{1}{2}\hbar\omega + \frac{1}{2}m\omega^2 |x_0|^2 = \frac{1}{2} + \frac{1}{2} 5^2 = 13$$ And finally we can also compute it directly from the Hamiltonian: $$<E> = <\Psi(x,0)| \hat{\mathrm{H}} | \Psi(x,0)> = \int \Psi^*(x,0)H \Psi(x,0) dx$$. ```python ``` ```python # cn=np.array([np.sum(psi[i]*psi0) for i in range(N)],dtype='float') cn = psi.dot(psi0) print(cn[0:18]) print("Check sum: {:6.4f}".format(np.sum(cn*cn))) E = np.sum(np.conjugate(cn)*cn*En) print ("<E> = {:9.4f}".format(E)) E_check = np.sum( np.conjugate(psi0)*H.dot(psi0)) print("Check E=",E_check) ``` We now want to compute: $$\Psi(x,t)=\sum_{n=1}^{n=\infty} c_n \psi_n(x) e^{-i(n+\frac{1}{2})\omega t}$$ For a particular time $t$ we thus want an array of numbers representing $\Psi$ at that time. A technical detail here is that we want to sum all the $n$ values for a particular $x_i$ of the product $c_n*\psi_n*\phi(t)$. Our wavefunctions are arranged in such a way that this would be a sum over the columns instead of over the rows (which is what we did when checking the normalization). We can circumvent this problem by using the original transposed version, psiT, of the wavefunctions. Below are three different implementation of this function, the first one is a bit more straight forward but slow, the second one is a bit faster (about a factor of 2.5), the third is fastest. At this point you should start to worry about numerical accuracy. It turns out that for this particular situation the method we are using is accurate enough, and the solution is *stable*, that is, there are no diverging terms in the calculation. This will not be true for all situations where you solve the Schrödinger equation using matrix inversion (i.e. finding the eigen vectors). In many situations, including scattering, you will need to use more sophisticated ways of obtaining solutions. ```python ``` ```python # This version creates an array of zeros, to which it then sequentially adds each of the terms in the sum. # Note that we use the global psi array. def psi_xt(t,cn): out = np.zeros(N,dtype='complex128') for n in range(N): out += cn[n]*psi[n]*np.exp(-1j*(n+0.5)*omega*t) return(out) # This version uses np.sum to accomplish the same thing as the function above. def psi_xt2(t,cn): n = np.arange(len(cn)) times = np.exp(-1j*(n+0.5)*omega*t) out = psiT.dot(cn*times) return(out) # This version uses np.sum and now also the previously calculated energyes. # This way, psi_xt3 will work even if the potential is distorted and the energy levels are no longer (n+0.5)*hbar*omega def psi_xt3(t,cn): out = psiT.dot(cn*np.exp(-1j*En*t/hbar)) return(out) ``` ```python ``` ```python fig2 = plt.figure(figsize=[10,5]) plt.title('Harmonic Oscillator') plt.ylabel('$\psi(x)$') plt.xlabel('$x$') plt.plot([0,0],[-6,V[0]],color="blue") plt.plot([-a/2.,a/2.+1.],[0,0],color="blue") plt.plot(x,0.05*V,color="grey",label="V(x) scaled by 0.05") plt.plot([-a/2.,a/2.],[E*0.05,E*0.05],color="grey",linestyle="dashed",label="<E> scaled by 0.05") plt.ylim((-.1,0.8)) # plt.plot(x,psi0/np.sqrt(h),color='#dddddd') for t in [0.,np.pi/4.,np.pi/2.,3.*np.pi/4.,np.pi]: # np.linspace(0,np.pi,8): print(t) plt.plot(x,np.abs(psi_xt3(t,cn))**2/h,label="t={:5.3}$\pi$".format(t/np.pi)) plt.legend() plt.savefig("Displaced_state_vs_time.pdf") plt.show() ``` ```python ``` ```python import matplotlib.animation as animation from IPython.display import HTML fig3 = plt.figure(figsize=[10,7]) ax = fig3.add_subplot(111, autoscale_on=False, xlim=(-10, 10), ylim=(-0.1, 1.)) ax.grid() line, = ax.plot([], [], lw=2,color='red') time_template = 'time = {:9.2f}s' time_text = ax.text(0.05, 0.93, '', transform=ax.transAxes) def init(): plt.title('Harmonic Oscillator') plt.ylabel('$\psi(x)$') plt.xlabel('$x$') plt.plot([0,0],[-6,V[0]],color="blue") plt.plot([-a/2.,a/2.],[0,0],color="blue") plt.plot(x,0.05*V,color="grey",label="V(x) scaled by 0.05") plt.plot([-a/2.,a/2.],[E*0.05,E*0.05],color="grey",linestyle="dashed",label="<E> scaled by 0.05") line.set_data([], []) time_text.set_text(time_template.format(0.)) return line, time_text def animate(t): #t = (float(i)/100.)*(4.*np.pi/omega) line.set_data(x,np.abs(psi_xt3(t,cn)/np.sqrt(h))) time_text.set_text(time_template.format(t)) return line, time_text frame_rate = 30 # Frame rate in Hz. Make higher for smoother movie, but it takes longer to compute. time_slowdown = 10 # Run time x times slower than normal. Since omega=1, we want this about 10. ani = animation.FuncAnimation(fig3, animate, np.linspace(0,2*np.pi/omega,frame_rate*time_slowdown), interval=1000./frame_rate, blit=True, init_func=init) HTML(ani.to_html5_video()) ``` ```python frame_rate = 30 # Frame rate in Hz. Make higher for smoother movie, but it takes longer to compute. time_slowdown = 10 # Run time x times slower than normal. Since omega=1, we want this about 10. ani = animation.FuncAnimation(fig3, animate, np.linspace(0,2*np.pi/omega,frame_rate*time_slowdown), interval=1000./frame_rate, blit=True, init_func=init) HTML(ani.to_jshtml()) ``` ```python # Hamiltonian matrix method to solve anharmonic oscillator 15/02/2021 # 15/02/2021 from matplotlib import pyplot as plt import numpy as np plt.style.use('fivethirtyeight') hbar=1 m=1 omega=1 N = 2014 a = 10.0 x = np.linspace(-a/2.,a/2.,N) h = x[1]-x[0] # Should be equal to 2*np.pi/(N-1) V = .5*m*omega*x*x+.1*x**4 #V[int(N/2)]=2/h # This would add a "delta" spike in the center. Mdd = 1./(h*h)*(np.diag(np.ones(N-1),-1) -2* np.diag(np.ones(N),0) + np.diag(np.ones(N-1),1)) H = -(hbar*hbar)/(2.0*m)*Mdd + np.diag(V) En,psiT = np.linalg.eigh(H) # This computes the eigen values and eigenvectors psi = np.transpose(psiT) # The psi now contain the wave functions ordered so that psi[n] if the n-th eigen state. plt.figure(figsize=(12,6)) plt.plot(x,psi[1],label='$\psi_1(x)$') plt.plot(x,psi[2],label='$\psi_2(x)$') plt.xlabel('x',size=24) plt.ylabel('$\psi_n(x)$',size=24) plt.legend(loc='upper left') plt.show() ``` ```python En[0:4] ``` ```python N=10 (np.diag(np.ones(N-1),-1) -2* np.diag(np.ones(N),0) + np.diag(np.ones(N-1),1)) ``` ```python ``` ```python # Hamiltonian matrix method to solve inside solution of infinite well 15/02/2021 # 15/02/2021 from matplotlib import pyplot as plt import numpy as np plt.style.use('fivethirtyeight') hbar=1 m=1 omega=1 N = 2014 a = 10.0 x = np.linspace(-a/2.,a/2.,N) h = x[1]-x[0] # Should be equal to 2*np.pi/(N-1) #V = .5*m*omega*x*x+.1*x**4 V = 0*x #V[int(N/2)]=2/h # This would add a "delta" spike in the center. Mdd = 1./(h*h)*(np.diag(np.ones(N-1),-1) -2* np.diag(np.ones(N),0) + np.diag(np.ones(N-1),1)) H = -(hbar*hbar)/(2.0*m)*Mdd + np.diag(V) En,psiT = np.linalg.eigh(H) # This computes the eigen values and eigenvectors psi = np.transpose(psiT) # The psi now contain the wave functions ordered so that psi[n] if the n-th eigen state. plt.figure(figsize=(12,6)) plt.plot(x,psi[1],label='$\psi_1(x)$') plt.plot(x,psi[2],label='$\psi_2(x)$') plt.xlabel('x') plt.ylabel('$\psi_n(x)$') plt.legend(loc='upper left') plt.show() ``` ```python En ``` ```python import matplotlib.pyplot as plt def simp13dis(h,fx): n=len(fx) I=0 for i in range(n): if i==0 or i==n: I+=fx[i] elif i%2!=0: I+=4*fx[i] else: I+=2*fx[i] I=I*h/3 return I # Normalisation of discrete wavefunction def norm(psi,dx): N=len(psi) psi2=[psi[i]**2 for i in range(N)] psimod2=simp13dis(dx,psi2) normpsi=[psi[i]/psimod2**0.5 for i in range(N)] return normpsi import matplotlib.pyplot as plt # Solution of Schrodinger equation: def wavefn(mhdx2,psi,vi,E): N=len(psi) psiE=[psi[i] for i in range(N)] P=[mhdx2*(vi[i]-E) for i in range(N)] for i in range(2,N): d=1-1/12*P[i] a=2*(1+5/12*P[i-1]) b=-(1-1/12*P[i-2]) psiE[i]=(a/d)*psiE[i-1]+(b/d)*psiE[i-2] return psiE def NumerovSch(mhdx2,vi,psi0,psi1,psiN,nodes,mxItr): N=len(vi)-1 Emx=max(vi) Emn=min(vi) psiIn=[0 for i in range(N+1)] psiIn[0],psiIn[1],psiIn[N]=psi0,psi1,psiN itr=0 while abs(Emx-Emn)>1e-6 and itr<mxItr: E=.5*(Emx+Emn) psi=wavefn(mhdx2,psiIn,vi,E) # Node counting cnt=0 for i in range(1,N-2): if psi[i]*psi[i+1]<0: cnt+=1 if cnt>nodes: Emx=E elif cnt<nodes: Emn=E else: if psi[N-1]>psi[N]: Emn=E elif psi[N-1]<psi[N]: Emx=E itr+=1 if itr<mxItr: return E,psi else: return None,None def V(k,x): return .5*k*x*x hbar,m=.1,1.0 dx=.01 mxItr=100 psi0,psiN=0,0 k=1 stln=['b','r','m','g','c','y'] x0,xN=[-1.2,-1.4,-1.5,-1.6,-1.7,-1.8],[1.2,1.4,1.5,1.6,1.7,1.8] psi0,psiN=0,0 for nodes in range(4): N=int((xN[nodes]-x0[nodes])/dx) dx=(xN[nodes]-x0[nodes])/N mhdx2=2*m*dx**2/hbar**2 x=[x0[nodes]+i*dx for i in range(N+1)] Vi=[V(k,x[i]) for i in range(N+1)] psi1=(-1)**nodes*1e-4 E,psi=NumerovSch(mhdx2,Vi,psi0,psi1,psiN,nodes,mxItr) if E!=None: psi=norm(psi,dx) #plt.figure(figsize=(12,6)) plt.plot(x,psi,stln[nodes],label=r'E=%.4f$\psi_%d(x)$'%(E,nodes)) #plt.plot(x,Vi,'k--',label='Potential') xax=[0 for i in range(N+1)] # x-axis #plt.figure(figsize=(12,6)) plt.plot(x,xax,'k') plt.plot(x,Vi,'k--',label='Potential') plt.legend(loc='lower left') plt.xlabel('x',size=20) plt.ylabel('$\psi(x)$',size=30) #plt.figure(figsize=(12,6)) plt.show() ``` # The harmonic oscillator wavefunctions: The harmonic oscillator is often used as an approximate model for the behaviour of some quantum systems, for example the vibrations of a diatomic molecule. The Schrödinger equation for a particle of mass m moving in one dimension in a potential $ V(x)=\frac{1}{2}kx^2$ is # $ −\frac{\hbar^2}{2m}\frac{d^2\psi}{dx^2}+\frac{1}{2}kx^2ψ=E\psi.$ With the change of variable, $ q=(mk/\hbar^2)^{1/4}x $, this equation becomes $-\frac{1}{2}\frac{d^2\psi}{dq^2}+\frac{1}{2}\psi=\frac{E\psi}{\hbar\omega}$ where $ω=\sqrt(k/m)$. This differential equation has an exact solution in terms of a quantum number $ v=0,1,2,⋯$ #$\psi(q)=N_vH_v(q)exp(−q^2/2)$ where $N_v=(\sqrtπ 2^vv!)^{−1/2}$ is a normalization constant and $H_v(q)$ is the Hermite polynomial of order v, defined by: $H_v(q)=(−1)^ve^{q^2}\frac{d^v}{dq^v}(e^{−q^2})$. The Hermite polynomials obey a useful recursion formula: $H_{n+1}(q)=2qH_n(q)−2nH_{n−1}(q)$. so given the first two: H0=1 and H1=2q, we can calculate all the others. The following code plots the harmonic oscillator wavefunctions (PLOT_PROB = False) or probability densities (PLOT_PROB = True) for vibrational levels up to VMAX on the vibrational energy levels depicted within the potential, $V=q^2/2$. http://phys.ubbcluj.ro/~tbeu/INP/programs.html ```python import numpy as np import matplotlib.pyplot as plt from scipy.constants import hbar m= 1e-27 E= 1.5 def numerov_step(psi_1,psi_2,k1,k2,k3,h): #k1=k_(n-1), k2=k_n, k3=k_(n+1) #psi_1 = psi_(n-1) and psi_2=psi_n m = 2*(1-(5/12) * h**2 * k2**2)*psi_2 n = (1+(1/12)*h**2*k1**2)*psi_1 o = 1 + (1/12) *h**2 *k3**2 return (m-n)/o def numerov(N,x0,xE,a): x,dx = np.linspace(x0,xE,N+1,retstep=True) def V(x,a): #if (np.abs(x)<a): return .5*x**2 #else: # return 0 k = np.zeros(N+1) for i in range(len(k)): k[i] = 2*m*(E-V(x[i],a))/hbar**2 psi= np.zeros(N+1) psi[0]=0 psi[1]=.10 psi[2]=1.0 for j in np.arange(2,N): psi[j+1]= numerov_step(psi[j],psi[j+1],k[j-1],k[j],k[j+1],dx) return psi x0 =-3 xE = 3 N =1000 psi=numerov(N,x0,xE,3) x = np.linspace(x0,xE,N+1) y=[psi[i] for i in range(len(x))] plt.figure() plt.plot(x,psi) plt.show() ``` ```python import pylab as lab import math N = 60000 # iterations h = 0.0001 h2 = pow(h,2) epsilon = 3.5 # n+1/2 y = 0.0 k = 0.0 x = -1*(N-2)*h k_minus_2 = epsilon + x-2*h # k_0 k_minus_1 = epsilon + x-h # k_1 a = 0.1 y_minus_2 = 0 # y_0 y_minus_1 = a # y_1 x_out = [] y_out = [] n=-1*N+2 while n<N-2: n+=1 x += h; k = 2*epsilon - pow(x, 2) b = h2/12 y = ( 2*(1-5*b*k_minus_1) * y_minus_1 - (1+b*k_minus_2) * y_minus_2 ) / (1 + b * k) # Save for plotting x_out.append(x) y_out.append(y) # Shift for next iteration y_minus_2 = y_minus_1 y_minus_1 = y k_minus_2 = k_minus_1 k_minus_1 = k # Plot lab.figure(1) lab.plot(x_out, y_out, label="$\epsilon = "+repr(epsilon)+"$") lab.xlabel("x") lab.ylabel("y") lab.title("Schroedinger Eqn in Harmonic Potential") lab.legend(loc=1) lab.show() lab.grid() ``` ```python from scipy import * from scipy import integrate from scipy import optimize def Schroed_deriv(y,r,l,En): "Given y=[u,u'] returns dy/dr=[u',u''] " (u,up) = y return array([up, (l*(l+1)/r**2-2/r-En)*u]) R = linspace(1e-10,20,500) l=0 E0=-1.0 ur = integrate.odeint(Schroed_deriv, [0.0, 1.0], R, args=(l,E0)) from pylab import * %matplotlib inline plot(R,ur) grid() show() ``` ```python R = linspace(1e-10,20,500) l=0 E0=-1.0 Rb=R[::-1] # invert the mesh urb = integrate.odeint(Schroed_deriv, [0.0, -1e-5], Rb, args=(l,E0)) ur = urb[:,0][::-1] # we take u(r) and invert it in R. norm=integrate.simps(ur**2,x=R) ur *= 1./sqrt(norm) ``` ```python plot(R,ur) grid() show() plot(R,ur) xlim(0,0.01) ylim(0,0.01) show() ``` ```python # Subroutine def SolveSchroedinger(En,l,R): Rb=R[::-1] du0=-1e-5 urb=integrate.odeint(Schroed_deriv, [0.0,du0], Rb, args=(l,En)) ur=urb[:,0][::-1] norm=integrate.simps(ur**2,x=R) ur *= 1./sqrt(norm) return ur l=1 En=-1./(2**2) # 2p orbital l=1 En = -0.25 Ri = linspace(1e-6,20,500) # linear mesh already fails for this case ui = SolveSchroedinger(En,l,Ri) R = logspace(-5,2.,500) ur = SolveSchroedinger(En,l,R) #ylim([-0.1,0.1]) plot(R,ur,'g-') #plot(Ri,ui,'s-') xlim([0,20]) ``` ```python def Shoot(En,R,l): Rb=R[::-1] du0=-1e-5 ub=integrate.odeint(Schroed_deriv, [0.0,du0], Rb, args=(l,En)) ur=ub[:,0][::-1] norm=integrate.simps(ur**2,x=R) ur *= 1./sqrt(norm) ur = ur/R**l f0 = ur[0] f1 = ur[1] f_at_0 = f0 + (f1-f0)*(0.0-R[0])/(R[1]-R[0]) return f_at_0 ``` ```python R = logspace(-5,2.2,500) Shoot(-1./2**2,R,1) ``` ```python def FindBoundStates(R,l,nmax,Esearch): n=0 Ebnd=[] u0 = Shoot(Esearch[0],R,l) for i in range(1,len(Esearch)): u1 = Shoot(Esearch[i],R,l) if u0*u1<0: Ebound = optimize.brentq(Shoot,Esearch[i-1],Esearch[i],xtol=1e-16,args=(R,l)) Ebnd.append((l,Ebound)) if len(Ebnd)>nmax: break n+=1 print('Found bound state at E=%14.9f E_exact=%14.9f l=%d' % (Ebound, -1.0/(n+l)**2,l)) u0=u1 return Ebnd Esearch = -1.2/arange(1,20,0.2)**2 R = logspace(-6,2.2,500) nmax=7 Bnd=[] for l in range(nmax-1): Bnd += FindBoundStates(R,l,nmax-l,Esearch) ``` ```python def cmpE(x,y): if abs(x[1]-y[1])>1e-4: return cmp(x[1],y[1]) else: return cmp(x[0],y[0]) ``` ```python Bnd ``` ```python Z=28 # like Ni N=0 rho=zeros(len(R)) for (l,En) in Bnd: ur = SolveSchroedinger(En,l,R) dN = 2*(2*l+1) if N+dN<=Z: ferm=1. else: ferm=(Z-N)/float(dN) drho = ur**2 * ferm * dN/(4*pi*R**2) rho += drho N += dN print('adding state (%2d,%14.9f) with fermi=%4.2f and current N=%5.1f' % (l,En,ferm,N)) if N>=Z: break ``` ```python from pylab import * %matplotlib inline plot(R,rho*(4*pi*R**2),label='charge density') xlim([0,25]) show() ``` # Numerov algorithm The general purpose integration routine is not the best method for solving the Schroedinger equation, which does not have first derivative terms. Numerov algorithm is better fit for such equations, and its algorithm is summarized below. The second order linear differential equation (DE) of the form $ x′′(t)=f(t)x(t)+u(t) $ is a target of Numerov algorithm. Due to a special structure of the DE, the fourth order error cancels and leads to sixth order algorithm using second order integration scheme. If we expand x(t) to some higher power and take into account the time reversal symmetry of the equation, all odd term cancel $x(h)=x(0)+hx′(0)+12h^2x′′(0)+\frac{1}{3!}h^3x^{(3)}(0)+\frac{1}{4!}h^4x^{(4)}(0)+\frac{1}{5!}h^5x^{(5)}(0)+...x(−h)=x(0)−hx′(0)+\frac{1}{2}h^2x′′(0)−\frac{1}{3!}h^3x^{(3)}(0)+\frac{1}{4!}h^4x^{(4)}(0)−\frac{1}{5!}h^5x^{(5)}(0)+... $ hence $ x(h)+x(−h)=2x(0)+h^2(f(0)x(0)+u(0))+\frac{2}{4!}h^4x^{(4)}(0)+O(h6)$ If we are happy with O(h4) algorithm, we can neglect x(4) term and get the following recursion relation $x_i+1−2x_i+x_i−1=h^2(f_ix_i+u_i)$. But we know from the differential equation that $x(4)=\frac{d^2x′′(t)}{dt^2}=\frac{d^2}{dt^2}(f(t)x(t)+u(t))$ which can be approximated by $x(4)∼f_i+1x_i+1+ui+1−2fixi−2ui+fi−1xi−1+ui−1h2 $ Inserting the fourth order derivative into the above recursive equation (forth equation in his chapter), we get $x_i+1−2x_i+x_i−1=h^2(f_ix_i+u_i)+h^2/12(f_i+1x_i+1+u_i+1−2f_ix_i−2u_i+f_i−1x_i−1+u_i−1)$ If we switch to a new variable wi=xi(1−h212fi)−h212ui we are left with the following equation $wi+1−2wi+wi−1=h^2(f_ix_i+u_i)+O(h6)$ The variable x needs to be recomputed at each step with $x_i=(w_i+h^2/12u_i)$$(1−\frac{h^2}{12}f_i)$ ```python # NUMEROV Solution Schrodinger Equation: Hydrogen Atom from pylab import * %matplotlib inline #import weave def Numerovc(f, x0_, dx, dh_): code_Numerov=""" double h2 = dh*dh; double h12 = h2/12.; double w0 = x(0)*(1-h12*f(0)); double w1 = x(1)*(1-h12*f(1)); double xi = x(1); double fi = f(1); for (int i=2; i<f.size(); i++){ double w2 = 2*w1-w0+h2*fi*xi; // here fi=f1 fi = f(i); // fi=f2 xi = w2/(1-h12*fi); x(i)=xi; w0 = w1; w1 = w2; } """ x = zeros(len(f)) dh=float(dh_) x[0]=x0_ x[1]=x0_+dh*dx #weave.inline(code_Numerov, ['f','dh','x'], type_converters=weave.converters.blitz, compiler = 'gcc') return x def fSchrod(En, l, R): return l*(l+1.)/R**2-2./R-En def ComputeSchrod(En,R,l): "Computes Schrod Eq." f = fSchrod(En,l,R[::-1]) ur = Numerovc(f,0.0,-1e-7,-R[1]+R[0])[::-1] norm = integrate.simps(ur**2,x=R) return ur*1/sqrt(abs(norm)) def Shoot(En,R,l): ur = ComputeSchrod(En,R,l) ur = ur/R**l f0 = ur[0] f1 = ur[1] f_at_0 = f0 + (f1-f0)*(0.0-R[0])/(R[1]-R[0]) return f_at_0 def FindBoundStates(R,l,nmax,Esearch): n=0 Ebnd=[] u0 = Shoot(Esearch[0],R,l) for i in range(1,len(Esearch)): u1 = Shoot(Esearch[i],R,l) if u0*u1<0: Ebound = optimize.brentq(Shoot,Esearch[i-1],Esearch[i],xtol=1e-16,args=(R,l)) Ebnd.append((l,Ebound)) if len(Ebnd)>nmax: break n+=1 print('Found bound state at E=%14.9f E_exact=%14.9f l=%d' % (Ebound, -1.0/(n+l)**2,l)) u0=u1 return Ebnd def cmpE(x,y): if abs(x[1]-y[1])>1e-4: return cmp(x[1],y[1]) else: return cmp(x[0],y[0]) Esearch = -1.2/arange(1,20,0.2)**2 R = linspace(1e-8,100,2000) nmax=5 Bnd=[] for l in range(nmax-1): Bnd += FindBoundStates(R,l,nmax-l,Esearch) #Bnd.sort(cmpE) Z=28 # Like Ni ion N=0 rho=zeros(len(R)) for (l,En) in Bnd: #ur = SolveSchroedinger(En,l,R) ur = ComputeSchrod(En,R,l) dN = 2*(2*l+1) if N+dN<=Z: ferm=1. else: ferm=(Z-N)/float(dN) drho = ur**2 * ferm * dN/(4*pi*R**2) rho += drho N += dN print('adding state', (l,En), 'with fermi=', ferm) plot(R, drho*(4*pi*R**2)) if N>=Z: break xlim([0,25]) show() plot(R,rho*(4*pi*R**2),label='charge density') xlim([0,25]) show() ``` # HYDROGEN ATOM: SCHRODINGER EQUATION # $ \hat {H} (r , \theta , \varphi ) \psi (r , \theta , \varphi ) = E \psi ( r , \theta , \varphi) $ # $ \hat {V} (r) = - \dfrac {e^2}{4 \pi \epsilon _0 r } $ # $$\left \{ -\dfrac {\hbar ^2}{2 \mu r^2} \left [ \dfrac {\partial}{\partial r} \left (r^2 \dfrac {\partial}{\partial r} \right ) + \dfrac {1}{\sin \theta } \dfrac {\partial}{\partial \theta } \left ( \sin \theta \dfrac {\partial}{\partial \theta} \right ) + \dfrac {1}{\sin ^2 \theta} \dfrac {\partial ^2}{\partial \varphi ^2} \right ] - \dfrac {e^2}{4 \pi \epsilon _0 r } \right \} \psi (r , \theta , \varphi ) = E \psi (r , \theta , \varphi ) $$ # $\color{red} \psi (r , \theta , \varphi ) =\color{green} R (r) Y (\theta , \varphi ) $ #$ \bbox[pink]{\frac{1}{R}\frac{\rm d}{{\rm d}r}\left(r^2\frac{{\rm d}R}{{\rm d}r}\right)}+\bbox[lightblue]{\frac{1}{Y\sin\theta}\frac{\partial}{\partial\theta}\left(\sin\theta\frac{\partial Y}{\partial\theta}\right)+\frac{1}{Y\sin^2\theta}\frac{\partial^2Y}{\partial\phi^2}}+\bbox[pink]{\frac{2\mu r^2}{\hbar^2}\left(E+\frac{Ze^2}{4\pi\epsilon_0r}\right)}=0\qquad. $ # Energy eigenvalues of Hydrogen atom: # NORMALIZATION CONDITION: ```python # CODE TO PLOT THE ABOVE FUNCTION import numpy as np from scipy import constants as const from scipy import sparse as sparse from scipy.sparse.linalg import eigs from matplotlib import pyplot as plt hbar = const.hbar e = const.e m_e = const.m_e pi = const.pi epsilon_0 = const.epsilon_0 joul_to_eV = e def calculate_potential_term(r): potential = e**2 / (4.0 * pi * epsilon_0) / r potential_term = sparse.diags((potential)) return potential_term def calculate_angular_term(r): angular = l * (l + 1) / r**2 angular_term = sparse.diags((angular)) return angular_term def calculate_laplace_three_point(r): h = r[1] - r[0] main_diag = -2.0 / h**2 * np.ones(N) off_diag = 1.0 / h**2 * np.ones(N - 1) laplace_term = sparse.diags([main_diag, off_diag, off_diag], (0, -1, 1)) return laplace_term def build_hamiltonian(r): laplace_term = calculate_laplace_three_point(r) angular_term = calculate_angular_term(r) potential_term = calculate_potential_term(r) hamiltonian = -hbar**2 / (2.0 * m_e) * (laplace_term - angular_term) - potential_term return hamiltonian N = 2000 l = 0 r = np.linspace(2e-9, 0.0, N, endpoint=False) hamiltonian = build_hamiltonian(r) """ solve eigenproblem """ number_of_eigenvalues = 30 eigenvalues, eigenvectors = eigs(hamiltonian, k=number_of_eigenvalues, which='SM') """ sort eigenvalue and eigenvectors """ eigenvectors = np.array([x for _, x in sorted(zip(eigenvalues, eigenvectors.T), key=lambda pair: pair[0])]) eigenvalues = np.sort(eigenvalues) """ compute probability density for each eigenvector """ densities = [np.absolute(eigenvectors[i, :])**2 for i in range(len(eigenvalues))] def plot(r, densities, eigenvalues): plt.xlabel('x ($\\mathrm{\AA}$)') plt.ylabel('probability density ($\\mathrm{\AA}^{-1}$)') energies = ['E = {: >5.2f} eV'.format(eigenvalues[i].real / e) for i in range(3)] plt.plot(r * 1e+10, densities[0], color='blue', label=energies[0]) plt.plot(r * 1e+10, densities[1], color='green', label=energies[1]) plt.plot(r * 1e+10, densities[2], color='red', label=energies[2]) plt.legend() plt.show() return """ plot results """ plot(r, densities, eigenvalues) ``` ## Spherical Harmonics $l=0:~~~~~~Y_{0}^{0}(\theta,\varphi)={1\over 2}\sqrt{1\over \pi}$ $l=1~~~\begin{align} Y_{1}^{-1}(\theta,\varphi) & = {1\over 2}\sqrt{3\over 2\pi}\cdot e^{-i\varphi}\cdot\sin\theta\quad = {1\over 2}\sqrt{3\over 2\pi}\cdot{(x-iy)\over r} \\ Y_{1}^{0}(\theta,\varphi) & = {1\over 2}\sqrt{3\over \pi}\cdot\cos\theta\quad \quad = {1\over 2}\sqrt{3\over \pi}\cdot{z\over r} \\ Y_{1}^{1}(\theta,\varphi) & = {-1\over 2}\sqrt{3\over 2\pi}\cdot e^{i\varphi}\cdot\sin\theta\quad = {-1\over 2}\sqrt{3\over 2\pi}\cdot{(x+iy)\over r} \end{align}$ # l = 0 \begin{align}Y_{00} & = s = Y_0^0 = \frac{1}{2} \sqrt{\frac{1}{\pi}}\end{align} $ $l = 1 \begin{align} Y_{1,-1} & = p_y = i \sqrt{\frac{1}{2}} \left( Y_1^{- 1} + Y_1^1 \right) = \sqrt{\frac{3}{4 \pi}} \cdot \frac{y}{r} \\ Y_{10} & = p_z = Y_1^0 = \sqrt{\frac{3}{4 \pi}} \cdot \frac{z}{r} \\ Y_{11} & = p_x = \sqrt{\frac{1}{2}} \left( Y_1^{- 1} - Y_1^1 \right) = \sqrt{\frac{3}{4 \pi}} \cdot \frac{x}{r} \end{align} $ $ l = 2 \begin{align}Y_{2,-2} & = d_{xy} = i \sqrt{\frac{1}{2}} \left( Y_2^{- 2} - Y_2^2\right) = \frac{1}{2} \sqrt{\frac{15}{\pi}} \cdot \frac{x y}{r^2} \\Y_{2,-1} & = d_{yz} = i \sqrt{\frac{1}{2}} \left( Y_2^{- 1} + Y_2^1 \right) = \frac{1}{2} \sqrt{\frac{15}{\pi}} \cdot \frac{y z}{r^2} \\Y_{20} & = d_{z^2} = Y_2^0 = \frac{1}{4} \sqrt{\frac{5}{\pi}} \cdot \frac{- x^2 - y^2 + 2 z^2}{r^2} \\Y_{21} & = d_{xz} = \sqrt{\frac{1}{2}} \left( Y_2^{- 1} - Y_2^1 \right) = \frac{1}{2} \sqrt{\frac{15}{\pi}} \cdot \frac{z x}{r^2} \\Y_{22} & = d_{x^2-y^2} = \sqrt{\frac{1}{2}} \left( Y_2^{- 2} + Y_2^2 \right) = \frac{1}{4} \sqrt{\frac{15}{\pi}} \cdot \frac{x^2 - y^2 }{r^2}\end{align} $ $ l = 3 \begin{align}Y_{3,-3} & = f_{y(3x^2-y^2)} = i \sqrt{\frac{1}{2}} \left( Y_3^{- 3} + Y_3^3 \right) = \frac{1}{4} \sqrt{\frac{35}{2 \pi}} \cdot \frac{\left( 3 x^2 - y^2 \right) y}{r^3} \\Y_{3,-2} & = f_{xyz} = i \sqrt{\frac{1}{2}} \left( Y_3^{- 2} - Y_3^2 \right) = \frac{1}{2} \sqrt{\frac{105}{\pi}} \cdot \frac{xy z}{r^3} \\Y_{3,-1} & = f_{yz^2} = i \sqrt{\frac{1}{2}} \left( Y_3^{- 1} + Y_3^1 \right) = \frac{1}{4} \sqrt{\frac{21}{2 \pi}} \cdot \frac{y (4 z^2 - x^2 - y^2)}{r^3} \\Y_{30} & = f_{z^3} = Y_3^0 = \frac{1}{4} \sqrt{\frac{7}{\pi}} \cdot \frac{z (2 z^2 - 3 x^2 - 3 y^2)}{r^3} \\Y_{31} & = f_{xz^2} = \sqrt{\frac{1}{2}} \left( Y_3^{- 1} - Y_3^1 \right) = \frac{1}{4} \sqrt{\frac{21}{2 \pi}} \cdot \frac{x (4 z^2 - x^2 - y^2)}{r^3} \\Y_{32} & = f_{z(x^2-y^2)} = \sqrt{\frac{1}{2}} \left( Y_3^{- 2} + Y_3^2 \right) = \frac{1}{4} \sqrt{\frac{105}{\pi}} \cdot \frac{\left( x^2 - y^2 \right) z}{r^3} \\Y_{33} & = f_{x(x^2-3y^2)} = \sqrt{\frac{1}{2}} \left( Y_3^{- 3} - Y_3^3 \right) = \frac{1}{4} \sqrt{\frac{35}{2 \pi}} \cdot \frac{\left( x^2 - 3 y^2 \right) x}{r^3}\end{align}$ $ l = 4 \begin{align}Y_{4,-4} & = g_{xy(x^2-y^2)} = i \sqrt{\frac{1}{2}} \left( Y_4^{- 4} - Y_4^4 \right) = \frac{3}{4} \sqrt{\frac{35}{\pi}} \cdot \frac{xy \left( x^2 - y^2 \right)}{r^4} \\Y_{4,-3} & = g_{zy^3} = i \sqrt{\frac{1}{2}} \left( Y_4^{- 3} + Y_4^3 \right) = \frac{3}{4} \sqrt{\frac{35}{2 \pi}} \cdot \frac{(3 x^2 - y^2) yz}{r^4} \\Y_{4,-2} & = g_{z^2xy} = i \sqrt{\frac{1}{2}} \left( Y_4^{- 2} - Y_4^2 \right) = \frac{3}{4} \sqrt{\frac{5}{\pi}} \cdot \frac{xy \cdot (7 z^2 - r^2)}{r^4} \\Y_{4,-1} & = g_{z^3y} = i \sqrt{\frac{1}{2}} \left( Y_4^{- 1} + Y_4^1\right) = \frac{3}{4} \sqrt{\frac{5}{2 \pi}} \cdot \frac{yz \cdot (7 z^2 - 3 r^2)}{r^4} \\Y_{40} & = g_{z^4} = Y_4^0 = \frac{3}{16} \sqrt{\frac{1}{\pi}} \cdot \frac{(35 z^4 - 30 z^2 r^2 + 3 r^4)}{r^4} \\Y_{41} & = g_{z^3x} = \sqrt{\frac{1}{2}} \left( Y_4^{- 1} - Y_4^1 \right) = \frac{3}{4} \sqrt{\frac{5}{2 \pi}} \cdot \frac{xz \cdot (7 z^2 - 3 r^2)}{r^4} \\Y_{42} & = g_{z^2xy} = \sqrt{\frac{1}{2}} \left( Y_4^{- 2} + Y_4^2 \right) = \frac{3}{8} \sqrt{\frac{5}{\pi}} \cdot \frac{(x^2 - y^2) \cdot (7 z^2 - r^2)}{r^4} \\Y_{43} & = g_{zx^3} = \sqrt{\frac{1}{2}} \left( Y_4^{- 3} - Y_4^3 \right) = \frac{3}{4} \sqrt{\frac{35}{2 \pi}} \cdot \frac{(x^2 - 3 y^2) xz}{r^4} \\Y_{44} & = g_{x^4+y^4} = \sqrt{\frac{1}{2}} \left( Y_4^{- 4} + Y_4^4 \right) = \frac{3}{16} \sqrt{\frac{35}{\pi}} \cdot \frac{x^2 \left( x^2 - 3 y^2 \right) - y^2 \left( 3 x^2 - y^2 \right)}{r^4}\end{align} $ ```python ! pip install ipyvolume ``` ```python %matplotlib inline import matplotlib.pyplot as plt from matplotlib import cm, colors from mpl_toolkits.mplot3d import Axes3D import numpy as np import scipy.integrate as integrate # Increase resolution for retina display from IPython.display import set_matplotlib_formats set_matplotlib_formats('retina') # Load interactive widgets import ipywidgets as widgets import ipyvolume as ipv ``` ```python # Import special functions import scipy.special as spe def psi_R(r,n=1,l=0): coeff = np.sqrt((2.0/n)**3 * spe.factorial(n-l-1) /(2.0*n*spe.factorial(n+l))) laguerre = spe.assoc_laguerre(2.0*r/n,n-l-1,2*l+1) return coeff * np.exp(-r/n) * (2.0*r/n)**l * laguerre r = np.linspace(0,100,1000) R = psi_R(r,n=5,l=1) plt.plot(r, R**2, lw=3) plt.xlabel('$r [a_0]$',fontsize=20) plt.ylabel('$R_{nl}(r)$', fontsize=20) plt.grid('True') ``` ```python nmax=10 @widgets.interact(n = np.arange(1,nmax,1), l = np.arange(0,nmax-1,1)) def plot_radial(n=1,l=0): r = np.linspace(0,250,10000) psi2 = psi_R(r,n,l)**2 * (r**2) plt.plot(r, psi2, lw=2, color='red') ''' Styling the plot''' plt.xlabel('$r [a_0]$') plt.ylabel('$R_{nl}(r)$') rmax = n**2*(1+0.5*(1-l*(l+1)/n**2)) plt.xlim([0, 2*rmax]) ``` ```python def psi_ang(phi,theta,l=0,m=0): sphHarm = spe.sph_harm(m,l,phi,theta) return sphHarm.real phi, theta = np.linspace(0, np.pi, 100), np.linspace(0, 2*np.pi, 100) phi, theta = np.meshgrid(phi, theta) Ylm = psi_ang(theta,phi,l=2,m=0) x = np.sin(phi) * np.cos(theta) * abs(Ylm) y = np.sin(phi) * np.sin(theta) * abs(Ylm) z = np.cos(phi) * abs(Ylm) '''Set up the 3D Canvas''' fig = plt.figure(figsize=(10,10)) ax = fig.add_subplot(111, projection='3d') ''' Normalize color bar to [0,1] scale''' fcolors = (Ylm - Ylm.min())/(Ylm.max() - Ylm.min()) '''Make 3D plot of real part of spherical harmonic''' ax.plot_surface(x, y, z, facecolors=cm.seismic(fcolors), alpha=0.3) ''' Project 3D plot onto 2D planes''' cset = ax.contour(x, y, z,20, zdir='z',offset = -1, cmap='summer') cset = ax.contour(x, y, z,20, zdir='y',offset = 1, cmap='winter' ) cset = ax.contour(x, y, z,20, zdir='x',offset = -1, cmap='autumn') ''' Set axes limit to keep aspect ratio 1:1:1 ''' ax.set_xlim(-1, 1) ax.set_ylim(-1, 1) ax.set_zlim(-1, 1) ``` ```python def HFunc(r,theta,phi,n,l,m): ''' Hydrogen wavefunction // a_0 = 1 INPUT r: Radial coordinate theta: Polar coordinate phi: Azimuthal coordinate n: Principle quantum number l: Angular momentum quantum number m: Magnetic quantum number OUTPUT Value of wavefunction ''' return psi_R(r,n,l) * psi_ang(phi,theta,l,m) nmax = 10 lmax = nmax-1 @widgets.interact(n=np.arange(1,nmax,1), l = np.arange(0,nmax-1,1), m=np.arange(-lmax,lmax+1,1)) def psi_xz_plot(n=1,l=0,m=0): plt.figure(figsize=(10,8)) limit = 4*(n+l) x_1d = np.linspace(-limit,limit,500) z_1d = np.linspace(-limit,limit,500) x,z = np.meshgrid(x_1d,z_1d) y = 0 r = np.sqrt(x**2 + y**2 + z**2) theta = np.arctan2(np.sqrt(x**2+y**2), z ) phi = np.arctan2(y, x) psi_nlm = HFunc(r,theta,phi,n,l,m) #plt.pcolormesh(x, z, psi_nlm, cmap='inferno') # Try cmap = inferno, rainbow, autumn, summer, plt.contourf(x, z, psi_nlm, 20, cmap='seismic', alpha=0.6) # Classic orbitals plt.colorbar() plt.title(f"$n,l,m={n,l,m}$",fontsize=20) plt.xlabel('X',fontsize=20) plt.ylabel('Z',fontsize=20) ``` ```python import ipyvolume as ipv #Variables to adjust maxi = 60 resolution = 160 base = np.linspace(-maxi, maxi, resolution)[:,np.newaxis,np.newaxis] x2 = np.tile(base, (1,resolution,resolution)) y2 = np.swapaxes(x2,0,1) z2 = np.swapaxes(x2,0,2) total = np.concatenate((x2[np.newaxis,:],y2[np.newaxis,:],z2[np.newaxis,:]), axis=0) r2 = np.linalg.norm(total, axis=0) #Alternative theta calculation #theta3 = np.abs(np.arctan2(np.linalg.norm(total[:2], axis=0),-total[2])) np.seterr(all='ignore') phi2 = np.arctan(np.divide(total[2],np.linalg.norm(total[:2], axis=0))) + np.pi/2 theta2 = np.arctan2(total[1],total[0]) ipv.figure() psi = HFunc(r2,theta2,phi2,2,1,1) ipv.volshow(r2**2 * np.sin(phi2)*psi**2) ipv.show() ``` ## CRANK-NICOLSON METHOD: SCHRODINGER TIME DEPENDENT EQUATION Since at this point we know everything about the Crank-Nicolson scheme, it is time to get our hands dirty. In this post, the third on the series on how to numerically solve 1D parabolic partial differential equations, I want to show a Python implementation of a Crank-Nicolson scheme for solving a heat diffusion problem. While Phython is certainly not the best choice for scientific computing, in terms of performance and optimization, it is a good language for rapid prototyping and scripting (and in many cases even for complex production-level code). For a problem of this type, Python is more than sufficient at doing the job. For more complicated problems involving multiple dimensions, more coupled equations and many extra terms, other languages are typically preferred (Fortran, C, C++,…), often with the inclusion of parallel programming using the Message Passing Interface (MPI) paradigm. The problem that I am going to present is the one proposed in the excellent book “Numerical Solution of Partial Differential Equations” by G.D. Smith (Oxford University Press), \begin{eqnarray} \frac{\partial u}{\partial t} \ \ & = & \ \frac{\partial^2 u}{\partial x^2}, \ \ & 0\leq x \leq 1 \nonumber \\ u(t,0) & = & u(t,1)=0 & \ \ \ \ \ \ \forall t\nonumber\\ u(0,x) & = & 2x & \mathrm{if} \ \ x\leq 0.5 \nonumber\\ u(0,x) & = & 2(1-x) & \mathrm{if} \ \ x> 0.5 \nonumber \end{eqnarray} \begin{equation} A\textbf{u}_{j+1} = B\textbf{u}_{j} + \textbf{b}_{j}, \end{equation} ```python import scipy as sp import numpy as np from scipy import integrate, sparse, linalg import scipy.sparse.linalg import pylab as pl nx = 8000 dx = 0.0025 dt = 0.00002 niter = 20 nonlin = 0.0 gridx = np.zeros(nx) igridx = np.array(range(nx)) psi = np.zeros(nx) pot = np.zeros(nx) depth = 0.01 # Set up grid, potential, and initial state gridx = dx*(igridx - nx/2) pot = depth*gridx*gridx psi = np.pi**(-1/4)*np.exp(-0.5*gridx*gridx) # Normalize Psi #psi /= sp.integrate.simps(psi*psi, dx=dx) # Plot parameters xlimit = [gridx[0], gridx[-1]] ylimit = [0, 2*psi[int(nx/2)]] # Set up diagonal coefficients Adiag = np.empty(nx) Asup = np.empty(nx) Asub = np.empty(nx) bdiag = np.empty(nx) bsup = np.empty(nx) bsub = np.empty(nx) Adiag.fill(1 - dt/dx**2) Asup.fill(dt/(2*dx**2)) Asub.fill(dt/(2*dx**2)) bdiag.fill(1 + dt/dx**2) bsup.fill(-dt/(2*dx**2)) bsub.fill(-dt/(2*dx**2)) # Construct tridiagonal matrix A = sp.sparse.spdiags([Adiag, Asup, Asub], [0, 1, -1], nx, nx) b = sp.sparse.spdiags([bdiag, bsup, bsub], [0, 1, -1], nx, nx) # Loop through time for t in range(0, niter) : # Calculate effect of potential and nonlinearity psi *= np.exp(-dt*(pot + nonlin*psi*psi)) # Calculate spacial derivatives psi = sp.sparse.linalg.bicg(A, b*psi)[0] # Normalize Psi psi /= sp.integrate.simps(psi*psi, dx=dx) # Output figures pl.plot(gridx, psi) pl.plot(gridx, psi*psi) pl.plot(gridx, pot) pl.xlim(xlimit) pl.ylim(ylimit) #pl.savefig('outputla/fig' + str(t)) #pl.clf() plt.grid() plt.show() ``` ```python import numpy as np N=100 # the number of grid points a=0 b=np.pi x,h = np.linspace(a,b,N,retstep = True) y=np.sin(x)*np.sinh(x) plt.plot(x,y) plt.grid() ``` ```python L=4 tau=.2 y = 0.01 * np.exp(-(x-L/2)**2 / 0.02) ynew = np.zeros_like(y) j = 0 t = 0 tmax = 2 plt.figure(1) # Open the figure window # the loop that steps the solution along while t < tmax: j = j+1 t = t + tau # Use leapfrog and the boundary conditions to load # ynew with y at the next time step using y and yold # update yold and y for next timestep # remember to use np.copy # make plots every 50 time steps if j % 50 == 0: #plt.clf() # clear the figure window plt.plot(x,y,'b-') plt.xlabel('x') plt.ylabel('y') plt.title('time={:1.3f}'.format(t)) plt.ylim([-0.03,0.03]) plt.xlim([0,1]) plt.draw() # Draw the plot plt.pause(1) # Give the computer time to draw plt.show() ``` ```python # Tools for sparse matrices import scipy.sparse as sparse import scipy.sparse.linalg # Numerical tools from numpy import * # Plotting library from matplotlib.pyplot import * """Physical constants""" _E0p = 938.27 # Rest energy for a proton [MeV] _hbarc = 0.1973 # [MeV pm] _c = 3.0e2 # Spees of light [pm / as] def Psi0( x ): ''' Initial state for a travelling gaussian wave packet. ''' x0 = -0.100 # [pm] a = 0.0050 # [pm] l = 200000.0 # [1 / pm] A = ( 1. / ( 2 * pi * a**2 ) )**0.25 K1 = exp( - ( x - x0 )**2 / ( 4. * a**2 ) ) K2 = exp( 1j * l * x ) return A * K1 * K2 def deltaPotential( x, height=75 ): """ A potential spike or delta potential in the center. @param height Defines the height of the barrier / spike. This should be chosen to be high "enough". """ # Declare new empty array with same length as x potential = zeros( len( x ) ) # Middle point has high potential potential[ 0.5*len(potential) ] = height return potential if __name__ == '__main__': nx = 1001 # Number of points in x direction dx = 0.001 # Distance between x points [pm] # Use zero as center, same amount of points each side a = - 0.5 * nx * dx b = 0.5 * nx * dx x = linspace( a, b, nx ) # Time parameters T = 0.005 # How long to run simulation [as] dt = 1e-5 # The time step [as] t = 0 time_steps = int( T / dt ) # Number of time steps # Constants - save time by calculating outside of loop k1 = - ( 1j * _hbarc * _c) / (2. * _E0p ) k2 = ( 1j * _c ) / _hbarc # Create the initial state Psi Psi = Psi0(x) # Create the matrix containing central differences. It it used to # approximate the second derivative. data = ones((3, nx)) data[1] = -2*data[1] diags = [-1,0,1] D2 = k1 / dx**2 * sparse.spdiags(data,diags,nx,nx) # Identity Matrix I = sparse.identity(nx) # Create the diagonal matrix containing the potential. V_data = deltaPotential(x) V_diags = [0] V = k2 * sparse.spdiags(V_data, V_diags, nx, nx) # Put mmatplotlib in interactive mode for animation ion() # Setup the figure before starting animation fig = figure() # Create window ax = fig.add_subplot(111) # Add axes line, = ax.plot( x, abs(Psi)**2, label='$|\Psi(x,t)|^2$' ) # Fetch the line object # Also draw a green line illustrating the potential ax.plot( x, V_data, label='$V(x)$' ) # Add other properties to the plot to make it elegant fig.suptitle("Solution of Schrodinger's equation with delta potential") # Title of plot ax.grid('on') # Square grid lines in plot ax.set_xlabel('$x$ [pm]') # X label of axes ax.set_ylabel('$|\Psi(x, t)|^2$ [1/pm] and $V(x)$ [MeV]') # Y label of axes ax.legend(loc='best') # Adds labels of the lines to the window draw() # Draws first window # Time loop while t < T: """ For each iteration: Solve the system of linear equations: (I - k/2*D2) u_new = (I + k/2*D2)*u_old """ # Set the elements of the equation A = I - dt*.5*(D2 + V) b = (I + dt*.5 * (D2 + V)) * Psi # Calculate the new Psi Psi = sparse.linalg.spsolve(A,b) # Update time t += dt # Plot this new state line.set_ydata( abs(Psi)**2 ) # Update the y values of the Psi line draw() # Update the plot # Turn off interactive mode ioff() # Add show so that windows do not automatically close show() ``` ```python # Create a single Gaussian wave packet and follow its evolution as it # crosses the computational domain and reflects off the boundaries. import sys import getopt import numpy as np import matplotlib.pyplot as plt # Physics: HBAR = 1.0 M = 1.0 DELX = 2.5 XBAR = -30.0 PBAR = 5.0 # wave packet energy is PBAR**2 / 2M # Range and time span: XMIN = -40.0 XMAX = 40.0 TMAX = 10.0 # Numerics: J = 1001 DX = (XMAX-XMIN)/(J-1.0) DT = 0.001 ALPHA = HBAR*DT/(2*M*DX**2) DTPLOT = 0.1 which = 0 I = 1j # physicist's square root of -1! def wavepacket(x, xb, pb): return np.exp(-(x-xb)**2/(4*DELX**2) + I*pb*x/HBAR) \ / (2*np.pi*DELX**2)**0.25 def initialize(x): return wavepacket(x, XBAR, PBAR) def tridiag(a, b, c, r): n = len(r) u = np.zeros(n, dtype=complex) gam = np.zeros(n, dtype=complex) bet = b[0] u[0] = r[0]/bet for j in range(1,n): gam[j] = c[j-1]/bet bet = b[j] - a[j]*gam[j] u[j] = (r[j]-a[j]*u[j-1])/bet for j in range(n-2,-1,-1): u[j] -= gam[j+1]*u[j+1] return u def cn_step(a, b, c, r, u): r[1:-1] = 0.5*I*ALPHA*(u[:-2]+u[2:]) + (1-I*ALPHA)*u[1:-1] return tridiag(a, b, c, r) # tridiag is fast enough in 1D... def display_data(x, u, t): if t > 0.0: plt.cla() title = 'time = '+'%.2f'%(t) plt.title(title) plt.xlabel('x') if which == 0: plt.ylim(0.0, 0.25) plt.ylabel('$|\psi|^2$') plt.plot(x, np.abs(u)**2) else: plt.ylim(-0.5, 0.5) plt.ylabel('$|\psi|$') plt.plot(x, np.abs(u)) plt.plot(x, np.real(u)) plt.plot(x, np.imag(u)) plt.pause(0.001) def prob(u, dx): # 1-d trapezoid pp = np.abs(u)**2 return dx*(0.5*pp[0]+np.sum(pp[1:-1])+0.5*pp[-1]) def main(argv): global J, DX, ALPHA dt = DT if len(sys.argv) > 1: dt = float(sys.argv[1]) if len(sys.argv) > 2: J = int(sys.argv[2]) DX = (XMAX-XMIN)/(J-1.0) ALPHA = HBAR*dt/(2*M*DX**2) dtplot = DTPLOT if dtplot < dt: dtplot = dt tplot = dtplot x = np.linspace(XMIN, XMAX, J) u = initialize(x) t = 0.0 int0 = prob(u, DX) u /= int0**0.5 display_data(x, u, t) a = -0.5*I*ALPHA*np.ones(J) b = (1+I*ALPHA)*np.ones(J) c = a.copy() r = np.zeros(J, dtype=complex) # Boundary conditions: b[0] = 1.0 c[0] = 0.0 # BC b[0]*u[0] + c[0]*u[1]] = r[0] r[0] = 0.0 a[-1] = 0.0 b[-1] = 1.0 # BC b[-1]*u[-1] + a[-1]*u[-2] = r[-1] r[-1] = 0.0 # Note that the vectors a, b, and c are constant for fixed time step. int0 = prob(u, DX) print('initial integral =', int0) while t < TMAX-0.5*dt: u = cn_step(a, b, c, r, u) t += dt if t > tplot-0.5*dt: display_data(x, u, t) tplot += dtplot int1 = prob(u, DX) print('final integral =', int1) # 'error =', int1/int0-1.0) plt.show() if __name__ == "__main__" : main(sys.argv) ``` ```python import numpy as np import matplotlib.pyplot as plt tfinal=1000 # Total simulation time dt=0.001#time step M=np.round(tfinal/dt) time_steps=M.astype(int)# number of time steps b=10.0# final x a=-10.0# initial x N=512# num of pieces dx=(b-a)/N # x-space step size dk=2*np.pi/(b-a) n=np.linspace(-N/2,N/2 -1,N) x=n*dx k=n*dk t=0 alpha=0.0005 beta=0.0001 acoef=(alpha-beta*np.cos(t))/(2*alpha**0.5) bcoef=(alpha-beta*np.cos(t))**0.5 / (2*alpha**0.5) V=0.5*(acoef*x**4 -bcoef*x**2) u0=np.exp(-(x+4.72)**2 /2)*(1/np.pi)**0.25 u=u0 for i in range(1,time_steps): u=np.exp(-1j*dt*V/2)*u c=np.fft.fftshift(np.fft.fft(u)) c=np.exp(-1j*dt*k**2 /2)*c u=np.fft.ifft(np.fft.fftshift(c)) u=np.exp(-1j*dt*V/2)*u t=t+dt plt.plot(x,u*np.conjugate(u),'r--') plt.xlim(-10,10) plt.ylim(0,0.6) plt.show ``` ```python plt.figure(1) for n in range(len(wplot)): w = wplot[n] g = l3.steadySol(f,h,w,T,u) plt.clf() # Clear the previous plot plt.plot(x,g) plt.title('$\omega={:1.2e}$'.format(w)) plt.xlabel('x') plt.ylim([-0.05, 0.05]) # prevent auto-scaling plt.draw() # Request to draw the plot now plt.pause(0.1) # Give th ``` ```python import numpy as np import matplotlib.pyplot as plt import os, sys import matplotlib matplotlib.rc('font', size=18) matplotlib.rc('font', family='Arial') #definition of numerical parameters N = 51 #number of grid points dt = 5.e-4 #time step L = float(1) #size of grid nsteps = 620 #number of time steps dx = L/(N-1) #grid spacing nplot = 20 #number of timesteps before plotting r = dt/dx**2 #assuming heat diffusion coefficient == 1 #initialize matrices A, B and b array A = np.zeros((N-2,N-2)) B = np.zeros((N-2,N-2)) b = np.zeros((N-2)) #define matrices A, B and b array for i in range(N-2): if i==0: A[i,:] = [2+2*r if j==0 else (-r) if j==1 else 0 for j in range(N-2)] B[i,:] = [2-2*r if j==0 else r if j==1 else 0 for j in range(N-2)] b[i] = 0. #boundary condition at i=1 elif i==N-3: A[i,:] = [-r if j==N-4 else 2+2*r if j==N-3 else 0 for j in range(N-2)] B[i,:] = [r if j==N-4 else 2-2*r if j==N-3 else 0 for j in range(N-2)] b[i] = 0. #boundary condition at i=N else: A[i,:] = [-r if j==i-1 or j==i+1 else 2+2*r if j==i else 0 for j in range(N-2)] B[i,:] = [r if j==i-1 or j==i+1 else 2-2*r if j==i else 0 for j in range(N-2)] #initialize grid x = np.linspace(0,1,N) #initial condition u = np.asarray([2*xx if xx<=0.5 else 2*(1-xx) for xx in x]) #evaluate right hand side at t=0 bb = B.dot(u[1:-1]) + b fig = plt.figure() plt.plot(x,u,linewidth=2) filename = 'foo000.jpg'; #fig.set_tight_layout(True,"h_pad=1.0"); plt.tight_layout(pad=3.0) plt.xlabel("x") plt.ylabel("u") plt.title("t = 0") plt.savefig(filename,format="jpg") plt.clf() c = 0 for j in range(nsteps): print(j) #find solution inside domain u[1:-1] = np.linalg.solve(A,bb) #update right hand side bb = B.dot(u[1:-1]) + b if(j%nplot==0): #plot results every nplot timesteps plt.plot(x,u,linewidth=2) plt.ylim([0,1]) filename = 'foo' + str(c+1).zfill(3) + '.jpg'; plt.xlabel("x") plt.ylabel("u") plt.title("t = %2.2f"%(dt*(j+1))) plt.savefig(filename,format="jpg") plt.clf() c += 1 #os.system("ffmpeg -y -i 'foo%03d.jpg' heat_equation.m4v") #os.system("rm -f *.jpg") ``` ```python import matplotlib.pyplot as plt import numpy as np def CN(pr,psiR,psiI,V,dx,dt,mxItr,tol): hbar,m=pr Nx=len(psiR) al=hbar*dt/(4*m*dx**2) be=dt/(2*hbar) psiR0=[0 for i in range(Nx)] psiI0=[0 for i in range(Nx)] gam=[2*al+be*V[i] for i in range(Nx)] for i in range(1,Nx-1): psiR0[i]=psiR[i]-al*(psiI[i-1]+psiI[i+1]+gam[i]*psiI[i]) psiI0[i]=psiI[i]-al*(psiR[i-1]+psiR[i+1]+gam[i]*psiR[i]) for it in range(1,mxItr-1): err=0 for i in range(1,Nx-1): psi1=psiR0[i]-al*(psiI[i-1]+psiI[i+1]+gam[i]*psiI[i]) psi2=psiI0[i]-al*(psiR[i-1]+psiR[i+1]+gam[i]*psiR[i]) errf=abs(psi1**2+psi2**2-psiR[i]**2-psiI[i]**2) if errf>err: err=errf psiR[i]=psi1 psiI[i]=psi2 if err<tol: break if it<mxItr: return psiR,psiI else: print('Function not Converging') return None,None # Normalization def normalize(psiR,psiI,dx): Nx=len(psiR) psi2=[psiR[i]**2+psiI[i]**2 for i in range(Nx)] psiNorm=0.5*(psi2[0]+psi2[Nx-1]) for i in range(1,Nx-1): psiNorm+=psi2[i] psiNorm*=dx psiR=[psiR[i]/psiNorm for i in range(Nx)] psiI=[psiI[i]/psiNorm for i in range(Nx)] return psiR,psiI def CN_TDSE(pr,wvpk,prWV,Pot,prPt,X0,XN,Nx,ts,T,tps): hbar,m=pr dx=(XN-X0)/(Nx-1) X=[X0+i*dx for i in range(Nx)] sig,k0=prWV[1],prWV[2] E=(hbar**2/(2*m))*(k0**2+.5/sig**2) psi=[wvpk(prWV,x) for x in X] psiR=[psi[i].real for i in range(Nx)] psiI=[psi[i].imag for i in range(Nx)] psiR,psiI=normalize(psiR,psiI,dx) V=Pot(prPt,Nx) Vmx=max(max(V),abs(min(V))) dt=hbar/(hbar**2/(m*dx**2)+Vmx/2) Xmx,Xmn,Ymx=max(X),min(X),1.5*max(psiR) if Vmx!=0: Efac=Ymx/(2*Vmx) V_plot=[V[i]*Efac for i in range(Nx)] print('Energy of the particle=',E,'Scaled Energy=',E*Efac) mxItr,tol=100,1e-5 t,it=0,0 while t<T: if it%ts==0: plt.axis([Xmn,Xmx,-Ymx,Ymx]) if Efac!=0: plt.plot(X,V_plot,':k') plt.axhline(E*Efac,color='g',label='E') plt.fill_between(X,V_plot,facecolor='lightgrey') plt.plot(X,psiR,'b',label=r'$\psi(x,t) $') plt.plot(X,[psiR[i]**2+psiI[i]**2 for i in range(Nx)],'k',label=r'$\psi(x,t)^2$') plt.text(.8*Xmx,.9*Ymx,'t=%.2f'%t) plt.legend(loc='lower left',prop={'size':12}) plt.xlabel('x') plt.pause(tps) plt.clf() psiR,psiI=CN(pr,psiR,psiI,V,dx,dt,mxItr,tol) it+=1 t+=dt plt.show() return None from math import* def Pot(V0,Nx): V=[V0 for i in range(Nx)] return V def gauss(pr,x): x0,sig,k0=pr a=1/((2*pi)**.5*sig)**.5 b=-1/(4*sig**2) gs=a*exp(b*(x-x0)**2) if gs<1e-10: gs=0 psi=gs*complex(cos(k0*x),sin(k0*x)) return psi hbar,m=1,1 X0,XN,Nx=-20,40,200 sig=(XN-X0)/40 x0,k0=X0+15*sig,pi V0=7 pr=[hbar,m] prWV=[x0,sig,k0] ts,T,tps=1,10,.05 CN_TDSE(pr,gauss,prWV,Pot,V0,X0,XN,Nx,ts,T,tps) ``` ```python ``` ```python ``` ```python ``` ```python ``` ```python # KRONIG-PENNY MODEL #!/usr/bin/python ''' This script is used to analyze the energy levels predicted by the Kronig- Penney model of electron band structure for a periodic potential. The end result of this program are plots of the E-K bands of the potential. /Kronig-Penney Model Potential/ U ^ b | a <----> | <-----> ----+ +----+ +----+ +----+ +----+ +---- Uo | | | | | | | | | | ... | | | | | | | | | | ... | | | | | | | | | | ---------------------------------------------------------------> x x = -b | x = a | *** NOTE *** If 'Uo' is negative (instead of having ridges, there are pits), then the resulting energy banding is the same and can be obtained by swapping 'a' with 'b' and by shifting all energy values down by the magnitude of 'Uo'. ''' ``` ```python ``` ```python ``` ```python ``` ```python # KRONIG-PENNY MODEL #!/usr/bin/python ''' This script is used to analyze the energy levels predicted by the Kronig- Penney model of electron band structure for a periodic potential. The end result of this program are plots of the E-K bands of the potential. /Kronig-Penney Model Potential/ U ^ b | a <----> | <-----> ----+ +----+ +----+ +----+ +----+ +---- Uo | | | | | | | | | | ... | | | | | | | | | | ... | | | | | | | | | | ---------------------------------------------------------------> x x = -b | x = a | *** NOTE *** If 'Uo' is negative (instead of having ridges, there are pits), then the resulting energy banding is the same and can be obtained by swapping 'a' with 'b' and by shifting all energy values down by the magnitude of 'Uo'. ''' from numpy import * from matplotlib.pyplot import * #------------------------------------------------------------------------------ # Physical Constants #------------------------------------------------------------------------------ _c = 2.998e17 # Speed of light in nm/s _m = 0.511e6/_c**2 # Electron mass in eV/c^2 _hbar = 6.583e-16 # h/(2*pi) in eV*s _Uo = _hbar**2/(2*_m) # If Uo = _Uo then u = 1 #------------------------------------------------------------------------------ # Model Parameters # (units: a,b = nm, Uo,dE = eV) #------------------------------------------------------------------------------ Uo = _Uo a = pi b = pi Emax = 4*Uo dE = 0.00001*Emax gap_tol = 1.000001*dE # Display model parameters print("----------------------------------------------------------------------") print("Model Parameters") print("Uo (eV):", Uo) print("a (nm):", a) print("b (nm):", b) print("dE (eV):", dE) print("Energy gap tolerance (eV):", gap_tol) #------------------------------------------------------------------------------ # Function definitions #------------------------------------------------------------------------------ def f_bound(E, Uo, a, b): u = sqrt(2*_m*Uo)/_hbar xi = E/Uo alpha = a*u*sqrt(xi) beta = b*u*sqrt(1 - xi) C = (1 - 2*xi)/(2*sqrt(xi*(1 - xi))) return cos(alpha)*cosh(beta) + C*sin(alpha)*sinh(beta) def f_free(E, Uo, a, b): u = sqrt(2*_m*Uo)/_hbar xi = E/Uo alpha = a*u*sqrt(xi) beta = b*u*sqrt(xi - 1) C = (1 - 2*xi)/(2*sqrt(xi*(xi - 1))) return cos(alpha)*cos(beta) + C*sin(alpha)*sin(beta) def f_top(Uo, a, b): u = sqrt(2*_m*Uo)/_hbar alpha = a*u C = -0.5*b*u return cos(alpha) + C*sin(alpha) def f_bot(Uo, a, b): u = sqrt(2*_m*Uo)/_hbar beta = b*u C = 0.5*a*u return cosh(beta) + C*sinh(beta) def mass_eff(k,E): return ((_hbar*_c)**2)/(polyfit(k,E,2)[0]) #============================================================================== # Perform Calculations - The main part of the script #============================================================================== # Assign initial values of E if Uo > 0: E = arange(0,Emax,dE) elif Uo < 0: print("Uo must be greater than 0!") exit() else: print("Uo cannont equal zero!") exit() # Calculate the energy bands f = [] E_bands = [] f_bands = [] for En in E: if En == 0: fn = f_bot(Uo, a, b) f.append(fn) if abs(fn) <= 1: E_bands.append(En) f_bands.append(fn) elif En < Uo: fn = f_bound(En, Uo, a, b) f.append(fn) if abs(fn) <= 1: E_bands.append(En) f_bands.append(fn) elif En == Uo: fn = f_top(Uo, a, b) f.append(fn) if abs(fn) <= 1: E_bands.append(En) f_bands.append(fn) elif En > Uo: fn = f_free(En, Uo, a, b) f.append(fn) if abs(fn) <= 1: E_bands.append(En) f_bands.append(fn) f = array(f) # f as a function of E E = array(E) # Emin to Emax by dE xi = E/Uo # Emin/Uo to Emax/Uo by dE/Uo E_bands = array(E_bands) # Allowed Energies f_bands = array(f_bands) # Allowed values of f xi_bands = E_bands/Uo # Normalized allowed energies K = arccos(f_bands)/(a+b) # K values corresponding to energies Kext = zeros(K.shape) # Extended K values # Find Band Gaps And Effective Mass At Band Ends E_gaps = [] # Array of tuples containing band gaps # (Bottom Energy, Top Energy, Gap Width) gap_idx = [] # Index of the bottom edge of every band n = 0 for i in range(1,E_bands.size): chgE = E_bands[i] - E_bands[i-1] if chgE > gap_tol: E_gaps.append((E_bands[i-1], E_bands[i], chgE)) gap_idx.append(i) n += 1 if n != 0: if n%2: Kext[i] = (n + 1)*pi/(a+b) - K[i] else: Kext[i] = n*pi/(a+b) + K[i] else: Kext[i] = K[i] del n # Normalized E_gaps xi_gaps = [(gap[0]/Uo, gap[1]/Uo, gap[2]/Uo) for gap in E_gaps] # Maximum value of K Kmax = max(Kext) # Energies of a free particle over the range -Kmax to Kmax fakeK = arange(-Kmax,Kmax,0.001*Kmax) E_empty = (_hbar*fakeK)**2/(2*_m) # Calculate the effective masses at each band edge effMass_gnd = mass_eff(Kext[0:3],E_bands[0:3]) # Ground State Effective Mass effMass = [] # Array of tuples of effective masses for bands # [(mass at bottom, mass at top), (..),...] # ----------"Band 1"-----------, ... mbot = effMass_gnd mtop = 0 for i in gap_idx: mtop = mass_eff(Kext[i-3:i],E_bands[i-3:i]) effMass.append((mbot,mtop)) mbot = mass_eff(Kext[i:i+3],E_bands[i:i+3]) del mbot, mtop #============================================================================== #------------------------------------------------------------------------------ # Display Ground State Energy, Energy Gaps, & Effective masses at band ends #------------------------------------------------------------------------------ print("----------------------------------------------------------------------") print("Ground State Energy (E/Uo):", E_bands[0]/Uo) print("Energy Gaps (E/Uo)") print("[Gap #] (Lower Energy, Upper Energy, Energy Gap)") for i in range(0,len(E_gaps)): print("[{0:2d}] ".format(i+1), xi_gaps[i]) print("----------------------------------------------------------------------") print("Ground State Energy (eV):", E_bands[0]) print("Energy Gaps (eV)") print("[Gap #] (Lower Energy, Upper Energy, Energy Gap)") for i in range(0,len(E_gaps)): print("[{0:2d}] ".format(i+1), E_gaps[i]) print("----------------------------------------------------------------------") print("Ground State Effective mass (MeV):", effMass_gnd/1e6) print("Effective Mass At Band Edges (MeV)") print("[Band #] (Mass At Bottom, Mass At Top)") for i in range(0,len(effMass)): print("[{0:2d}] ".format(i+1), (effMass[i][0]/1e6, effMass[i][1]/1e6)) #------------------------------------------------------------------------------ # Display Pretty Figures #------------------------------------------------------------------------------ # Graphical Solution ''' f1 = figure(1) plot(xi, f, 'b', xi, zeros(xi.shape), 'k', xi, ones(xi.shape), 'r', xi, -1*ones(xi.shape),'r', figure=f1) grid(True) ylim([-4,4]) xlabel("E/Uo") ylabel("f(E)") ''' # Normalized E-K Plots f2 = figure(2) plot(-1*K*(a+b)/pi, xi_bands, 'b', K*(a+b)/pi, xi_bands, 'b', -1*Kext*(a+b)/pi, xi_bands, 'r', Kext*(a+b)/pi, xi_bands, 'r', fakeK*(a+b)/pi, E_empty/Uo, 'g--', figure=f2) grid(True) xlim([-1.1*Kmax*(a+b)/pi,1.1*Kmax*(a+b)/pi]) ylim([0,Emax/Uo]) xlabel("K*(a + b)/Pi") ylabel("E/Uo") title("EK Plots") ''' # E-K Plots f3 = figure(3) plot(-1*K, E_bands, 'b', K, E_bands, 'b', -1*Kext, E_bands, 'r', Kext, E_bands, 'r', fakeK, E_empty, 'g--', figure=f3) grid(True) xlim([-1.1*Kmax, 1.1*Kmax]) ylim([0,Emax]) xlabel("K (1/nm)") ylabel("E (eV)") title("EK Plots") ''' show() ``` ```python # Graphical Solution f1 = figure(1) plot(xi, f, 'b', xi, zeros(xi.shape), 'k', xi, ones(xi.shape), 'r', xi, -1*ones(xi.shape),'r', figure=f1) grid(True) ylim([-4,4]) xlabel("E/Uo") ylabel("f(E)") ``` ```python # Normalized E-K Plots f2 = figure(2) plot(-1*K*(a+b)/pi, xi_bands, 'b', K*(a+b)/pi, xi_bands, 'b', -1*Kext*(a+b)/pi, xi_bands, 'r', Kext*(a+b)/pi, xi_bands, 'r', fakeK*(a+b)/pi, E_empty/Uo, 'g--', figure=f2) grid(True) xlim([-1.1*Kmax*(a+b)/pi,1.1*Kmax*(a+b)/pi]) ylim([0,Emax/Uo]) xlabel("K*(a + b)/Pi") ylabel("E/Uo") title("EK Plots") ``` ```python # E-K Plots f3 = figure(3) plot(-1*K, E_bands, 'b', K, E_bands, 'b', -1*Kext, E_bands, 'r', Kext, E_bands, 'r', fakeK, E_empty, 'g--', figure=f3) grid(True) xlim([-1.1*Kmax, 1.1*Kmax]) ylim([0,Emax]) xlabel("K (1/nm)") ylabel("E (eV)") title("EK Plots") ``` ```python %matplotlib inline import matplotlib.pyplot as plt plt.style.use('seaborn-white') import numpy as np def f(x, y): return np.sin(x) ** 10 + np.cos(10 + y * x) * np.cos(x) x = np.linspace(0, 5, 50) y = np.linspace(0, 5, 40) X, Y = np.meshgrid(x, y) Z = f(X, Y) plt.contour(X, Y, Z, colors='black'); ``` ```python plt.contour(X, Y, Z, 20, cmap='RdGy'); ``` ```python plt.imshow(Z, extent=[0, 5, 0, 5], origin='lower', cmap='RdGy') plt.colorbar() plt.axis(aspect='image'); ``` ```python contours = plt.contour(X, Y, Z, 3, colors='black') plt.clabel(contours, inline=True, fontsize=8) plt.imshow(Z, extent=[0, 5, 0, 5], origin='lower', cmap='RdGy', alpha=0.5) plt.colorbar(); ``` ```python %matplotlib inline import numpy as np import matplotlib.pyplot as plt fig = plt.figure() ax = plt.axes(projection='3d') ax = plt.axes(projection='3d') # Data for a three-dimensional line zline = np.linspace(0, 15, 1000) xline = np.sin(zline) yline = np.cos(zline) ax.plot3D(xline, yline, zline, 'gray') # Data for three-dimensional scattered points zdata = 15 * np.random.random(100) xdata = np.sin(zdata) + 0.1 * np.random.randn(100) ydata = np.cos(zdata) + 0.1 * np.random.randn(100) ax.scatter3D(xdata, ydata, zdata, c=zdata, cmap='YlGnBu') ``` ```python def f(x, y): return np.sin(np.sqrt(x ** 2 + y ** 2)) x = np.linspace(-6, 6, 30) y = np.linspace(-6, 6, 30) X, Y = np.meshgrid(x, y) Z = f(X, Y) fig = plt.figure() ax = plt.axes(projection='3d') ax.contour3D(X, Y, Z, 50, cmap='Greens') ax.set_xlabel('x') ax.set_ylabel('y') ax.set_zlabel('z'); ``` ```python # DOUBLE PENDULAM import matplotlib matplotlib.use('TKAgg') # 'tkAgg' if Qt not present import matplotlib.pyplot as plt import scipy as sp import matplotlib.animation as animation class Pendulum: def __init__(self, theta1, theta2, dt): self.theta1 = theta1 self.theta2 = theta2 self.p1 = 0.0 self.p2 = 0.0 self.dt = dt self.g = 9.81 self.length = 1.0 self.trajectory = [self.polar_to_cartesian()] def polar_to_cartesian(self): x1 = self.length * sp.sin(self.theta1) y1 = -self.length * sp.cos(self.theta1) x2 = x1 + self.length * sp.sin(self.theta2) y2 = y1 - self.length * sp.cos(self.theta2) print(self.theta1, self.theta2) return sp.array([[0.0, 0.0], [x1, y1], [x2, y2]]) def evolve(self): theta1 = self.theta1 theta2 = self.theta2 p1 = self.p1 p2 = self.p2 g = self.g l = self.length expr1 = sp.cos(theta1 - theta2) expr2 = sp.sin(theta1 - theta2) expr3 = (1 + expr2**2) expr4 = p1 * p2 * expr2 / expr3 expr5 = (p1**2 + 2 * p2**2 - p1 * p2 * expr1) \ * sp.sin(2 * (theta1 - theta2)) / 2 / expr3**2 expr6 = expr4 - expr5 self.theta1 += self.dt * (p1 - p2 * expr1) / expr3 self.theta2 += self.dt * (2 * p2 - p1 * expr1) / expr3 self.p1 += self.dt * (-2 * g * l * sp.sin(theta1) - expr6) self.p2 += self.dt * ( -g * l * sp.sin(theta2) + expr6) new_position = self.polar_to_cartesian() self.trajectory.append(new_position) print(new_position) return new_position class Animator: def __init__(self, pendulum, draw_trace=False): self.pendulum = pendulum self.draw_trace = draw_trace self.time = 0.0 # set up the figure self.fig, self.ax = plt.subplots() self.ax.set_ylim(-2.5, 2.5) self.ax.set_xlim(-2.5, 2.5) # prepare a text window for the timer self.time_text = self.ax.text(0.05, 0.95, '', horizontalalignment='left', verticalalignment='top', transform=self.ax.transAxes) # initialize by plotting the last position of the trajectory self.line, = self.ax.plot( self.pendulum.trajectory[-1][:, 0], self.pendulum.trajectory[-1][:, 1], marker='o') # trace the whole trajectory of the second pendulum mass if self.draw_trace: self.trace, = self.ax.plot( [a[2, 0] for a in self.pendulum.trajectory], [a[2, 1] for a in self.pendulum.trajectory]) def advance_time_step(self): while True: self.time += self.pendulum.dt yield self.pendulum.evolve() def update(self, data): self.time_text.set_text('Elapsed time: {:6.2f} s'.format(self.time)) self.line.set_ydata(data[:, 1]) self.line.set_xdata(data[:, 0]) if self.draw_trace: self.trace.set_xdata([a[2, 0] for a in self.pendulum.trajectory]) self.trace.set_ydata([a[2, 1] for a in self.pendulum.trajectory]) return self.line, def animate(self): self.animation = animation.FuncAnimation(self.fig, self.update, self.advance_time_step, interval=25, blit=False) pendulum = Pendulum(theta1=sp.pi, theta2=sp.pi - 0.01, dt=0.01) animator = Animator(pendulum=pendulum, draw_trace=True) animator.animate() plt.show() ``` ```python # QUANTUM TUNNELING import matplotlib import numpy as np #matplotlib.use('TKAgg') import matplotlib.pyplot as plt from scipy.sparse import linalg as ln from scipy import sparse as sparse import matplotlib.animation as animation class Wave_Packet: def __init__(self, n_points, dt, sigma0=5.0, k0=1.0, x0=-150.0, x_begin=-200.0, x_end=200.0, barrier_height=1.0, barrier_width=3.0): self.n_points = n_points self.sigma0 = sigma0 self.k0 = k0 self.x0 = x0 self.dt = dt self.prob = np.zeros(n_points) self.barrier_width = barrier_width self.barrier_height = barrier_height """ 1) Space discretization """ self.x, self.dx = np.linspace(x_begin, x_end, n_points, retstep=True) """ 2) Initialization of the wave function to Gaussian wave packet """ norm = (2.0 * np.pi * sigma0**2)**(-0.25) self.psi = np.exp(-(self.x - x0)**2 / (4.0 * sigma0**2)) self.psi *= np.exp(1.0 * k0 * self.x) self.psi *= (2.0 * np.pi * sigma0**2)**(-0.25) """ 3) Setting up the potential barrier """ self.potential = np.array( [barrier_height if 0.0 < x < barrier_width else 0.0 for x in self.x]) """ 4) Creating the Hamiltonian """ h_diag = np.ones(n_points) / self.dx**2 + self.potential h_non_diag = np.ones(n_points - 1) * (-0.5 / self.dx**2) hamiltonian = sparse.diags([h_diag, h_non_diag, h_non_diag], [0, 1, -1]) """ 5) Computing the Crank-Nicolson time evolution matrix """ implicit = (sparse.eye(self.n_points) - dt / 2.0j * hamiltonian).tocsc() explicit = (sparse.eye(self.n_points) + dt / 2.0j * hamiltonian).tocsc() self.evolution_matrix = ln.inv(implicit).dot(explicit).tocsr() def evolve(self): self.psi = self.evolution_matrix.dot(self.psi) self.prob = abs(self.psi)**2 norm = sum(self.prob) self.prob /= norm self.psi /= norm**0.5 return self.prob class Animator: def __init__(self, wave_packet): self.time = 0.0 self.wave_packet = wave_packet self.fig, self.ax = plt.subplots() plt.plot(self.wave_packet.x, self.wave_packet.potential * 0.1, color='r') self.time_text = self.ax.text(0.05, 0.95, '', horizontalalignment='left', verticalalignment='top', transform=self.ax.transAxes) self.line, = self.ax.plot(self.wave_packet.x, self.wave_packet.evolve()) self.ax.set_ylim(0, 0.2) self.ax.set_xlabel('Position (a$_0$)') self.ax.set_ylabel('Probability density (a$_0$)') def update(self, data): self.line.set_ydata(data) return self.line, def time_step(self): while True: self.time += self.wave_packet.dt self.time_text.set_text( 'Elapsed time: {:6.2f} fs'.format(self.time * 2.419e-2)) yield self.wave_packet.evolve() def animate(self): self.ani = animation.FuncAnimation( self.fig, self.update, self.time_step, interval=5, blit=False) wave_packet = Wave_Packet(n_points=500, dt=0.5, barrier_width=10, barrier_height=1) animator = Animator(wave_packet) animator.animate() plt.show() from IPython.display import HTML ani=Animator(wave_packet).animate() ani ``` ```python from __future__ import print_function from __future__ import division import numpy as np import matplotlib.pyplot as plt import matplotlib.animation as animation def D_wrap(A, dX): d = A - np.roll(A, 1) d = 0.5 * (d + np.roll(d, -1)) return d #doesn't wrap over, faster def D_nowrap(A, dX): d = A[1:] - A[:-1] d = np.concatenate(([d[0]], d, [d[-1]])) d = 0.5 * (d[1:] + d[:-1]) return d D = D_nowrap #select diff function N = 400 #number of points size = 10 #x in [-size, size] dX = 2.*size/N #x step dt = 0.0005 #time step X = np.linspace(-size, size, N) x0 = -5 A = np.exp(-4*(X-x0)*((X-x0)+1500j)) #initial wave function A = np.array(A, dtype=np.complex) #V = np.zeros(N) V = 0.5*(np.abs(X - 2) < 0.5) #potential fig, ax = plt.subplots() line, = ax.plot(X, A) ax.set_ylim([0, 1]) ax.plot(X, V) def animate(i): global A for i in range(1000): #don't show every time step A += dt*(1j*D(D(A, dX), dX) - 1j * V * A) #schrodinger equation print(np.sum(np.abs(A**2))) #print norm line.set_ydata(np.abs(A**2)) return line, ani = animation.FuncAnimation(fig, animate, np.arange(1, 200), interval=25, blit=True) plt.show() ani ``` ```python import numpy as np from matplotlib import pyplot as pl from matplotlib import animation from scipy.fftpack import fft,ifft class Schrodinger(object): """ Class which implements a numerical solution of the time-dependent Schrodinger equation for an arbitrary potential """ def __init__(self, x, psi_x0, V_x, k0 = None, hbar=1, m=1, t0=0.0): """ Parameters ---------- x : array_like, float length-N array of evenly spaced spatial coordinates psi_x0 : array_like, complex length-N array of the initial wave function at time t0 V_x : array_like, float length-N array giving the potential at each x k0 : float the minimum value of k. Note that, because of the workings of the fast fourier transform, the momentum wave-number will be defined in the range k0 < k < 2*pi / dx where dx = x[1]-x[0]. If you expect nonzero momentum outside this range, you must modify the inputs accordingly. If not specified, k0 will be calculated such that the range is [-k0,k0] hbar : float value of planck's constant (default = 1) m : float particle mass (default = 1) t0 : float initial tile (default = 0) """ # Validation of array inputs self.x, psi_x0, self.V_x = map(np.asarray, (x, psi_x0, V_x)) N = self.x.size assert self.x.shape == (N,) assert psi_x0.shape == (N,) assert self.V_x.shape == (N,) # Set internal parameters self.hbar = hbar self.m = m self.t = t0 self.dt_ = None self.N = len(x) self.dx = self.x[1] - self.x[0] self.dk = 2 * np.pi / (self.N * self.dx) # set momentum scale if k0 == None: self.k0 = -0.5 * self.N * self.dk else: self.k0 = k0 self.k = self.k0 + self.dk * np.arange(self.N) self.psi_x = psi_x0 self.compute_k_from_x() # variables which hold steps in evolution of the self.x_evolve_half = None self.x_evolve = None self.k_evolve = None # attributes used for dynamic plotting self.psi_x_line = None self.psi_k_line = None self.V_x_line = None def _set_psi_x(self, psi_x): self.psi_mod_x = (psi_x * np.exp(-1j * self.k[0] * self.x) * self.dx / np.sqrt(2 * np.pi)) def _get_psi_x(self): return (self.psi_mod_x * np.exp(1j * self.k[0] * self.x) * np.sqrt(2 * np.pi) / self.dx) def _set_psi_k(self, psi_k): self.psi_mod_k = psi_k * np.exp(1j * self.x[0] * self.dk * np.arange(self.N)) def _get_psi_k(self): return self.psi_mod_k * np.exp(-1j * self.x[0] * self.dk * np.arange(self.N)) def _get_dt(self): return self.dt_ def _set_dt(self, dt): if dt != self.dt_: self.dt_ = dt self.x_evolve_half = np.exp(-0.5 * 1j * self.V_x / self.hbar * dt ) self.x_evolve = self.x_evolve_half * self.x_evolve_half self.k_evolve = np.exp(-0.5 * 1j * self.hbar / self.m * (self.k * self.k) * dt) psi_x = property(_get_psi_x, _set_psi_x) psi_k = property(_get_psi_k, _set_psi_k) dt = property(_get_dt, _set_dt) def compute_k_from_x(self): self.psi_mod_k = fft(self.psi_mod_x) def compute_x_from_k(self): self.psi_mod_x = ifft(self.psi_mod_k) def time_step(self, dt, Nsteps = 1): """ Perform a series of time-steps via the time-dependent Schrodinger Equation. Parameters ---------- dt : float the small time interval over which to integrate Nsteps : float, optional the number of intervals to compute. The total change in time at the end of this method will be dt * Nsteps. default is N = 1 """ self.dt = dt if Nsteps > 0: self.psi_mod_x *= self.x_evolve_half for i in range(Nsteps - 1): self.compute_k_from_x() self.psi_mod_k *= self.k_evolve self.compute_x_from_k() self.psi_mod_x *= self.x_evolve self.compute_k_from_x() self.psi_mod_k *= self.k_evolve self.compute_x_from_k() self.psi_mod_x *= self.x_evolve_half self.compute_k_from_x() self.t += dt * Nsteps ###################################################################### # Helper functions for gaussian wave-packets def gauss_x(x, a, x0, k0): """ a gaussian wave packet of width a, centered at x0, with momentum k0 """ return ((a * np.sqrt(np.pi)) ** (-0.5) * np.exp(-0.5 * ((x - x0) * 1. / a) ** 2 + 1j * x * k0)) def gauss_k(k,a,x0,k0): """ analytical fourier transform of gauss_x(x), above """ return ((a / np.sqrt(np.pi))**0.5 * np.exp(-0.5 * (a * (k - k0)) ** 2 - 1j * (k - k0) * x0)) ###################################################################### # Utility functions for running the animation def theta(x): """ theta function : returns 0 if x<=0, and 1 if x>0 """ x = np.asarray(x) y = np.zeros(x.shape) y[x > 0] = 1.0 return y def square_barrier(x, width, height): return height * (theta(x) - theta(x - width)) ###################################################################### # Create the animation # specify time steps and duration dt = 0.01 N_steps = 50 t_max = 120 frames = int(t_max / float(N_steps * dt)) # specify constants hbar = 1.0 # planck's constant m = 1.9 # particle mass # specify range in x coordinate N = 2 ** 11 dx = 0.1 x = dx * (np.arange(N) - 0.5 * N) # specify potential V0 = 1.5 L = hbar / np.sqrt(2 * m * V0) a = 3 * L x0 = -60 * L V_x = square_barrier(x, a, V0) V_x[x < -98] = 1E6 V_x[x > 98] = 1E6 # specify initial momentum and quantities derived from it p0 = np.sqrt(2 * m * 0.2 * V0) dp2 = p0 * p0 * 1./80 d = hbar / np.sqrt(2 * dp2) k0 = p0 / hbar v0 = p0 / m psi_x0 = gauss_x(x, d, x0, k0) # define the Schrodinger object which performs the calculations S = Schrodinger(x=x, psi_x0=psi_x0, V_x=V_x, hbar=hbar, m=m, k0=-28) ###################################################################### # Set up plot fig = pl.figure() # plotting limits xlim = (-100, 100) klim = (-5, 5) # top axes show the x-space data ymin = 0 ymax = V0 ax1 = fig.add_subplot(211, xlim=xlim, ylim=(ymin - 0.2 * (ymax - ymin), ymax + 0.2 * (ymax - ymin))) psi_x_line, = ax1.plot([], [], c='r', label=r'$|\psi(x)|$') V_x_line, = ax1.plot([], [], c='k', label=r'$V(x)$') center_line = ax1.axvline(0, c='k', ls=':', label = r"$x_0 + v_0t$") title = ax1.set_title("") ax1.legend(prop=dict(size=12)) ax1.set_xlabel('$x$') ax1.set_ylabel(r'$|\psi(x)|$') # bottom axes show the k-space data ymin = abs(S.psi_k).min() ymax = abs(S.psi_k).max() ax2 = fig.add_subplot(212, xlim=klim, ylim=(ymin - 0.2 * (ymax - ymin), ymax + 0.2 * (ymax - ymin))) psi_k_line, = ax2.plot([], [], c='r', label=r'$|\psi(k)|$') p0_line1 = ax2.axvline(-p0 / hbar, c='k', ls=':', label=r'$\pm p_0$') p0_line2 = ax2.axvline(p0 / hbar, c='k', ls=':') mV_line = ax2.axvline(np.sqrt(2 * V0) / hbar, c='k', ls='--', label=r'$\sqrt{2mV_0}$') ax2.legend(prop=dict(size=12)) ax2.set_xlabel('$k$') ax2.set_ylabel(r'$|\psi(k)|$') V_x_line.set_data(S.x, S.V_x) ###################################################################### # Animate plot def init(): psi_x_line.set_data([], []) V_x_line.set_data([], []) center_line.set_data([], []) psi_k_line.set_data([], []) title.set_text("") return (psi_x_line, V_x_line, center_line, psi_k_line, title) def animate(i): S.time_step(dt, N_steps) psi_x_line.set_data(S.x, 4 * abs(S.psi_x)) V_x_line.set_data(S.x, S.V_x) center_line.set_data(2 * [x0 + S.t * p0 / m], [0, 1]) psi_k_line.set_data(S.k, abs(S.psi_k)) title.set_text("t = %.2f" % S.t) return (psi_x_line, V_x_line, center_line, psi_k_line, title) # call the animator. blit=True means only re-draw the parts that have changed. anim = animation.FuncAnimation(fig, animate, init_func=init, frames=frames, interval=30, blit=True) # uncomment the following line to save the video in mp4 format. This # requires either mencoder or ffmpeg to be installed on your system anim.save('schrodinger_barrier.mp4', fps=15, extra_args=['-vcodec', 'libx264']) pl.show() ``` # Double Finite Square Well The double finite square well is an interesting problem because it shows, in a very rudamentary way, how you can get binding between two atoms simply because they share a particle. The idea is that the overall energy of the system wants to trend to the minimum. We follow the now familiar recipe to get the energy levels of a quantum system. ```python import numpy as np import matplotlib.pyplot as plt import scipy.linalg as scl plt.style.use('fivethirtyeight') hbar=1 m=1 N = 4096 x_min = -50.0 x_max = 50 x = np.linspace(x_min,x_max,N) # We want to store step size, this is the reliable way: h = x[1]-x[0] # Should be equal to 2*np.pi/(N-1) a=2. b=2*a V0 = -.5 # # V=np.zeros(N) for i in range(N): if x[i] > -a -b/2. and x[i]< -b/2.: V[i]= V0 elif x[i] > b/2. and x[i] < b/2. + a : V[i]= V0 Mdd = 1./(h*h)*(np.diag(np.ones(N-1),-1) -2* np.diag(np.ones(N),0) + np.diag(np.ones(N-1),1)) H = -(hbar*hbar)/(2.0*m)*Mdd + np.diag(V) E,psiT = np.linalg.eigh(H) # This computes the eigen values and eigenvectors psi = np.transpose(psiT) # We take the transpose of psiT to the wavefunction vectors can accessed as psi[n] # ``` ```python fig = plt.figure(figsize=(10,8)) ax1 = fig.add_subplot(111) ax1.set_xlabel("x") ax1.set_ylabel("$\psi_n(x)$") for i in range(2): if E[i]<0: # Only plot the bound states. The scattering states are not reliably computed. if psi[i][int(N/2)+10] < 0: # Flip the wavefunctions if it is negative at large x, so plots are more consistent. ax1.plot(x,-psi[i]/np.sqrt(h),label="$E_{}$={:>8.3f}".format(i,E[i])) else: ax1.plot(x,psi[i]/np.sqrt(h),label="$E_{}$={:>8.3f}".format(i,E[i])) plt.title("Wavefunctions for the Finite Square Well") # Plot the potential as well, on a separate y axis ax2 = ax1.twinx() ax2.set_ylabel("Energy") # To get separate energy scale ax2.plot(x,V,color="Gray",label="V(x)") ax1.set_xlim((-a-b-5,a+b+5)) legendh1,labels1 = ax1.get_legend_handles_labels() # For putting all legends in one box. legendh2,labels2 = ax2.get_legend_handles_labels() plt.legend(legendh1+legendh2,labels1+labels2,loc="lower right") plt.savefig("Double_Finite_Square_Well_WaveFunctions1.pdf") plt.show() ``` ```python # Change of barrier width ``` ```python import numpy as np import matplotlib.pyplot as plt E_dw=[] psi_dw=[] b_arr = [0.,0.25*a,0.5*a,0.75*a,1.*a,1.25*a,1.5*a,1.75*a,2.*a,2.5*a,3.*a,4.*a,5.*a] for b in b_arr: V0 = -1. V=np.zeros(N) for i in range(N): if x[i] > -a -b/2. and x[i]< -b/2.: V[i]= V0 elif x[i] > b/2. and x[i] < b/2. + a : V[i]= V0 Mdd = 1./(h*h)*(np.diag(np.ones(N-1),-1) -2* np.diag(np.ones(N),0) + np.diag(np.ones(N-1),1)) H = -(hbar*hbar)/(2.0*m)*Mdd + np.diag(V) E,psiT = np.linalg.eigh(H) # This computes the eigen values and eigenvectors psi = np.transpose(psiT) # We take the transpose of psiT to the wavefunction vectors can accessed as psi[n] E_dw.append(E) psi_dw.append(psi) ``` ```python import numpy as np import matplotlib.pyplot as plt fig = plt.figure(figsize=(10,8)) E_0=[E_dw[i][0] for i in range(len(b_arr))] E_1=[E_dw[i][1] for i in range(len(b_arr))] plt.plot(b_arr,E_0,label="$E_1$ Ground state") plt.plot(b_arr,E_1,label="$E_2$ 1st excited") plt.legend() plt.savefig("Double_Finite_Well_E") plt.show() ``` # Hyperbolic Partial Differential Equation: ## $ \frac{\partial^2\psi}{\partial t^2}=c^2\frac{\partial^2\psi}{\partial x^2}$ ```python !pip install gekko ``` ```python import numpy as np import matplotlib.pyplot as plt from gekko import* from mpl_toolkits.mplot3d.axes3d import Axes3D tf = .0005 npt = 100 xf = 2*np.pi npx = 100 time = np.linspace(0,tf,npt) xpos = np.linspace(0,xf,npx) m = GEKKO() m.time = time def phi(x): phi = np.cos(x) return phi def psi(x): psi = np.sin(2*x) return psi x0 = phi(xpos) v0 = psi(xpos) dx = xpos[1]-xpos[0] a = 18996.06 c = m.Const(value = a) dx = m.Const(value = dx) u = [m.Var(value = x0[i]) for i in range(npx)] v = [m.Var(value = v0[i]) for i in range(npx)] [m.Equation(u[i].dt()==v[i]) for i in range(npx)] m.Equation(v[0].dt()==c**2 * \ (u[1] - 2.0*u[0] + u[npx-1])/dx**2 ) [m.Equation(v[i+1].dt()== \ c**2 * (u[i+2] - 2.0*u[i+1] + u[i])/dx**2) \ for i in range(npx-2) ] m.Equation(v[npx-1].dt()== c**2 * \ (u[npx-2] - 2.0*u[npx-1] + u[0])/dx**2 ) m.options.imode = 4 m.options.solver = 1 m.options.nodes = 3 m.solve() # re-arrange results for plotting for i in range(npx): if i ==0: ustor = np.array([u[i]]) tstor = np.array([m.time]) else: ustor = np.vstack([ustor,u[i]]) tstor = np.vstack([tstor,m.time]) for i in range(npt): if i == 0: xstor = xpos else: xstor = np.vstack([xstor,xpos]) xstor = xstor.T t = tstor ustor = np.array(ustor) fig = plt.figure() ax = fig.add_subplot(1,1,1,projection='3d') ax.set_xlabel('Distance (ft)', fontsize = 12) ax.set_ylabel('Time (seconds)', fontsize = 12) ax.set_zlabel('Position (ft)', fontsize = 12) ax.set_zlim((-1,1)) p = ax.plot_wireframe(xstor,tstor,ustor,\ rstride=1,cstride=1) fig.savefig('wave_3d.png', Transparent=True) plt.figure() plt.contour(xstor, tstor, ustor, 150) plt.colorbar() plt.xlabel('X') plt.ylabel('Time') plt.savefig('wave_contour.png', Transparent=True) plt.show() ``` ```python # Solving wave equation by explicit method def PDE(U0,U1,v0,c,hx,ht): ``` ```python import numpy as np from scipy.integrate import odeint import matplotlib.pyplot as plt from scipy.fftpack import diff as psdiff N = 100 #no. of mesh points L = 1.0 x = np.linspace(0, L, N) #mesh points xi, 0 < xi < 1 h = x[1] - x[0] k = -1.0 def odefunc(u, t): ux = np.zeros(x.shape) u[0] = 1 # boundary condition for i in range(1,N-1): ux[i] = float(u[i+1] - u[i-1])/(2*h) # ux[i] = float(u[i] - u[i-1])/h dudt = -ux return dudt init = np.zeros(x.shape, np.float) #initial condition tspan = np.linspace(0.0, 2.0, N) sol = odeint(odefunc, init, tspan, mxstep=5000) for i in range(0, len(tspan), 2): plt.plot(x, sol[N-1], label='t={0:1.2f}'.format(tspan[i])) plt.legend(loc='center left', bbox_to_anchor=(1, 0.5)) plt.xlabel('t') plt.ylabel('u(x,t)') plt.subplots_adjust(top=0.89, right=0.77) plt.savefig('pde.png') from mpl_toolkits.mplot3d import Axes3D fig = plt.figure() ax = fig.add_subplot(111, projection='3d') SX, ST = np.meshgrid(x, tspan) ax.plot_surface(SX, ST, sol, cmap='jet') ax.set_xlabel('x') ax.set_ylabel('t') ax.set_zlabel('u(x,t)') ax.view_init(elev=15, azim=-100) # adjust view so it is easy to see plt.savefig('pde-3d.png') ``` ## Heat Conduction equation Heat Equation The heat equation in one dimension is a parabolic PDE. The one dimensional transient heat equation is contains a partial derivative with respect to time and a second partial derivative with respect to distance. $\rho c_p \frac{\partial T}{\partial t} = \frac{\partial}{\partial t} \left( k \frac{\partial T}{\partial t} \right) + \dot Q$ with ρ as density, c p as heat capacity, T as the temperature, k as the thermal conductivity, and . Q as the heat input rate. The heat equation is discretized in space to give a set of Ordinary Differential Equations (ODEs) in time. Heated Rod (Left Boundary Condition) The following simulation is for a heated rod (10 cm) with the left side temperature step to 100 oC. The heat transfers to the right by conduction and away from the rod by convection. The temperature at the tip is the lowest temperature because of heat lost by convection to the surrounding air. ```python # The parabolic PDE equation describes the evolution of temperature # for the interior region of the rod. This model is modified to make # one end of the rod fixed and the other temperature at the end of the # rod calculated. import numpy as np from gekko import GEKKO import matplotlib.pyplot as plt # Steel rod temperature profile # Diameter = 3 cm # Length = 10 cm seg = 100 # number of segments T_melt = 1426 # melting temperature of H13 steel pi = 3.14159 # pi d = 3 / 100 # rod diameter (m) L = 10 / 100 # rod length (m) L_seg = L / seg # length of a segment (m) A = pi * d**2 / 4 # rod cross-sectional area (m) As = pi * d * L_seg # surface heat transfer area (m^2) heff = 5.8 # heat transfer coeff (W/(m^2*K)) keff = 28.6 # thermal conductivity in H13 steel (W/m-K) rho = 7760 # density of H13 rod steel (kg/m^3) cp = 460 # heat capacity of H13 steel (J/kg-K) Ts = 23 # temperature of the surroundings (°C) c2k = 273.15 # Celcius to Kelvin m = GEKKO() # create GEKKO model tf = 3000 nt = int(tf/30) + 1 m.time = np.linspace(0,tf,nt) Th = m.MV(ub=T_melt) # heater temperature (°C) Th.value = np.ones(nt) * 23 # start at room temperature Th.value[10:] = 100 # step at 300 sec T = [m.Var(23) for i in range(seg)] # temperature of the segments (°C) # Energy balance for the rod (segments) # accumulation = # (heat gained from upper segment) # - (heat lost to lower segment) # - (heat lost to surroundings) # Units check # kg/m^3 * m^2 * m * J/kg-K * K/sec = # W/m-K * m^2 * K / m # - W/m-K * m^2 * K / m # - W/m^2-K * m^2 * K # first segment m.Equation(rho*A*L_seg*cp*T[0].dt() == \ keff*A*(Th-T[0])/L_seg \ - keff*A*(T[0]-T[1])/L_seg \ - heff*As*(T[0]-Ts)) # middle segments m.Equations([rho*A*L_seg*cp*T[i].dt() == \ keff*A*(T[i-1]-T[i])/L_seg \ - keff*A*(T[i]-T[i+1])/L_seg \ - heff*As*(T[i]-Ts) for i in range(1,seg-1)]) # last segment m.Equation(rho*A*L_seg*cp*T[seg-1].dt() == \ keff*A*(T[seg-2]-T[seg-1])/L_seg \ - heff*(As+A)*(T[seg-1]-Ts)) # simulation m.options.IMODE = 4 m.solve() # plot results plt.figure() tm = m.time / 60.0 plt.plot(tm,Th.value,'r-',label=r'$T_{heater}\,(^oC)$') plt.plot(tm,T[5].value,'k--',label=r'$T_5\,(^oC)$') plt.plot(tm,T[15].value,'k:',label=r'$T_{15}\,(^oC)$') plt.plot(tm,T[25].value,'k:',label=r'$T_{25}\,(^oC)$') plt.plot(tm,T[45].value,'k-.',label=r'$T_{45}\,(^oC)$') plt.plot(tm,T[-1].value,'b-',label=r'$T_{tip}\,(^oC)$') plt.ylabel(r'$T\,(^oC$)') plt.xlabel('Time (min)') plt.xlim([0,50]) plt.legend(loc=4) plt.show() ``` ```python # The parabolic PDE equation describes the evolution of temperature # for the interior region of the rod. This model is modified to make # one end of the device fixed and the other temperature at the end of the # device calculated. import numpy as np from gekko import GEKKO import matplotlib.pyplot as plt import matplotlib.animation as animation # Steel temperature profile # Diameter = 3 cm # Length = 10 cm seg = 100 # number of segments T_melt = 1426 # melting temperature of H13 steel pi = 3.14159 # pi d = 3 / 100 # diameter (m) L = 10 / 100 # length (m) L_seg = L / seg # length of a segment (m) A = pi * d**2 / 4 # cross-sectional area (m) As = pi * d * L_seg # surface heat transfer area (m^2) heff = 5.8 # heat transfer coeff (W/(m^2*K)) keff = 28.6 # thermal conductivity in H13 steel (W/m-K) rho = 7760 # density of H13 steel (kg/m^3) cp = 460 # heat capacity of H13 steel (J/kg-K) Ts = 23 # temperature of the surroundings (°C) m = GEKKO() # create GEKKO model tf = 3000 nt = int(tf/30) + 1 dist = np.linspace(0,L,seg+2) m.time = np.linspace(0,tf,nt) T1 = m.MV(ub=T_melt) # temperature 1 (°C) T1.value = np.ones(nt) * 23 # start at room temperature T1.value[10:] = 80 # step at 300 sec T = [m.Var(23) for i in range(seg)] # temperature of the segments (°C) T2 = m.MV(ub=T_melt) # temperature 2 (°C) T2.value = np.ones(nt) * 23 # start at room temperature T2.value[50:] = 100 # step at 300 sec # Energy balance for the segments # accumulation = # (heat gained from upper segment) # - (heat lost to lower segment) # - (heat lost to surroundings) # Units check # kg/m^3 * m^2 * m * J/kg-K * K/sec = # W/m-K * m^2 * K / m # - W/m-K * m^2 * K / m # - W/m^2-K * m^2 * K # first segment m.Equation(rho*A*L_seg*cp*T[0].dt() == \ keff*A*(T1-T[0])/L_seg \ - keff*A*(T[0]-T[1])/L_seg \ - heff*As*(T[0]-Ts)) # middle segments m.Equations([rho*A*L_seg*cp*T[i].dt() == \ keff*A*(T[i-1]-T[i])/L_seg \ - keff*A*(T[i]-T[i+1])/L_seg \ - heff*As*(T[i]-Ts) for i in range(1,seg-1)]) # last segment m.Equation(rho*A*L_seg*cp*T[-1].dt() == \ keff*A*(T[-2]-T[-1])/L_seg \ - keff*A*(T[-1]-T2)/L_seg \ - heff*As*(T[-1]-Ts)) # simulation m.options.IMODE = 4 m.solve() # plot results plt.figure() tm = m.time / 60.0 plt.plot(tm,T1.value,'k-',linewidth=2,label=r'$T_{left}\,(^oC)$') plt.plot(tm,T[5].value,':',color='yellow',label=r'$T_{5}\,(^oC)$') plt.plot(tm,T[15].value,'--',color='red',label=r'$T_{15}\,(^oC)$') plt.plot(tm,T[25].value,'--',color='green',label=r'$T_{50}\,(^oC)$') plt.plot(tm,T[45].value,'-.',color='gray',label=r'$T_{85}\,(^oC)$') plt.plot(tm,T[95].value,'-',color='orange',label=r'$T_{95}\,(^oC)$') plt.plot(tm,T2.value,'b-',linewidth=2,label=r'$T_{right}\,(^oC)$') plt.ylabel(r'$T\,(^oC$)') plt.xlabel('Time (min)') plt.xlim([0,50]) plt.legend(loc=4) plt.savefig('heat.png') # create animation as heat.mp4 fig = plt.figure(figsize=(5,4)) fig.set_dpi(300) ax1 = fig.add_subplot(1,1,1) # store results in d d = np.empty((seg+2,len(m.time))) d[0] = np.array(T1.value) for i in range(seg): d[i+1] = np.array(T[i].value) d[-1] = np.array(T2.value) d = d.T k = 0 def animate(i): global k k = min(len(m.time)-1,k) ax1.clear() plt.plot(dist*100,d[k],color='red',label=r'Temperature ($^oC$)') plt.text(1,100,'Elapsed time '+str(round(m.time[k]/60,2))+' min') plt.grid(True) plt.ylim([20,110]) plt.xlim([0,L*100]) plt.ylabel(r'T ($^oC$)') plt.xlabel(r'Distance (cm)') plt.legend(loc=1) k += 1 anim = animation.FuncAnimation(fig,animate,frames=len(m.time),interval=20) # requires ffmpeg to save mp4 file # available from https://ffmpeg.zeranoe.com/builds/ # add ffmpeg.exe to path such as C:\ffmpeg\bin\ in # environment variables try: anim.save('heat.mp4',fps=10) except: print('requires ffmpeg to save mp4 file') plt.show() ``` ## SYMPY https://docs.sympy.org/latest/tutorial/calculus.html ```python from sympy import * x, y, z = symbols('x y z') init_printing(use_unicode=True) diff(cos(x), x) ``` ```python from numpy import linspace, zeros, asarray import matplotlib.pyplot as plt def ode_FE(f, U_0, dt, T): N_t = int(round(float(T)/dt)) # Ensure that any list/tuple returned from f_ is wrapped as array f_ = lambda u, t: asarray(f(u, t)) u = zeros((N_t+1, len(U_0))) t = linspace(0, N_t*dt, len(u)) u[0] = U_0 for n in range(N_t): u[n+1] = u[n] + dt*f_(u[n], t[n]) return u, t """Verify the implementation of the diffusion equation.""" from numpy import linspace, zeros, abs def rhs(u, t): N = len(u) - 1 rhs = zeros(N+1) rhs[0] = dsdt(t) for i in range(1, N): rhs[i] = (beta/dx**2)*(u[i+1] - 2*u[i] + u[i-1]) + \ f(x[i], t) rhs[N] = (beta/dx**2)*(2*u[N-1] + 2*dx*dudx(t) - 2*u[N]) + f(x[N], t) return rhs def u_exact(x, t): return (3*t + 2)*(x - L) def dudx(t): return (3*t + 2) def s(t): return u_exact(0, t) def dsdt(t): return 3*(-L) def f(x, t): return 3*(x-L) def verify_sympy_ForwardEuler(): import sympy as sp beta, x, t, dx, dt, L = sp.symbols('beta x t dx dt L') u = lambda x, t: (3*t + 2)*(x - L)**2 f = lambda x, t, beta, L: 3*(x-L)**2 - (3*t + 2)*2*beta s = lambda t: (3*t + 2)*L**2 N = 4 rhs = [None]*(N+1) rhs[0] = sp.diff(s(t), t) for i in range(1, N): rhs[i] = (beta/dx**2)*(u(x+dx,t) - 2*u(x,t) + u(x-dx,t)) + \ f(x, t, beta, L) rhs[N] = (beta/dx**2)*(u(x-dx,t) + 2*dx*(3*t+2) - 2*u(x,t) + u(x-dx,t)) + f(x, t, beta, L) for i in range(len(rhs)): rhs[i] = sp.simplify(sp.expand(rhs[i])).subs(x, i*dx) print(rhs[i]) lhs = (u(x, t+dt) - u(x,t))/dt # Forward Euler difference lhs = sp.simplify(sp.expand(lhs.subs(x, i*dx))) print(lhs) print(sp.simplify(lhs - rhs[i])) print('---') def test_diffusion_exact_linear(): global beta, dx, L, x # needed in rhs L = 1.5 beta = 0.5 N = 4 x = linspace(0, L, N+1) dx = x[1] - x[0] u = zeros(N+1) U_0 = zeros(N+1) U_0[0] = s(0) U_0[1:] = u_exact(x[1:], 0) dt = 0.1 print(dt) u, t = ode_FE(rhs, U_0, dt, T=1.2) tol = 1E-12 for i in range(0, u.shape[0]): diff = abs(u_exact(x, t[i]) - u[i,:]).max() assert diff < tol, 'diff=%.16g' % diff print('diff=%g at t=%g' % (diff, t[i])) if __name__ == '__main__': test_diffusion_exact_linear() verify_sympy_ForwardEuler() ``` ## Application: heat conduction in a rod Let us return to the case with heat conduction in a rod (120)-(123). Assume that the rod is 50 cm long and made of aluminum alloy 6082. The β parameter equals κ/(ϱc), where κ is the heat conduction coefficient, ϱ is the density, and c is the heat capacity. We can find proper values for these physical quantities in the case of aluminum alloy 6082: ϱ=2.7⋅103 kg/m3, κ=200WmK, c=900JKkg. This results in β=κ/(ϱc)=8.2⋅10−5 m2/s. Preliminary simulations show that we are close to a constant steady state temperature after 1 h, i.e., T=3600 s. The rhs function from the previous section can be reused, only the functions s, dsdt, g, and dudx must be changed (see file rod_FE.py): ```python """Temperature evolution in a rod, computed by a ForwardEuler method.""" from numpy import linspace, zeros, linspace import time def rhs(u, t): N = len(u) - 1 rhs = zeros(N+1) rhs[0] = dsdt(t) for i in range(1, N): rhs[i] = (beta/dx**2)*(u[i+1] - 2*u[i] + u[i-1]) + \ g(x[i], t) i = N rhs[i] = (beta/dx**2)*(2*u[i-1] + 2*dx*dudx(t) - 2*u[i]) + g(x[N], t) return rhs def dudx(t): return 0 def s(t): return 323 def dsdt(t): return 0 def g(x, t): return 0 L = 0.5 beta = 8.2E-5 N = 40 x = linspace(0, L, N+1) dx = x[1] - x[0] u = zeros(N+1) U_0 = zeros(N+1) U_0[0] = s(0) U_0[1:] = 283 dt = dx**2/(2*beta) #print('stability limit:', dt) #dt = 0.00034375 t0 = time.clock() u, t = ode_FE(rhs, U_0, dt, T=1*60*60) t1 = time.clock() #print('CPU time: %.1fs' % (t1 - t0)) # Make movie import os os.system('rm tmp_*.png') import matplotlib.pyplot as plt plt.ion() y = u[0,:] lines = plt.plot(x, y) plt.axis([x[0], x[-1], 273, s(0)+10]) plt.xlabel('x') plt.ylabel('u(x,t)') counter = 0 # Plot each of the first 100 frames, then increase speed by 10x change_speed = 100 for i in range(0, u.shape[0]): #print(t[i]) plot = True if i <= change_speed else i % 10 == 0 lines[0].set_ydata(u[i,:]) if i > change_speed: plt.legend(['t=%.0f 10x' % t[i]]) else: plt.legend(['t=%.0f' % t[i]]) plt.draw() if plot: plt.savefig('tmp_%04d.png' % counter) counter += 1 time.sleep(0.2) ``` ## Numerical Python http://people.bu.edu/andasari/courses/numericalpython/python.html ```python import numpy as np import matplotlib.pyplot as plt class beamWarming1: def __init__(self, N, tmax): self.N = N # number of nodes self.tmax = tmax self.xmin = 0 self.xmax = 1 self.dt = 0.009 # timestep self.v = 1 # velocity self.xc = 0.25 self.initializeDomain() self.initializeU() self.initializeParams() def initializeDomain(self): self.dx = (self.xmax - self.xmin)/self.N self.x = np.arange(self.xmin-self.dx, self.xmax+(2*self.dx), self.dx) def initializeU(self): u0 = np.exp(-200*(self.x-self.xc)**2) self.u = u0.copy() self.unp1 = u0.copy() def initializeParams(self): self.nsteps = round(self.tmax/self.dt) self.alpha1 = self.v*self.dt/(2*self.dx) self.alpha2 = self.v**2*self.dt**2/(2*self.dx**2) def solve_and_plot(self): tc = 0 for i in range(self.nsteps): plt.clf() # The Beam-Warming scheme, Eq. (18.25) for j in range(self.N+3): self.unp1[j] = self.u[j] - self.alpha1*(3*self.u[j] - 4*self.u[j-1] + self.u[j-2]) + \ self.alpha2*(self.u[j] - 2*self.u[j-1] + self.u[j-2]) self.u = self.unp1.copy() # Periodic boundary conditions self.u[0] = self.u[self.N+1] self.u[1] = self.u[self.N+2] uexact = np.exp(-200*(self.x-self.xc-self.v*tc)**2) plt.plot(self.x, uexact, 'r', label="Exact solution") plt.plot(self.x, self.u, 'bo-', label="Beam-Warming") plt.axis((self.xmin-0.15, self.xmax+0.15, -0.2, 1.4)) plt.grid(True) plt.xlabel("Distance (x)") plt.ylabel("u") plt.legend(loc=1, fontsize=12) plt.suptitle("Time = %1.3f" % (tc+self.dt)) plt.pause(0.01) tc += self.dt def main(): sim = beamWarming1(100, 1.5) sim.solve_and_plot() plt.show() if __name__ == "__main__": main() #N = 100 #tmax = 2.5 # maximum value of t ``` ```python import matplotlib.pyplot as plt import numpy as np def feval(funcName, *args): return eval(funcName)(*args) def RKF45(func, yinit, x_range, h): m = len(yinit) n = int((x_range[-1] - x_range[0])/h) x = x_range[0] y = yinit xsol = np.empty(0) xsol = np.append(xsol, x) ysol = np.empty(0) ysol = np.append(ysol, y) for i in range(n): k1 = feval(func, x, y) yp2 = y + k1*(h/5) k2 = feval(func, x+h/5, yp2) yp3 = y + k1*(3*h/40) + k2*(9*h/40) k3 = feval(func, x+(3*h/10), yp3) yp4 = y + k1*(3*h/10) - k2*(9*h/10) + k3*(6*h/5) k4 = feval(func, x+(3*h/5), yp4) yp5 = y - k1*(11*h/54) + k2*(5*h/2) - k3*(70*h/27) + k4*(35*h/27) k5 = feval(func, x+h, yp5) yp6 = y + k1*(1631*h/55296) + k2*(175*h/512) + k3*(575*h/13824) + k4*(44275*h/110592) + k5*(253*h/4096) k6 = feval(func, x+(7*h/8), yp6) for j in range(m): y[j] = y[j] + h*(37*k1[j]/378 + 250*k3[j]/621 + 125*k4[j]/594 + 512*k6[j]/1771) x = x + h xsol = np.append(xsol, x) for r in range(len(y)): ysol = np.append(ysol, y[r]) return [xsol, ysol] def myFunc(x, y): dy = np.zeros((len(y))) dy[0] = np.exp(-2*x) - 2*y[0] return dy # ----------------------- h = 0.2 x = np.array([0.0, 2.0]) yinit = np.array([1.0/10]) [ts, ys] = RKF45('myFunc', yinit, x, h) dt = int((x[-1]-x[0])/h) t = [x[0]+i*h for i in range(dt+1)] yexact = [] for i in range(dt+1): ye = (1.0 / 10) * np.exp(-2 * t[i]) + t[i] * np.exp(-2 * t[i]) yexact.append(ye) y_diff = ys - yexact print("max diff =", np.max(abs(y_diff))) plt.plot(ts, ys, 'rs') plt.plot(t, yexact, 'b') plt.xlim(x[0], x[1]) plt.legend(["RKF45", "Exact solution"], loc=1) plt.xlabel('x', fontsize=17) plt.ylabel('y', fontsize=17) plt.tight_layout() plt.show() # Uncomment the following to print the figure: #plt.savefig('Fig_ex2_RK4_h0p1.png', dpi=600) ``` ```python import matplotlib.pyplot as plt import numpy as np def feval(funcName, *args): return eval(funcName)(*args) def RK4thOrder(func, yinit, x_range, h): m = len(yinit) n = int((x_range[-1] - x_range[0])/h) x = x_range[0] y = yinit xsol = np.empty(0) xsol = np.append(xsol, x) ysol = np.empty(0) ysol = np.append(ysol, y) for i in range(n): k1 = feval(func, x, y) yp2 = y + k1*(h/2) k2 = feval(func, x+h/2, yp2) yp3 = y + k2*(h/2) k3 = feval(func, x+h/2, yp3) yp4 = y + k3*h k4 = feval(func, x+h, yp4) for j in range(m): y[j] = y[j] + (h/6)*(k1[j] + 2*k2[j] + 2*k3[j] + k4[j]) x = x + h xsol = np.append(xsol, x) for r in range(len(y)): ysol = np.append(ysol, y[r]) return [xsol, ysol] def myFunc(x, y): dy = np.zeros((len(y))) dy[0] = np.exp(-2*x) - 2*y[0] return dy # ----------------------- h = 0.2 x = np.array([0.0, 2.0]) yinit = np.array([1.0/10]) [ts, ys] = RK4thOrder('myFunc', yinit, x, h) dt = int((x[-1]-x[0])/h) t = [x[0]+i*h for i in range(dt+1)] yexact = [] for i in range(dt+1): ye = (1.0/10)*np.exp(-2*t[i]) + t[i]*np.exp(-2*t[i]) yexact.append(ye) diff = ys - yexact print("Maximum difference =", np.max(abs(diff))) plt.plot(ts, ys, 'r') plt.plot(t, yexact, 'b') plt.xlim(x[0], x[1]) plt.legend(["4th Order RK", "Exact solution"], loc=1) plt.xlabel('x', fontsize=17) plt.ylabel('y', fontsize=17) plt.tight_layout() plt.show() # Uncomment the following to print the figure: #plt.savefig('Fig_ex2_RK4_h0p1.png', dpi=600) ``` ```python import numpy as np import matplotlib.pyplot as plt from mpl_toolkits.mplot3d import Axes3D from matplotlib import cm from IPython.display import HTML class WaveEquationFD: def __init__(self, N, D, Mx, My): self.N = N self.D = D self.Mx = Mx self.My = My self.tend = 6 self.xmin = 0 self.xmax = 2 self.ymin = 0 self.ymax = 2 self.initialization() self.eqnApprox() def initialization(self): self.dx = (self.xmax - self.xmin)/self.Mx self.dy = (self.ymax - self.ymin)/self.My self.x = np.arange(self.xmin, self.xmax+self.dx, self.dx) self.y = np.arange(self.ymin, self.ymax+self.dy, self.dy) #----- Initial condition -----# self.u0 = lambda r, s: 0.1*np.sin(np.pi*r)*np.sin(np.pi*s/2) #----- Initial velocity -----# self.v0 = lambda a, b: 0 #----- Boundary conditions -----# self.bxyt = lambda left, right, time: 0 self.dt = (self.tend - 0)/self.N self.t = np.arange(0, self.tend+self.dt/2, self.dt) # Assertion for the condition of r < 1, for stability r = 4*self.D*self.dt**2/(self.dx**2+self.dy**2); assert r < 1, "r is bigger than 1!" def eqnApprox(self): #----- Approximation equation properties -----# self.rx = self.D*self.dt**2/self.dx**2 self.ry = self.D*self.dt**2/self.dy**2 self.rxy1 = 1 - self.rx - self.ry self.rxy2 = self.rxy1*2 #----- Initialization matrix u for solution -----# self.u = np.zeros((self.Mx+1, self.My+1)) self.ut = np.zeros((self.Mx+1, self.My+1)) self.u_1 = self.u.copy() #----- Fills initial condition and initial velocity -----# for j in range(1, self.Mx): for i in range(1, self.My): self.u[i,j] = self.u0(self.x[i], self.y[j]) self.ut[i,j] = self.v0(self.x[i], self.y[j]) def solve_and_animate(self): u_2 = np.zeros((self.Mx+1, self.My+1)) xx, yy = np.meshgrid(self.x, self.y) fig = plt.figure() ax = fig.add_subplot(111, projection='3d') wframe = None k = 0 nsteps = self.N while k < nsteps: if wframe: ax.collections.remove(wframe) self.t = k*self.dt #----- Fills in boundary condition along y-axis (vertical, columns 0 and Mx) -----# for i in range(self.My+1): self.u[i, 0] = self.bxyt(self.x[0], self.y[i], self.t) self.u[i, self.Mx] = self.bxyt(self.x[self.Mx], self.y[i], self.t) for j in range(self.Mx+1): self.u[0, j] = self.bxyt(self.x[j], self.y[0], self.t) self.u[self.My, j] = self.bxyt(self.x[j], self.y[self.My], self.t) if k == 0: for j in range(1, self.My): for i in range(1, self.Mx): self.u[i,j] = 0.5*(self.rx*(self.u_1[i-1,j] + self.u_1[i+1,j])) \ + 0.5*(self.ry*(self.u_1[i,j-1] + self.u_1[i,j+1])) \ + self.rxy1*self.u[i,j] + self.dt*self.ut[i,j] else: for j in range(1, self.My): for i in range(1, self.Mx): self.u[i,j] = self.rx*(self.u_1[i-1,j] + self.u_1[i+1,j]) \ + self.ry*(self.u_1[i,j-1] + self.u_1[i,j+1]) \ + self.rxy2*self.u[i,j] - u_2[i,j] u_2 = self.u_1.copy() self.u_1 = self.u.copy() wframe = ax.plot_surface(xx, yy, self.u, cmap=cm.coolwarm, linewidth=2, antialiased=False) ax.set_xlim3d(0, 2.0) ax.set_ylim3d(0, 2.0) ax.set_zlim3d(-1.5, 1.5) ax.set_xticks([0, 0.5, 1.0, 1.5, 2.0]) ax.set_yticks([0, 0.5, 1.0, 1.5, 2.0]) ax.set_xlabel("x") ax.set_ylabel("y") ax.set_zlabel("U") plt.pause(0.01) k += 0.5 def main(): simulator = WaveEquationFD(200, 0.25, 50, 50) simulator.solve_and_animate() plt.show() if __name__ == "__main__": main() simulator=WaveEquationFD(200, 0.25, 50, 50) ani=simulator.solve_and_animate() ani.save(r'movie11,mp4',fps=10) ``` ```python """ 2D wave equation via FFT u_tt = u_xx + u_yy on [-1, 1]x[-1, 1], t > 0 and Dirichlet BC u=0 """ import numpy as np from scipy import interpolate import matplotlib.pyplot as plt from mpl_toolkits.mplot3d import Axes3D from matplotlib import cm class WaveEquation: def __init__(self, N): self.N = N self.x0 = -1.0 self.xf = 1.0 self.y0 = -1.0 self.yf = 1.0 self.initialization() self.initCond() def initialization(self): k = np.arange(self.N + 1) self.x = np.cos(k*np.pi/self.N) self.y = self.x.copy() self.xx, self.yy = np.meshgrid(self.x, self.y) self.dt = 6/self.N**2 self.plotgap = round((1/3)/self.dt) self.dt = (1/3)/self.plotgap def initCond(self): self.vv = np.exp(-40*((self.xx-0.4)**2 + self.yy**2)) self.vvold = self.vv.copy() def solve_and_animate(self): fig = plt.figure() ax = fig.add_subplot(111, projection='3d') tc = 0 nstep = round(3*self.plotgap+1) wframe = None while tc < nstep: if wframe: ax.collections.remove(wframe) xxx = np.arange(self.x0, self.xf+1/16, 1/16) yyy = np.arange(self.y0, self.yf+1/16, 1/16) vvv = interpolate.interp2d(self.x, self.y, self.vv, kind='cubic') Z = vvv(xxx, yyy) xxf, yyf = np.meshgrid(np.arange(self.x0,self.xf+1/16,1/16), np.arange(self.y0,self.yf+1/16,1/16)) wframe = ax.plot_surface(xxf, yyf, Z, cmap=cm.coolwarm, linewidth=0, antialiased=False) ax.set_xlim3d(self.x0, self.xf) ax.set_ylim3d(self.y0, self.yf) ax.set_zlim3d(-0.15, 1) ax.set_xlabel("x") ax.set_ylabel("y") ax.set_zlabel("U") ax.set_xticks([-1.0, -0.5, 0.0, 0.5, 1.0]) ax.set_yticks([-1.0, -0.5, 0.0, 0.5, 1.0]) fig.suptitle("Time = %1.3f" % (tc/(3*self.plotgap-1)-self.dt)) #plt.tight_layout() ax.view_init(elev=30., azim=-110) plt.pause(0.01) uxx = np.zeros((self.N+1, self.N+1)) uyy = np.zeros((self.N+1, self.N+1)) ii = np.arange(1, self.N) for i in range(1, self.N): v = self.vv[i,:] V = np.hstack((v, np.flipud(v[ii]))) U = np.fft.fft(V) U = U.real r1 = np.arange(self.N) r2 = 1j*np.hstack((r1, 0, -r1[:0:-1]))*U W1 = np.fft.ifft(r2) W1 = W1.real s1 = np.arange(self.N+1) s2 = np.hstack((s1, -s1[self.N-1:0:-1])) s3 = -s2**2*U W2 = np.fft.ifft(s3) W2 = W2.real uxx[i,ii] = W2[ii]/(1-self.x[ii]**2) - self.x[ii]*W1[ii]/(1-self.x[ii]**2)**(3/2) for j in range(1, self.N): v = self.vv[:,j] V = np.hstack((v, np.flipud(v[ii]))) U = np.fft.fft(V) U = U.real r1 = np.arange(self.N) r2 = 1j*np.hstack((r1, 0, -r1[:0:-1]))*U W1 = np.fft.ifft(r2) W1 = W1.real s1 = np.arange(self.N+1) s2 = np.hstack((s1, -s1[self.N-1:0:-1])) s3 = -s2**2*U W2 = np.fft.ifft(s3) W2 = W2.real uyy[ii,j] = W2[ii]/(1-self.y[ii]**2) - self.y[ii]*W1[ii]/(1-self.y[ii]**2)**(3/2) vvnew = 2*self.vv - self.vvold + self.dt**2*(uxx+uyy) self.vvold = self.vv.copy() self.vv = vvnew.copy() tc += 1 def main(): simulator = WaveEquation(30) simulator.solve_and_animate() plt.show() if __name__ == "__main__": main() ``` ```python # Animated surface plot import numpy as np from scipy import sparse import matplotlib.pyplot as plt from mpl_toolkits.mplot3d import Axes3D from matplotlib import cm class ADImethod: def __init__(self, M, maxt, D): self.M = M self.x0 = 0 self.xf = 1 self.y0 = 0 self.yf = 1 self.maxt = maxt self.dt = 0.01 self.D = D self.h = 1/self.M self.r = self.D*self.dt/(2*self.h**2) self.generateGrid() self.lhsMatrixA() self.rhsMatrixA() def generateGrid(self): self.X, self.Y = np.meshgrid(np.linspace(self.x0, self.xf, self.M), np.linspace(self.y0, self.yf,self. M)) ic01 = np.logical_and(self.X >= 1/4, self.X <= 3/4) ic02 = np.logical_and(self.Y >= 1/4, self.Y <= 3/4) ic0 = np.multiply(ic01, ic02) self.U = ic0*1 def lhsMatrixA(self): maindiag = (1+2*self.r)*np.ones((1, self.M)) offdiag = -self.r*np.ones((1, self.M-1)) a = maindiag.shape[1] diagonals = [maindiag, offdiag, offdiag] Lx = sparse.diags(diagonals, [0, -1, 1], shape=(a, a)).toarray() Ix = sparse.identity(self.M).toarray() self.A = sparse.kron(Ix, Lx).toarray() pos1 = np.arange(0,self.M**2,self.M) for i in range(len(pos1)): self.A[pos1[i], pos1[i]] = 1 + self.r pos2 = np.arange(self.M-1, self.M**2, self.M) for j in range(len(pos2)): self.A[pos2[j], pos2[j]] = 1 + self.r def rhsMatrixA(self): maindiag = (1-self.r)*np.ones((1, self.M)) offdiag = self.r*np.ones((1, self.M-1)) a = maindiag.shape[1] diagonals = [maindiag, offdiag, offdiag] Rx = sparse.diags(diagonals, [0, -1, 1], shape=(a, a)).toarray() Ix = sparse.identity(self.M).toarray() self.A_rhs = sparse.kron(Rx, Ix).toarray() pos3 = np.arange(self.M, self.M**2-self.M) for k in range(len(pos3)): self.A_rhs[pos3[k], pos3[k]] = 1 - 2*self.r def solve_and_animate(self): fig = plt.figure() ax = fig.gca(projection='3d') ax.set_zlim(0, 1) tc = 0 nstep = round(self.maxt/self.h) wframe = None while tc < nstep+1: if wframe: ax.collections.remove(wframe) b1 = np.flipud(self.U).reshape(self.M**2, 1) sol = np.linalg.solve(self.A, np.matmul(self.A_rhs, b1)) self.U = np.flipud(sol).reshape(self.M, self.M) b2 = np.flipud(self.U).reshape(self.M**2, 1) sol = np.linalg.solve(self.A, np.matmul(self.A_rhs, b2)) self.U = np.flipud(sol).reshape(self.M, self.M) wframe = ax.plot_surface(self.X, self.Y, self.U, cmap=cm.coolwarm, linewidth=0, antialiased=False) fig.suptitle("Time = %s" % tc) plt.pause(0.001) tc += 1 def main(): simulator = ADImethod(50, 2.5, 0.01) simulator.solve_and_animate() plt.show() if __name__ == "__main__": main() ``` http://people.bu.edu/andasari/courses/numericalpython/python.html ```python def forwardDifference(f, x, h): return (f(x+h) - f(x))/h def backwardDifference(f, x, h): return (f(x) - f(x-h))/h def centralDifference(f, x, h): return (f(x+h) - f(x-h))/(2*h) def myFunc(x): return 2*x**3 + 4*x**2 - 5*x x = 1 h = 0.1 dydt_f = forwardDifference(myFunc, x, h) dydt_b = backwardDifference(myFunc, x, h) dydt_c = centralDifference(myFunc, x, h) exact = 6*x**2 + 8*x - 5 print("Forward difference =", dydt_f) print("Backward difference =", dydt_b) print("Central difference =", dydt_c) print("Exact value =", exact) ``` ```python def forwardDifference(f, x, h): return (f(x+h+h) - 2*f(x+h) + f(x))/h**2 def backwardDifference(f, x, h): return (f(x) - 2*f(x-h) + f(x-h-h))/h**2 def centralDifference(f, x, h): return (f(x+h) - 2*f(x) + f(x-h))/h**2 def myFunc(x): return 2*x**3 + 4*x**2 - 5*x x = 1 h = 0.1 dydt_f = forwardDifference(myFunc, x, h) dydt_b = backwardDifference(myFunc, x, h) dydt_c = centralDifference(myFunc, x, h) exact = 12*x + 8 print("Forward difference =", dydt_f) print("Backward difference =", dydt_b) print("Central difference =", dydt_c) print("Exact value =", exact) ``` ```python import numpy as np def forwardDiff(f, x, h, *fparams): return (f(x+h, *fparams) - f(x, *fparams))/h def backwardDiff(f, x, h, *fparams): return (f(x, *fparams) - f(x-h, *fparams))/h def centralDiff(f, x, h, *fparams): return (f(x+h, *fparams) - f(x-h, *fparams))/(2*h) def y(t, mu, k): return mu*t + 1.3*k*t**2 def G(x, t, A, r, phi): return A*np.exp(-r*t**2)*np.sin(phi*x) dydtf = forwardDiff(y, 0.1, 1e-9, 3, 9.81) # f=y, x=0.1, h=1e-9, # params[0]=mu=3, params[1]=k=9.81 dydtb = backwardDiff(y, 0.1, 1e-9, 3, 9.81) dydtc = centralDiff(y, 0.1, 1e-9, 3, 9.81) print("Forward difference dydt =", dydtf) print("Backward difference dydt =", dydtb) print("Central difference dydt =", dydtc) print("--------------------") dGdtf = forwardDiff(G, 0.5, 1e-9, 1, 1, 0.6, 100) # f=G, x=0.5, h=1e-9, # params[0]=t=0, # params[1]=A=1, # params[2]=r=0.6, # params[3]=phi=100 dGdtb = backwardDiff(G, 0.5, 1e-9, 1, 1, 0.6, 100) dGdtc = centralDiff(G, 0.5, 1e-9, 1, 1, 0.6, 100) print("Forward difference dGdt =", dGdtf) print("Backward difference dGdt =", dGdtb) print("Central difference dGdt =", dGdtc) print("--------------------") ``` ```python import numpy as np import math def feval(funcName, *args): ''' This function is similar to "feval" in Matlab. Example: feval('cos', pi) = -1. ''' return eval(funcName)(*args) a = feval('np.cos', np.pi) print("Cos(pi) =", a) b = feval('math.log', 1000, 10) print("Log10(1000) =", round(b)) def myFunc(x): return x**2 c1 = 9.0 c = feval('myFunc', c1) print("If x =", str(c1), "then x^2 =", c) ``` ```python import matplotlib.pyplot as plt import math def feval(funcName, *args): return eval(funcName)(*args) def mult(vector, scalar): newvector = [0]*len(vector) for i in range(len(vector)): newvector[i] = vector[i]*scalar return newvector def backwardEuler(func, yinit, x_range, h): numOfODEs = len(yinit) sub_intervals = int((x_range[-1] - x_range[0])/h) x = x_range[0] y = yinit xsol = [x] ysol = [y[0]] for i in range(sub_intervals): yprime = feval(func, x+h, y) yp = mult(yprime, (1/(1+h))) for j in range(numOfODEs): y[j] = y[j] + h*yp[j] x += h xsol.append(x) for r in range(len(y)): ysol.append(y[r]) # Saves all new y's return [xsol, ysol] def myFunc(x, y): ''' We define our ODEs in this function. ''' dy = [0] * len(y) dy[0] = 3 * (1 + x) - y[0] return dy h = 0.2 x = [1.0, 2.0] yinit = [4.0] [ts, ys] = backwardEuler('myFunc', yinit, x, h) # Calculates the exact solution, for comparison dt = int((x[-1] - x[0]) / h) t = [x[0]+i*h for i in range(dt+1)] yexact = [] for i in range(dt+1): ye = 3 * t[i] + math.exp(1 - t[i]) yexact.append(ye) plt.plot(ts, ys, 'r') plt.plot(t, yexact, 'b') plt.xlim(x[0], x[1]) plt.legend(["Backward Euler method", "Exact solution"], loc=2) plt.xlabel('x', fontsize=17) plt.ylabel('y', fontsize=17) plt.tight_layout() plt.show() # Uncomment the following to print the figure: #plt.savefig('Fig1.png', dpi=600) ``` ```python import matplotlib.pyplot as plt import numpy as np def feval(funcName, *args): return eval(funcName)(*args) def RK2A(func, yinit, x_range, h): m = len(yinit) n = int((x_range[-1] - x_range[0])/h) x = x_range[0] y = yinit xsol = np.empty(0) xsol = np.append(xsol, x) ysol = np.empty(0) ysol = np.append(ysol, y) for i in range(n): k1 = feval(func, x, y) ypredictor = y + k1 * h k2 = feval(func, x+h, ypredictor) for j in range(m): y[j] = y[j] + (h/2)*(k1[j] + k2[j]) x = x + h xsol = np.append(xsol, x) for r in range(len(y)): ysol = np.append(ysol, y[r]) return [xsol, ysol] def myFunc(x, y): dy = np.zeros((len(y))) dy[0] = np.exp(-2 * x) - 2 * y[0] return dy # ----------------------- h = 0.2 x = np.array([0, 2]) yinit = np.array([1.0/10]) [ts, ys] = RK2A('myFunc', yinit, x, h) dt = int((x[-1]-x[0])/h) t = [x[0]+i*h for i in range(dt+1)] yexact = [] for i in range(dt+1): ye = (1.0/10)*np.exp(-2*t[i]) + t[i]*np.exp(-2*t[i]) yexact.append(ye) plt.figure(figsize=(12,6)) plt.plot(ts, ys, 'r') plt.plot(t, yexact, 'b') plt.xlim(x[0], x[1]) plt.legend(["2nd Order RK, A=1/2 ", "Exact solution"], loc=1) plt.xlabel('x', fontsize=17) plt.ylabel('y', fontsize=17) plt.tight_layout() plt.show() # Uncomment the following to print the figure: #plt.savefig('Fig2.png', dpi=600) ``` ```python import numpy as np from matplotlib import pyplot as pl from matplotlib import animation from scipy.fftpack import fft,ifft from IPython.display import HTML class Schrodinger(object): """ Class which implements a numerical solution of the time-dependent Schrodinger equation for an arbitrary potential """ def __init__(self, x, psi_x0, V_x, k0 = None, hbar=1, m=1, t0=0.0): # Validation of array inputs self.x, psi_x0, self.V_x = map(np.asarray, (x, psi_x0, V_x)) N = self.x.size assert self.x.shape == (N,) assert psi_x0.shape == (N,) assert self.V_x.shape == (N,) # Set internal parameters self.hbar = hbar self.m = m self.t = t0 self.dt_ = None self.N = len(x) self.dx = self.x[1] - self.x[0] self.dk = 2 * np.pi / (self.N * self.dx) # set momentum scale if k0 == None: self.k0 = -0.5 * self.N * self.dk else: self.k0 = k0 self.k = self.k0 + self.dk * np.arange(self.N) self.psi_x = psi_x0 self.compute_k_from_x() # variables which hold steps in evolution of the self.x_evolve_half = None self.x_evolve = None self.k_evolve = None # attributes used for dynamic plotting self.psi_x_line = None self.psi_k_line = None self.V_x_line = None def _set_psi_x(self, psi_x): self.psi_mod_x = (psi_x * np.exp(-1j * self.k[0] * self.x) * self.dx / np.sqrt(2 * np.pi)) def _get_psi_x(self): return (self.psi_mod_x * np.exp(1j * self.k[0] * self.x) * np.sqrt(2 * np.pi) / self.dx) def _set_psi_k(self, psi_k): self.psi_mod_k = psi_k * np.exp(1j * self.x[0] * self.dk * np.arange(self.N)) def _get_psi_k(self): return self.psi_mod_k * np.exp(-1j * self.x[0] * self.dk * np.arange(self.N)) def _get_dt(self): return self.dt_ def _set_dt(self, dt): if dt != self.dt_: self.dt_ = dt self.x_evolve_half = np.exp(-0.5 * 1j * self.V_x / self.hbar * dt ) self.x_evolve = self.x_evolve_half * self.x_evolve_half self.k_evolve = np.exp(-0.5 * 1j * self.hbar / self.m * (self.k * self.k) * dt) psi_x = property(_get_psi_x, _set_psi_x) psi_k = property(_get_psi_k, _set_psi_k) dt = property(_get_dt, _set_dt) def compute_k_from_x(self): self.psi_mod_k = fft(self.psi_mod_x) def compute_x_from_k(self): self.psi_mod_x = ifft(self.psi_mod_k) def time_step(self, dt, Nsteps = 1): self.dt = dt if Nsteps > 0: self.psi_mod_x *= self.x_evolve_half for i in range(Nsteps - 1): self.compute_k_from_x() self.psi_mod_k *= self.k_evolve self.compute_x_from_k() self.psi_mod_x *= self.x_evolve self.compute_k_from_x() self.psi_mod_k *= self.k_evolve self.compute_x_from_k() self.psi_mod_x *= self.x_evolve_half self.compute_k_from_x() self.t += dt * Nsteps ###################################################################### # Helper functions for gaussian wave-packets def gauss_x(x, a, x0, k0): """ a gaussian wave packet of width a, centered at x0, with momentum k0 """ return ((a * np.sqrt(np.pi)) ** (-0.5) * np.exp(-0.5 * ((x - x0) * 1. / a) ** 2 + 1j * x * k0)) def gauss_k(k,a,x0,k0): """ analytical fourier transform of gauss_x(x), above """ return ((a / np.sqrt(np.pi))**0.5 * np.exp(-0.5 * (a * (k - k0)) ** 2 - 1j * (k - k0) * x0)) ###################################################################### # Utility functions for running the animation def theta(x): """ theta function : returns 0 if x<=0, and 1 if x>0 """ x = np.asarray(x) y = np.zeros(x.shape) y[x > 0] = 1.0 return y def square_barrier(x, width, height): return height * (theta(x) - theta(x - width)) ###################################################################### # Create the animation # specify time steps and duration dt = 0.01 N_steps = 50 t_max = 120 frames = int(t_max / float(N_steps * dt)) # specify constants hbar = 1.0 # planck's constant m = 1.9 # particle mass # specify range in x coordinate N = 2 ** 11 dx = 0.1 x = dx * (np.arange(N) - 0.5 * N) # specify potential V0 = 1.5 L = hbar / np.sqrt(2 * m * V0) a = 3 * L x0 = -60 * L V_x = square_barrier(x, a, V0) V_x[x < -98] = 1E6 V_x[x > 98] = 1E6 # specify initial momentum and quantities derived from it p0 = np.sqrt(2 * m * 0.2 * V0) dp2 = p0 * p0 * 1./80 d = hbar / np.sqrt(2 * dp2) k0 = p0 / hbar v0 = p0 / m psi_x0 = gauss_x(x, d, x0, k0) # define the Schrodinger object which performs the calculations S = Schrodinger(x=x, psi_x0=psi_x0, V_x=V_x, hbar=hbar, m=m, k0=-28) ###################################################################### # Set up plot fig = pl.figure() # plotting limits xlim = (-100, 100) klim = (-5, 5) # top axes show the x-space data ymin = 0 ymax = V0 ax1 = fig.add_subplot(211, xlim=xlim, ylim=(ymin - 0.2 * (ymax - ymin), ymax + 0.2 * (ymax - ymin))) psi_x_line, = ax1.plot([], [], c='r', label=r'$|\psi(x)|$') V_x_line, = ax1.plot([], [], c='k', label=r'$V(x)$') center_line = ax1.axvline(0, c='k', ls=':', label = r"$x_0 + v_0t$") title = ax1.set_title("") ax1.legend(prop=dict(size=12)) ax1.set_xlabel('$x$') ax1.set_ylabel(r'$|\psi(x)|$') # bottom axes show the k-space data ymin = abs(S.psi_k).min() ymax = abs(S.psi_k).max() ax2 = fig.add_subplot(212, xlim=klim, ylim=(ymin - 0.2 * (ymax - ymin), ymax + 0.2 * (ymax - ymin))) psi_k_line, = ax2.plot([], [], c='r', label=r'$|\psi(k)|$') p0_line1 = ax2.axvline(-p0 / hbar, c='k', ls=':', label=r'$\pm p_0$') p0_line2 = ax2.axvline(p0 / hbar, c='k', ls=':') mV_line = ax2.axvline(np.sqrt(2 * V0) / hbar, c='k', ls='--', label=r'$\sqrt{2mV_0}$') ax2.legend(prop=dict(size=12)) ax2.set_xlabel('$k$') ax2.set_ylabel(r'$|\psi(k)|$') V_x_line.set_data(S.x, S.V_x) ###################################################################### # Animate plot def init(): psi_x_line.set_data([], []) V_x_line.set_data([], []) center_line.set_data([], []) psi_k_line.set_data([], []) title.set_text("") return (psi_x_line, V_x_line, center_line, psi_k_line, title) def animate(i): S.time_step(dt, N_steps) psi_x_line.set_data(S.x, 4 * abs(S.psi_x)) V_x_line.set_data(S.x, S.V_x) center_line.set_data(2 * [x0 + S.t * p0 / m], [0, 1]) psi_k_line.set_data(S.k, abs(S.psi_k)) title.set_text("t = %.2f" % S.t) return (psi_x_line, V_x_line, center_line, psi_k_line, title) anim = animation.FuncAnimation(fig, animate, init_func=init, frames=frames, interval=30, blit=True) anim.save('schrodinger_barrier.mp4', fps=15, extra_args=['-vcodec', 'libx264']) pl.show() HTML(anim.to_jshtml()) ``` ```python # Infinite potential well wavefunction import matplotlib.pyplot as plt import numpy as np plt.style.use('fivethirtyeight') #Constants h = 6.626e-34 m = 9.11e-31 #Values for L and x x_list = np.linspace(0,1,100) L = 1 def psi(n,L,x): return np.sqrt(2/L)*np.sin(n*np.pi*x/L) def psi_2(n,L,x): return np.square(psi(n,L,x)) plt.figure(figsize=(15,10)) plt.suptitle("Wave Functions", fontsize=18) for n in range(1,4): #Empty lists for energy and psi wave psi_2_list = [] psi_list = [] for x in x_list: psi_2_list.append(psi_2(n,L,x)) psi_list.append(psi(n,L,x)) plt.subplot(3,2,2*n-1) plt.plot(x_list, psi_list) plt.xlabel("L", fontsize=13) plt.ylabel("Ψ", fontsize=13) plt.xticks(np.arange(0, 1, step=0.5)) plt.title("n="+str(n), fontsize=16) plt.grid() plt.subplot(3,2,2*n) plt.plot(x_list, psi_2_list) plt.xlabel("L", fontsize=13) plt.ylabel("Ψ*Ψ", fontsize=13) plt.xticks(np.arange(0, 1, step=0.5)) plt.title("n="+str(n), fontsize=16) plt.tight_layout(rect=[0, 0.03, 1, 0.95]) ``` ```python # Schrodinger Equation Solver import numpy as np from matplotlib import pyplot as pl from matplotlib import animation from scipy.fftpack import fft,ifft plt.style.use('fivethirtyeight') class Schrodinger(object): """ Class which implements a numerical solution of the time-dependent Schrodinger equation for an arbitrary potential """ def __init__(self, x, psi_x0, V_x, k0 = None, hbar=1, m=1, t0=0.0): """ Parameters ---------- x : array_like, float length-N array of evenly spaced spatial coordinates psi_x0 : array_like, complex length-N array of the initial wave function at time t0 V_x : array_like, float length-N array giving the potential at each x k0 : float the minimum value of k. Note that, because of the workings of the fast fourier transform, the momentum wave-number will be defined in the range k0 < k < 2*pi / dx where dx = x[1]-x[0]. If you expect nonzero momentum outside this range, you must modify the inputs accordingly. If not specified, k0 will be calculated such that the range is [-k0,k0] hbar : float value of planck's constant (default = 1) m : float particle mass (default = 1) t0 : float initial tile (default = 0) """ # Validation of array inputs self.x, psi_x0, self.V_x = map(np.asarray, (x, psi_x0, V_x)) N = self.x.size assert self.x.shape == (N,) assert psi_x0.shape == (N,) assert self.V_x.shape == (N,) # Set internal parameters self.hbar = hbar self.m = m self.t = t0 self.dt_ = None self.N = len(x) self.dx = self.x[1] - self.x[0] self.dk = 2 * np.pi / (self.N * self.dx) # set momentum scale if k0 == None: self.k0 = -0.5 * self.N * self.dk else: self.k0 = k0 self.k = self.k0 + self.dk * np.arange(self.N) self.psi_x = psi_x0 self.compute_k_from_x() # variables which hold steps in evolution of the self.x_evolve_half = None self.x_evolve = None self.k_evolve = None # attributes used for dynamic plotting self.psi_x_line = None self.psi_k_line = None self.V_x_line = None def _set_psi_x(self, psi_x): self.psi_mod_x = (psi_x * np.exp(-1j * self.k[0] * self.x) * self.dx / np.sqrt(2 * np.pi)) def _get_psi_x(self): return (self.psi_mod_x * np.exp(1j * self.k[0] * self.x) * np.sqrt(2 * np.pi) / self.dx) def _set_psi_k(self, psi_k): self.psi_mod_k = psi_k * np.exp(1j * self.x[0] * self.dk * np.arange(self.N)) def _get_psi_k(self): return self.psi_mod_k * np.exp(-1j * self.x[0] * self.dk * np.arange(self.N)) def _get_dt(self): return self.dt_ def _set_dt(self, dt): if dt != self.dt_: self.dt_ = dt self.x_evolve_half = np.exp(-0.5 * 1j * self.V_x / self.hbar * dt ) self.x_evolve = self.x_evolve_half * self.x_evolve_half self.k_evolve = np.exp(-0.5 * 1j * self.hbar / self.m * (self.k * self.k) * dt) psi_x = property(_get_psi_x, _set_psi_x) psi_k = property(_get_psi_k, _set_psi_k) dt = property(_get_dt, _set_dt) def compute_k_from_x(self): self.psi_mod_k = fft(self.psi_mod_x) def compute_x_from_k(self): self.psi_mod_x = ifft(self.psi_mod_k) def time_step(self, dt, Nsteps = 1): """ Perform a series of time-steps via the time-dependent Schrodinger Equation. Parameters ---------- dt : float the small time interval over which to integrate Nsteps : float, optional the number of intervals to compute. The total change in time at the end of this method will be dt * Nsteps. default is N = 1 """ self.dt = dt if Nsteps > 0: self.psi_mod_x *= self.x_evolve_half for i in range(Nsteps - 1): self.compute_k_from_x() self.psi_mod_k *= self.k_evolve self.compute_x_from_k() self.psi_mod_x *= self.x_evolve self.compute_k_from_x() self.psi_mod_k *= self.k_evolve self.compute_x_from_k() self.psi_mod_x *= self.x_evolve_half self.compute_k_from_x() self.t += dt * Nsteps ###################################################################### # Helper functions for gaussian wave-packets def gauss_x(x, a, x0, k0): """ a gaussian wave packet of width a, centered at x0, with momentum k0 """ return ((a * np.sqrt(np.pi)) ** (-0.5) * np.exp(-0.5 * ((x - x0) * 1. / a) ** 2 + 1j * x * k0)) def gauss_k(k,a,x0,k0): """ analytical fourier transform of gauss_x(x), above """ return ((a / np.sqrt(np.pi))**0.5 * np.exp(-0.5 * (a * (k - k0)) ** 2 - 1j * (k - k0) * x0)) ###################################################################### # Utility functions for running the animation def theta(x): """ theta function : returns 0 if x<=0, and 1 if x>0 """ x = np.asarray(x) y = np.zeros(x.shape) y[x > 0] = 1.0 return y def square_barrier(x, width, height): return height * (theta(x) - theta(x - width)) ###################################################################### # Create the animation # specify time steps and duration dt = 0.01 N_steps = 50 t_max = 120 frames = int(t_max / float(N_steps * dt)) # specify constants hbar = 1.0 # planck's constant m = 1.9 # particle mass # specify range in x coordinate N = 2 ** 11 dx = 0.1 x = dx * (np.arange(N) - 0.5 * N) # specify potential V0 = 1.5 L = hbar / np.sqrt(2 * m * V0) a = 3 * L x0 = -60 * L V_x = square_barrier(x, a, V0) V_x[x < -98] = 1E6 V_x[x > 98] = 1E6 # specify initial momentum and quantities derived from it p0 = np.sqrt(2 * m * 0.2 * V0) dp2 = p0 * p0 * 1./80 d = hbar / np.sqrt(2 * dp2) k0 = p0 / hbar v0 = p0 / m psi_x0 = gauss_x(x, d, x0, k0) # define the Schrodinger object which performs the calculations S = Schrodinger(x=x, psi_x0=psi_x0, V_x=V_x, hbar=hbar, m=m, k0=-28) ###################################################################### # Set up plot fig = pl.figure() # plotting limits xlim = (-100, 100) klim = (-5, 5) # top axes show the x-space data ymin = 0 ymax = V0 ax1 = fig.add_subplot(211, xlim=xlim, ylim=(ymin - 0.2 * (ymax - ymin), ymax + 0.2 * (ymax - ymin))) psi_x_line, = ax1.plot([], [], c='r', label=r'$|\psi(x)|$') V_x_line, = ax1.plot([], [], c='k', label=r'$V(x)$') center_line = ax1.axvline(0, c='k', ls=':', label = r"$x_0 + v_0t$") title = ax1.set_title("") ax1.legend(prop=dict(size=12)) ax1.set_xlabel('$x$') ax1.set_ylabel(r'$|\psi(x)|$') # bottom axes show the k-space data ymin = abs(S.psi_k).min() ymax = abs(S.psi_k).max() ax2 = fig.add_subplot(212, xlim=klim, ylim=(ymin - 0.2 * (ymax - ymin), ymax + 0.2 * (ymax - ymin))) psi_k_line, = ax2.plot([], [], c='r', label=r'$|\psi(k)|$') p0_line1 = ax2.axvline(-p0 / hbar, c='k', ls=':', label=r'$\pm p_0$') p0_line2 = ax2.axvline(p0 / hbar, c='k', ls=':') mV_line = ax2.axvline(np.sqrt(2 * V0) / hbar, c='k', ls='--', label=r'$\sqrt{2mV_0}$') ax2.legend(prop=dict(size=12)) ax2.set_xlabel('$k$') ax2.set_ylabel(r'$|\psi(k)|$') V_x_line.set_data(S.x, S.V_x) ###################################################################### # Animate plot def init(): psi_x_line.set_data([], []) V_x_line.set_data([], []) center_line.set_data([], []) psi_k_line.set_data([], []) title.set_text("") return (psi_x_line, V_x_line, center_line, psi_k_line, title) def animate(i): S.time_step(dt, N_steps) psi_x_line.set_data(S.x, 4 * abs(S.psi_x)) V_x_line.set_data(S.x, S.V_x) center_line.set_data(2 * [x0 + S.t * p0 / m], [0, 1]) psi_k_line.set_data(S.k, abs(S.psi_k)) title.set_text("t = %.2f" % S.t) return (psi_x_line, V_x_line, center_line, psi_k_line, title) # call the animator. blit=True means only re-draw the parts that have changed. anim = animation.FuncAnimation(fig, animate, init_func=init, frames=frames, interval=30, blit=True) # uncomment the following line to save the video in mp4 format. This # requires either mencoder or ffmpeg to be installed on your system anim.save('schrodinger_barrier.mp4', fps=15, extra_args=['-vcodec', 'libx264']) pl.show() ``` ```python from pylab import * from scipy.integrate import odeint from scipy.optimize import brentq def V(x): """ Potential function in the finite square well. Width is L and value is global variable Vo """ L = 1 if abs(x) > L: return 0 else: return Vo def SE(psi, x): """ Returns derivatives for the 1D schrodinger eq. Requires global value E to be set somewhere. State0 is first derivative of the wave function psi, and state1 is its second derivative. """ state0 = psi[1] state1 = 2.0*(V(x) - E)*psi[0] return array([state0, state1]) def Wave_function(energy): """ Calculates wave function psi for the given value of energy E and returns value at point b """ global psi global E E = energy psi = odeint(SE, psi0, x) return psi[-1,0] def find_all_zeroes(x,y): """ Gives all zeroes in y = Psi(x) """ all_zeroes = [] s = sign(y) for i in range(len(y)-1): if s[i]+s[i+1] == 0: zero = brentq(Wave_function, x[i], x[i+1]) all_zeroes.append(zero) return all_zeroes def find_analytic_energies(en): """ Calculates Energy values for the finite square well using analytical model (Griffiths, Introduction to Quantum Mechanics, 1st edition, page 62.) """ z = sqrt(2*en) z0 = sqrt(2*Vo) z_zeroes = [] f_sym = lambda z: tan(z)-sqrt((z0/z)**2-1) # Formula 2.138, symmetrical case f_asym = lambda z: -1/tan(z)-sqrt((z0/z)**2-1) # Formula 2.138, antisymmetrical case # first find the zeroes for the symmetrical case s = sign(f_sym(z)) for i in range(len(s)-1): # find zeroes of this crazy function if s[i]+s[i+1] == 0: zero = brentq(f_sym, z[i], z[i+1]) z_zeroes.append(zero) print("Energies from the analyitical model are: ") print("Symmetrical case)") for i in range(0, len(z_zeroes),2): # discard z=(2n-1)pi/2 solutions cause that's where tan(z) is discontinous print("%.4f" %(z_zeroes[i]**2/2)) # Now for the asymmetrical z_zeroes = [] s = sign(f_asym(z)) for i in range(len(s)-1): # find zeroes of this crazy function if s[i]+s[i+1] == 0: zero = brentq(f_asym, z[i], z[i+1]) z_zeroes.append(zero) print ('Antisymmetrical case') for i in range(0, len(z_zeroes),2): # discard z=npi solutions cause that's where ctg(z) is discontinous print("%.4f" %(z_zeroes[i]**2/2)) N = 1000 # number of points to take psi = np.zeros([N,2]) # Wave function values and its derivative (psi and psi') psi0 = array([0,1]) # Wave function initial states Vo = 20 E = 0.0 # global variable Energy needed for Sch.Eq, changed in function "Wave function" b = 2 # point outside of well where we need to check if the function diverges x = linspace(-b, b, N) # x-axis def main(): # main program en = linspace(0, Vo, 100) # vector of energies where we look for the stable states psi_b = [] # vector of wave function at x = b for all of the energies in en for e1 in en: psi_b.append(Wave_function(e1)) # for each energy e1 find the the psi(x) at x = b E_zeroes = find_all_zeroes(en, psi_b) # now find the energies where psi(b) = 0 # Print energies for the bound states print("Energies for the bound states are: ") for E in E_zeroes: print("%.2f" %E) # Print energies of each bound state from the analytical model find_analytic_energies(en) # Plot wave function values at b vs energy vector figure() plot(en/Vo,psi_b) title('Values of the $\Psi(b)$ vs. Energy') xlabel('Energy, $E/V_0$') ylabel('$\Psi(x = b)$', rotation='horizontal') for E in E_zeroes: plot(E/Vo, [0], 'go') annotate("E = %.2f"%E, xy = (E/Vo, 0), xytext=(E/Vo, 30)) grid() # Plot the wavefunctions for first 4 eigenstates figure(2) for E in E_zeroes[0:4]: Wave_function(E) plot(x, psi[:,0], label="E = %.2f"%E) legend(loc="upper right") title('Wave function') xlabel('x, $x/L$') ylabel('$\Psi(x)$', rotation='horizontal', fontsize = 15) grid() if __name__ == "__main__": main() ``` ```python import scipy as sp import scipy.constants as spc import scipy.integrate import math import numpy from matplotlib import pyplot as plt import datetime #--------------------------- # VARIABLES - #--------------------------- #equilibrium bond length in Angstrom re = 0.96966 #effective mass in kg amu = spc.physical_constants['atomic mass constant'][0] mass = (1.*16./(1.+16.))*amu *2 #minimum x value for partice in a box calculation xmin = -0.5+re #maximum x value for particle in a box calculation #there is no limit, but if xmax<xmin, the values will be swapped #if xmax = xmin, then xmax will be set to xmin + 1 xmax = 1.5+re #number of grid points at which to calculate integral #must be an odd number. If an even number is given, 1 will be added. #minimum number of grid points is 3 ngrid = 501 #number of PIB wavefunctions to include in basis set #minimum is 1 nbasis = 100 #if you want to control the plot ranges, you can do so here make_plots = True plotymin = 0 plotymax = 0 plotxmin = 0 plotxmax = 0 #dissociation energy in cm-1 de = 37778.617 #force constant in N / m fk = 774.7188418117737*0.75 #angular frequency in rad/s omega = numpy.sqrt(fk/mass) #output file for eigenvalues outfile = "eigenvalues.txt" #output PDF for energy spectrum spectrumfile = "energy.pdf" #output PDF for potential and eigenfunctions potentialfile = "potential.pdf" #-------------------------- # POTENTIAL DEFINITIONS - #-------------------------- #definitions of potential functions #particle in a box: no potential. Note: you need to manually set plotymin and plotymax above for proper graphing def box(x): return 0 #purely harmonic potential #energy in cm^-1 prefactor = 0.5 * fk * 1e-20/(spc.h*spc.c*100.0) def harmonic(x): return prefactor*(x-re)*(x-re) #anharmonic potential #def anharmonic(x): # return 0.5*(x**2.) + 0.05*(x**4.) #Morse potential #energy in cm^-1 #alpha in A^-1 alpha = math.sqrt(fk/2.0/(de*spc.h*spc.c*100.0))*1e-10 def morse(x): return de*(1.-numpy.exp(-alpha*(x-re)))**2. #double well potential (minima at x = +/-3) #def doublewell(x): # return x**4.-18.*x**2. + 81. #potential function used for this calculation def V(x): return morse(x) #------------------------ # BEGIN CALCULATION - #------------------------ #verify that inputs are sane if xmax==xmin: xmax = xmin+1. elif xmax<xmin: xmin,xmax = xmax,xmin L = xmax - xmin #function to compute normalized PIB wavefunction tl = numpy.sqrt(2./L) pixl = numpy.pi/L def pib(x,n,L): return tl*math.sin(n*x*pixl) ngrid = max(ngrid,3) if not ngrid%2: ngrid+=1 nbasis = max(1,nbasis) #get current time starttime = datetime.datetime.now() #create grid x = numpy.linspace(xmin,xmax,ngrid) #create Hamiltonian matrix; fill with zeros H = numpy.zeros((nbasis,nbasis)) #split Hamiltonian into kinetic energy and potential energy terms #H = T + V #V is defined above, and will be evaluated numerically #Compute kinetic energy #The Kinetic enery operator is T = -hbar^2/2m d^2/dx^2 #in the PIB basis, T|phi(i)> = hbar^2/2m n^2pi^2/L^2 |phi(i)> #Therefore <phi(k)|T|phi(i)> = hbar^2/2m n^2pi^2/L^2 delta_{ki} #Kinetic energy is diagonal kepf = spc.hbar*spc.hbar*math.pi**2./(2.*mass*(L*1e-10)*(L*1e-10)*spc.h*spc.c*100) for i in range(0,nbasis): H[i,i] += kepf*(i+1.)*(i+1.) #now, add in potential energy matrix elements <phi(j)|V|phi(i)> #that is, multiply the two functions by the potential at each grid point and integrate for i in range(0,nbasis): for j in range(0,nbasis): if j >= i: y = numpy.zeros(ngrid) for k in range(0,ngrid): p = x[k] y[k] += pib(p-xmin,i+1.,L)*V(p)*pib(p-xmin,j+1.,L) H[i,j] += sp.integrate.simps(y,x) else: H[i,j] += H[j,i] #Solve for eigenvalues and eigenvectors evalues, evectors = sp.linalg.eigh(H) evalues = evalues #get ending time endtime = datetime.datetime.now() #------------------------ # GENERATE OUTPUT - #------------------------ print("Results:") print("-------------------------------------") print(" v Energy (cm-1) Delta E (cm-1) ") print("-------------------------------------") for i in range(min(40,len(evalues))): if i>0: deltae = evalues[i] - evalues[i-1] print(" {:>3d} {:>13.3f} {:>14.3f} ".format(i,evalues[i],deltae)) else: print(" {:>3d} {:>13.3f} ------ ".format(i,evalues[i])) with open(outfile,'w') as f: f.write(str('#pibsolver.py output\n')) f.write('#start time ' + starttime.isoformat(' ') + '\n') f.write('#end time ' + endtime.isoformat(' ') + '\n') f.write(str('#elapsed time ' + str(endtime-starttime) + '\n')) f.write(str('#xmin {:1.4f}\n').format(xmin)) f.write(str('#xmax {:1.4f}\n').format(xmax)) f.write(str('#grid size {0}\n').format(ngrid)) f.write(str('#basis size {0}\n\n').format(nbasis)) f.write(str('#eigenvalues\n')) f.write(str('{0:.5e}').format(evalues[0])) for i in range(1,nbasis): f.write(str('\t{0:.5e}').format(evalues[i])) f.write('\n\n#eigenvectors\n') for j in range(0,nbasis): f.write(str('{0:.5e}').format(evectors[j,0])) for i in range(1,nbasis): f.write(str('\t{0:.5e}').format(evectors[j,i])) f.write('\n') if make_plots == True: #if this is run in interactive mode, make sure plot from previous run is closed plt.figure(1) plt.close() plt.figure(2) plt.close() plt.figure(1) #Make graph of eigenvalue spectrum title = "EV Spectrum, Min={:1.4f}, Max={:1.4f}, Grid={:3d}, Basis={:3d}".format(xmin,xmax,ngrid,nbasis) plt.plot(evalues,'ro') plt.xlabel('v') plt.ylabel(r'E (cm$^{-1}$)') plt.title(title) plt.savefig(spectrumfile) plt.show() #Make graph with potential and eigenfunctions plt.figure(2) title = "Wfns, Min={:1.4f}, Max={:1.4f}, Grid={:3d}, Basis={:3d}".format(xmin,xmax,ngrid,nbasis) vplot = numpy.zeros(x.size) for i in range(0,x.size): vplot[i] = V(x[i]) plt.plot(x,vplot) if plotxmin == 0: plotxmin = xmin if plotxmax == 0: plotxmax = xmax if(plotxmin == plotxmax): plotxmin, plotmax = xmin, xmax if(plotxmin > plotxmax): plotxmin, plotxmax = plotxmax,plotxmin if plotymax == 0: plotymax = 1.25*de # plotymax = evalues[10] if(plotymin > plotymax): plotymin, plotymax = plotymax,plotymin sf = 1.0 if len(evalues)>2: sf = (evalues[2]-evalues[0])/5.0 for i in range(0,nbasis): plt.plot([xmin,xmax],[evalues[i],evalues[i]],'k-') for i in range(0,nbasis): ef = numpy.zeros(ngrid) ef += evalues[i] for j in range(0,nbasis): for k in range(0,ngrid): ef[k] += evectors[j,i]*pib(x[k]-xmin,j+1,L)*sf plt.plot(x,ef) plt.plot([xmin,xmin],[plotymin,plotymax],'k-') plt.plot([xmax,xmax],[plotymin,plotymax],'k-') plt.axis([plotxmin,plotxmax,plotymin,plotymax]) plt.title(title) plt.xlabel('$R$ (Angstrom)') plt.ylabel(r'V (cm$^{-1}$)') plt.savefig(potentialfile) plt.show() ``` ```python import matplotlib.pyplot as plt import numpy as np #Probability of 1s def prob_1s(x,y,z): r=np.sqrt(np.square(x)+np.square(y)+np.square(z)) #Remember.. probability is psi squared! return np.square(np.exp(-r)/np.sqrt(np.pi)) #Random coordinates x=np.linspace(0,1,30) y=np.linspace(0,1,30) z=np.linspace(0,1,30) elements = [] probability = [] for ix in x: for iy in y: for iz in z: #Serialize into 1D object elements.append(str((ix,iy,iz))) probability.append(prob_1s(ix,iy,iz)) #Ensure sum of probability is 1 probability = probability/sum(probability) #Getting electron coordinates based on probabiliy coord = np.random.choice(elements, size=100000, replace=True, p=probability) elem_mat = [i.split(',') for i in coord] elem_mat = np.matrix(elem_mat) x_coords = [float(i.item()[1:]) for i in elem_mat[:,0]] y_coords = [float(i.item()) for i in elem_mat[:,1]] z_coords = [float(i.item()[0:-1]) for i in elem_mat[:,2]] #Plotting fig = plt.figure(figsize=(10,10)) ax = fig.add_subplot(111, projection='3d') ax.scatter(x_coords, y_coords, z_coords, alpha=0.05, s=2) ax.set_title("Hydrogen 1s density") plt.show() ``` ```python import matplotlib #matplotlib.use("TkAgg") import matplotlib.pyplot as plt from matplotlib import animation from matplotlib import style import seaborn import numpy as np import pandas as pd import warnings ###################################################################### #Ignore complex casting warning warnings.filterwarnings('ignore') class time_evolution: ''' Class that take an approach at solving the Time-Dependent Schrodinger equation for an unbounded particle in an infinite square well and generates a gaussian wave function for the psi initial. ''' def __init__(self, hbar, m, quantum_number, total_time, dt, L, x, n, a, l): self.hbar = hbar self.mass = m self.quantum_number = quantum_number self.total_time = total_time self.time_step = dt self.length = L self.x = x self.n = n self.a = a ''' Parameters ---------- x : array, float length-N array of evenly spaced spatial coordinates psi_x0 : array, complex Initial wave function at time t0 = 0 psi_xt : array, complex Time-dependent Schrodinger equation hbar : scalar, float value of planck's constant m : scalar, float particle mass quantum_number : scalar, integer values of conserved quantities in a quantum system total_time : float Time_step : scalar, integer ''' def gaussan_wave_packet(self,x,x0,l,a): A = (1/(4*a**2))**(1/4.0) self.psi_x0 = A*(np.exp((-(x - x0)**2) /(4*a**2))*np.exp(1j*l*x)).reshape(len(x),1) print("psi_x0: " + str(self.psi_x0.shape)) def normalize(self): self.A = ( 1/(np.sqrt(np.trapz((np.conj(self.psi_x0[:,0]) *self.psi_x0[:,0]), x[:,0])))) self.psi_x0_normalized = self.A*self.psi_x0 print("Scalar A: " + str(A)) print("Psi0 Normalized: " + str(self.psi_x0_normalized.shape)) def phi_n(self): self.phi = ( np.sqrt( 2/L ) * np.sin( (n * np.pi * x) /L ) ) print("Phi: " + str(self.phi.shape)) def energy_eigenvalues(self): self.En = ((np.power(n,2)) * (np.pi**2)*(hbar**2))/(2*m*L**2) print("En: " + str(self.En.shape)) def C_n(self): self.Cn = np.zeros((quantum_number,1),dtype=complex) for i in range(0,quantum_number): self.Cn[i,0] = np.trapz((np.conj(self.phi) * self.psi_x0_normalized)[:,i], x[:,0]) self.Cn = self.Cn.reshape(1,500) print("Cn: " + str(self.Cn.shape)) def schrodinger_equation(self, total_time): count = 0 for j in range(0, total_time, dt): time = j self.psi_xt = np.zeros((len(x),1),dtype=complex).reshape(len(x),1) for k in range(0, quantum_number): self.psi_xt[:,0] = self.psi_xt[:,0] + (self.Cn[0,k] * self.phi[:,k] * (np.exp((-1j * self.En[0,k] * time)/hbar))) count += 1 ###################################################################### # plot style.use('seaborn-dark') plt.plot(x, np.real(self.psi_xt),'r', label='real' r'$\psi(x,t)$', linewidth = 0.75) plt.plot(x, np.imag(self.psi_xt),'b', label=r'$imag \psi(x,t)$', linewidth = 0.75) plt.plot(x, np.abs(self.psi_xt),'y', label=r'$|\psi(x,t)|$', linewidth = 0.75) x_min = min(self.x[:,0]-5) x_max = max(self.x[:,0]+5) psi_min = -A psi_max = A plt.xlim((x_min, x_max)) plt.ylim((psi_min, psi_max)) plt.legend(prop=dict(size=6)) psi_x_line, = plt.plot([], [], c='r') V_x_line, = plt.plot([], [], c='k') left_wall_line = plt.axvline(0, c='k', linewidth=2) right_well_line = plt.axvline(x[-1], c='k', linewidth=2) plt.pause(0.01) plt.draw() plt.clf() plt.cla() print('The number of iterations: ' + str(count)) ###################################################################### #Predefined parameters quantum_number = 500 x = np.linspace(0,100,1000).astype(complex).reshape(1000,1) n = np.arange(1,quantum_number+1).reshape(1,quantum_number) x0 = 30 a = 5 l = 2 A = (1/(4*a**2))**(1/4.0) m = 2#int(938000000) hbar = 1#6.58211951*10**(-16) total_time = 1*10**2 L = x[-1] dt = 1 ###################################################################### #Welcome statement print('-'*100 + '\n' + 'Analytical solution to the Time-Dependent Schrodinger equation \n' + 'for an unbounded particle in an infinite square well \n \n' + 'author: Dr. Anathnath Ghosh \n' + 'email: anathnath.rivu@gmail.com \n') print('Note: change frames in animate for length of recording') ######################################################################## #Inputs for customization choose_custom = int(input('Enter 1 to run or enter any key to customize: ')) if choose_custom == int(1): pass else: quantum_number = int(input('Quantum number: ')) length_of_well = int(input('Length of the well (nm): ')) x0 = int(input('Center of wave packet (i.e. center of well): ')) a = int(input('Enter the width of wave packet (sigma): ')) l = int(input('Enter number of waves: ')) total_time = int(input('Total run time: ')) dt = int(input('Enter time step: ')) dx = int(input('Enter length intervals: ')) x = np.linspace(0,int(length_of_well), int(dx)).astype(complex).reshape(int(dx),1) ######################################################################### #Run class choose_run= int(input('Enter 1 to run for loop or any key to \n' 'run animation for recording: ')) Schrodinger = time_evolution(hbar,m,quantum_number,total_time,dt, L,x,n,a,l) if choose_run == int(1): Schrodinger.gaussan_wave_packet(x,x0,l,a) Schrodinger.normalize() Schrodinger.phi_n() Schrodinger.energy_eigenvalues() Schrodinger.C_n() Schrodinger.schrodinger_equation(total_time) elif choose_run == int(2): ###################################################################### # animate Schrodinger.gaussan_wave_packet(x,x0,l,a) Schrodinger.normalize() Schrodinger.phi_n() Schrodinger.energy_eigenvalues() Schrodinger.C_n() style.use('seaborn-dark') fig = plt.figure(figsize=(20,15)) x_min = min(Schrodinger.x[:,0]-5) x_max = max(Schrodinger.x[:,0]+5) psi_min = A * (-1) psi_max = A xlim = ((x_min, x_max)) ylim = ((psi_min, psi_max)) ax = fig.add_subplot(111, xlim = xlim, ylim = ylim) psi_xt_real, = ax.plot([], [], c='r', label='real' r'$\psi(x,t)$', linewidth = 0.75) psi_xt_imag, = ax.plot([], [], c='b', label=r'$imag \psi(x,t)$', linewidth = 0.75) psi_xt_abs, = ax.plot([], [], c='y', label=r'$|\psi(x,t)|$', linewidth = 0.75) left_wall_line = ax.axvline(0, c='k', linewidth=1) right_well_line = ax.axvline(x[-1], c='k', linewidth=1) title = ax.set_title('', fontsize=20) ax.legend(prop=dict(size=15), loc='upper center', shadow=True, ncol=3) ax.set_xlabel('$x$', fontsize=20) ax.set_ylabel(r'$|\psi(x)|$', fontsize=20) ax.xaxis.set_tick_params(labelsize=20) ax.yaxis.set_tick_params(labelsize=20) i = np.zeros([]) def init(): psi_xt_real.set_data([], []) psi_xt_imag.set_data([], []) psi_xt_abs.set_data([], []) title.set_text('') return psi_xt_real, def animate(i): i = i/50 time = np.linspace(0,1000,1000).astype(complex) psi_xt = np.zeros((len(x),1),dtype=complex).reshape(len(x),1) for k in range(0, quantum_number): psi_xt[:,0] = psi_xt[:,0] + (Schrodinger.Cn[0,k] * Schrodinger.phi[:,k] * (np.exp((-1j * Schrodinger.En[0,k] * i)/hbar))) psi_xt_real.set_data(x, np.real(psi_xt)) psi_xt_imag.set_data(x, np.imag(psi_xt)) psi_xt_abs.set_data(x, np.abs(psi_xt)) title.set_text('Time evolution: t = %.2f' %i) record = str(input('Do you want to record? Enter y or n: ')) if record == 'y': animate = matplotlib.animation.FuncAnimation(fig, animate, init_func=init, frames=1000, interval=1, repeat=False) animate.save('animation.gif', writer='imagemagick', fps=60, dpi=80) animate.save('time_evolution.mp4', fps=120, extra_args=['-vcodec', 'libx264']) else: plt.show() plt.clf() if __name__ == '__main__': init() animate(i) ``` ```python import numpy as np import matplotlib.pyplot as plt from scipy.special import genlaguerre from scipy.integrate import simps a = 5.29*10**-11 numValues = 20000 def R(n,l,r): '''Returns the radial wavefunction for each value of r where n is the principle quantum number and l is the angular momentum quantum number.''' y=np.zeros(numValues) #Generates an associated laguerre polynomial as a scipy.special.orthogonal.orthopoly1d Lag = genlaguerre(n-l-1, 2*l+1) #Loops through each power of r in the laguerre polynomial and adds to the total for i in range(len(Lag)+1): i = float(i) #The main equation (What its all about) y = y + (((r/(n*a))**(l))*(np.exp(-r/(a*n)))*Lag[int(i)]*(((2*r)/(a*n))**i)) return y #Approximates integral value and divides by the absolute value. def normalise(x,y):#Doesnt normalise. Calculates integral, we want area under the graphs. Haven't looked at this in a while, needs checking. integral = simps(np.absolute(y),x) print(integral, "simps") print(type(integral)) y = y/np.absolute(integral) return y def plotPsi(r,psi): plt.subplot(311) plt.plot(r, psi) plt.grid(True) plt.xlabel("r/a (m)") plt.ylabel("Psi") def plotPsiSquared(r,psi): psiSquared = psi**2 psiSquared = normalise(r,psiSquared) plt.plot(r, psiSquared) plt.grid(True) plt.xlabel("r/a (m)") plt.ylabel("Psi^2") def plotRadialDistribution(r,psi): radialDistribution = 4*np.pi*(r**2)*psi**2 radialDistribution = normalise(r, radialDistribution) plt.plot(r, radialDistribution) plt.grid(True) plt.xlabel("r/a (m)") plt.ylabel("4*pi*(r^2)*Psi") def plotAll(r,psi): plt.figure(1) plt.subplot(311) plotPsi(r,psi) plt.subplot(312) plotPsiSquared(r,psi) plt.subplot(313) plotRadialDistribution(r,psi) def graphs(r, psi,choice): if choice == 1: plotPsi(r,psi) elif choice == 2: plotPsiSquared(r,psi) elif choice == 3: plotRadialDistribution(r,psi) else: plotAll(r,psi) def main(): numPsi = int(input("How many wavefunctions do you want to draw?")) #Note that the whole wavefunction should be drawn or the normalise function will not work correctly width = float(input("To what value of r (in units of a) do you want to plot?")) * a print("1: Plot the wavefunction") print("2: Plot the wavefunction squared (the probability density)") print("3: Plot the wavefunction squared times pi r^2 (the radial distribution function)") print("4: Plot all 3") choice = int(input("Choose an option:")) for i in range(numPsi): print("Wavefunction " + str(i+1)) n = float(input("Enter n:")) l = float(input("Enter l:")) r = np.linspace(0,width, numValues) psi = R(n,l,r) #Converts r into units of a r = r/a psi = normalise(r, psi) graphs(r, psi,choice) plt.show() if __name__ == '__main__': main() ``` ```python !pip install Schrodinger ``` ```python import numpy as np from scipy import fftpack #Class to obtain a solution of the Schrodinger equation for a given potential class Schrodinger(object): #All parameters of the class are validated and initialised here def __init__(self, x, psi_x0, V_x, k0 = None, hbar = 1, m = 1, t0 = 0.0): #Validation of array inputs self.x, psi_x0, self.V_x = map(np.asarray, (x, psi_x0, V_x)) N = self.x.size #Set internal parameters assert hbar > 0 assert m > 0 self.hbar = hbar self.m = m self.t = t0 self.dt_ = None self.N = len(x) self.dx = self.x[1] - self.x[0] self.dk = 2 * np.pi / (self.N * self.dx) #Set momentum scale if k0 == None: self.k0 = -0.5 * self.N * self.dk else: assert k0 < 0 self.k0 = k0 self.k = self.k0 + self.dk * np.arange(self.N) self.psi_x = psi_x0 self.compute_k_from_x() #Variables which hold steps in evolution self.x_evolve_half = None self.x_evolve = None self.k_evolve = None def _set_psi_x(self, psi_x): assert psi_x.shape == self.x.shape self.psi_mod_x = (psi_x * np.exp(-1j * self.k[0] * self.x) * self.dx / np.sqrt(2 * np.pi)) self.psi_mod_x /= self.norm self.compute_k_from_x() def _get_psi_x(self): return (self.psi_mod_x * np.exp(1j * self.k[0] * self.x) * np.sqrt(2 * np.pi) / self.dx) def _set_psi_k(self, psi_k): assert psi_k.shape == self.x.shape self.psi_mod_k = psi_k * np.exp(1j * self.x[0] * self.dk * np.arange(self.N)) self.compute_x_from_k() self.compute_k_from_x() def _get_psi_k(self): return self.psi_mod_k * np.exp(-1j * self.x[0] * self.dk * np.arange(self.N)) def _get_dt(self): return self.dt_ def _set_dt(self, dt): assert dt != 0 if dt != self.dt_: self.dt_ = dt self.x_evolve_half = np.exp(-0.5 * 1j * self.V_x / self.hbar * self.dt) self.x_evolve = self.x_evolve_half * self.x_evolve_half self.k_evolve = np.exp(-0.5 * 1j * self.hbar / self.m * (self.k * self.k) * self.dt) def _get_norm(self): return self.wf_norm(self.psi_mod_x) psi_x = property(_get_psi_x, _set_psi_x) psi_k = property(_get_psi_k, _set_psi_k) norm = property(_get_norm) dt = property(_get_dt, _set_dt) #The Fourier transform def compute_k_from_x(self): self.psi_mod_k = fftpack.fft(self.psi_mod_x) #The inverse Fourier transform def compute_x_from_k(self): self.psi_mod_x = fftpack.ifft(self.psi_mod_k) #To calculate the norm of a wave function def wf_norm(self, wave_fn): assert wave_fn.shape == self.x.shape return np.sqrt((abs(wave_fn) ** 2).sum() * 2 * np.pi / self.dx) def solve(self, dt, Nsteps = 1, eps = 1e-3, max_iter = 1000): eps = abs(eps) assert eps > 0 t0 = self.t old_psi = self.psi_x d_psi = 2 * eps num_iter = 0 while (d_psi > eps) and (num_iter <= max_iter): num_iter += 1 self.time_step(-1j * dt, Nsteps) d_psi = self.wf_norm(self.psi_x - old_psi) old_psi = 1. * self.psi_x self.t = t0 #Discretization and solving for each time interval... def time_step(self, dt, Nsteps = 1): assert Nsteps >= 0 self.dt = dt if Nsteps > 0: self.psi_mod_x *= self.x_evolve_half for num_iter in xrange(Nsteps - 1): self.compute_k_from_x() self.psi_mod_k *= self.k_evolve self.compute_x_from_k() self.psi_mod_x *= self.x_evolve self.compute_k_from_x() self.psi_mod_k *= self.k_evolve self.compute_x_from_k() self.psi_mod_x *= self.x_evolve_half self.compute_k_from_x() self.psi_mod_x /= self.norm self.compute_k_from_x() self.t += dt * Nsteps import matplotlib.pyplot as plt from matplotlib import animation import numpy as np #from schrod_class import Schrodinger #Helper functions for Gaussian wave-packets def gauss_x(x, a, x0, k0): #A Gaussian wave packet of width a, centered at x0, with momentum k0 return ((a * np.sqrt(np.pi)) ** (-0.5) * np.exp(-0.5 * ((x - x0) * 1. / a) ** 2 + 1j * x * k0)) def gauss_k(k, a, x0, k0): #Fourier transform of gauss_x(x) return ((a / np.sqrt(np.pi)) ** 0.5 * np.exp(-0.5 * (a * (k - k0)) ** 2 - 1j * (k - k0) * x0)) #Helper function to define the potential barrier def theta(x): #Return 0 if x <= 0, and 1 if x > 0 x = np.asarray(x) y = np.zeros(x.shape) y[x > 0] = 1.0 return y #The potential barrier def square_barrier(x, width, height): return height * (theta(x) - theta(x - width)) #Create the animation #Time steps and duration (to be used as parameters for the FFT and the animation) dt = 0.01 N_steps = 50 t_max = 120 frames = int(t_max / float(N_steps * dt)) #Constants hbar = 1.0 #Planck's constant m = 1.9 #Particle mass #Range of values of x N = 2 ** 11 dx = 0.1 x = dx * (np.arange(N) - 0.5 * N) #Potential specification V0 = 1.5 #Barrier height L = hbar / np.sqrt(2 * m * V0) a = 3 * L #Barrier width x0 = -60 * L V_x = square_barrier(x, a, V0) V_x[x < -98] = 1E6 V_x[x > 98] = 1E6 #Specify initial momentum and quantities derived from it p0 = np.sqrt(2 * m * 0.2 * V0) dp2 = p0 * p0 * 1. / 80 d = hbar / np.sqrt(2 * dp2) k0 = p0 / hbar v0 = p0 / m psi_x0 = gauss_x(x, d, x0, k0) #Define the Schrodinger object which performs the calculations S = Schrodinger(x = x, psi_x0 = psi_x0, V_x = V_x, hbar = hbar, m = m, k0 = -28) #Setting up the plot... fig = plt.figure() #Axis limits xlim = (-100, 100) klim = (-5, 5) #First plot (x-space) : ymin = 0 ymax = V0 ax1 = fig.add_subplot(211, xlim = xlim, ylim = (ymin - 0.2 * (ymax - ymin), ymax + 0.2 * (ymax - ymin))) psi_x_line, = ax1.plot([], [], c = 'r', label = r'$|\psi(x)|$') V_x_line, = ax1.plot([], [], c = 'k', label = r'$V(x)$') center_line = ax1.axvline(0, c = 'k', ls = ':', label = r"$x_0 + v_0t$") title = ax1.set_title("") ax1.legend(prop = dict(size = 12)) ax1.set_xlabel('$x$') ax1.set_ylabel(r'$|\psi(x)|$') #Second plot (k-space) : ymin = abs(S.psi_k).min() ymax = abs(S.psi_k).max() ax2 = fig.add_subplot(212, xlim = klim, ylim = (ymin - 0.2 * (ymax - ymin), ymax + 0.2 * (ymax - ymin))) psi_k_line, = ax2.plot([], [], c = 'r', label = r'$|\psi(k)|$') p0_line1 = ax2.axvline(-p0 / hbar, c = 'k', ls = ':', label = r'$\pm p_0$') p0_line2 = ax2.axvline(p0 / hbar, c = 'k', ls = ':') mV_line = ax2.axvline(np.sqrt(2 * V0) / hbar, c = 'k', ls = '--', label = r'$\sqrt{2mV_0}$') ax2.legend(prop = dict(size = 12)) ax2.set_xlabel('$k$') ax2.set_ylabel(r'$|\psi(k)|$') V_x_line.set_data(S.x, S.V_x) #Feeding the plot with the data #Functions to help in animation def init(): psi_x_line.set_data([], []) V_x_line.set_data([], []) center_line.set_data([], []) psi_k_line.set_data([], []) title.set_text("") return (psi_x_line, V_x_line, center_line, psi_k_line, title) def animate(i): S.time_step(dt, N_steps) psi_x_line.set_data(S.x, 4 * abs(S.psi_x)) V_x_line.set_data(S.x, S.V_x) center_line.set_data(2 * [x0 + S.t * p0 / m], [0, 1]) psi_k_line.set_data(S.k, abs(S.psi_k)) title.set_text("t = %.2f" % S.t) return (psi_x_line, V_x_line, center_line, psi_k_line, title) anim = animation.FuncAnimation(fig, animate, init_func = init, frames = frames, interval = 30, blit = True) plt.show() ``` ```python import numpy as np import matplotlib.pyplot as plt import matplotlib.animation as animation def timevol(x, q, N, problem, fPOT): # ucnomment these two lines, as well as anim.save # to encode and save the simulatation video #Writer = animation.writers['ffmpeg'] #writer = Writer(fps=30, bitrate=1800) def _update_plot(i, fig, phi): ax.clear() ax.set_xlim([-50, 50]) ax.set_ylim([-1, 1]) scat = plt.plot(x, q[:, i]) return scat fig = plt.figure() ax = fig.add_subplot(111) ax.set_xlim([-50, 50]) ax.set_ylim([-1, 1]) scat = plt.plot(x, q[:, 0]) anim = animation.FuncAnimation(fig, _update_plot, fargs=(fig, scat), frames=N, interval=N/10) anim.save(r'free.mp4') plt.show() ``` ```python import numpy as np import matplotlib.pyplot as plt L = 200 #number of discretisation nodes T = 2000 #number of steps dt = 0.001 #step size x = range(L) #solution space (1D) def D2(F): #Discrete Laplacian with periodic boundary conditions and next-neighbour kernel ker = np.array([1,-2,1]) Fnew = np.zeros_like(F) for x in range(L): xleft = (x+L-1)%L xright = (x+L+1)%L Fnew[x]= ker[0]*F[xleft] + ker[1]*F[x] + ker[2]*F[xright] return Fnew def schrodinger(Y): #schrodinger equation for a free particle (V=0) iY_t = Y_xx, letting Y=u+iv and solving Re and Im separately u,v=Y[0,:],Y[1,:] ut = -D2(v) vt = D2(u) return np.array([u+ut*dt,v+vt*dt]) uo = np.zeros(L) vo = np.zeros(L) xo = np.random.randint(0,L) uo[(xo+1)%L]=1/np.sqrt(3) uo[xo]=1/np.sqrt(3) uo[(xo-1+L)%L]=1/np.sqrt(3) Yo = np.array([uo,vo]) #setting initial conditions fig=plt.figure() plt.plot(x,np.zeros(L)) plt.plot(x,np.power(Yo[0,:],2)+np.power(Yo[1,:],2)) plt.ylim(0,1) plt.savefig("out.png") #plotting initial stage plt.close(fig) Y=schrodinger(Yo) for t in range(T): #plotting time evolution fig=plt.figure() plt.plot(x,np.zeros(L)) plt.plot(x,np.power(Y[0,:],2)+np.power(Y[1,:],2)) plt.ylim(0,1) #plt.savefig("out {0:03d}.png".format(t+1)) plt.close(fig) Y=schrodinger(Y) ``` ```python Y ``` # ACKNOWLEDGEMENTS: # 1. Prof. Abhijit KarGupta, Pashkura College # 2. Prof. Arunava Adhikary, WBSU # 3. Book: Physics in Laboratory # by Dr. Pradipta Kumar Mandal # 4. Book: Python Programming # by Dr. Abhijit KarGupta # 5. GOOGLE MASTER !

ba9090260504921d07725e6eb929bcfac9f8d9c0

ipynb

Jupyter Notebook

CBCS_V_SchrodingerEquationPartI.ipynb

anathnath/EDA

26b24ccfffe70747b84074598a069cdc96300163

CBCS_V_SchrodingerEquationPartI.ipynb

anathnath/EDA

26b24ccfffe70747b84074598a069cdc96300163

CBCS_V_SchrodingerEquationPartI.ipynb

anathnath/EDA

26b24ccfffe70747b84074598a069cdc96300163

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# Loading and Plotting Data For the first part, we'll be doing linear regression with one variable, and so we'll use only two fields from the daily data set: the normalized high temperature in C, and the total number of bike rentals. The values for rentals are scaled by a factor of a thousand, given the difference in magnitude between them and the normalized temperatures. ```python import pandas as pd data = pd.read_csv("./data.csv") temps = data['atemp'].values rentals = data['cnt'].values / 1000 print(temps) ``` [0.363625 0.353739 0.189405 0.212122 0.22927 0.233209 0.208839 0.162254 0.116175 0.150888 0.191464 0.160473 0.150883 0.188413 0.248112 0.234217 0.176771 0.232333 0.298422 0.25505 0.157833 0.0790696 0.0988391 0.11793 0.234526 0.2036 0.2197 0.223317 0.212126 0.250322 0.18625 0.23453 0.254417 0.177878 0.228587 0.243058 0.291671 0.303658 0.198246 0.144283 0.149548 0.213509 0.232954 0.324113 0.39835 0.254274 0.3162 0.428658 0.511983 0.391404 0.27733 0.284075 0.186033 0.245717 0.289191 0.350461 0.282192 0.351109 0.400118 0.263879 0.320071 0.200133 0.255679 0.378779 0.366252 0.238461 0.3024 0.286608 0.385668 0.305 0.32575 0.380091 0.332 0.318178 0.36693 0.410333 0.527009 0.466525 0.32575 0.409735 0.440642 0.337939 0.270833 0.256312 0.257571 0.250339 0.257574 0.292908 0.29735 0.257575 0.283454 0.315637 0.378767 0.542929 0.39835 0.387608 0.433696 0.324479 0.341529 0.426737 0.565217 0.493054 0.417283 0.462742 0.441913 0.425492 0.445696 0.503146 0.489258 0.564392 0.453892 0.321954 0.450121 0.551763 0.5745 0.594083 0.575142 0.578929 0.497463 0.464021 0.448204 0.532833 0.582079 0.40465 0.441917 0.474117 0.512621 0.518933 0.525246 0.522721 0.5284 0.523363 0.4943 0.500629 0.536 0.550512 0.538529 0.527158 0.510742 0.529042 0.571975 0.5745 0.590296 0.604813 0.615542 0.654688 0.637008 0.612379 0.61555 0.671092 0.725383 0.720967 0.643942 0.587133 0.594696 0.616804 0.621858 0.65595 0.727279 0.757579 0.703292 0.678038 0.643325 0.601654 0.591546 0.587754 0.595346 0.600383 0.643954 0.645846 0.595346 0.637646 0.693829 0.693833 0.656583 0.643313 0.637629 0.637004 0.692558 0.654688 0.637008 0.652162 0.667308 0.668575 0.665417 0.696338 0.685633 0.686871 0.670483 0.664158 0.690025 0.729804 0.739275 0.689404 0.635104 0.624371 0.638263 0.669833 0.703925 0.747479 0.74685 0.826371 0.840896 0.804287 0.794829 0.720958 0.696979 0.690667 0.7399 0.785967 0.728537 0.729796 0.703292 0.707071 0.679937 0.664788 0.656567 0.676154 0.715292 0.703283 0.724121 0.684983 0.651521 0.654042 0.645858 0.624388 0.616167 0.645837 0.666671 0.662258 0.633221 0.648996 0.675525 0.638254 0.606067 0.630692 0.645854 0.659733 0.635556 0.647959 0.607958 0.594704 0.611121 0.614921 0.604808 0.633213 0.665429 0.625646 0.5152 0.544229 0.555361 0.578946 0.607962 0.609229 0.60213 0.603554 0.6269 0.553671 0.461475 0.478512 0.490537 0.529675 0.532217 0.550533 0.554963 0.522125 0.564412 0.572637 0.589042 0.574525 0.575158 0.574512 0.544829 0.412863 0.345317 0.392046 0.472858 0.527138 0.480425 0.504404 0.513242 0.523983 0.542925 0.546096 0.517717 0.551804 0.529675 0.498725 0.503154 0.510725 0.522721 0.513848 0.466525 0.423596 0.425492 0.422333 0.457067 0.463375 0.472846 0.457046 0.318812 0.227913 0.321329 0.356063 0.397088 0.390133 0.405921 0.403392 0.323854 0.362358 0.400871 0.412246 0.409079 0.373721 0.306817 0.357942 0.43055 0.524612 0.507579 0.451988 0.323221 0.272721 0.324483 0.457058 0.445062 0.421696 0.430537 0.372471 0.380671 0.385087 0.4558 0.490122 0.451375 0.311221 0.305554 0.331433 0.310604 0.3491 0.393925 0.4564 0.400246 0.256938 0.317542 0.266412 0.253154 0.270196 0.301138 0.338362 0.412237 0.359825 0.249371 0.245579 0.280933 0.396454 0.428017 0.426121 0.377513 0.299242 0.279961 0.315535 0.327633 0.279974 0.263892 0.318812 0.414121 0.375621 0.252304 0.126275 0.119337 0.278412 0.340267 0.390779 0.340258 0.247479 0.318826 0.282821 0.381938 0.249362 0.183087 0.161625 0.190663 0.364278 0.275254 0.190038 0.220958 0.174875 0.16225 0.243058 0.349108 0.294821 0.35605 0.415383 0.326379 0.272721 0.262625 0.381317 0.466538 0.398971 0.309346 0.272725 0.264521 0.296426 0.361104 0.266421 0.261988 0.293558 0.210867 0.101658 0.227913 0.333946 0.351629 0.330162 0.351629 0.355425 0.265788 0.273391 0.295113 0.392667 0.444446 0.410971 0.255675 0.268308 0.357954 0.353525 0.34847 0.475371 0.359842 0.413492 0.303021 0.241171 0.255042 0.3851 0.524604 0.397083 0.277767 0.35967 0.459592 0.542929 0.548617 0.532825 0.436229 0.505046 0.464 0.532821 0.538533 0.513258 0.531567 0.570067 0.486733 0.437488 0.43875 0.315654 0.47095 0.482304 0.375621 0.421708 0.417287 0.427513 0.461483 0.53345 0.431163 0.390767 0.426129 0.492425 0.476638 0.436233 0.337274 0.387604 0.431808 0.487996 0.573875 0.614925 0.598487 0.457038 0.493046 0.515775 0.542921 0.389504 0.301125 0.405283 0.470317 0.483583 0.452637 0.377504 0.450121 0.457696 0.577021 0.537896 0.537242 0.590917 0.584608 0.546737 0.527142 0.557471 0.553025 0.491783 0.520833 0.544817 0.585238 0.5499 0.576404 0.595975 0.572613 0.551121 0.566908 0.583967 0.565667 0.580825 0.584612 0.6067 0.627529 0.642696 0.641425 0.6793 0.672992 0.611129 0.631329 0.607962 0.566288 0.575133 0.578283 0.525892 0.542292 0.569442 0.597862 0.648367 0.663517 0.659721 0.597875 0.611117 0.624383 0.599754 0.594708 0.571975 0.544842 0.654692 0.720975 0.752542 0.724121 0.652792 0.674254 0.654042 0.594704 0.640792 0.675512 0.786613 0.687508 0.750629 0.702038 0.70265 0.732337 0.761367 0.752533 0.804913 0.790396 0.654054 0.664796 0.650271 0.654683 0.667933 0.666042 0.705196 0.724125 0.755683 0.745583 0.714642 0.613025 0.549912 0.623125 0.690017 0.70645 0.654054 0.739263 0.734217 0.697604 0.667933 0.684987 0.662896 0.667308 0.707088 0.722867 0.751267 0.731079 0.710246 0.697621 0.707717 0.699508 0.667942 0.638267 0.644579 0.662254 0.676779 0.654037 0.654688 0.2424 0.618071 0.603554 0.595967 0.601025 0.621854 0.637008 0.6471 0.618696 0.595996 0.654688 0.66605 0.635733 0.652779 0.6894 0.702654 0.649 0.661629 0.686888 0.708983 0.655329 0.657204 0.611121 0.578925 0.565654 0.554292 0.570075 0.579558 0.594083 0.585867 0.563125 0.55305 0.565067 0.540404 0.532192 0.571971 0.610488 0.518933 0.502513 0.544179 0.596613 0.607975 0.585863 0.530296 0.517663 0.512 0.542333 0.599133 0.607975 0.580187 0.538521 0.419813 0.387608 0.438112 0.503142 0.431167 0.433071 0.391396 0.508204 0.53915 0.460846 0.450108 0.512625 0.537896 0.472842 0.456429 0.482942 0.530304 0.558721 0.529688 0.52275 0.515133 0.467771 0.4394 0.309909 0.3611 0.369942 0.356042 0.323846 0.329538 0.308075 0.281567 0.274621 0.341891 0.355413 0.393937 0.421713 0.475383 0.323225 0.281563 0.324492 0.347204 0.326383 0.337746 0.375621 0.380667 0.364892 0.350371 0.378779 0.248742 0.257583 0.339004 0.281558 0.289762 0.298422 0.323867 0.316904 0.359208 0.455796 0.469054 0.428012 0.258204 0.321958 0.389508 0.390146 0.435575 0.338363 0.297338 0.294188 0.294192 0.338383 0.369938 0.4015 0.409708 0.342162 0.335217 0.301767 0.236113 0.259471 0.2589 0.294465 0.220333 0.226642 0.255046 0.2424 0.2317 0.223487 ] The plot reveals some degree of correlation between temperature and bike rentals, as one might guess. ```python import matplotlib.pyplot as plt %matplotlib inline plt.scatter(temps, rentals, marker='x', color='red') plt.xlabel('Normalized Temperature in C') plt.ylabel('Bike Rentals in 1000s') ``` # Simple Linear Regression We'll start by implementing the [cost function](https://en.wikipedia.org/wiki/Loss_function) for linear regression, specifically [mean squared error](https://en.wikipedia.org/wiki/Mean_squared_error) (MSE). Intuitively, MSE represents an aggregation of the distances between point's actual y value and what a hypothesis function $h_\theta(x)$ predicted it would be. That hypothesis function and the cost function $J(\theta)$ are defined as \begin{align} h_\theta(x) & = \theta_0 + \theta_1x_1 \\ J(\theta) & = \frac{1}{2m}\sum\limits_{i = 1}^{m}(h_\theta(x^{(i)}) - y^{(i)})^2 \end{align} where $\theta$ is a vector of feature weights, $x^{(i)}$ is the ith training example, $y^{(i)}$ is that example's y value, and $x_j$ is the value for its jth feature. ```python import numpy as np def compute_cost(X, y, theta): return np.sum(np.square(np.matmul(X, theta) - y)) / (2 * len(y)) ``` Before computing the cost with an initial guess for $\theta$, a column of 1s is prepended onto the input data. This allows us to vectorize the cost function, as well as make it usable for multiple linear regression later. This first value $\theta_0$ now behaves as a constant in the cost function. ```python # [T0 t1] # X # [T0 T1] X [1] # [X] theta = np.zeros(2) X = np.column_stack((np.ones(len(temps)), temps)) y = rentals cost = compute_cost(X, y, theta) print('theta:', theta) print('cost:', cost) print(X) ``` theta: [0. 0.] cost: 12.018406441176468 [[1. 0.363625] [1. 0.353739] [1. 0.189405] ... [1. 0.2424 ] [1. 0.2317 ] [1. 0.223487]] We'll now minimize the cost using the [gradient descent](https://en.wikipedia.org/wiki/Gradient_descent) algorithm. Intuitively, gradient descent takes small, linear hops down the slope of a function in each feature dimension, with the size of each hop determined by the partial derivative of the cost function with respect to that feature and a learning rate multiplier $\alpha$. If tuned properly, the algorithm converges on a global minimum by iteratively adjusting feature weights $\theta$ of the cost function, as shown here for two feature dimensions: \begin{align} \theta_0 & := \theta_0 - \alpha\frac{\partial}{\partial\theta_0} J(\theta_0,\theta_1) \\ \theta_1 & := \theta_1 - \alpha\frac{\partial}{\partial\theta_1} J(\theta_0,\theta_1) \end{align} The update rule each iteration then becomes: \begin{align} \theta_0 & := \theta_0 - \alpha\frac{1}{m} \sum_{i=1}^m (h_\theta(x^{(i)})-y^{(i)}) \\ \theta_1 & := \theta_1 - \alpha\frac{1}{m} \sum_{i=1}^m (h_\theta(x^{(i)})-y^{(i)})x_1^{(i)} \\ \end{align} See [here](http://mccormickml.com/2014/03/04/gradient-descent-derivation/) for a more detailed explanation of how the update equations are derived. ```python def gradient_descent(X, y, alpha, iterations): theta = np.zeros(2) m = len(y) for i in range(iterations): t0 = theta[0] - (alpha / m) * np.sum(np.dot(X, theta) - y) t1 = theta[1] - (alpha / m) * np.sum((np.dot(X, theta) - y) * X[:,1]) theta = np.array([t0, t1]) return theta iterations = 5000 alpha = 0.1 theta = gradient_descent(X, y, alpha, iterations) cost = compute_cost(X, y, theta) print("theta:", theta) print('cost:', compute_cost(X, y, theta)) ``` theta: [0.94588081 7.50171673] cost: 1.1275869258439812 We can examine the values of $\theta$ chosen by the algorithm using a few different visualizations, first by plotting $h_\theta(x)$ against the input data. The results show the expected correlation between temperature and rentals. ```python plt.scatter(temps, rentals, marker='x', color='red') plt.xlabel('Normalized Temperature in C') plt.ylabel('Bike Rentals in 1000s') samples = np.linspace(min(temps), max(temps)) plt.plot(samples, theta[0] + theta[1] * samples) ``` A surface plot is a better illustration of how gradient descent approaches a global minimum, plotting the values for $\theta$ against their associated cost. This requires a bit more code than an implementation in Octave / MATLAB, largely due to how the input data is generated and fed to the surface plot function. ```python from mpl_toolkits.mplot3d import Axes3D from matplotlib import cm Xs, Ys = np.meshgrid(np.linspace(-5, 5, 50), np.linspace(-40, 40, 50)) Zs = np.array([compute_cost(X, y, [t0, t1]) for t0, t1 in zip(np.ravel(Xs), np.ravel(Ys))]) Zs = np.reshape(Zs, Xs.shape) fig = plt.figure(figsize=(7,7)) ax = fig.gca(projection="3d") ax.set_xlabel(r't0') ax.set_ylabel(r't1') ax.set_zlabel(r'cost') ax.view_init(elev=25, azim=40) # rotate 3D image ax.plot_surface(Xs, Ys, Zs, cmap=cm.rainbow) ``` Finally, a countour plot reveals slices of that surface plot in 2D space, and can show the resulting $\theta$ values sitting exactly at the global minimum. ```python ax = plt.figure().gca() ax.plot(theta[0], theta[1], 'r*') plt.contour(Xs, Ys, Zs, np.logspace(-3, 3, 15)) #plt.contour(Xs, Ys, Zs) ``` # Multiple Linear Regression First, we reload the data and add two more features, humidity and windspeed. Before implementing gradient descent for multiple variables, we'll also apply [feature scaling](https://en.wikipedia.org/wiki/Feature_scaling) to normalize feature values, preventing any one of them from disproportionately influencing the results, as well as helping gradient descent converge more quickly. In this case, each feature value is adjusted by subtracting the mean and dividing the result by the standard deviation of all values for that feature: $$ z = \frac{x - \mu}{\sigma} $$ More details on feature scaling and normalization can be found [here](http://sebastianraschka.com/Articles/2014_about_feature_scaling.html). ```python data ``` <div> <style scoped> .dataframe tbody tr th:only-of-type { vertical-align: middle; } .dataframe tbody tr th { vertical-align: top; } .dataframe thead th { text-align: right; } </style> <table border="1" class="dataframe"> <thead> <tr style="text-align: right;"> <th></th> <th>instant</th> <th>dteday</th> <th>season</th> <th>yr</th> <th>mnth</th> <th>holiday</th> <th>weekday</th> <th>workingday</th> <th>weathersit</th> <th>temp</th> <th>atemp</th> <th>hum</th> <th>windspeed</th> <th>casual</th> <th>registered</th> <th>cnt</th> </tr> </thead> <tbody> <tr> <th>0</th> <td>1</td> <td>2011-01-01</td> <td>1</td> <td>0</td> <td>1</td> <td>0</td> <td>6</td> <td>0</td> <td>2</td> <td>0.344167</td> <td>0.363625</td> <td>0.805833</td> <td>0.160446</td> <td>331</td> <td>654</td> <td>985</td> </tr> <tr> <th>1</th> <td>2</td> <td>2011-01-02</td> <td>1</td> <td>0</td> <td>1</td> <td>0</td> <td>0</td> <td>0</td> <td>2</td> <td>0.363478</td> <td>0.353739</td> <td>0.696087</td> <td>0.248539</td> <td>131</td> <td>670</td> <td>801</td> </tr> <tr> <th>2</th> <td>3</td> <td>2011-01-03</td> <td>1</td> <td>0</td> <td>1</td> <td>0</td> <td>1</td> <td>1</td> <td>1</td> <td>0.196364</td> <td>0.189405</td> <td>0.437273</td> <td>0.248309</td> <td>120</td> <td>1229</td> <td>1349</td> </tr> <tr> <th>3</th> <td>4</td> <td>2011-01-04</td> <td>1</td> <td>0</td> <td>1</td> <td>0</td> <td>2</td> <td>1</td> <td>1</td> <td>0.200000</td> <td>0.212122</td> <td>0.590435</td> <td>0.160296</td> <td>108</td> <td>1454</td> <td>1562</td> </tr> <tr> <th>4</th> <td>5</td> <td>2011-01-05</td> <td>1</td> <td>0</td> <td>1</td> <td>0</td> <td>3</td> <td>1</td> <td>1</td> <td>0.226957</td> <td>0.229270</td> <td>0.436957</td> <td>0.186900</td> <td>82</td> <td>1518</td> <td>1600</td> </tr> <tr> <th>...</th> <td>...</td> <td>...</td> <td>...</td> <td>...</td> <td>...</td> <td>...</td> <td>...</td> <td>...</td> <td>...</td> <td>...</td> <td>...</td> <td>...</td> <td>...</td> <td>...</td> <td>...</td> <td>...</td> </tr> <tr> <th>726</th> <td>727</td> <td>2012-12-27</td> <td>1</td> <td>1</td> <td>12</td> <td>0</td> <td>4</td> <td>1</td> <td>2</td> <td>0.254167</td> <td>0.226642</td> <td>0.652917</td> <td>0.350133</td> <td>247</td> <td>1867</td> <td>2114</td> </tr> <tr> <th>727</th> <td>728</td> <td>2012-12-28</td> <td>1</td> <td>1</td> <td>12</td> <td>0</td> <td>5</td> <td>1</td> <td>2</td> <td>0.253333</td> <td>0.255046</td> <td>0.590000</td> <td>0.155471</td> <td>644</td> <td>2451</td> <td>3095</td> </tr> <tr> <th>728</th> <td>729</td> <td>2012-12-29</td> <td>1</td> <td>1</td> <td>12</td> <td>0</td> <td>6</td> <td>0</td> <td>2</td> <td>0.253333</td> <td>0.242400</td> <td>0.752917</td> <td>0.124383</td> <td>159</td> <td>1182</td> <td>1341</td> </tr> <tr> <th>729</th> <td>730</td> <td>2012-12-30</td> <td>1</td> <td>1</td> <td>12</td> <td>0</td> <td>0</td> <td>0</td> <td>1</td> <td>0.255833</td> <td>0.231700</td> <td>0.483333</td> <td>0.350754</td> <td>364</td> <td>1432</td> <td>1796</td> </tr> <tr> <th>730</th> <td>731</td> <td>2012-12-31</td> <td>1</td> <td>1</td> <td>12</td> <td>0</td> <td>1</td> <td>1</td> <td>2</td> <td>0.215833</td> <td>0.223487</td> <td>0.577500</td> <td>0.154846</td> <td>439</td> <td>2290</td> <td>2729</td> </tr> </tbody> </table> <p>731 rows × 16 columns</p> </div> ```python def feature_normalize(X): ''' make sure features are on similar scale --> gradient decense will converge faster ''' n_features = X.shape[1] means = np.array([np.mean(X[:,i]) for i in range(n_features)]) stddevs = np.array([np.std(X[:,i]) for i in range(n_features)]) normalized = (X - means) / stddevs return normalized ''' X = data.values X = np.matrix(X) X = feature_normalize(X) X = np.column_stack((np.ones(len(X)), X)) data_y = pd.read_csv("E:\DATAs\data.csv",usecols=['cnt']) y = data_y['cnt'].values/1000 ''' data2 = pd.read_csv("./data.csv",usecols=['atemp', 'hum', 'windspeed']) X = data2.values #X = np.matrix(X) #X = data.as_matrix(columns=['atemp', 'hum', 'windspeed']) print(np.shape(X)) X = feature_normalize(X) X = np.column_stack((np.ones(len(X)), X)) y = data['cnt'].values / 1000 ``` (731, 3) ```python print(X) print(X.shape) ``` [[ 1. -0.67994602 1.25017133 -0.38789169] [ 1. -0.74065231 0.47911298 0.74960172] [ 1. -1.749767 -1.33927398 0.74663186] ... [ 1. -1.42434419 0.87839173 -0.85355213] [ 1. -1.49004895 -1.01566357 2.06944426] [ 1. -1.54048197 -0.35406086 -0.46020122]] (731, 4) The next step is to implement gradient descent for any number of features. Fortunately, the update step generalizes easily, and can be vectorized to avoid iterating through $\theta_j$ values as might be suggested by the single variable implementation above: $$ \theta_j := \theta_j - \alpha\frac{1}{m} \sum_{i=1}^m (h_\theta(x^{(i)})-y^{(i)})x_j^{(i)} $$ ```python def gradient_descent_multi(X, y, theta, alpha, iterations): theta = np.zeros(X.shape[1]) m = len(X) for i in range(iterations): gradient = (1/m) * np.matmul(X.T, np.matmul(X, theta) - y) theta = theta - alpha * gradient return theta theta = gradient_descent_multi(X, y, theta, alpha, iterations) cost = compute_cost(X, y, theta) print('theta:', theta) print('cost', cost) ``` theta: [ 4.50434884 1.22203893 -0.45083331 -0.34166068] cost 1.0058709247119848 Unfortunately, it's now more difficult to evaluate the results visually, but we can check them a totally different method of calculating the answer, the [normal equation](http://eli.thegreenplace.net/2014/derivation-of-the-normal-equation-for-linear-regression/). This solves directly for the solution without iteration specifying an $\alpha$ value, although it begins to perform worse than gradient descent with large (10,000+) numbers of features. $$ \theta = (X^TX)^{-1}X^Ty $$ ```python from numpy.linalg import inv def normal_eq(X, y): return inv(X.T.dot(X)).dot(X.T).dot(y) theta = normal_eq(X, y) cost = compute_cost(X, y, theta) print('theta:', theta) print('cost:', cost) ``` theta: [ 4.50434884 1.22203893 -0.45083331 -0.34166068] cost: 1.0058709247119846 The $\theta$ values and costs for each implementation are identical, so we can have a high degree of confidence they are correct. ## Linear Regression in Tensorflow Tensorflow offers significantly higher-level abstractions to work with, representing the algorithm as a computational graph. It has a built-in gradient descent optimizer that can minimize the cost function without us having to define the gradient manually. We'll begin by reloading the data and adapting it to more Tensorflow-friendly data structures and terminology. Features are still normalized as before, but the added column of 1s is absent: the constant is treated separately as a *bias* variable, the previous $\theta$ values are now *weights*. ```python import tensorflow as tf X = data.as_matrix(columns=['atemp', 'hum', 'windspeed']) X = feature_normalize(X) y = data['cnt'].values / 1000 y = y.reshape((-1, 1)) m = X.shape[0] n = X.shape[1] examples = tf.placeholder(tf.float32, [m,n]) labels = tf.placeholder(tf.float32, [m,1]) weights = tf.Variable(tf.zeros([n,1], dtype=np.float32), name='weight') bias = tf.Variable(tf.zeros([1], dtype=np.float32), name='bias') ``` The entire gradient descent occurs below in only three lines of code. All that's needed is to define the hypothesis and cost functions, and then a gradient descent optimizer to find the minimum. ```python hypothesis = tf.add(tf.matmul(examples, weights), bias) cost = tf.reduce_sum(tf.square(hypothesis - y)) / (2 * m) optimizer = tf.train.GradientDescentOptimizer(alpha).minimize(cost) ``` The graph is now ready to use, and all the remains is to start up a session, run the optimizer iteratively, and check the results. ```python with tf.Session() as sess: init = tf.global_variables_initializer() sess.run(init) for i in range(1, iterations): sess.run(optimizer, feed_dict={ examples: X, labels: y }) print('bias:', sess.run(bias)) print('weights:', sess.run(weights)) ``` The bias and weight values are identical to the $\theta$ values calculated in both implementations previously, so the Tensorflow implementation of the algorithm looks correct.

8b1641c3692f61ac9799e2a0578ce27680cf1af5

ipynb

Jupyter Notebook

ml-linear-regression.ipynb

Jerry671/natural-language-project

943415ac6085a74363b4f7e881454ebcfccc7689

ml-linear-regression.ipynb

Jerry671/natural-language-project

943415ac6085a74363b4f7e881454ebcfccc7689

ml-linear-regression.ipynb

Jerry671/natural-language-project

943415ac6085a74363b4f7e881454ebcfccc7689

2020-11-28T07:41:42.000Z

2020-11-28T07:41:42.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

```python import numpy as np %matplotlib inline import matplotlib.pyplot as plt import seaborn as sns sns.set() ``` # The frequency of a Ricker wavelet We often use Ricker wavelets to model seismic, for example when making a synthetic seismogram with which to help tie a well. One simple way to guesstimate the peak or central frequency of the wavelet that will model a particlar seismic section is to count the peaks per unit time in the seismic. But this tends to overestimate the actual frequency because the maximum [frequency](http://www.subsurfwiki.org/wiki/Frequency) of [a Ricker wavelet](http://subsurfwiki.org/wiki/Ricker_wavelet) is more than the peak frequency. The question is, how much more? To investigate, let's make a Ricker wavelet and see what it looks like in the time and frequency domains. ```python T, dt, f = 0.256, 0.001, 25 import bruges w, t = bruges.filters.ricker(T, dt, f, return_t=True) import scipy.signal f_W, W = scipy.signal.welch(w, fs=1/dt, nperseg=256) ``` ```python fig, axs = plt.subplots(figsize=(15,5), ncols=2) axs[0].plot(t, w) axs[0].set_xlabel("Time [s]") axs[1].plot(f_W[:25], W[:25], c="C1") axs[1].set_xlabel("Frequency [Hz]") plt.show() ``` When we count the peaks in a section, the assumption is that this apparent frequency &mdash; that is, the reciprocal of apparent period or distance between the extrema &mdash; tells us the dominant or peak frequency. To help see why this assumption is wrong, let's compare the Ricker with a signal whose apparent frequency does match its peak frequency: a pure cosine: ```python c = np.cos(2*25*np.pi*t) f_C, C = scipy.signal.welch(c, fs=1/dt, nperseg=256) ``` ```python fig, axs = plt.subplots(figsize=(15,5), ncols=2) axs[0].plot(t, c, c="C2") axs[0].set_xlabel("Time [s]") axs[1].plot(f_C[:25], C[:25], c="C1") axs[1].set_xlabel("Frequency [Hz]") plt.show() ``` Notice that the signal is much narrower in bandwidth. If we allowed more oscillations, it would be even narrower. If it lasted forever, it would be a spike in the frequency domain. Let's overlay the signals to get a picture of the difference in the relative periods: ```python plt.figure(figsize=(15, 5)) plt.plot(t, c, c='C2') plt.plot(t, w) plt.xlabel("Time [s]") plt.show() ``` The practical consequence of this is that if we estimate the peak frequency to be $f\ \mathrm{Hz}$, then we need to reduce $f$ by some factor if we want to design a wavelet to match the data. To get this factor, we need to know the apparent period of the Ricker function, as given by the time difference between the two minima. Let's look at a couple of different ways to find those minima: numerically and analytically. ## Find minima numerically We'll use [`scipy.optimize.minimize`](https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize.html#scipy.optimize.minimize) to find a numerical solution. In order to use it, we'll need a slightly different expression for the Ricker function &mdash; casting it in terms of a time basis `t`. We'll also keep `f` as a variable, rather than hard-coding it in the expression, to give us the flexibility of computing the minima for different values of `f`. Here's the equation we're implementing: $$w(t, f) = (1 - 2\pi^2 f^2 t^2)\ e^{-\pi^2 f^2 t^2}$$ ```python def ricker(t, f): return (1 - 2*(np.pi*f*t)**2) * np.exp(-(np.pi*f*t)**2) ``` Check that the wavelet looks like it did before, by comparing the output of this function when `f` is 25 with the wavelet `w` we were using before: ```python f = 25 np.allclose(w, ricker(t, f=25)) ``` True ```python plt.figure(figsize=(15, 5)) plt.plot(w, lw=3) plt.plot(ricker(t, f), '--', c='C4', lw=3) plt.show() ``` Now we call SciPy's `minimize` function on our `ricker` function. It itertively searches for a minimum solution, then gives us the `x` (which is really `t` in our case) at that minimum: ```python import scipy.optimize f = 25 scipy.optimize.minimize(ricker, x0=0, args=(f)) ``` fun: -0.4462603202963996 hess_inv: array([[1]]) jac: array([-2.19792128e-07]) message: 'Optimization terminated successfully.' nfev: 30 nit: 1 njev: 10 status: 0 success: True x: array([0.01559393]) So the minimum amplitude, given by `fun`, is $-0.44626$ and it occurs at an `x` (time) of $\pm 0.01559\ \mathrm{s}$. In comparison, the minima of the cosine function occur at a time of $\pm 0.02\ \mathrm{s}$. In other words, the period appears to be $0.02 - 0.01559 = 0.00441\ \mathrm{s}$ shorter than the pure waveform, which is... ```python (0.02 - 0.01559) / 0.02 ``` 0.22050000000000003 ...about 22% shorter. This means that if we naively estimate frequency by counting peaks or zero crossings, we'll tend to overestimate the peak frequency of the wavelet by about 22% &mdash; assuming it is approximately Ricker-like; if it isn't we can use the same method to estimate the error for other functions. This is good to know, but it would be interesting to know if this parameter depends on frequency, and also to have a more precise way to describe it than a decimal. To get at these questions, we need an analytic solution. ## Find minima analytically Python's [SymPy package](http://sympy.org/) is a bit like Maple &mdash; it understands math symbolically. We'll use [`sympy.solve`](http://docs.sympy.org/latest/modules/solvers/solvers.html) to find an analytic solution. It turns out that it needs the Ricker function writing in yet another way, using SymPy symbols and expressions for $\mathrm{e}$ and $\pi$. ```python import sympy as sp t = sp.Symbol('t') f = sp.Symbol('f') r = (1 - 2*(sp.pi*f*t)**2) * sp.exp(-(sp.pi*f*t)**2) ``` Now we can easily find the solutions to the Ricker equation, that is, the times at which the function is equal to zero: ```python sp.solvers.solve(r, t) ``` [-sqrt(2)/(2*pi*f), sqrt(2)/(2*pi*f)] But this is not quite what we want. We need the minima, not the zero-crossings. Maybe there's a better way to do this, but here's one way. Note that the gradient (slope or derivative) of the Ricker function is zero at the minima, so let's just solve the first time derivative of the Ricker function. That will give us the three times at which the function has a gradient of zero. ```python dwdt = sp.diff(r, t) sp.solvers.solve(dwdt, t) ``` [0, -sqrt(6)/(2*pi*f), sqrt(6)/(2*pi*f)] In other words, the non-zero minima of the Ricker function are at: $$\pm \frac{\sqrt{6}}{2\pi f}$$ Let's just check that this evaluates to the same answer we got from `scipy.optimize`, which was 0.01559. ```python np.sqrt(6) / (2 * np.pi * 25) ``` 0.015593936024673521 The solutions agree. While we're looking at this, we can also compute the analytic solution to the amplitude of the minima, which SciPy calculated as -0.446. We just substitute one of the expressions for the minimum time into the expression for `r`: ```python r.subs({t: sp.sqrt(6)/(2*sp.pi*f)}) ``` -2*exp(-3/2) ## Apparent frequency So what's the result of all this? What's the correction we need to make? The minima of the Ricker wavelet are $\sqrt{6}\ /\ \pi f_\mathrm{actual}\ \mathrm{s}$ apart &mdash; this is the apparent period. If we're assuming a pure tone, this period corresponds to an apparent frequency of $\pi f_\mathrm{actual}\ /\ \sqrt{6}\ \mathrm{Hz}$. For $f = 25\ \mathrm{Hz}$, this apparent frequency is: ```python (np.pi * 25) / np.sqrt(6) ``` 32.06374575404661 If we were to try to model the data with a Ricker of 32 Hz, the frequency will be too high. We need to multiply the frequency by a factor of $\sqrt{6} / \pi$, like so: ```python 32.064 * np.sqrt(6) / (np.pi) ``` 25.00019823475659 This gives the correct frequency of 25 Hz. To sum up, rearranging the expression above: $$f_\mathrm{actual} = f_\mathrm{apparent} \frac{\sqrt{6}}{\pi}$$ Expressed as a decimal, the factor we were seeking is therefore $\sqrt{6}\ /\ \pi$: ```python np.sqrt(6) / np.pi ``` 0.779696801233676 That is, the reduction factor is 22%. ---- Curious coincidence: in [the recent Pi Day post](https://agilescientific.com/blog/2018/3/14/happy-pi-day-einstein), I mentioned the Riemann zeta function of 2 as a way to compute pi. It evaluates to $(\pi / \sqrt{6})^2$. Is there a connection between the Ricker wavelet and the Riemann hypothesis? I doubt it.

6d3dd9a9d6328af6673124db842a76ef6f03aaa4

ipynb

Jupyter Notebook

The_frequency_of_a_Ricker.ipynb

agilescientific/notebooks

cc5ef92f218d39d1d31f9c5e89aaeb8c6d466c20

2015-01-02T16:45:25.000Z

2022-01-29T14:01:00.000Z

The_frequency_of_a_Ricker.ipynb

afcarl/notebooks-agile-geoscience

446a992bf670ddbae7d2524a41e667a56db09bff

2018-01-02T15:25:06.000Z

2018-01-02T15:25:06.000Z

The_frequency_of_a_Ricker.ipynb

afcarl/notebooks-agile-geoscience

446a992bf670ddbae7d2524a41e667a56db09bff

2015-01-02T16:45:25.000Z

2022-02-25T01:18:45.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

## Teoría de perturbaciones Consiste en resolver un sistema perturbado(se conoce la solución al no perturbado), y donde el interés es conocer la contribución de la parte perturbada $H'$ al nuevo sistema total. $$ H = H^{0} + H'$$ Para sistemas no degenerados, la corrección a la energía a primer orden se calcula como $$ E_{n}^{(1)} = \int\psi_{n}^{(0)*} H' \psi_{n}^{(0)}d\tau$$ ** Tarea 1 : Programar esta ecuación si conoces $H^{0}$ y sus soluciones. ** ```python from sympy.physics.qho_1d import psi_n from sympy.physics.qho_1d import E_n from sympy import * from sympy import init_printing; init_printing(use_latex = 'mathjax') n, m, m_e, omega, hbar = symbols('n m m_e omega hbar', real = True, constant = True) var('x') m_e = 9.10938356e-31 n = Abs(sympify(input('Valor de la energia: '))) omega = sympify(input('Frecuencia Angular: ')) # Funcion de onda del hamiltoniano H.O no perturbado FunOnda = psi_n(n, x, m_e, omega) #Energia del hamiltoniano no perturbado E0 = E_n(n, omega) #Se necesita definir el nuevo hamiltoniano agregando la perturbacion H = ((-(hbar**2)/(2*m_e))*diff(FunOnda, x, 2) + FunOnda*(m_e*(omega*x)**2)/(2))+FunOnda*sympify(input('Perturbation: ')) #Producto interno sandwich = conjugate(FunOnda)*H E = integrate(sandwich, (x, -oo,oo)) Error = (((E-E0)*100)/E0) E ``` Valor de la energia: 1 Frecuencia Angular: 1 Perturbation: 0 $$\frac{0.75 \hbar^{2}}{\hbar} + 0.75 \hbar$$ Y la corrección a la función de onda, también a primer orden, se obtiene como: $$ \psi_{n}^{(1)} = \sum_{m\neq n} \frac{\langle\psi_{m}^{(0)} | H' | \psi_{n}^{(0)} \rangle}{E_{n}^{(0)} - E_{m}^{(0)}} \psi_{m}^{(0)}$$ **Tarea 2: Programar esta ecuación si conoces $H^{0}$ y sus soluciones. ** ```python ### Solución #Importar de sympy el hamiltoniano y eigenfunciones para el oscilador armónico cuántico from sympy.physics.qho_1d import psi_n from sympy.physics.qho_1d import E_n from sympy import * from sympy import init_printing; init_printing(use_latex = 'mathjax') n, m, m_e, omega, hbar = symbols('n m m_e omega hbar', real = True, constant = True) var('x') m_e = 9.10938356e-31 #Nivel de energia, sobre el cual realizar la corrección n = Abs(sympify(input('Nivel de energia para la correcion de la funcion de onda: '))) i= Abs(sympify(input('Nivel mas alto de energia:'))) omega = sympify(input('Frecuencia Angular: ')) #Funcion de onda no perturbada FunOnda = psi_n(n, x, m_e, omega) #Energía previa a la perturbación E0 = E_n(n, omega) #Nuevo hamiltoniano, contiene el original y la perturbacion H = FunOnda*sympify(input('Perturbacion: ')) #Energia no perturbada del Hamiltoniano E0 = E_n(n, omega) psicorrec = 0 for m in range(i): if m !=n: psim= psi_n(m, x, m_e, omega) producto = conjugate(psim)*H sandwich = integrate(producto, (x,-oo,oo)) Em = E_n(m, omega) correc = ((sandwich)/(E0-Em))*psim psicorrec = psicorrec + correc else: psicorrec = psicorrec #Integral del producto interno sandwich = conjugate(FunOnda)*H E = E0 + integrate(sandwich, (x, -oo,oo)) Error = (((E-E0)*100)/E0) psipert = FunOnda + psicorrec psipert.evalf() psiplot = conjugate(psipert)*psipert plot(psiplot,(x,-0.1,0.1)) ``` **Tarea 3: Investigue las soluciones a segundo orden y también programe las soluciones. ** ```python ### Solución #La forma para la corrección de la energía a segundo orden es parecida. Trabajamos con energía en vez de funciones de onda. from sympy.physics.qho_1d import psi_n from sympy.physics.qho_1d import E_n from sympy import * from sympy import init_printing; init_printing(use_latex = 'mathjax') n, m, m_e, omega, hbar = symbols('n m m_e omega hbar', real = True, constant = True) var('x') m_e = 9.10938356e-31 #Nivel de energia sobre la cual trabajamos n = Abs(sympify(input('Nivel de energia para la correcion de la funcion de onda: '))) i= Abs(sympify(input('Nivel mas alto de energia:'))) omega = sympify(input('Frecuencia angular: ')) #Funcion de onda no perturbada FunOnda = psi_n(n, x, m_e, omega) #Energía antes de la perturbación E0 = E_n(n, omega) #Nuevo hamiltoniano, contiene el original y la perturbacion H = FunOnda*sympify(input('Perturbacion: ')) intepriorden = conjugate(FunOnda)*H priorden = integrate (intepriorden, (x,-oo,oo)) #Energia del hamiltoniano no perturbado E0 = E_n(n, omega) Ecorrec = 0 #La primera parte de la corrección a 2º orden es la de primer orden for m in range(i): if m !=n: psim= psi_n(m, x, m_e, omega) product = conjugate(psim)*H sandwich = integrate(product, (x,-oo,oo)) Em = E_n(m, omega) corr = ((sandwich)**2/(E0-Em)) Ecorrec = Ecorrec + corr else: Ecorrec = Ecorrec E = E0 + priorden + Ecorrec E ``` Nivel de energia para la correcion de la funcion de onda: 1 Nivel mas alto de energia:10 Frecuencia angular: 1 Perturbacion: x**3 $$- 1.17409001625997 \cdot 10^{91} \hbar^{2} - \frac{\hbar^{2}}{\pi} 1.883130520616 \cdot 10^{59} + \frac{3 \hbar}{2}$$ **Tarea 4. Resolver el átomo de helio aplicando los programas anteriores.** ```python from sympy.physics.hydrogen import E_nl, R_nl var('r1, r2, q', positive=True, real=True) def Helium(N1,N2,L1,L2): Eb=E_nl(N1,1)+E_nl(N2,1) Psi1=R_nl(N1, L1, r1, Z=1) Psi2=R_nl(N2, L2, r2, Z=1) Psi=Psi1*Psi2 E_correction1 = integrate(integrate(r1**2*r2**2*conjugate(Psi1)*conjugate(Psi2)*q**2*Psi1*Psi2/abs(r1-r2), (r1,0,oo)), (r2,0,oo)) E_correctionR1 = q**2*integrate(r2**2*conjugate(Psi2)*Psi2*(integrate(r1**2*conjugate(Psi1)*Psi1/r2, (r1,0,r2))+integrate(r1**2*conjugate(Psi1)*Psi1/r1, (r1,r2,oo))), (r2,0,oo)) return Psi, Eb, E_correction1, E_correctionR1 E_correction1, E_correctionR1 Helium (1,1,0,0) ``` $$\left ( \frac{4}{e^{r_{1}} e^{r_{2}}}, \quad -1, \quad 16 q^{2} \int_{0}^{\infty} \frac{r_{2}^{2}}{e^{2 r_{2}}} \int_{0}^{\infty} \frac{r_{1}^{2}}{e^{2 r_{1}} \left|{r_{1} - r_{2}}\right|}\, dr_{1}\, dr_{2}, \quad \frac{5 q^{2}}{8}\right )$$ **Tarea 5: Método variacional-perturbativo. ** Este método nos permite estimar de forma precisa $E^{(2)}$ y correcciones perturbativas de la energía de órdenes más elevados para el estado fundamental del sistema, sin evaluar sumas infinitas. Ver ecuación 9.38 del libro. **Resolver el átomo de helio, considerando este método (sección 9.4), como mejor le parezca. ** **Tarea 6. Revisar sección 9.7. ** Inicialmente a mano, y sengunda instancia favor de intentar programar sección del problema, i.e. integral de Coulomb e integral de intercambio. ## Siguiente: Segunda parte, Octubre Simetrías moleculares y Hartree-Fock ```python ```

2f78a038361aa710d2708c8a8776481c4f713f38

ipynb

Jupyter Notebook

Perturbaciones/Perturbaciones lalo.ipynb

lazarusA/Density-functional-theory

c74fd44a66f857de570dc50471b24391e3fa901f

Perturbaciones/Perturbaciones lalo.ipynb

lazarusA/Density-functional-theory

c74fd44a66f857de570dc50471b24391e3fa901f

Perturbaciones/Perturbaciones lalo.ipynb

lazarusA/Density-functional-theory

c74fd44a66f857de570dc50471b24391e3fa901f

Qwen/Qwen-72B

1. YES 2. YES

__label__spa_Latn

## Heat Transfer problem with linear initial temperature and steady surface temperature ```python import numpy as np import math import matplotlib.pyplot as plt %matplotlib inline from scipy.optimize import newton from mpl_toolkits.mplot3d import axes3d from matplotlib import cm import numpy.ma as ma from scipy.integrate import odeint from matplotlib import cm import matplotlib.image as mpimg ``` ```python pic = mpimg.imread('screenshot.png') plt.imshow(pic) plt.axis('off') plt.show() ``` \begin{equation}\begin{aligned}& \frac{{\partial u}}{{\partial t}} = k\frac{{{\partial ^2}u}}{{\partial {x^2}}}\\ & u\left( {x,0} \right) = T_0+bx\hspace{0.25in}u\left( {0,t} \right) = {T_0}\hspace{0.25in}\,\,\,\,\,u\left( {L,t} \right) = {T_0}\end{aligned}\label{eq:eq1}\end{equation} This question can be easily solved by Fourier sine series, but we cannot use separation of variables directly since it has nonhomogeneous boundary conditions. Here we us a little trick: Let:$$v(x,t)=u(x,t)-T_0$$ Then the heat equation can be rewritten as: $$ \frac{\partial v}{\partial t}=k\frac{\partial^2 v}{\partial x^2}$$ with the homogeneous boundary conditions: $$v(x,0)=bx, v(0,t)=0, v(L,t)=0$$ The solution can be given by Fourier sine series as: $$v\left( {x,t} \right) = \sum\limits_{n = 1}^\infty {{B_n}\sin \left( {\frac{{n\pi x}}{L}} \right){{\bf{e}}^{ - k{{\left( {\frac{{n\pi }}{L}} \right)}^2}\,t}}}$$ where the coefficient $B_n$ is: \begin{align*}{B_{\,n}} & = \frac{2}{L}\int_{{\,0}}^{{\,L}}{{bx\sin \left( {\frac{{n\,\pi x}}{L}} \right)\,dx}} = \frac{2b}{L}\left. {\left( {\frac{L}{{{n^2}{\pi ^2}}}} \right)\left( {L\sin \left( {\frac{{n\,\pi x}}{L}} \right) - n\pi x\cos \left( {\frac{{n\,\pi x}}{L}} \right)} \right)} \right|_0^L\\ & = \frac{2b}{{{n^2}{\pi ^2}}}\left( {L\sin \left( {n\,\pi } \right) - n\pi L\cos \left( {n\,\pi } \right)} \right)\end{align*} It follows that: $$B_n = \frac{(-1)^{n+1}2bL}{n\pi}$$ The final solution is given as: $$\frac{u(x,t)-T_0}{bl}=\frac{2}{\pi}\sum\limits_{n = 1}^\infty \frac{(-1)^{n+1}}{n}sin(\frac{n\pi x}{L})e^{-k(\frac{n\pi}{L})^2 t}$$ ##### Discussion: In transient heat transfer problems,introduce the dimensionless number: Fourier number ,noted as $Fo$ $$Fo=\frac{kt}{L^2}$$ where k is the thermal diffusivity in $m^2/s$. The physical meaning of $Fo$ is: $$Fo = \frac{\text{diffusive transport rate}}{\text{storage rate}}$$ $Fo$ can act as "Dimentionless time" in related analysis since the originial heat equation: $$\frac{\partial u}{\partial t} = k \frac{\partial^2 u}{\partial x^2}$$ can be rewritten as the dimentionless form: $$\frac{\partial u}{\partial \Theta} = \frac{\partial^2 u}{\partial X^2}$$ where $\Theta = Fo$ and $X=\frac{x}{L}$ ##### Visualize the Fourier series ```python x = np.linspace(0,1,100) y1 = x a = 0 fig, ax = plt.subplots() for n in range (1,50): B = ((-1)**(n+1))/n a = a+ B*np.sin(n*math.pi*x) y2 = 2*a/math.pi ax.plot(x,y1) ax.plot(x,y2) ``` ##### Draw the temperature profile: ```python x = np.linspace(0,1,100) fo = np.linspace(0,0.5,100) xv, fov = np.meshgrid(x,fo) a = 0 for n in range (1,200): B = ((-1)**(n+1))/n a = a+ (B*np.sin(n*math.pi*xv)*np.exp((-(n**2)*(math.pi)**2)*fov)) u = (2*a)/(math.pi)+273 fig = plt.figure(figsize=(8, 8)) ax = fig.add_subplot(111, projection='3d') ax.plot_surface(xv, fov, u, cmap=cm.coolwarm) ax.set_xlabel('x') ax.set_ylabel('Fo') ax.view_init(elev=50, azim=70) # Set To=273K and coefficients b=1, L=1 ``` A perfect visualization of Fourier series in heat transfer problems is given by [3Blue1Brown Solve the heat equations](https://www.youtube.com/watch?v=ToIXSwZ1pJU&t=127s) ```python ```

8cd1f6a76bb8d0952c6af65787270520e59595d6

ipynb

Jupyter Notebook

presentations/11_04_19_Renyu.ipynb

uw-cheme512/uw-cheme512.github.io

6dad7a9554eafb6eba347462d30c62bf9c0ec4da

presentations/11_04_19_Renyu.ipynb

uw-cheme512/uw-cheme512.github.io

6dad7a9554eafb6eba347462d30c62bf9c0ec4da

presentations/11_04_19_Renyu.ipynb

uw-cheme512/uw-cheme512.github.io

6dad7a9554eafb6eba347462d30c62bf9c0ec4da

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

```python # Libraries Sympy and Numpy from sympy import* import numpy as np # To define automatic printing mode (Not needed anymore) # init_printing() # For priting with text from IPython.display import display, Latex # Plotting Libraries from mpl_toolkits import mplot3d import matplotlib.pyplot as plt from matplotlib import cm from matplotlib.ticker import LinearLocator, FormatStrFormatter import matplotlib.ticker as ticker #interactive plotting in separate window #%matplotlib qt #normal charts inside notebooks #%matplotlib inline # Use Latex in plots plt.rcParams['text.usetex'] = False ``` # 1. IPT System Frequency Splitting Model ## Equations Derivation ```python # Definition of the symbolic variables # Resistances --> Coils and Load R_1, R_2, R_L = symbols('R_1, R_2, R_L', real = True) # Inductance and Capacitance C_1, C_2, L_1, L_2, M_i = symbols('C_1, C_2, L_1,L_2, M_i', real = True) # Reactance X_1, X_2 = symbols('X_1, X_2', real = True) # Angular frequency w_e = symbols('w_e', real = True) # Input Voltage and Current V_1, I_1 = symbols('V_1, I_1', real = True) ``` ```python # Reactance in each mesh #X_1 = (w_e*L_1) - (1/(w_e*C_1)) #X_2 = (w_e*L_2) - (1/(w_e*C_2)) ``` - Equivalent Circuit's Matrix Representation: $[Z][I] = [V]$ ```python # Impedance Matriz [Z] Z_m = Matrix([[R_1 + (I*X_1), I*w_e*M_i], [I*w_e*M_i, R_2 + R_L + (I*X_2)]]) # Voltage Vector V_m = Matrix([[V_1], [0]]) ``` ```python # Solve the System of Equations I_m = Z_m.inv()*V_m ``` ```python # Input Current result_I = "Input Current: \n $${} = {}$$".format(latex(I_1), latex(I_m[0])) display(Latex(result_I)) # Separate Numerator and denominator of I1 I_1_n, I_1_d = fraction(I_m[0]) ``` Input Current: $$I_{1} = \frac{V_{1} \left(- i R_{2} - i R_{L} + X_{2}\right)}{- i M_{i}^{2} w_{e}^{2} - i R_{1} R_{2} - i R_{1} R_{L} + R_{1} X_{2} + R_{2} X_{1} + R_{L} X_{1} + i X_{1} X_{2}}$$ ```python # Operate separately each polynomial display(factor(I_1_n)) display(factor(I_1_d + (I*(M_i**2)*(w_e**2)))) ``` $\displaystyle - i V_{1} \left(R_{2} + R_{L} + i X_{2}\right)$ $\displaystyle - i \left(R_{1} + i X_{1}\right) \left(R_{2} + R_{L} + i X_{2}\right)$ ```python # Reconstruct the factored result I_1 = (factor(I_1_n))/(factor(I_1_d + (I*(M_i**2)*(w_e**2))) - (I*(M_i**2)*(w_e**2))) display(simplify(I_1)) ``` $\displaystyle \frac{V_{1} \left(R_{2} + R_{L} + i X_{2}\right)}{M_{i}^{2} w_{e}^{2} + \left(R_{1} + i X_{1}\right) \left(R_{2} + R_{L} + i X_{2}\right)}$ - Input Impedance Expression $Z_{in}$: ```python Z_in = V_1*(1/simplify(I_1)) display(Z_in) ``` $\displaystyle \frac{M_{i}^{2} w_{e}^{2} + \left(R_{1} + i X_{1}\right) \left(R_{2} + R_{L} + i X_{2}\right)}{R_{2} + R_{L} + i X_{2}}$ - Freq. Splitting occurs when $\Im(Z_{in}) = 0$ ```python # Assume both reactance are equal for simplicity # Common reactance X_e X_e = symbols('X_e', real = True) # Substitute the variable Z_in = Z_in.subs([(X_1, X_e), (X_2, X_e)]) # Imaginary part of Zin simplify(im(Z_in)) ``` $\displaystyle \frac{X_{e} \left(- M_{i}^{2} w_{e}^{2} - R_{1} R_{2} - R_{1} R_{L} + X_{e}^{2} + \left(R_{2} + R_{L}\right) \left(R_{1} + R_{2} + R_{L}\right)\right)}{X_{e}^{2} + \left(R_{2} + R_{L}\right)^{2}}$ ```python # Operate separately factor(-(R_1*R_2) - (R_1*R_L) + ((R_2 + R_L)*(R_1 + R_2 + R_L))) ``` $\displaystyle \left(R_{2} + R_{L}\right)^{2}$ ## a) 1st Condition to only have one non-trivial root: $\Delta < 0$ ```python # Angular Resonance frequency (central) w_c = 2*np.pi*(800e3) # 800 kHz # Assume coils' self-inductance equal [H] L_c = 53.49e-6 # Frequency-dependent parameter beta_c = (w_c*L_c)**2 ``` ```python # Formula for condition Delta Delta_c = lambda R, beta, k: (((R**2) - (2*beta))**2) - (4*(beta**2)*(1 - (k**2))) # Inductive Coupling Coefficient Range k_i k_i = np.arange(0, 1 + 0.01, 0.01) print(k_i.shape) print(k_i[-1]) # Load Resistance [ohms] R_L = np.arange(1., 1000. + 1., 1.) print(R_L.shape) print(R_L[-1]) # Create a mesh k_i_m, R_L_m = np.meshgrid(k_i, R_L) # Calculate the function Delta f_delta = Delta_c(R_L_m, beta_c, k_i_m) print(f_delta.shape) ``` (101,) 1.0 (1000,) 1000.0 (1000, 101) ```python #interactive plotting in separate window #%matplotlib qt #normal charts inside notebooks %matplotlib inline # Set the plot --> size(width, height) fig1 = plt.figure(figsize=(15,10)) ################ # 1st Subplot ################ # Set the subplot for the two graphs axs = fig1.add_subplot(1, 2, 1, projection = '3d') # Complete figure information fig1.suptitle('Frequency Splitting: $\Delta$ < 0', fontsize = 20) # For a simple 3D plot #ax = fig.gca(projection = '3d') # Axis labels axs.set_xlabel('Inductive Coupling Coefficient ($k_{i}$)') axs.set_ylabel('Load Resistance ($R^{\'}_{L}$) [$\Omega$]') axs.set_zlabel('Function $\Delta$') # Title axs.set_title('3D Plot of $\Delta$ Function', fontsize = 15) # Plot the surface surf = axs.plot_surface(k_i_m, R_L_m, f_delta, cmap = cm.coolwarm, linewidth = 0, antialiased = False) # Figure size (single plot) #plt.rcParams["figure.figsize"] = (30,30) # Add a color bar which maps values to colors. plt.colorbar(surf, orientation = 'horizontal', shrink=0.6, aspect=20, pad = 0.05) ################ # 2nd Subplot ################ # Set the subplot for the two graphs axs = fig1.add_subplot(1, 2, 2) # Plot the contour plot cp = plt.contour(k_i_m, R_L_m, f_delta, cmap = cm.Spectral) # Define the levels to label #c_labels = [0.e0] # To specify scientific notation fmt = ticker.LogFormatterSciNotation() axs.clabel(cp, inline = 1, colors = 'k', fmt = fmt, fontsize = 10) # Color bar plt.colorbar(cp, orientation = 'horizontal', shrink=0.6, aspect=20, pad = 0.1) # Information axs.set_title('Contour Plot of $\Delta$ Function', fontsize = 15) # Axis labels axs.set_xlabel('Inductive Coupling Coefficient ($k_{i}$)') axs.set_ylabel('Load Resistance ($R^{\'}_{L}$) [$\Omega$]') axs.xaxis.grid(True) axs.yaxis.grid(True) # Distance between subplots fig1.subplots_adjust(wspace=0.3) plt.show() ``` ```python #fig1.savefig ("delta_ipt.eps", format = 'eps') fig1.savefig ("delta_ipt.svg", format = "svg", dpi = 1200) ``` ## b) 2nd Condition to only have one non-trivial root: $(q>0) \wedge (\Delta>0) \wedge (-q + \sqrt{\Delta} \leq 0)$ - The condition $q>0$ implies $R_{L}> \sqrt{2}\omega L$ ```python # We use the previously defined w_c, L_c, and beta_c # RL is re-defined to comply with the condition: # Load Resistance [ohms] R_L = np.arange(np.ceil(np.sqrt(2)*w_c*L_c), 1000. + 1., 1.) # Ceil function --> Up the inferior limit print(R_L.shape) print(f'Load Resistance interval: ({R_L[0]}, {R_L[-1]}]') ``` (620,) Load Resistance interval: (381.0, 1000.0] - With the previous $R_L$ values, determine: <ol> <li> Plot of $\Gamma(R_L, k_i) = -q(R_L) + \sqrt{\Delta(R_L, k_i)} \leq 0$. <li> Only $\Delta > 0$ are importat, so the rest will be nan. </ol> ```python # Formula for condition Gamma Gamma_c = lambda R, beta, k: -((R**2) - (2*beta)) + (np.sqrt(Delta_c(R, beta, k))) # Create a new mesh k_i_m, R_L_m = np.meshgrid(k_i, R_L) print(k_i_m.shape) print(k_i_m) print(R_L_m.shape) print(R_L_m) print() # Calculate the Gamma function f_gamma= Gamma_c(R_L_m, beta_c, k_i_m) print(f'With sqrt(-1): \n {f_gamma} \n') # Since 1 is not part of the result # Invalid values (nan) are set to 1 f_gamma = np.nan_to_num(f_gamma, nan = 1) print(f'After setting to 1: \n {f_gamma} \n') ``` (620, 101) [[0. 0.01 0.02 ... 0.98 0.99 1. ] [0. 0.01 0.02 ... 0.98 0.99 1. ] [0. 0.01 0.02 ... 0.98 0.99 1. ] ... [0. 0.01 0.02 ... 0.98 0.99 1. ] [0. 0.01 0.02 ... 0.98 0.99 1. ] [0. 0.01 0.02 ... 0.98 0.99 1. ]] (620, 101) [[ 381. 381. 381. ... 381. 381. 381.] [ 382. 382. 382. ... 382. 382. 382.] [ 383. 383. 383. ... 383. 383. 383.] ... [ 998. 998. 998. ... 998. 998. 998.] [ 999. 999. 999. ... 999. 999. 999.] [1000. 1000. 1000. ... 1000. 1000. 1000.]] With sqrt(-1): [[ nan nan nan ... nan nan 0. ] [ nan nan nan ... nan nan 0. ] [ nan nan nan ... nan nan 0. ] ... [-12365.74627493 -12364.50058911 -12360.76354272 ... -486.26641676 -244.32643007 0. ] [-12336.38550525 -12335.14282056 -12331.41477751 ... -485.12790536 -243.75454267 0. ] [-12307.13565211 -12305.89595691 -12302.17688225 ... -483.99358204 -243.18475785 0. ]] After setting to 1: [[ 1.00000000e+00 1.00000000e+00 1.00000000e+00 ... 1.00000000e+00 1.00000000e+00 0.00000000e+00] [ 1.00000000e+00 1.00000000e+00 1.00000000e+00 ... 1.00000000e+00 1.00000000e+00 0.00000000e+00] [ 1.00000000e+00 1.00000000e+00 1.00000000e+00 ... 1.00000000e+00 1.00000000e+00 0.00000000e+00] ... [-1.23657463e+04 -1.23645006e+04 -1.23607635e+04 ... -4.86266417e+02 -2.44326430e+02 0.00000000e+00] [-1.23363855e+04 -1.23351428e+04 -1.23314148e+04 ... -4.85127905e+02 -2.43754543e+02 0.00000000e+00] [-1.23071357e+04 -1.23058960e+04 -1.23021769e+04 ... -4.83993582e+02 -2.43184758e+02 0.00000000e+00]] <ipython-input-13-0713b495cec5>:2: RuntimeWarning: invalid value encountered in sqrt Gamma_c = lambda R, beta, k: -((R**2) - (2*beta)) + (np.sqrt(Delta_c(R, beta, k))) ```python # Index of an specific value result = np.where(f_gamma == 1) print('Tuple of arrays returned : ', result) # zip the 2 arrays to get the exact coordinates listOfCoordinates= list(zip(result[0], result[1])) # iterate over the list of coordinates #for cord in listOfCoordinates: # print(cord) # Just the first and last coordinate print(f'1st: {listOfCoordinates[0]},\nlast: {listOfCoordinates[-1]} \n') # Minimum value in sq_de #ind = np.unravel_index(np.argmin(sq_delta, axis=None), sq_delta.shape) #print(ind) #print(sq_delta[ind]) ``` Tuple of arrays returned : (array([ 0, 0, 0, ..., 156, 156, 156]), array([ 0, 1, 2, ..., 8, 9, 10])) 1st: (0, 0), last: (156, 10) ```python #interactive plotting in separate window #%matplotlib qt #normal charts inside notebooks %matplotlib inline # Set the plot --> size(width, height) fig2 = plt.figure(figsize=(15,10)) ################ # 1st Subplot ################ # Set the subplot for the two graphs axs = fig2.add_subplot(1, 2, 1, projection = '3d') # Complete figure information fig2.suptitle('Frequency Splitting: $(q>0) \wedge (\Delta>0) \wedge (-q + \sqrt{\Delta} \leq 0)$', fontsize = 20) # For a simple 3D plot #ax = fig.gca(projection = '3d') # Axis labels axs.set_xlabel('Inductive Coupling Coefficient ($k_{i}$)') axs.set_ylabel('Load Resistance ($R_{L}$) [$\Omega$]') axs.set_zlabel('Function $\Gamma$') # Title axs.set_title('3D Plot of $\Gamma$ Function', fontsize = 15) # Plot the surface surf = axs.plot_surface(k_i_m, R_L_m, f_gamma, cmap = cm.coolwarm, linewidth = 0, antialiased = False) # Figure size (single plot) #plt.rcParams["figure.figsize"] = (30,30) # Add a color bar which maps values to colors. plt.colorbar(surf, orientation = 'horizontal', shrink=0.6, aspect=20, pad = 0.05) ################ # 2nd Subplot ################ # Set the subplot for the two graphs axs = fig2.add_subplot(1, 2, 2) # Plot the contour plot cp = plt.contour(k_i_m, R_L_m,f_gamma, levels = [-4e4, -2e4, -1e4, 0], cmap = cm.Spectral) # Define the levels to label #c_labels = [0.e0] # To specify scientific notation fmt = ticker.LogFormatterSciNotation() axs.clabel(cp, inline = 1, colors = 'k', fmt = fmt, fontsize = 10) # Color bar plt.colorbar(cp, orientation = 'horizontal', shrink=0.6, aspect=20, pad = 0.1) # Information axs.set_title('Contour Plot of $\Gamma$ Function', fontsize = 15) # Axis labels axs.set_xlabel('Inductive Coupling Coefficient ($k_{i}$)') axs.set_ylabel('Load Resistance ($R_{L}$) [$\Omega$]') axs.xaxis.grid(True) axs.yaxis.grid(True) # Distance between subplots fig2.subplots_adjust(wspace=0.3) plt.show() ``` ### - Another way yo visualize only the regions: ```python """ Terms definitions for the IPT problem """ # Definition of term p # Return the value of p term def p_termi(L, k_i): return (L**2)*(1 - (k_i**2)) # Definition of term q # Return the value of q term def q_termi(R, L, C): return (R**2) - ((2*L)/(C)) # Definition of term r # Return the value of r term def r_termi(C): return (1/(C**(2))) # Definition of condition Delta def Delta_IPT(R, L, C, k_i): p_aux = p_termi(L, k_i) #print(f'p {p_aux}') q_aux = q_termi(R, L, C) #print(f'q {q_aux}') r_aux = r_termi(C) #print(f'r {r_aux}') # Delta condition delta = (q_aux**2) - (4*p_aux*r_aux) #print(f'delta {delta}') return delta ``` ```python # Assume coils' self-inductance equal [H] L_c = 53.49e-6 C_r = 739.92e-12 # Inductive Coupling Coefficient Range k_i k_i = np.arange(0, 1 + 0.01, 0.01) print(k_i.shape) print(k_i[-1]) # Load Resistance [ohms] R_L = np.arange(1., 1000. + 1., 1.) print(R_L.shape) print(R_L[-1]) # Create a mesh k_i_m, R_L_m = np.meshgrid(k_i, R_L) ``` (101,) 1.0 (1000,) 1000.0 ```python # Calculate the function gamma (Condition 2) # Only check for the region, the value of # the function is not important f_gamma = ((q_termi(R_L_m, L_c, C_r) > 0) & (Delta_IPT(R_L_m, L_c, C_r, k_i_m) > 0) & (-q_termi(R_L_m, L_c, C_r) + np.sqrt(Delta_IPT(R_L_m, L_c, C_r, k_i_m)) <= 0)).astype(int) print(f_gamma.shape) print(f_gamma) ``` (1000, 101) [[0 0 0 ... 0 0 0] [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]] <ipython-input-25-ae9987a86952>:8: RuntimeWarning: invalid value encountered in sqrt + np.sqrt(Delta_IPT(R_L_m, L_c, C_r, k_i_m)) <= 0)).astype(int) ```python #interactive plotting in separate window #%matplotlib qt #normal charts inside notebooks %matplotlib inline # Set the plot --> size(width, height) fig2 = plt.figure(figsize=(15,10)) ################ # 1st Subplot ################ # Set the subplot for the two graphs axs = fig2.add_subplot(1, 2, 1, projection = '3d') # Complete figure information fig2.suptitle('Frequency Splitting: $(q>0) \wedge (\Delta>0) \wedge (-q + \sqrt{\Delta} \leq 0)$', fontsize = 20) # For a simple 3D plot #ax = fig.gca(projection = '3d') # Axis labels axs.set_xlabel('Inductive Coupling Coefficient ($k_{i}$)') axs.set_ylabel('Load Resistance ($R^{\'}_{L}$) [$\Omega$]') axs.set_zlabel('Function $\Gamma$') # Title axs.set_title('3D Plot of $\Gamma$ Function', fontsize = 15) # Plot the surface surf = axs.plot_surface(k_i_m, R_L_m, f_gamma, cmap = cm.coolwarm, linewidth = 0, antialiased = False) # Figure size (single plot) #plt.rcParams["figure.figsize"] = (30,30) # Add a color bar which maps values to colors. plt.colorbar(surf, orientation = 'horizontal', shrink=0.6, aspect=20, pad = 0.05) ################ # 2nd Subplot ################ # Set the subplot for the two graphs axs = fig2.add_subplot(1, 2, 2) # Plot the contour plot cp = plt.contourf(k_i_m, R_L_m,f_gamma, levels = [-1, 0, 1], cmap = cm.Spectral) # Define the levels to label #c_labels = [0.e0] # To specify scientific notation fmt = ticker.LogFormatterSciNotation() axs.clabel(cp, inline = 1, colors = 'k', fmt = fmt, fontsize = 10) # Color bar plt.colorbar(cp, orientation = 'horizontal', shrink=0.6, aspect=20, pad = 0.1) # Information axs.set_title('Contour Plot of $\Gamma$ Function', fontsize = 15) # Axis labels axs.set_xlabel('Inductive Coupling Coefficient ($k_{i}$)') axs.set_ylabel('Load Resistance ($R^{\'}_{L}$) [$\Omega$]') axs.xaxis.grid(True) axs.yaxis.grid(True) # Distance between subplots fig2.subplots_adjust(wspace=0.5) plt.show() ``` ```python fig2.savefig ("gamma_ipt.svg", format = "svg", dpi = 1200) ``` ## c) 3nd Condition to only have one non-trivial root: $(q<0) \wedge (\Delta>0) \wedge (-q - \sqrt{\Delta} \leq 0)$ <br> This is not a condition to consider since it will provide at least <br> one non-trivial root. - The condition $q<0$ implies $R_L < \sqrt{2}\omega L$ ```python # We use the previously defined w_c, L_c, and beta_c # RL is re-defined to comply with the condition: # Load Resistance [ohms] R_L = np.arange(1., (np.sqrt(2)*w_c*L_c), 1.) print(R_L.shape) print(f'Load Resistance interval: [{R_L[0]}, {R_L[-1]})') ``` (380,) Load Resistance interval: [1.0, 380.0) - With the previous $R_L$ values, determine: <ol> <li> Plot of $\Psi(R_L, k_i) = -q(R_L) - \sqrt{\Delta(R_L, k_i)} \leq 0$. <li> Only $\Delta > 0$ are importat, so the rest will be nan. </ol> ```python # Formula for condition Psi Psi_c = lambda R, beta, k: -((R**2) - (2*beta)) - (np.sqrt(Delta_c(R, beta, k))) # Create a new mesh k_i_m, R_L_m = np.meshgrid(k_i, R_L) print(k_i_m.shape) print(k_i_m) print(R_L_m.shape) print(R_L_m) print() # Calculate the Psi function f_psi= Psi_c(R_L_m, beta_c, k_i_m) print(f'With sqrt(-1): \n {f_psi} \n') # Since 1 is not part of the result # Invalid values (nan) are set to 1 f_psi = np.nan_to_num(f_psi, nan = 1.) print(f'After setting to 1: \n {f_psi} \n') ``` (380, 101) [[0. 0.01 0.02 ... 0.98 0.99 1. ] [0. 0.01 0.02 ... 0.98 0.99 1. ] [0. 0.01 0.02 ... 0.98 0.99 1. ] ... [0. 0.01 0.02 ... 0.98 0.99 1. ] [0. 0.01 0.02 ... 0.98 0.99 1. ] [0. 0.01 0.02 ... 0.98 0.99 1. ]] (380, 101) [[ 1. 1. 1. ... 1. 1. 1.] [ 2. 2. 2. ... 2. 2. 2.] [ 3. 3. 3. ... 3. 3. 3.] ... [378. 378. 378. ... 378. 378. 378.] [379. 379. 379. ... 379. 379. 379.] [380. 380. 380. ... 380. 380. 380.]] With sqrt(-1): [[ nan 143239.12214754 141740.019677 ... 2891.66489673 1445.83234529 0. ] [ nan 143611.91175624 141894.01763856 ... 2891.72612341 1445.86264939 0. ] [ nan nan 142173.38925858 ... 2891.82817368 1445.91315905 0. ] ... [ nan nan nan ... nan nan 0. ] [ nan nan nan ... nan nan 0. ] [ nan nan nan ... nan nan 0. ]] After setting to 1: [[1.00000000e+00 1.43239122e+05 1.41740020e+05 ... 2.89166490e+03 1.44583235e+03 0.00000000e+00] [1.00000000e+00 1.43611912e+05 1.41894018e+05 ... 2.89172612e+03 1.44586265e+03 0.00000000e+00] [1.00000000e+00 1.00000000e+00 1.42173389e+05 ... 2.89182817e+03 1.44591316e+03 0.00000000e+00] ... [1.00000000e+00 1.00000000e+00 1.00000000e+00 ... 1.00000000e+00 1.00000000e+00 0.00000000e+00] [1.00000000e+00 1.00000000e+00 1.00000000e+00 ... 1.00000000e+00 1.00000000e+00 0.00000000e+00] [1.00000000e+00 1.00000000e+00 1.00000000e+00 ... 1.00000000e+00 1.00000000e+00 0.00000000e+00]] <ipython-input-12-f4cf8d1a4a28>:2: RuntimeWarning: invalid value encountered in sqrt Psi_c = lambda R, beta, k: -((R**2) - (2*beta)) - (np.sqrt(Delta_c(R, beta, k))) ```python # Index of an specific value result = np.where(f_psi == 1) print('Tuple of arrays returned : ', result) # zip the 2 arrays to get the exact coordinates listOfCoordinates= list(zip(result[0], result[1])) # iterate over the list of coordinates #for cord in listOfCoordinates: # print(cord) # Just the first and last coordinate print(f'1st: {listOfCoordinates[0]},\nlast: {listOfCoordinates[-1]} \n') # Minimum value in sq_de #ind = np.unravel_index(np.argmin(sq_delta, axis=None), sq_delta.shape) #print(ind) #print(sq_delta[ind]) ``` Tuple of arrays returned : (array([ 0, 1, 2, ..., 379, 379, 379]), array([ 0, 0, 0, ..., 97, 98, 99])) 1st: (0, 0), last: (379, 99) ```python #interactive plotting in separate window #%matplotlib qt #normal charts inside notebooks %matplotlib inline # To specify scientific notation fmt = ticker.LogFormatterSciNotation() # Set the plot --> size(width, height) fig = plt.figure(figsize=(15,10)) ################ # 1st Subplot ################ # Set the subplot for the two graphs axs = fig.add_subplot(1, 2, 1, projection = '3d') # Complete figure information fig.suptitle('Frequency Splitting: $(q<0) \wedge (\Delta>0) \wedge (-q - \sqrt{\Delta} \leq 0)$', fontsize = 20) # For a simple 3D plot #ax = fig.gca(projection = '3d') # Axis labels axs.set_xlabel('Inductive Coupling Coefficient ($k_{i}$)') axs.set_ylabel('Load Resistance ($R_{L}$) [$\Omega$]') axs.set_zlabel('Function $\Psi$') # Title axs.set_title('3D Plot of $\Psi$ Function', fontsize = 15) # Plot the surface surf = axs.plot_surface(k_i_m, R_L_m, f_psi, cmap = cm.coolwarm, linewidth = 0, antialiased = False) # Figure size (single plot) #plt.rcParams["figure.figsize"] = (30,30) # Add a color bar which maps values to colors. plt.colorbar(surf, orientation = 'horizontal', shrink=0.6, aspect=20, pad = 0.05) ################ # 2nd Subplot ################ # Set the subplot for the two graphs axs = fig.add_subplot(1, 2, 2) # Plot the contour plot cp = plt.contour(k_i_m, R_L_m,f_psi, levels = [0, 2e4, 6e4, 1e5], cmap = cm.Spectral) # Define the levels to label #c_labels = [-2e10, 0, 1e10] axs.clabel(cp, inline = 1, colors = 'k', fmt = fmt, fontsize = 10) # Color bar plt.colorbar(cp, format = fmt, orientation = 'horizontal', shrink=0.6, aspect=20, pad = 0.1) # Information axs.set_title('Contour Plot of $\Psi$ Function', fontsize = 15) # Axis labels axs.set_xlabel('Inductive Coupling Coefficient ($k_{i}$)') axs.set_ylabel('Load Resistance ($R_{L}$) [$\Omega$]') axs.xaxis.grid(True) axs.yaxis.grid(True) # Distance between subplots fig.subplots_adjust(wspace=0.3) plt.show() ``` # 2. Freq. Splitting Model for Active Compensation Network ## Equations Derivation ```python # Definition of the symbolic variables # Resistances --> Coils and Load R_1, R_2, R_L = symbols('R_1, R_2, R_L', real = True) # Inductance and Capacitance C_1, C_2, L_1, L_2, M_i = symbols('C_1, C_2, L_1,L_2, M_i', real = True) # Reactance X_1, X_2, X_m = symbols('X_1, X_2, X_m', real = True) # Angular frequency w_e = symbols('w_e', real = True) # Input Voltage and Current V_1, I_1 = symbols('V_1, I_1', real = True) ``` - Equivalent Circuit's Matrix Representation: $[Z][I] = [V]$ ```python # Impedance Matriz [Z] Z_m = Matrix([[R_1 + (I*X_1), I*X_m], [I*X_m, R_2 + R_L + (I*X_2)]]) # Voltage Vector V_m = Matrix([[V_1], [0]]) ``` ```python # Solve the System of Equations I_m = Z_m.inv()*V_m ``` ```python # Input Current result_I = "Input Current: \n $${} = {}$$".format(latex(I_1), latex(I_m[0])) display(Latex(result_I)) # Separate Numerator and denominator of I1 I_1_n, I_1_d = fraction(I_m[0]) ``` Input Current: $$I_{1} = \frac{V_{1} \left(- i R_{2} - i R_{L} + X_{2}\right)}{- i R_{1} R_{2} - i R_{1} R_{L} + R_{1} X_{2} + R_{2} X_{1} + R_{L} X_{1} + i X_{1} X_{2} - i X_{m}^{2}}$$ ```python # Operate separately each polynomial display(factor(I_1_n)) display(factor(I_1_d + (I*(X_m**2)))) ``` $\displaystyle - i V_{1} \left(R_{2} + R_{L} + i X_{2}\right)$ $\displaystyle - i \left(R_{1} + i X_{1}\right) \left(R_{2} + R_{L} + i X_{2}\right)$ ```python # Reconstruct the factored result I_1 = (factor(I_1_n))/(factor(I_1_d + (I*(X_m**2))) - (I*(X_m**2))) display(simplify(I_1)) ``` $\displaystyle \frac{V_{1} \left(R_{2} + R_{L} + i X_{2}\right)}{X_{m}^{2} + \left(R_{1} + i X_{1}\right) \left(R_{2} + R_{L} + i X_{2}\right)}$ - Input Impedance Expression $Z_{in}$: ```python Z_in = V_1*(1/simplify(I_1)) display(Z_in) ``` $\displaystyle \frac{X_{m}^{2} + \left(R_{1} + i X_{1}\right) \left(R_{2} + R_{L} + i X_{2}\right)}{R_{2} + R_{L} + i X_{2}}$ - Freq. Splitting occurs when $\Im(Z_{in}) = 0$ ```python # Assume both reactance are equal for simplicity # Common reactance X_e X_e = symbols('X_e', real = True) # Substitute the variable Z_in = Z_in.subs([(X_1, X_e), (X_2, X_e)]) # Imaginary part of Zin simplify(im(Z_in)) ``` $\displaystyle \frac{X_{e} \left(- R_{1} R_{2} - R_{1} R_{L} + X_{e}^{2} - X_{m}^{2} + \left(R_{2} + R_{L}\right) \left(R_{1} + R_{2} + R_{L}\right)\right)}{X_{e}^{2} + \left(R_{2} + R_{L}\right)^{2}}$ ```python # Operate separately factor(-(R_1*R_2) - (R_1*R_L) + ((R_2 + R_L)*(R_1 + R_2 + R_L))) ``` $\displaystyle \left(R_{2} + R_{L}\right)^{2}$ - Analyze the simple non-trivial root $\chi = 0$ ```python # Definition of the symbolic variables # Capacitances T-Model C_ep, C_Mp = symbols('C_ep, C_Mp', real = True) # Capacitances Pi-Model C_e, C_M = symbols('C_e, C_M', real = True) # Capacitive Coupling Coefficient k_c = symbols('k_c', real = True) ``` ```python # Replace the k_c C_M = k_c*C_e # Equivalent Pi --> T Model C_ep = C_e + (2*C_M) C_Mp = (C_e/C_M)*(C_ep) ``` ```python # Operation for the main resonance frequency # Defining the equivalent parallel capacitance C_pp = ((1/C_ep) + (1/C_Mp))**(-1) simplify(C_pp) ``` $\displaystyle \frac{C_{e} \left(2 k_{c} + 1\right)}{k_{c} + 1}$ ```python # C_Mp also appears in the formula simplify(C_Mp) ``` $\displaystyle 2 C_{e} + \frac{C_{e}}{k_{c}}$ ## a) 1st Condition to only have one non-trivial root: $\Delta < 0$ <ol> <li> $L$ and $k_i$ are fixed from the IPT Model. <li> External capacitance $C_e$ is defined according to standard values. <li> $0 < k_c < 1$ <li> Frequency dependence is visualized separetely. </ol> ```python # Defining the Inductive Coupling Coefficient k_i k_i = np.array([0.214]) # Assume coils' self-inductance equal [H] L_c = 53.49e-6 # External Capacitance [F] C_e = np.array([0.668e-9]) ``` - Define methods to calculate the condition $\Delta$ ```python ################################## ## Define Methods for Calculations ################################## # Definition of Equivalent Parallel Capacitance C_pp def C_ppri(C, k_c): return (C*(1 + (2*k_c)))/(1 + k_c) # Definition of the Mutual Capacitance in T-Model (C_Mp) def C_Mpri(C, k_c): return C*((1/k_c) + 2) # Definition of term p # Return the value of p term def p_term(L, k_i): return (L**2)*(1 - (k_i**2)) # Definition of term q # Return the value of q term def q_term(R, L, C, k_c, k_i): return (R**2) + (2*L*((k_i/C_Mpri(C, k_c)) - (1/C_ppri(C, k_c)))) # Definition of term r # Return the value of r term def r_term(C, k_c): return (1/((C_ppri(C, k_c))**2)) - (1/((C_Mpri(C, k_c))**2)) # Definition of condition Delta def Delta_c1(R, L, C, k_c, k_i): # Auxiliar variables C_Mp = C_Mpri(C, k_c) #print(f'C_Mp {C_Mp}') C_pp = C_ppri(C, k_c) #print(f'C_pp {C_pp}') p_aux = p_term(L, k_i) #print(f'p {p_aux}') q_aux = q_term(R, L, C, k_c, k_i) #print(f'q {q_aux}') r_aux = r_term(C, k_c) #print(f'r {r_aux}') # Delta condition delta = (q_aux**2) - (4*p_aux*r_aux) #print(f'delta {delta}') return delta ``` ```python # Capacitive Coupling Coefficient Range k_c k_c = np.arange(0.01, 1 + 0.01, 0.01) print(k_c.shape) print(k_c) # Load Resistance [ohms] R_L = np.arange(1., 1000. + 1., 1.) print(R_L.shape) print(R_L[-1]) # Create a mesh k_c_m, R_L_m = np.meshgrid(k_c, R_L) # Calculate the function Delta f_delta = Delta_c1(R_L_m, L_c, C_e, k_c_m, k_i) print(f_delta.shape) ``` (100,) [0.01 0.02 0.03 0.04 0.05 0.06 0.07 0.08 0.09 0.1 0.11 0.12 0.13 0.14 0.15 0.16 0.17 0.18 0.19 0.2 0.21 0.22 0.23 0.24 0.25 0.26 0.27 0.28 0.29 0.3 0.31 0.32 0.33 0.34 0.35 0.36 0.37 0.38 0.39 0.4 0.41 0.42 0.43 0.44 0.45 0.46 0.47 0.48 0.49 0.5 0.51 0.52 0.53 0.54 0.55 0.56 0.57 0.58 0.59 0.6 0.61 0.62 0.63 0.64 0.65 0.66 0.67 0.68 0.69 0.7 0.71 0.72 0.73 0.74 0.75 0.76 0.77 0.78 0.79 0.8 0.81 0.82 0.83 0.84 0.85 0.86 0.87 0.88 0.89 0.9 0.91 0.92 0.93 0.94 0.95 0.96 0.97 0.98 0.99 1. ] (1000,) 1000.0 (1000, 100) ```python #interactive plotting in separate window #%matplotlib qt #normal charts inside notebooks %matplotlib inline # Set the plot --> size(width, height) fig1 = plt.figure(figsize=(15,10)) ################ # 1st Subplot ################ # Set the subplot for the two graphs axs = fig1.add_subplot(1, 2, 1, projection = '3d') # Complete figure information fig1.suptitle('Frequency Splitting Active CN: $\Delta$ Function', fontsize = 20) # For a simple 3D plot #ax = fig.gca(projection = '3d') # Axis labels axs.set_xlabel('Capacitive Coupling Coefficient ($k_c$)') axs.set_ylabel('Load Resistance ($R_L$) [$\Omega$]') axs.set_zlabel('Function $\Delta$') # Title axs.set_title('3D Plot of $\Delta$ Function', fontsize = 15) # Plot the surface surf = axs.plot_surface(k_c_m, R_L_m, f_delta, cmap = cm.coolwarm, linewidth = 0, antialiased = False) # Figure size (single plot) #plt.rcParams["figure.figsize"] = (30,30) # Add a color bar which maps values to colors. plt.colorbar(surf, orientation = 'horizontal', shrink=0.6, aspect=20, pad = 0.05) ################ # 2nd Subplot ################ # Set the subplot for the two graphs axs = fig1.add_subplot(1, 2, 2) # Plot the contour plot cp = plt.contour(k_c_m, R_L_m, f_delta, levels = [-0.5e11, 0, 1.5e11, 3e11, 4.5e11], cmap = cm.Spectral) # Define the levels to label #c_labels = [0.e0] # To specify scientific notation fmt = ticker.LogFormatterSciNotation() axs.clabel(cp, inline = 1, colors = 'k', fmt = fmt, fontsize = 10) # Color bar plt.colorbar(cp, orientation = 'horizontal', shrink=0.6, aspect=20, pad = 0.1) # Information axs.set_title('Contour Plot of $\Delta$ Function', fontsize = 15) # Axis labels axs.set_xlabel('Capacitive Coupling Coefficient ($k_c$)') axs.set_ylabel('Load Resistance ($R_L$) [$\Omega$]') axs.xaxis.grid(True) axs.yaxis.grid(True) # Distance between subplots fig1.subplots_adjust(wspace=0.3) plt.show() ``` ```python #fig1.savefig ("delta_ipt.eps", format = 'eps') fig1.savefig ("delta_acn.svg", format = "svg", dpi = 1200) ``` - Plot the behavior of resonance frequency (central) w.r.t. $k_c$ <br> $w_r = \sqrt{\frac{1}{L {C^{\prime}_{p}}}}$ ```python # Define central resonance frequency def f_operation(L, C, k_c): freq = (1/(2*np.pi))*np.sqrt((1)/(L*C_ppri(C, k_c))) return freq ``` ```python # Calculate the resonance frequency f_res = (1e-3)*f_operation(L_c, C_e, k_c) print(f_res.shape) ``` (100,) ```python #interactive plotting in separate window %matplotlib qt #normal charts inside notebooks #%matplotlib inline # Set the plot --> size(width, height) fig2 = plt.figure(figsize=(10,10)) ax = fig2.gca() # Axis labels ax.set_xlabel('Capacitive Coupling Coefficient $k_{c}$') ax.set_ylabel('Resonance Frequency ($f_{r}$) [kHz]') # Title ax.set_title('System\'s Resonance Frequency', fontsize = 25) # Plot the surface lines = ax.plot(k_c, f_res, 'g', linewidth = 2.5) ax.xaxis.grid(True) ax.yaxis.grid(True) # Axis limits ax.set_xlim([0, 1]) # Legend #plt.legend(('Maxwell'), loc = 'upper right') plt.show() ``` ```python fig2.savefig ("fresonant_acn.svg", format = "svg", dpi = 1200) ``` ## b) 2nd Condition to only have one non-trivial root: $(q>0) \wedge (\Delta>0) \wedge (-q + \sqrt{\Delta} \leq 0)$ ```python # Defining the Inductive Coupling Coefficient k_i k_i = np.array([0.214]) # Assume coils' self-inductance equal [H] L_c = np.array([53.49e-6]) # External Capacitance [F] C_e = np.array([0.66e-9]) ``` ```python # Capacitive Coupling Coefficient Range k_c k_c = np.arange(0.01, 1 + 0.01, 0.01) print(k_c.shape) print(k_c) # Load Resistance [ohms] R_L = np.arange(1., 1000. + 1., 1.) print(R_L.shape) print(R_L[-1]) # Create a mesh k_c_m, R_L_m = np.meshgrid(k_c, R_L) ``` (100,) [0.01 0.02 0.03 0.04 0.05 0.06 0.07 0.08 0.09 0.1 0.11 0.12 0.13 0.14 0.15 0.16 0.17 0.18 0.19 0.2 0.21 0.22 0.23 0.24 0.25 0.26 0.27 0.28 0.29 0.3 0.31 0.32 0.33 0.34 0.35 0.36 0.37 0.38 0.39 0.4 0.41 0.42 0.43 0.44 0.45 0.46 0.47 0.48 0.49 0.5 0.51 0.52 0.53 0.54 0.55 0.56 0.57 0.58 0.59 0.6 0.61 0.62 0.63 0.64 0.65 0.66 0.67 0.68 0.69 0.7 0.71 0.72 0.73 0.74 0.75 0.76 0.77 0.78 0.79 0.8 0.81 0.82 0.83 0.84 0.85 0.86 0.87 0.88 0.89 0.9 0.91 0.92 0.93 0.94 0.95 0.96 0.97 0.98 0.99 1. ] (1000,) 1000.0 ```python # Calculate the function gamma (Condition 2) # Only check for the region, the value of # the function is not important f_gamma = ((q_term(R_L_m, L_c, C_e, k_c_m, k_i) > 0) & (Delta_c1(R_L_m, L_c, C_e, k_c_m, k_i) > 0) & (-q_term(R_L_m, L_c, C_e, k_c_m, k_i) + np.sqrt(Delta_c1(R_L_m, L_c, C_e, k_c_m, k_i)) <= 0)).astype(int) print(f_gamma.shape) print(f_gamma) ``` (1000, 100) [[0 0 0 ... 0 0 0] [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]] <ipython-input-17-fd1090a33310>:8: RuntimeWarning: invalid value encountered in sqrt + np.sqrt(Delta_c1(R_L_m, L_c, C_e, k_c_m, k_i)) <= 0)).astype(int) ```python # Index of an specific value result = np.where(np.isnan(f_gamma)) print('Tuple of arrays returned : ', result) # zip the 2 arrays to get the exact coordinates listOfCoordinates= list(zip(result[0], result[1])) # iterate over the list of coordinates #for cord in listOfCoordinates: # print(cord) # Just the first and last coordinate print(f'1st: {listOfCoordinates[0]},\nlast: {listOfCoordinates[-1]} \n') # Minimum value in sq_de #ind = np.unravel_index(np.argmin(sq_delta, axis=None), sq_delta.shape) #print(ind) #print(sq_delta[ind]) ``` ```python #interactive plotting in separate window #%matplotlib qt #normal charts inside notebooks %matplotlib inline # Set the plot --> size(width, height) fig1 = plt.figure(figsize=(15,10)) ################ # 1st Subplot ################ # Set the subplot for the two graphs axs = fig1.add_subplot(1, 2, 1, projection = '3d') # Complete figure information fig1.suptitle('Frequency Splitting: $(q>0) \wedge (\Delta>0) \wedge (-q + \sqrt{\Delta} \leq 0)$', fontsize = 20) # For a simple 3D plot #ax = fig.gca(projection = '3d') # Axis labels axs.set_xlabel('Capacitive Coupling Coefficient ($k_c$)') axs.set_ylabel('Load Resistance ($R_{L}$) [$\Omega$]') axs.set_zlabel('Function $\Gamma$') # Title axs.set_title('3D Plot of $\Gamma$ Function', fontsize = 15) # Plot the surface surf = axs.plot_surface(k_c_m, R_L_m, f_gamma, cmap = cm.coolwarm, linewidth = 0, antialiased = False) # Figure size (single plot) #plt.rcParams["figure.figsize"] = (30,30) # Add a color bar which maps values to colors. plt.colorbar(surf, orientation = 'horizontal', shrink=0.6, aspect=20, pad = 0.05) ################ # 2nd Subplot ################ # Set the subplot for the two graphs axs = fig1.add_subplot(1, 2, 2) # Plot the contour plot cp = plt.contourf(k_c_m, R_L_m, f_gamma, levels = [-1, 0, 1], cmap = cm.Spectral) # Define the levels to label #c_labels = [0.e0] # To specify scientific notation fmt = ticker.LogFormatterSciNotation() axs.clabel(cp, inline = 1, colors = 'k', fmt = fmt, fontsize = 10) # Color bar plt.colorbar(cp, orientation = 'horizontal', shrink=0.6, aspect=20, pad = 0.09) # Information axs.set_title('Contour Plot of $\Gamma$ Function', fontsize = 15) # Axis labels axs.set_xlabel('Capacitive Coupling Coefficient ($k_c$)') axs.set_ylabel('Load Resistance ($R_L$) [$\Omega$]') axs.xaxis.grid(True) axs.yaxis.grid(True) # Distance between subplots fig1.subplots_adjust(wspace=0.3) plt.show() ``` ```python fig1.savefig ("fresonant_acn.svg", format = "svg", dpi = 1200) ``` ```python # 3. $\pi$-Model and $T$-Model equivalent equations - Equivalent capacitive model for 4 plates ``` ## $\pi$-Model: ```python # Define the symbolic variables # Capacitance c_1, c_2, c_M = symbols('c_1 c_2 c_M', real = True) # Angular frequency w = symbols('w', real = True) ``` ```python # Common denominator com_D = (1/(w*I))*(1/c_1 + 1/c_2 + 1/c_M) ``` ```python # T-model equivalent c'_1 Zp_1 = ((1/(w*I))**2)*((1/c_1)*(1/c_M))/com_D simplify(Zp_1) ``` ```python # T-model equivalent c'_2 Zp_2 = ((1/(w*I))**2)*((1/c_2)*(1/c_M))/com_D simplify(Zp_2) ``` ```python # T-model equivalent c'_M Zp_M = ((1/(w*I))**2)*((1/c_1)*(1/c_2))/com_D simplify(Zp_M) ``` ## $T$-Model: ```python # Define the symbolic variables # Capacitance cp_1, cp_2, cp_M = symbols('cp_1 cp_2 cp_M', real = True) ``` ```python # Common numerator com_N = ((1/(w*I))**2)*((1/(cp_1*cp_M)) + (1/(cp_1*cp_2)) + (1/(cp_M*cp_2))) ``` ```python # Pi-model equivalent c_1 Z_1 = (com_N)/(1/(w*cp_2*I)) simplify(Z_1) ``` ```python # Pi-model equivalent c_2 Z_2 = (com_N)/(1/(w*cp_1*I)) simplify(Z_2) ``` ```python # Pi-model equivalent c_M Z_M = (com_N)/(1/(w*cp_M*I)) simplify(Z_M) ``` # 4. Latex Formulas $\Im(Z_{in}) = \frac{\chi [(R^{'}_{L} + R_{2})^{2} + \chi^{2} - (\omega M)^{2}]}{(R^{'}_{L} + R_{2})^{2} + \chi^{2}} = 0$ $\chi = \omega L - \frac{1}{\omega C}$ $k_{i} = \frac{M}{L} $ $R^{'}_{L} \gg R_{2} \Rightarrow (R^{'}_{L} + R_{2}) \approx R^{'}_{L}$ $f(\omega^{2}) = \left[ L^{2}(1 - k_{i}^{2}) \right] (\omega^{2})^{2} + \left[ R^{'2}_{L} - \frac{2L}{C} \right] \omega^{2} + \frac{1}{C^{2}}$ $\omega = \sqrt{\frac{-q \pm \sqrt{\Delta}}{2p}}$ $\Delta = q^{2} - 4pr$ $-q \pm \sqrt{\Delta} \leq 0$ $\Im(Z_{in}) = \frac{\chi [(R^{'}_{L} + R_{2})^{2} + \chi^{2} - \chi_{m}^{2}]}{(R^{'}_{L} + R_{2})^{2} + \chi^{2}} = 0$ $\chi = \omega L - \frac{1}{\omega C^{'}_{p}}$ $\chi_{m} = \omega M - \frac{1}{\omega C^{'}_{M}}$ $\frac{1}{C^{'}_{p}} = \frac{1}{C^{'}} + \frac{1}{C^{'}_{M}} = \frac{C + C_{M}}{C(C + 2C_{M})}$ $f(\omega^{2}) = \left[ L^{2}(1 - k_{i}^{2}) \right] (\omega^{2})^{2} + \left[ R^{'2}_{L} + 2L \left(\frac{k_{i}}{C^{'}_{M}} - \frac{1}{C^{'}_{p}} \right) \right] \omega^{2} + \left( \frac{1}{C^{'2}_{p}} - \frac{1}{C^{'2}_{M}} \right)$ $k_{c} = \frac{C_{M}}{C} $ ```python ```

3746cff2a0ac284d2be70101aaf1f9ee848ec599

ipynb

Jupyter Notebook

Active_CN_Model.ipynb

SanTT19/Symbolic_Python

3bfaec4fc62de52e6a592cf3db333e605a35fcbc

Active_CN_Model.ipynb

SanTT19/Symbolic_Python

3bfaec4fc62de52e6a592cf3db333e605a35fcbc

Active_CN_Model.ipynb

SanTT19/Symbolic_Python

3bfaec4fc62de52e6a592cf3db333e605a35fcbc

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

<a href="https://colab.research.google.com/github/colbrydi/Scientific_Image_Understanding/blob/master/05-Registration-pre-class-assignment.ipynb" target="_parent"></a> # Pre-Class Assignment: Image Registration # Goals for today's pre-class assignment 1. [Image Registration](#Image-Registration) 2. [Basic Rigid Transforms](#Basic-Rigid-Transforms) 3. [ Affine Transforms](#-Affine-Transforms) 4. [Projective Transformations](#Projective-Transformations) 5. [Homography](#Homography) --- <a name=Image-Registration></a> # 1. Image Registration Image registration is the process of transforming different sets of image data into a common coordinate system. This is like moving one image on top of another image. A reasonable overview for image Registration can be found here; https://en.wikipedia.org/wiki/Image_registration Consider the following example of two pictures of Beaumont Tower at Michigan State university: ```python # Read data for this assignment %matplotlib inline import matplotlib.pyplot as plt from urllib.request import urlopen, urlretrieve from imageio import imread, imsave url1 = 'http://res.cloudinary.com/miles-extranet-dev/image/upload/ar_16:9,c_fill,w_1000,g_face,q_50/Michigan/migration_photos/G21696/G21696-msubeaumonttower01.jpg' file1='Tower1.jpeg' urlretrieve(url1, file1) im1 = imread(file1) url2 = 'https://research.msu.edu/wp-content/uploads/2019/11/beaumont-winter.jpg' file2 = 'Tower2.jpeg' urlretrieve(url2, file2) im2= imread(file2) f, (ax1, ax2) = plt.subplots(1, 2,figsize=(20,10)) ax1.imshow(im1) ax2.imshow(im2) ``` --- <a name=Basic-Rigid-Transforms></a> # 2. Basic Rigid Transforms **&#9989; DO THIS:** Use the following code and sliders to register the second image onto the first image. Try to find the best fit so that the towers line up exactly. The sliders will let you change the scale (s), x translation (tx), y-translation (ty), and rotation angle (angle). You can also adjust the alpha measure to help "see though" one image into the other. ```python from __future__ import division import matplotlib.pyplot as plt import numpy as np from skimage import transform from ipywidgets import interact, fixed import warnings warnings.simplefilter(action='ignore', category=FutureWarning) im = im1 def affine_image(im1, im2, s=1,tx=0,ty=0, angle=0, alpha=0.5): theta = -angle/180 * np.pi dx = tx*im.shape[1] dy = ty*im.shape[0] S = np.matrix([[1/s,0,0], [0,1/s,0], [0,0,1]]) T2 = np.matrix([[1,0,im.shape[1]/2], [0,1,im.shape[0]/2], [0,0,1]]) T1 = np.matrix([[1,0,-im.shape[1]/2-dx], [0,1,-im.shape[0]/2-dy], [0,0,1]]) R = np.matrix([[np.cos(theta),-np.sin(theta),0],[np.sin(theta), np.cos(theta),0],[0,0,1]]) T = T2*S*R*T1; img = transform.warp(im, T); plt.imshow(im2); plt.imshow(img, alpha=alpha); plt.show(); interact(affine_image, im1=fixed(im1), im2=fixed(im2), s=(0.001,5), tx=(-1.0,1.0), ty=(-1,1,0.1), angle=(-180,180), alpha=(0.0,1.0)); ``` --- <a name=-Affine-Transforms></a> # 3. Affine Transforms The above example is for an Rigid body transform. However, more complex transformations are possible. Watch the following video to learn more about Affine Transforms. ```python from IPython.display import YouTubeVideo YouTubeVideo("il6Z5LCykZk",width=640,height=360) ``` --- <a name=Projective-Transformations></a> # 4. Projective Transformations Projective transforms add additional degrees of freedom and can "skew" an image. Watch the following video on Projective Transforms. ```python from IPython.display import YouTubeVideo YouTubeVideo("uyYKPUZg3og",width=640,height=360) ``` --- <a name=Homography></a> # 5. Homography The Homography operations calculates a projective transformation using a set of points on one plain mapped to a similar set of points on a different plain. Since images often represent plains this turns out to be a useful registration method in image analysis. More information about the math can be found here: https://en.wikipedia.org/wiki/Homography_(computer_vision) and http://people.scs.carleton.ca/~c_shu/Courses/comp4900d/notes/homography.pdf Consider the following example code from a psychological study in game theory. The researcher would like to have a computer watch a game between two checkers players and analysis their moves. To do this they need to register the checkboards to the same grid. The code below uses the ```skimage.transform.ProjectiveTransform``` which calculates the transform using homography. ```python #The following code snip-it downloads a file from internet and saves it to your local directory. from urllib.request import urlopen, urlretrieve import scipy.misc as misc url = 'https://goo.gl/j2SFnL' file1 = 'Checkers.png' urlretrieve(url, file1); im = imread(file1) #Points in source image coordinate system src = np.array([[156, 197],[284, 181],[407, 177],[172, 296],[318, 275],[452, 264],[190, 418],[359, 387],[507, 371]]) ``` ```python #Calculate Transform from skimage import transform width=1000 #Points in desitnation coordinate system dst = np.array([[0, width/2, width, 0, width/2, width, 0, width/2, width,], [0, 0, 0, width/2, width/2, width/2, width, width, width]]).T #Calculate projective transform from the source to the destination tform = transform.ProjectiveTransform() tform.estimate(dst, src) im2 = transform.warp(im, tform, output_shape=(width,width)) ``` ```python import sympy as sym sym sym.Matrix(tform.params) ``` ```python #show original image next to transformed image f, (ax1, ax2) = plt.subplots(1, 2,figsize=(20,10)) ax1.imshow(im) ax1.scatter(src[:,0],src[:,1]) #Add numbers for i in range(dst.shape[0]): ax1.annotate(str(i+1), (src[i,0]+20,src[i,1]), color='white'); ax1.set_title('Source Plain') ax2.imshow(im2) ax2.scatter(dst[:,0],dst[:,1]) #Add numbers for i in range(dst.shape[0]): ax2.annotate(str(i+1), (dst[i,0]+20,dst[i,1])); ax2.set_title('Destination Plain') ax2.axis('equal'); ``` --- Written by Dr. Dirk Colbry, Michigan State University <a rel="license" href="http://creativecommons.org/licenses/by-nc/4.0/"></a><br />This work is licensed under a <a rel="license" href="http://creativecommons.org/licenses/by-nc/4.0/">Creative Commons Attribution-NonCommercial 4.0 International License</a>. ---

b4a973a529ea760a226a73e32a230e2ac0bf05dd

ipynb

Jupyter Notebook

05-Registration-pre-class-assignment.ipynb

colbrydi/Scientific_Image_Understandin

c4c931fd3bf20f899b8ebaaeef24c15eaca43867

2021-02-24T15:23:42.000Z

2022-01-10T20:36:11.000Z

05-Registration-pre-class-assignment.ipynb

colbrydi/Scientific_Image_Understandin

c4c931fd3bf20f899b8ebaaeef24c15eaca43867

05-Registration-pre-class-assignment.ipynb

colbrydi/Scientific_Image_Understandin

c4c931fd3bf20f899b8ebaaeef24c15eaca43867

2021-03-01T16:54:31.000Z

2022-01-24T20:42:36.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# Balancer Simulations Math Challenge - Advanced This notebook provides a collection of challenges for an advanced understanding of Balancer Math. ```python import numpy as np import pandas as pd import plotly.express as px import plotly.graph_objects as go from plotly.subplots import make_subplots import math ``` # Challenge No. 1 For the following questions, there are two tokens $X$ and $Y$, with $x$ representing the number of Token $X$ in the pool, and $y$ representing the number of Token $Y$ in the pool. The plots below represent the invariant curves for two Balancer Pools. Both curves are of the form $2 = x^ay^{1-a}$ for some value of $a$. Try as many of the exercises below as you want -- discuss them with others and have fun! 1. Explain how the equation $V = B_1^{W_1}B_2^{W_2}$ becomes $2 = x^ay^{1-a}$ in this context. #### Solution $V$ is the invariant and the specific value for this case is 2 $a$ and $1-a$ are the weights of token $x$ and token $y$ respectively 2. Give one possible value of $a$ and a pair of possible legal values for $x$ and $y$ in this context. #### Solution The only restriction for $a$ is it to be a positive value in range (0,1). Let´s assume $x = 10$ and let´s see how $y$ changes with regard to $a$ ```python a_vals = pd.Series(range(1,10,1)) List = pd.DataFrame(a_vals/10, columns=['a']) List['1-a'] = 1-List.a List['token_A'] = 10 List['token_B'] = (2/(List.token_A**List.a))**(1/(1-List.a)) List ``` <div> <style scoped> .dataframe tbody tr th:only-of-type { vertical-align: middle; } .dataframe tbody tr th { vertical-align: top; } .dataframe thead th { text-align: right; } </style> <table border="1" class="dataframe"> <thead> <tr style="text-align: right;"> <th></th> <th>a</th> <th>1-a</th> <th>token_A</th> <th>token_B</th> </tr> </thead> <tbody> <tr> <th>0</th> <td>0.1</td> <td>0.9</td> <td>10</td> <td>1.672502</td> </tr> <tr> <th>1</th> <td>0.2</td> <td>0.8</td> <td>10</td> <td>1.337481</td> </tr> <tr> <th>2</th> <td>0.3</td> <td>0.7</td> <td>10</td> <td>1.003394</td> </tr> <tr> <th>3</th> <td>0.4</td> <td>0.6</td> <td>10</td> <td>0.683990</td> </tr> <tr> <th>4</th> <td>0.5</td> <td>0.5</td> <td>10</td> <td>0.400000</td> </tr> <tr> <th>5</th> <td>0.6</td> <td>0.4</td> <td>10</td> <td>0.178885</td> </tr> <tr> <th>6</th> <td>0.7</td> <td>0.3</td> <td>10</td> <td>0.046784</td> </tr> <tr> <th>7</th> <td>0.8</td> <td>0.2</td> <td>10</td> <td>0.003200</td> </tr> <tr> <th>8</th> <td>0.9</td> <td>0.1</td> <td>10</td> <td>0.000001</td> </tr> </tbody> </table> </div> 3. Rewrite the curve $2 = x^ay^{1-a}$ in the form "$y =$ (some expression involving x)" and plot it using the Python tool of your choice. #### Solution $$ y = (\frac{2}{x^a})^{1/(1-a)} $$ 4. Generate 100 $(x,y)$ points on the curve $2 = x^{0.6}y^{0.4}$. Now take the **logarithm** of both $x$ and $y$ in your 100 points. Plot $\log(x)$ against $\log(y)$. What do you notice? ```python x = pd.Series(range(10,0,-1)) a = .6 b = .4 List = pd.DataFrame(x, columns=['token_A']) List['token_B'] = (2/(List.token_A**a))**(1/(b)) List['log_A'] = np.log(List.token_A) List['log_B'] = np.log(List.token_B) List ``` <div> <style scoped> .dataframe tbody tr th:only-of-type { vertical-align: middle; } .dataframe tbody tr th { vertical-align: top; } .dataframe thead th { text-align: right; } </style> <table border="1" class="dataframe"> <thead> <tr style="text-align: right;"> <th></th> <th>token_A</th> <th>token_B</th> <th>log_A</th> <th>log_B</th> </tr> </thead> <tbody> <tr> <th>0</th> <td>10</td> <td>0.178885</td> <td>2.302585</td> <td>-1.721010</td> </tr> <tr> <th>1</th> <td>9</td> <td>0.209513</td> <td>2.197225</td> <td>-1.562969</td> </tr> <tr> <th>2</th> <td>8</td> <td>0.250000</td> <td>2.079442</td> <td>-1.386294</td> </tr> <tr> <th>3</th> <td>7</td> <td>0.305441</td> <td>1.945910</td> <td>-1.185997</td> </tr> <tr> <th>4</th> <td>6</td> <td>0.384900</td> <td>1.791759</td> <td>-0.954771</td> </tr> <tr> <th>5</th> <td>5</td> <td>0.505964</td> <td>1.609438</td> <td>-0.681289</td> </tr> <tr> <th>6</th> <td>4</td> <td>0.707107</td> <td>1.386294</td> <td>-0.346574</td> </tr> <tr> <th>7</th> <td>3</td> <td>1.088662</td> <td>1.098612</td> <td>0.084950</td> </tr> <tr> <th>8</th> <td>2</td> <td>2.000000</td> <td>0.693147</td> <td>0.693147</td> </tr> <tr> <th>9</th> <td>1</td> <td>5.656854</td> <td>0.000000</td> <td>1.732868</td> </tr> </tbody> </table> </div> ```python #plot curves with all fig = px.line(List, x='log_B', y='log_A') fig.update_xaxes(range=[-6, 6]) fig.update_yaxes(range=[-1, 6]) fig.update_layout(height=800, width=800, title_text='<b>AMM Curve</b>') fig.show() ``` #### Solutions The relationship between the variables is linear and the slope of the line is the ration between the weights of the tokens 5. Both pictures above represent AMM curves of the form $2 = x^{a}y^{1-a}$. One of the curves has $a =0.6$ and the other has $a = 0.8$. Which is which? How can you tell? #### Solution - There are no pics 6. Both of the curves pictured above contain the point $(2,2)$. Explain why any curve of the form $2= x^{a}y^{1-a}$ will pass through $(2,2)$. Is this a special property of the number 2, or will any curve of the form $k = x^{a}y^{1-a}$ pass through $(k,k)$? (You can determine this with an algebraic proof, or by playing with Python graphs.) #### Solution Proof by contradiction. (Attempt 1) Suppose there is no point $(k, k)$ in the curve $k = x^{a}y^{1-a}$. $\begin{align} & \text{Let $ y := x $} \quad (\textit{Is this sound?})\tag{1}. \\ & k = x^{a}y^{1-a} \quad \text{(given)} \tag{2} \\ & k = x^{a}x^{1-a} \quad \text{(substituting from (1))} \tag{3} \\ & k = x^{a+1-a} \quad \text{(product of exponents)} \tag{4} \\ & k = x^{1} \tag{5} \\ & k = x \tag{6} \end{align} $ However, since $x = k$, per (1) this means $y = k$ also, meaning that point $(k, k)$ exists, contradicting the original assumption. $\square$ Proof by contradiction. (Attempt 2) Suppose there is no point $(k, k)$ in the curve $k = x^{a}y^{1-a}$. $ \begin{align*} \text{Let}\ x &:= k \tag{1}. \\ k &= x^{a}y^{1-a} \quad \text{(Given.)} \tag{2} \\ k &= k^{a}y^{1-a} \quad \text{(Substituting from (1).)} \tag{3} \\ \frac{k}{k^{a}} &= y^{1-a} \tag{4} \\ \log \frac{k}{k^{a}} &= \log y^{1-a} \tag{5} \\ \log {k} - \log {k^{a}} &= \log y^{1-a} \tag{6} \\ \log {k} - a \log {k} &= (1-a) \log y \tag{7} \\ \log {k} - a \log {k} &= \log y - a \log y\tag{8} \\ k &= y \tag{9} \quad \text{(Since a $\log$ function has only one $x$ mapping to every $\log x$.)} \end{align*} $ However, since $x = k$ per (1) and also $y=k$ per (9) this means point $(k, k)$ exists, contradicting the original assumption. $\square$ 7. Suppose a curve $2 = x^ay^{1-a}$ passes through the point $(2,2)$ and $(p,q)$. Explain how you can use the values of $p$ and $q$ to determine the weights of Token $X$ and Token $Y$. #### Solution $ \begin{align*} 2 &= x^a y^{(1-a)} \\ 2 &= p^a q^{(1-a)} \\ 2 &= x^a y^{(1-a)} \\ p^a q^{(1-a)} &= x^a y^{(1-a)}\\ \log \left(p^a q^{(1-a)}\right) &= \log \left( x^a y^{(1-a)} \right)\\ \log (p^a) + \log (q^{(1-a)}) &= \log (x^a) + \log (y^{(1-a)}) \\ a \log p + (1-a) \log q &= a \log x + (1-a) \log y \\ a \log p + \log q - a \log q &= a \log x + \log y - a \log y \\ a (\log p - \log q) + \log q &= a (\log x - \log y) + \log y \\ \log q - \log y &= a (\log x - \log y) - a (\log p - \log q)\\ \log q - \log y &= a ((\log x - \log y) - (\log p - \log q))\\ \log q - \log y &= a (\log x + \log q - \log y - \log p )\\ \frac{\log q - \log y}{\log x + \log q - \log y - \log p }&= a \\ \end{align*} $ $ \begin{align} a = \frac{\log q - \log y}{\log x + \log q - \log y - \log p } \tag{1} \end{align} $ Check: ```python a = 0.8 # Let a = 0.8; we'll use this to check the Equation 1. x = 2 # Per premise y = 2 # Per premise p = 5 # Arbitrary point q = (2/(p**a))**(1/(1-a)) # Calculated from p via invariant function """Check equality in Equation 1.""" (math.log(q)- math.log(y))/(math.log(x) + math.log(q) - math.log(y) - math.log(p)) == a ``` 8. In **Alice's Pool**, which point has the highest spot price $SP_X^{Y}$: **A**, **B** or **C**? (You may be able to answer this without calculation.) 9. Suppose Alice is actively managing her pool against Bob's pool and wishes to trade it against Bob's pool. Identify a pair of points -- one in her pool and one in Bob's pool -- that would represent an arbitrage opportunity for Alice. ```python x = pd.Series(range(100,0,-1)) a = .6 b = .4 List = pd.DataFrame(x/10, columns=['token_A']) List['token_B'] = (2/(List.token_A**a))**(1/(b)) a = .8 b = .2 List2 = pd.DataFrame(x/10, columns=['token_A2']) List2['token_B2'] = (2/(List2.token_A2**a))**(1/(b)) L = pd.concat([List, List2], axis=1) L.head(20) ``` <div> <style scoped> .dataframe tbody tr th:only-of-type { vertical-align: middle; } .dataframe tbody tr th { vertical-align: top; } .dataframe thead th { text-align: right; } </style> <table border="1" class="dataframe"> <thead> <tr style="text-align: right;"> <th></th> <th>token_A</th> <th>token_B</th> <th>token_A2</th> <th>token_B2</th> </tr> </thead> <tbody> <tr> <th>0</th> <td>10.0</td> <td>0.178885</td> <td>10.0</td> <td>0.003200</td> </tr> <tr> <th>1</th> <td>9.9</td> <td>0.181603</td> <td>9.9</td> <td>0.003331</td> </tr> <tr> <th>2</th> <td>9.8</td> <td>0.184389</td> <td>9.8</td> <td>0.003469</td> </tr> <tr> <th>3</th> <td>9.7</td> <td>0.187248</td> <td>9.7</td> <td>0.003615</td> </tr> <tr> <th>4</th> <td>9.6</td> <td>0.190181</td> <td>9.6</td> <td>0.003768</td> </tr> <tr> <th>5</th> <td>9.5</td> <td>0.193192</td> <td>9.5</td> <td>0.003929</td> </tr> <tr> <th>6</th> <td>9.4</td> <td>0.196283</td> <td>9.4</td> <td>0.004099</td> </tr> <tr> <th>7</th> <td>9.3</td> <td>0.199458</td> <td>9.3</td> <td>0.004278</td> </tr> <tr> <th>8</th> <td>9.2</td> <td>0.202718</td> <td>9.2</td> <td>0.004467</td> </tr> <tr> <th>9</th> <td>9.1</td> <td>0.206069</td> <td>9.1</td> <td>0.004666</td> </tr> <tr> <th>10</th> <td>9.0</td> <td>0.209513</td> <td>9.0</td> <td>0.004877</td> </tr> <tr> <th>11</th> <td>8.9</td> <td>0.213054</td> <td>8.9</td> <td>0.005100</td> </tr> <tr> <th>12</th> <td>8.8</td> <td>0.216696</td> <td>8.8</td> <td>0.005336</td> </tr> <tr> <th>13</th> <td>8.7</td> <td>0.220443</td> <td>8.7</td> <td>0.005586</td> </tr> <tr> <th>14</th> <td>8.6</td> <td>0.224299</td> <td>8.6</td> <td>0.005850</td> </tr> <tr> <th>15</th> <td>8.5</td> <td>0.228269</td> <td>8.5</td> <td>0.006130</td> </tr> <tr> <th>16</th> <td>8.4</td> <td>0.232357</td> <td>8.4</td> <td>0.006427</td> </tr> <tr> <th>17</th> <td>8.3</td> <td>0.236569</td> <td>8.3</td> <td>0.006743</td> </tr> <tr> <th>18</th> <td>8.2</td> <td>0.240910</td> <td>8.2</td> <td>0.007078</td> </tr> <tr> <th>19</th> <td>8.1</td> <td>0.245385</td> <td>8.1</td> <td>0.007434</td> </tr> </tbody> </table> </div> ```python # In pool 1, to buy 0.1 tokens A $0.181603 - 0.178885 = 0.0027179$ tokens_B are required # In pool 2, to buy 0.1 tokens A $0.003331 - 0.003200 = 0.0001310$ tokens_B are required # Considering the point token_A = 9.9, if we sell 0.1 token_A in pool 1 we get 0.0027179 token_B but the price of buying 0.1 token_A in pool 2 is only $0.003469-0.003331=0.0001379$ so we end up with the same amount of token_A + $0.0027179 - 0.0001379 = 0.002580$ token_B. # If we want to buy more token_A in pool 2, our next 0.1 token_A would cost $0.003615-0.003469=0.0001460$ so we could have now .2 token_A plus $0.002580-0.0001460=0.002434$ token_B ``` 0.002434 ```python cash = L.token_B.iloc[1]-L.token_B.iloc[0] expense = 0 i = 1 count = 0.1 while expense < cash: expense_new = L.token_B2.iloc[i+1]-L.token_B2.iloc[i] i+=1 expense += expense_new count += 0.1 count ``` 1.5000000000000002 ```python #plot curves with all List = List[['token_A', 'token_B']] List2 = List2[['token_B2']] df = pd.concat([List, List2], axis=1, ignore_index=False) fig = px.line(df, x="token_A", y=["token_B", 'token_B2']) fig.update_xaxes(range=[0, 10]) fig.update_yaxes(range=[0, 10]) fig.update_layout(height=1000, width=1000, title_text='<b>AMM Curve</b>') fig.show() ``` 10. Create the invariant curves for Alice's pool and Bob's pool in Python using the graphing tool of your choice. Choose one point on Bob's curve and highlight it in Blue. Call this point **Z**. On your graph of Alice's curve, color in red **all of the points that represent arbitrage opportunities for Alice against Z**, i.e. color red all of the points on Alice's curve that represent where she could make a profit if she traded with Bob while he held the position represented by **Z**. (**Note**: This is the hardest one in terms of symbolic math, since it involves solving an inequality involving power functions.) # Challenge No. 2 Alice wants to set up another pool. She knows that the current price of 1 token C is 37 token D. She owns 57000 token C, and 510000 token D. She plans to set a fee to 1%, and maximize her capital returns via this pool. #### 1. What is the optimal set up for Alice’s new pool? Think about how you’d approach it and explain why. #### 2. Due to a huge price dump, the price of token C on external markets drops to 28 token D. Now, Arbitrage traders get to work. Image Alice wanted to re-balance the pool herself, how much token C would she need in order to re-balance the pool in one trade? Keep in mind swap fees and slippage! #### 3. Imagine Alice’s pool would be twice as big. How much liquidity would she need for the same price change? #### 4. Explore the general relation between the size of the pool (liquidity m in token C and n in token D) and price changes with a series of experiments. • derive an expression • plot a graph #### SOLUTION 1. We understand that profit comes from trading and to be effective and maximize the return, the equilibrium of the pool should be around the trading price. In that sens, we need to calculate the weights of each token according to a Spot Price (SP) equal to the current price $$ SP = \frac{\frac{B_c}{W_c}}{\frac{B_d}{W_d}} = \frac{1}{37} $$ with $$ W_c + W_d = 1 $$ $$ W_d = 1 - W_c $$ $$ SP = \frac{B_c*W_d}{B_d*W_c} = \frac{B_c}{B_d} * \frac{W_d}{1-W_d} $$ $$ SP * \frac{B_d}{B_c} * (1-W_d) = W_d $$ $$ SP * \frac{B_d}{B_c} = x $$ $$ x * (1-W_d) = x - x*W_d = W_d $$ $$ x = W_d (1+x)$$ $$ W_d = \frac{x}{1+x} $$ ```python SP = 1/37 Bc = 57000 Bd = 510000 x = SP*Bd/Bc Wd = x/(1+x) Wd ``` 0.19473081328751435 ```python Wc = 1-Wd Wc ``` 0.8052691867124857 ```python # Checking: SP_check = (Bc/Wc)/(Bd/Wd) SP_check ``` 0.027027027027027032 ```python # What should be the same as: 1/37 ``` 0.02702702702702703 #### SOLUTION 2. Now the $ Price = 1/28 $ but the pool $ SP = 1/37$ so arbitrage is possible. To avoid it through one swap (including fees) we need to look for the trade that moves the price in the pool to $1/28$. As a simplification we are going to consider: $W_c = 0.805$ $W_b = 0.195$ ```python # FIRST WITHOUT FEES ! Bc = 57000 # initial balance Bd = 510000 # initial balance Wc = 0.805 #define weight Wd = 0.195 #define weight s_f = 0.01 #swap fee inv = (Bc**Wc)*(Bd**Wd) #calculate invariant a_vals = pd.Series(range(60160,60170,1)) #create dataframe with based on a_vals List = pd.DataFrame(a_vals, columns=['token_C']) #create values for plot, add Y_balances according to current invariant List['invariant'] = inv #value required to calculate token B value List['token_D'] = (List.invariant/(List.token_C**Wc))**(1/Wd)# calculate corresponding token_B value according to invariant List['Price_C'] = 1/((List.token_C/Wc) / (List.token_D/Wd)) # List['In-Given-Out'] = List.token_D * (( List.token_C / (List.token_C-1) )**(Wc/Wd) -1) List['Out-Given-Out'] = List.token_D * (( List.token_C / (List.token_C-1) )**(Wc/Wd) -1) List ``` <div> <style scoped> .dataframe tbody tr th:only-of-type { vertical-align: middle; } .dataframe tbody tr th { vertical-align: top; } .dataframe thead th { text-align: right; } </style> <table border="1" class="dataframe"> <thead> <tr style="text-align: right;"> <th></th> <th>token_C</th> <th>invariant</th> <th>token_D</th> <th>Price_C</th> <th>In-Given-Out</th> </tr> </thead> <tbody> <tr> <th>0</th> <td>60160</td> <td>87388.733071</td> <td>408163.402192</td> <td>28.008349</td> <td>28.009542</td> </tr> <tr> <th>1</th> <td>60161</td> <td>87388.733071</td> <td>408135.395038</td> <td>28.005961</td> <td>28.007155</td> </tr> <tr> <th>2</th> <td>60162</td> <td>87388.733071</td> <td>408107.390270</td> <td>28.003574</td> <td>28.004768</td> </tr> <tr> <th>3</th> <td>60163</td> <td>87388.733071</td> <td>408079.387889</td> <td>28.001187</td> <td>28.002381</td> </tr> <tr> <th>4</th> <td>60164</td> <td>87388.733071</td> <td>408051.387896</td> <td>27.998800</td> <td>27.999994</td> </tr> <tr> <th>5</th> <td>60165</td> <td>87388.733071</td> <td>408023.390288</td> <td>27.996414</td> <td>27.997607</td> </tr> <tr> <th>6</th> <td>60166</td> <td>87388.733071</td> <td>407995.395067</td> <td>27.994028</td> <td>27.995221</td> </tr> <tr> <th>7</th> <td>60167</td> <td>87388.733071</td> <td>407967.402233</td> <td>27.991642</td> <td>27.992835</td> </tr> <tr> <th>8</th> <td>60168</td> <td>87388.733071</td> <td>407939.411783</td> <td>27.989256</td> <td>27.990449</td> </tr> <tr> <th>9</th> <td>60169</td> <td>87388.733071</td> <td>407911.423720</td> <td>27.986871</td> <td>27.988064</td> </tr> </tbody> </table> </div> An approximation: Bc should be between 60100 and 60200 so the owner would need to bring ~3,1k token_C into the pool and would get 510k-408k = 102k token_B The exact calculation can be done with the In-Given-Price formula: $$ A_i = B_i ((\frac{SP_{new}}{SP})^{(\frac{w_0}{w_0+w_i})})-1)$$ ```python SP = 1/37 SP_new = 1/28 A = Bc * (((SP_new/SP)**(Wd/(Wd+Wc)))-1) A # Amount of token_C to bring to the pool (in exchange for token_B) ``` 3183.6295721159863 #### SOLUTION 2. with fees In-Given-Out formula with fees: a) paying the fee in the token I am getting $$ A_i = B_i * ((\frac{B_o}{B_o + A_o(1-fee)})^{\frac{w_o}{w_i}} -1) $$ or b) if I pay the fee in the token I am giving $$ A_i*(1-fee) = B_i * ((\frac{B_o}{B_o + A_o})^{\frac{w_o}{w_i}} -1) $$ ```python # WITH FEES # First considerations: the amount of tokens to be paid should be higher as some of them goes directly to pay fees Bc = 57000 # initial balance Bd = 510000 # initial balance Wc = 0.805 #define weight Wd = 0.195 #define weight s_f = 0 #swap fee inv = (Bc**Wc)*(Bd**Wd) #calculate invariant a_vals = pd.Series(range(0,5,1)) delta = 1-s_f #create dataframe with based on a_vals List = pd.DataFrame(a_vals, columns=['index']) List['token_C'] = Bc + List.index*(delta) #create values for plot, add Y_balances according to current invariant List['invariant'] = inv #value required to calculate token B value List['token_D'] = (List.invariant/(List.token_C**Wc))**(1/Wd) # calculate corresponding token_B value according to invariant List['Price_C'] = 1/((List.token_C/Wc) / (List.token_D/Wd)) # List['In-Given-Out'] = (List.token_C * (( List.token_D / (List.token_D-1) )**(Wd/Wc) -1)) # / (1-s_f) # List['Out-Given-In'] = (List.token_D * (( List.token_C / (List.token_C + 1) )**(Wc/Wd) -1)) List['New_Own'] = List.token_D * (List.token_C/(List.token_C + delta))**(Wc/Wd) - List.token_D List ``` <div> <style scoped> .dataframe tbody tr th:only-of-type { vertical-align: middle; } .dataframe tbody tr th { vertical-align: top; } .dataframe thead th { text-align: right; } </style> <table border="1" class="dataframe"> <thead> <tr style="text-align: right;"> <th></th> <th>index</th> <th>token_C</th> <th>invariant</th> <th>token_D</th> <th>Price_C</th> <th>New_Own</th> </tr> </thead> <tbody> <tr> <th>0</th> <td>0</td> <td>57000</td> <td>87388.733071</td> <td>510000.000000</td> <td>36.936572</td> <td>-36.934911</td> </tr> <tr> <th>1</th> <td>1</td> <td>57001</td> <td>87388.733071</td> <td>509963.065089</td> <td>36.933249</td> <td>-36.931588</td> </tr> <tr> <th>2</th> <td>2</td> <td>57002</td> <td>87388.733071</td> <td>509926.133501</td> <td>36.929927</td> <td>-36.928266</td> </tr> <tr> <th>3</th> <td>3</td> <td>57003</td> <td>87388.733071</td> <td>509889.205236</td> <td>36.926604</td> <td>-36.924943</td> </tr> <tr> <th>4</th> <td>4</td> <td>57004</td> <td>87388.733071</td> <td>509852.280292</td> <td>36.923283</td> <td>-36.921622</td> </tr> </tbody> </table> </div> ```python List.token_D.iloc[2] - List.token_D.iloc[1] ``` -36.93158792384202 ```python a_vals = pd.Series(range(0,5,1)) s_f = 0.01 delta = 1-s_f #create dataframe with based on a_vals List2 = pd.DataFrame(a_vals, columns=['index']) List2['token_C'] = Bc + List2.index*(delta) #create values for plot, add Y_balances according to current invariant List2['invariant'] = inv #value required to calculate token B value List2['token_D'] = (List2.invariant/(List2.token_C**Wc))**(1/Wd) # calculate corresponding token_B value according to invariant List2['Price_C'] = 1/((List2.token_C/Wc) / (List2.token_D/Wd)) # List['In-Given-Out'] = (List.token_C * (( List.token_D / (List.token_D-1) )**(Wd/Wc) -1)) # / (1-s_f) # List['Out-Given-In'] = (List.token_D * (( List.token_C / (List.token_C + 1) )**(Wc/Wd) -1)) List2['New_Own'] = List2.token_D * (List2.token_C/(List2.token_C +(delta)))**(Wc/Wd) - List2.token_D List2 ``` <div> <style scoped> .dataframe tbody tr th:only-of-type { vertical-align: middle; } .dataframe tbody tr th { vertical-align: top; } .dataframe thead th { text-align: right; } </style> <table border="1" class="dataframe"> <thead> <tr style="text-align: right;"> <th></th> <th>index</th> <th>token_C</th> <th>invariant</th> <th>token_D</th> <th>Price_C</th> <th>New_Own</th> </tr> </thead> <tbody> <tr> <th>0</th> <td>0</td> <td>57000.00</td> <td>87388.733071</td> <td>510000.000000</td> <td>36.936572</td> <td>-36.565578</td> </tr> <tr> <th>1</th> <td>1</td> <td>57000.99</td> <td>87388.733071</td> <td>509963.434422</td> <td>36.933282</td> <td>-36.562321</td> </tr> <tr> <th>2</th> <td>2</td> <td>57001.98</td> <td>87388.733071</td> <td>509926.872101</td> <td>36.929993</td> <td>-36.559065</td> </tr> <tr> <th>3</th> <td>3</td> <td>57002.97</td> <td>87388.733071</td> <td>509890.313035</td> <td>36.926704</td> <td>-36.555809</td> </tr> <tr> <th>4</th> <td>4</td> <td>57003.96</td> <td>87388.733071</td> <td>509853.757226</td> <td>36.923415</td> <td>-36.552554</td> </tr> </tbody> </table> </div> ```python List2.token_D.iloc[2] - List2.token_D.iloc[1] ``` -36.56232138548512 ```python 1/(List2.token_D.iloc[3]/List.token_D.iloc[3]) ``` 0.9999978273765967 ```python # Easy solution: # The effective tokens in the trade should be the same as before: 3183.6295721159863 but fees need to be paid # As the effective tokens going into the pool are X-fee = 3183.63 and fee = 1%, .99*X = 3183.63 -> # fee: s_f = 0.01 A_new = A / (1-s_f) A_new ``` 3215.7874465818045 ```python # Paid fees: 3215.7874465818045 - 3183.6295721159863 ``` 32.15787446581817 #### SOLUTION 3. ```python SP = 1/37 SP_new = 1/28 Bc = 2*Bc A = Bc * (((SP_new/SP)**(Wd/(Wd+Wc)))-1) A # Amount of token_C to bring to the pool (in exchange for token_B) ``` 6367.259144231973 ```python # Ratio 6367.259144231973 / 3183.6295721159863 ``` 2.0 ```python # Variables # Size: S # Change in price: delta # Number of tokens: T # T produces a delta in a pool with size S # n*t produces a delta in a pool with size n*S ``` $$ A_i = B_i ((\frac{SP_{new}}{SP})^{(\frac{w_0}{w_0+w_i})})-1)$$ $$ A_i = B_i*(cte)$$ New pool with $n*B_i$ $$ m*A_i = n*B_i*(cte)$$ $$ \frac{m*A_i}{A_i} = \frac{n*B_i (cte)}{B_i*(cte)}$$ $$ m = n $$ If size is double: $B_i -> 2*B_i$ means that $A_i -> 2*A_i$ So we need more tokens in the sam factor as times the new pool is bigger than the old one # Challenge No. 3 Bob runs a 50-50 Token X-Token Y pool with a 5% swap fee. The following traders want to interact with this pool: - Carlos wants to increase the amount of Token X by 10% by trading X for Y - Diana wants to increase the amount of Token Y by 10% by trading Y for X - Ellen wants to increase the spot price X:Y by 10% - Fabricio wants to increase the spot price Y:X by 10% #### 1. For each action, specify the amount that the person will need to trade in to achieve the result. #### 2. These actions can not occur simultaneously and will be processed in some order. There are 24 different total orders -- choose a few different ones and simulate the effect on spot price and liquidity. Can you make a conclusion about how increasing liquidity or changing balances affects spot price? If not, try running additional simulations with varying numbers besides 10%. #### 3. Now add in two agents who want to increase the pool liquidity by making a deposit. With 6 actors, there are 720 different orderings of the actions. Analyze some. Which actions work "together" (reducing the amount needed of the second action to achieve a particular effect) and which work "against each other"? #### SOLUTION 1. ```python # Pool definition Bc = 50000 # initial balance Bd = 50000 # initial balance Wc = 0.5 #define weight Wd = 0.5 #define weight s_f = 0.05 #swap fee inv = (Bc**Wc)*(Bd**Wd) #calculate invariant a_vals = pd.Series(range(50000,55000,1)) #create dataframe with based on a_vals List = pd.DataFrame(a_vals, columns=['token_C']) #create values for plot, add Y_balances according to current invariant List['invariant'] = inv #value required to calculate token B value List['token_D'] = (List.invariant/((List.token_C)**Wc))**(1/Wd)# calculate corresponding token_B value according to invariant # List['In-Given-Out'] = List.token_D * (( List.token_C / (List.token_C-1) )**(Wc/Wd) -1) # List['Out-Given-Out'] = List.token_D * (( List.token_C / (List.token_C-(1-s_f)) )**(Wc/Wd) -1) List ``` <div> <style scoped> .dataframe tbody tr th:only-of-type { vertical-align: middle; } .dataframe tbody tr th { vertical-align: top; } .dataframe thead th { text-align: right; } </style> <table border="1" class="dataframe"> <thead> <tr style="text-align: right;"> <th></th> <th>token_C</th> <th>invariant</th> <th>token_D</th> </tr> </thead> <tbody> <tr> <th>0</th> <td>50000</td> <td>50000.0</td> <td>50000.000000</td> </tr> <tr> <th>1</th> <td>50001</td> <td>50000.0</td> <td>49999.000020</td> </tr> <tr> <th>2</th> <td>50002</td> <td>50000.0</td> <td>49998.000080</td> </tr> <tr> <th>3</th> <td>50003</td> <td>50000.0</td> <td>49997.000180</td> </tr> <tr> <th>4</th> <td>50004</td> <td>50000.0</td> <td>49996.000320</td> </tr> <tr> <th>...</th> <td>...</td> <td>...</td> <td>...</td> </tr> <tr> <th>4995</th> <td>54995</td> <td>50000.0</td> <td>45458.678062</td> </tr> <tr> <th>4996</th> <td>54996</td> <td>50000.0</td> <td>45457.851480</td> </tr> <tr> <th>4997</th> <td>54997</td> <td>50000.0</td> <td>45457.024929</td> </tr> <tr> <th>4998</th> <td>54998</td> <td>50000.0</td> <td>45456.198407</td> </tr> <tr> <th>4999</th> <td>54999</td> <td>50000.0</td> <td>45455.371916</td> </tr> </tbody> </table> <p>5000 rows × 3 columns</p> </div> ```python # Carlos wants to increase the amount of Token X by 10% by trading X for Y # He needs to bring into the pool x*(1-s_f) = 0.1*B_x # x = (0.1*B_x) / (1-s_f) # Diana: same result changing X for Y # Ellen & Fabricio: ``` $$ A_i = B_i ((\frac{SP_{new}}{SP})^{(\frac{w_0}{w_0+w_i})})-1)$$ $$ A_i = B_i ((1.1*SP)^{(\frac{w_0}{w_0+w_i})})-1)$$ ```python A_i = Bc*((1.1)**(0.5)-1) A_i ``` 2440.4424085075816 ```python 2440.4424085075816/Bc ``` 0.04880884817015163 #### BE CAREFUL: WEIGHTS HAVE CHANGED NOW #### SOLUTION 2. acting in the same direction: - trading X for Y and increasing SP bringing X to the pool - trading Y for X and increasing SP bringing Y to the pool # Challenge No. 4 A user has $a$ **TKNA** and $b$ **TKNB**: The TKNA-TKNB pool has 50:50 weights, and reserves of TKNA and TKNB of m and n, respectively. The user wishes to perform a swap such that the ratio of TKNA:TKNB in their wallet is p:q $$\frac{a + x}{b + y} = \frac{p}{q}$$ #### 1. Assuming the user performs a swap between TKNA and TKNB on the TKNA-TKNB pool, derive an expression for x and y. #### 2. Using data or algebra, which is the best option to reduce slippage when trading X for Y: a) finding a pool with the same invariant but a different X balance value, b) finding a pool with a different weight on X, c) or finding a pool with a different invariant value? Justify your answer in any way you like, and explain whether "different" should be "smaller" or "larger" here. #### SOLUTION 1. $$ x = \frac{p}{q} * (b+y) - a $$ Out-Given-In $$ A_o = B_o * (1-(\frac{B_i}{B_i + A_i})^{(\frac{w_i}{w_o}})) = B_o * (1- \frac{B_i}{B_i + A_i}) = n * (1- \frac{m}{m + \frac{p}{q} * (b+y) - a}) = b$$ where $A_i = x$ and $A_o = y$ #### SOLUTION 2. a) if the pools have he same invariant, the depth (and resistance to slippage is the same). The exact value of slippage can be calculated according to the balance point and here we can add that, if the number of tokens X is bigger in the second pool, the slippage would be smaller and if the number of tokens X is smaller, the slippage would be bigger b) if the weight of X is bigger, the pool is more resistant to slippage, however, if the weight is smaller, the impact of a swap is bigger c) a bigger invariatn value (comming from a bigger depth of the pool, a bigger amount of tokens X and tokens Y) makes the pool more resitant to slippage

c7a5a424e6233ef9e90b16030822d07a0715158b

ipynb

Jupyter Notebook

Math Challenges-Advanced.ipynb

bloxmove-com/Token_Engineering_Math_Challenge_All

73fbff799cc4aa31dbea95cc80e2345219864aa5

Math Challenges-Advanced.ipynb

bloxmove-com/Token_Engineering_Math_Challenge_All

73fbff799cc4aa31dbea95cc80e2345219864aa5

Math Challenges-Advanced.ipynb

bloxmove-com/Token_Engineering_Math_Challenge_All

73fbff799cc4aa31dbea95cc80e2345219864aa5

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# [HW10] Simple Linear Regression ## 1. Linear regression Linear regression은 종속 변수 $y$와 한개 이상의 독립 변수 $X$와의 선형 관계를 모델링하는 방법론입니다. 여기서 독립 변수는 입력 값이나 원인을 나타내고, 종속 변수는 독립 변수에 의해 영향을 받는 변수입니다. 종속 변수는 보통 결과물을 나타냅니다. 선형 관계를 모델링한다는 것은 1차로 이루어진 직선을 구하는 것입니다. 우리의 데이터를 가장 잘 설명하는 최적의 직선을 찾아냄으로써 독립 변수와 종속 변수 사이의 관계를 도출해 내는 과정입니다. 이번 실습에서는 독립 변수가 1개인 simple linear regression을 진행하겠습니다. 변수가 하나인 직선을 정의하겠습니다. $$f(x_i) = wx_i + b$$ 우리의 데이터를 가장 잘 설명하는 직선은 우리가 직선을 통해 예측한 값이 실제 데이터의 값과 가장 비슷해야 합니다. 우리의 모델이 예측한 값은 위에서 알 수 있듯 $f(x_i)$입니다. 그리고 실제 데이터는 $y$ 입니다. 실제 데이터(위 그림에서 빨간 점) 과 직선 사이의 차이를 줄이는 것이 우리의 목적입니다. 그것을 바탕으로 cost function을 다음과 같이 정의해보겠습니다. $$\text{cost function} = \frac{1}{N}\sum_{i=1}^n (y_i - f(x_i))^2$$ 우리는 cost function을 최소로 하는 $w$와 $b$를 찾아야 합니다. 우리의 cost function은 이차함수입니다. 우리는 고등학교 수학시간에 이차함수의 최솟값을 구하는 방법을 배웠습니다! 고등학교 때 배웠던 방법을 다시 한번 알아보고, 새로운 gradient descent 방법도 알아보겠습니다. ### 1.1 Analytically 다음 식의 최솟값을 어떻게 찾을 수 있을까요? $$f(w) = w^2 + 3w -5$$ 고등학교 때 배운 방법은 미분한 값이 0이 되는 지점을 찾는 것입니다. 손으로 푸는 방법은 익숙하겠지만 sympy와 numpy 패키지를 사용하여 코드를 통해서 알아보도록 하겠습니다. ```python import sympy import numpy from matplotlib import pyplot %matplotlib inline sympy.init_printing() ``` ```python w = sympy.Symbol('w', real=True) f = w**2 + 3*w - 5 f ``` ```python sympy.plotting.plot(f); ``` 1차 미분한 식은 다음과 같이 알아볼 수 있습니다. ```python fprime = f.diff(w) fprime ``` 그리고 해당 식의 해는 다음과 같이 구할 수 있습니다. ```python sympy.solve(fprime, w) ``` ### 1.2 Gradient Descent 두번째 방법은 오늘 배운 Gradient Descent 방법으로 한번에 정답에 접근하는 것이 아닌 반복적으로 정답에 가까워지는 방법입니다. 이것도 코드를 통해서 이해해보도록 하겠습니다. 먼저 기울기값을 구하는 함수를 먼저 만들겠습니다. ```python fpnum = sympy.lambdify(w, fprime) type(fpnum) ``` function 그 다음 처음 $w$ 값을 설정한 뒤, 반복적으로 최솟값을 향해서 접근해보겠습니다. ```python w = 10.0 # starting guess for the min for i in range(1000): w = w - fpnum(w)*0.01 # with 0.01 the step size print(w) ``` -1.4999999806458753 이처럼 첫번째 방법과 두번째 방법에서 같은 값이 나온 것을 알 수 있습니다. Gradient descent 방법을 직접 데이터를 만들어서 적용해보겠습니다. ### 1.3 Linear regression 실제로 linear 한 관계를 가진 데이터 셋을 사용하기 위해서 직접 데이터를 만들어보도록 하겠습니다. Numpy 패키지 안에 Normal distribution 함수를 통해서 조금의 noise 를 추가해서 생성하도록 하겠습니다. ```python x_data = numpy.linspace(-5, 5, 100) w_true = 2 b_true = 20 y_data = w_true*x_data + b_true + numpy.random.normal(size=len(x_data)) pyplot.scatter(x_data,y_data); ``` ```python x_data.shape ``` ```python y_data.shape ``` 총 100개의 데이터를 생성하였습니다. 이제 코드를 통해 접근해보도록 하겠습니다. 먼저 cost function을 나타내보겠습니다. ```python w, b, x, y = sympy.symbols('w b x y') cost_function = (w*x + b - y)**2 cost_function ``` 위의 gradient descent 예시에서 한 것처럼 기울기 함수를 정의합니다. ```python grad_b = sympy.lambdify([w,b,x,y], cost_function.diff(b), 'numpy') grad_w = sympy.lambdify([w,b,x,y], cost_function.diff(w), 'numpy') ``` 이제 $w$와 $b$의 초기값을 정의하고 gradient descent 방법을 적용하여 cost function을 최소로 하는 $w$와 $b$ 값을 찾아보겠습니다. ```python w = 0 b = 0 for i in range(1000): descent_b = numpy.sum(grad_b(w,b,x_data,y_data))/len(x_data) descent_w = numpy.sum(grad_w(w,b,x_data,y_data))/len(x_data) w = w - descent_w*0.01 # with 0.01 the step size b = b - descent_b*0.01 print(w) print(b) ``` 2.0303170198038307 19.90701393429327 처음에 데이터를 생성할 때 정의한 $w, b$ 값과 매우 유사한 값을 구할 수 있었습니다. ```python pyplot.scatter(x_data,y_data) pyplot.plot(x_data, w*x_data + b, '-r'); ``` 우리가 구한 직선이 데이터와 잘 맞는 것을 볼 수 있습니다. 이번에는 실제 데이터에서 linear regression을 진행해보겠습니다. ## 2. Earth temperature over time 오늘 배운 linear regression 방법을 사용해서 시간 흐름에 따른 지구의 온도 변화를 분석해보겠습니다. Global temperature anomaly라는 지표를 통해서 분석을 해볼 것입니다. 여기서 temperature anomaly는 어떠한 기준 온도 값을 정해놓고 그것과의 차이를 나타낸 것입니다. 예를 들어서 temperature anomaly가 양수의 높은 값을 가진다면 그것은 평소보다 따듯한 기온을 가졌다는 말이고, 음수의 작은 값을 가진다면 그것은 평소보다 차가운 기온을 가졌다는 말입니다. 세계 여러 지역의 온도가 각각 다 다르기 때문에 global temperature anomaly를 사용해서 분석을 하도록 하겠습니다. 자세한 내용은 아래 링크에서 확인하실 수 있습니다. https://www.ncdc.noaa.gov/monitoring-references/faq/anomalies.php ```python from IPython.display import YouTubeVideo YouTubeVideo('gGOzHVUQCw0') ``` 위 영상으로 기온이 점점 상승하고 있다는 것을 알 수 있습니다. 이제부터는 실제 데이터를 가져와서 분석해보도록 하겠습니다. ### Step 1 : Read a data file NOAA(National Oceanic and Atmospheric Administration) 홈페이지에서 데이터를 가져오겠습니다. 아래 명령어로 데이터를 다운받겠습니다. ```python from urllib.request import urlretrieve URL = 'http://go.gwu.edu/engcomp1data5?accessType=DOWNLOAD' urlretrieve(URL, 'land_global_temperature_anomaly-1880-2016.csv') ``` ('land_global_temperature_anomaly-1880-2016.csv', <http.client.HTTPMessage at 0x7f158b3dca50>) 다운로드한 데이터를 numpy 패키지를 이용해 불러오겠습니다. ```python import numpy ``` ```python fname = '/content/land_global_temperature_anomaly-1880-2016.csv' year, temp_anomaly = numpy.loadtxt(fname, delimiter=',', skiprows=5, unpack=True) ``` ### Step 2 : Plot the data Matplotlib 패키지의 pyplot을 이용해서 2D plot을 찍어보도록 하겠습니다. ```python from matplotlib import pyplot %matplotlib inline ``` ```python pyplot.plot(year, temp_anomaly); ``` Plot 에 여러 정보를 추가해서 더 보기 좋게 출력해보겠습니다. ```python pyplot.rc('font', family='serif', size='18') #You can set the size of the figure by doing: pyplot.figure(figsize=(10,5)) #Plotting pyplot.plot(year, temp_anomaly, color='#2929a3', linestyle='-', linewidth=1) pyplot.title('Land global temperature anomalies. \n') pyplot.xlabel('Year') pyplot.ylabel('Land temperature anomaly [°C]') pyplot.grid(); ``` ### Step 3 : Analytically Linear regression을 하기 위해서 먼저 직선을 정의하겠습니다. $$f(x_i) = wx + b$$ 그 다음 수업 시간에 배운 cost function을 정의하도록 하겠습니다. 우리가 최소화 해야 할 cost function은 다음과 같습니다. $$\frac{1}{n} \sum_{i=1}^n (y_i - f(x_i))^2 = \frac{1}{n} \sum_{i=1}^n (y_i - (wx_i + b))^2$$ 이제 cost function 을 구하고자 하는 변수로 미분한 뒤 0이 되도록 하는 값을 찾으면 됩니다. 먼저 $b$에 대해서 미분을 하겠습니다. $$\frac{\partial{J(w,b)}}{\partial{b}} = \frac{1}{n}\sum_{i=1}^n -2(y_i - (wx_i+b)) = \frac{2}{n}\left(b + w\sum_{i=1}^n x_i -\sum_{i=1}^n y_i\right) = 0$$ 위 식을 만족하는 $b$에 대해서 정리하면 $$b = \bar{y} - w\bar{x}$$ 여기서 $\bar{x} = \frac{\sum_{i=1}^n x_i}{n}$ , $\bar{y} = \frac{\sum_{i=1}^n y_i}{n}$ 입니다. 이제 $w$에 대해서 미분을 하겠습니다. $$\frac{\partial{J(w,b)}}{\partial{w}} = \frac{1}{n}\sum_{i=1}^n -2(y_i - (wx_i+b))x_i = \frac{2}{n}\left(b\sum_{i=1}^nx_i + w\sum_{i=1}^n x_i^2 - \sum_{i=1}^n x_iy_i\right)$$ 여기에 아까 구한 $b$를 대입한 후 0이 되는 $w$값을 구하하면 $$w = \frac{\sum_{i=1}^ny_i(x_i-\bar{x_i})}{\sum_{i=1}^nx_i(x_i-\bar{x_i})}$$ 가 됩니다. 우리는 계산을 통해서 $w$와 $b$ 값을 구했습니다. 이제 코드를 통해서 적용해보도록 하겠습니다. ```python w = numpy.sum(temp_anomaly*(year - year.mean())) / numpy.sum(year*(year - year.mean())) b = a_0 = temp_anomaly.mean() - w*year.mean() print(w) print(b) ``` 0.01037028394347266 -20.148685384658464 이제 그래프로 그려서 확인해보도록 하겠습니다. ```python reg = b + w * year ``` ```python pyplot.figure(figsize=(10, 5)) pyplot.plot(year, temp_anomaly, color='#2929a3', linestyle='-', linewidth=1, alpha=0.5) pyplot.plot(year, reg, 'k--', linewidth=2, label='Linear regression') pyplot.xlabel('Year') pyplot.ylabel('Land temperature anomaly [°C]') pyplot.legend(loc='best', fontsize=15) pyplot.grid(); ``` 오늘은 linear regression을 직접 만든 데이터와 실제로 있는 데이터로 진행해보았습니다. 년도에 따른 기온의 변화를 gradient descent 로 하는 방법은 내일 실습에서 추가로 알아보도록 하겠습니다. 질문 있으면 편하게 해주세요~~

50e4482ffb529e6b342b8c353d02d9fce71f8ea0

ipynb

Jupyter Notebook

03_Machine_Learning/sol/[HW10]_Simple_Linear_Regression.ipynb

wjh1065/goormNLP

ed6aeef6f76507f3e1a2abb15abdad33074bdaaa

03_Machine_Learning/sol/[HW10]_Simple_Linear_Regression.ipynb

wjh1065/goormNLP

ed6aeef6f76507f3e1a2abb15abdad33074bdaaa

03_Machine_Learning/sol/[HW10]_Simple_Linear_Regression.ipynb

wjh1065/goormNLP

ed6aeef6f76507f3e1a2abb15abdad33074bdaaa

Qwen/Qwen-72B

1. YES 2. YES

__label__kor_Hang

# Best Approximation in Hilbert Spaces ```python %matplotlib inline import sympy as sym import pylab as pl import numpy as np import numpy.polynomial.polynomial as n_poly import numpy.polynomial.legendre as leg ``` ## Mindflow We want the best approximation (in Hilbert Spaces) of the function $f$, on the space $V = \mathrm{span}\{v_i\}$. Remember that $p\in V$ is best approximation of $f$ if and only if: $$ (p-f,q)=0, \quad \forall q\in V. $$ Focus one second on the fact that both $p$ and $q$ belong to $V$. We know that any $q$ can be expressed as a linear combination of the basis functions $v_i$: $$ (p-f,v_i)=0, \quad \forall v_i\in V. $$ Moreover $p$ is uniquely defined by the coefficients $p^j$ such that $p = p^j\,v_j$. Collecting this information together we get: $$ (v_j,v_i) p^j = (f,v_i),\quad \forall v_i\in V. $$ Now that we know our goal (finding these $p^j$ coefficients) we do what the rangers do: we explore! We understand that we will need to invert the matrix: $$ M_{ij} = (v_j,v_i) = \int v_i\cdot v_j $$ What happens if we choose basis functions such that $(v_j,v_i) = \delta_{ij}$? How to construct numerical techniques to evaluate integrals in an efficient way? Evaluate the $L^2$ projection. ## Orthogonal Polynomials Grham Schmidt $$ p_0(x) = 1, \qquad p_k(x) = x^k - \sum_{j=0}^{k-1} \frac{(x^k,p_j(x))}{(p_j(x),p_j(x))} p_j(x) $$ or, alternatively $$ p_0(x) = 1, \qquad p_k(x) = x\,p_{k-1}(x) - \sum_{j=0}^{k-1} \frac{(x p_{k-1}(x),p_j(x))}{(p_j(x),p_j(x))} p_j(x) $$ ```python def scalar_prod(p0,p1,a=0,b=1): assert len(p0.free_symbols) <= 1, "I can only do this for single variable functions..." t = p0.free_symbols.pop() if len(p0.free_symbols) == 1 else sym.symbols('t') return sym.integrate(p0*p1,(t,a,b)) ``` ```python t = sym.symbols('t') #k = 3 Pk = [1+0*t] # Force it to be a sympy expression for k in range(1,5): s = 0 for j in range(0,k): s+= scalar_prod(t**k,Pk[j])/scalar_prod(Pk[j],Pk[j])*Pk[j] pk = t**k-s # pk = pk/sym.sqrt(scalar_prod(pk,pk)) pk = pk/pk.subs(t,1.) Pk.append(pk) M = [] for i in range(len(Pk)): row = [] for j in range(len(Pk)): row.append(scalar_prod(Pk[i],Pk[j])) M.append(row) M = sym.Matrix(M) print(M) print Pk x = np.linspace(0,1,2**5 + 1) print x for p in Pk: if p != 1 : fs = sym.lambdify(t, p, 'numpy') #print x.shape #print fs(x) _ = pl.plot(x,fs(x)) ``` ## Theorem Le $q$ be nonzero polynomial of degree $n+1$ and $\omega(x)$ a positive weight function, s. t.: $$ \int_a^b x^k q(x)\, \omega(x) = 0, \quad k = 0,\ldots, n $$ If $x_i$ are zeros of $q(x)$, then: $$ \int_a^b f(x)\, \omega(x)\approx \sum_{i=0}^nw_i\, f(x_i) $$ with: $$ w_i = \int_a^b l_i(x)\, \omega(x) $$ is exact for all polynomials of degree at most $2n+1$. Here $l_i(x)$ are the usual Lagrange interpolation polynomials. **Proof:** assume $f(x)$ is a polynomial of degree at most $2n+1$ and show: $$ \int_a^b f(x)\, \omega(x) = \sum_{i=0}^nw_i\, f(x_i). $$ Usign the polynomial division we have: $$ \underbrace{f(x)}_{2n+1} = \underbrace{q(x)}_{n+1}\, \underbrace{p(x)}_{n} + \underbrace{r(x)}_{n}. $$ By taking $x_i$ as zeros of $q(x)$ we have: $$ f(x_i) = r(x_i) $$ Now: $$ \int_a^b f(x)\, \omega(x) = \int_a^b [q(x)\, p(x) + r(x)]\, \omega(x) $$ $$ = \underbrace{\int_a^b q(x)\, p(x) \, \omega(x)}_{=0} + \int_a^b r(x)\, \omega(x) $$ Since $r(x)$ is a polynomial of order $n$ this is exact: $$ \int_a^b f(x)\, \omega(x) = \int_a^b r(x)\, \omega(x) = \sum_{i=0}^nw_i\, r(x_i) $$ But since we chose $x_i$ such that $f(x_i) = r(x_i)$, we have: $$ \int_a^b f(x)\, \omega(x) = \int_a^b r(x)\, \omega(x) = \sum_{i=0}^nw_i\, f(x_i) $$ This completes the proof. ## Legendre Polynomial Two term recursion, to obtain the same orthogonal polynomials above (defined between [-1,1]), normalized to be one in $x=1$: $$ (n+1) p^{n+1}(x) = (2n+1)\, x\, p^n(x) - n\, p^{n-1}(x) $$ ```python Pn = [1.,t] #Pn = [1.,x, ((2*n+1)*x*Pn[n] - n*Pn[n-1])/(n+1.) for n in range(1,2)] for n in range(1,5): pn1 = ((2*n+1)*t*Pn[n] - n*Pn[n-1])/(n+1.) Pn.append(sym.simplify(pn1)) print(Pn) #print(sym.poly(p)) #print(sym.real_roots(sym.poly(p))) print(sym.integrate(Pn[4]*Pn[3],(t,-1,1))) x = np.linspace(-1,1,100) for p in Pn: if p != 1. : fs = sym.lambdify(t, p, 'numpy') #print x.shape #print fs(x) _ = pl.plot(x,fs(x)) ``` In our proof we selected to evaluate $ r $ and $f$ in $x_i$ at the zeros of the legendre polynomials, this is why we need to evaluate the zeros of the polynomials. ```python print(sym.real_roots(sym.poly(Pn[3]))) #q = [-1.]+sym.real_roots(sym.poly(Pn[2]))+[1.] q = sym.real_roots(sym.poly(Pn[3])) print(q) for p in Pn: if p != 1. : #print(sym.poly(p)) #print(sym.real_roots(sym.poly(p))) print(sym.nroots(sym.poly(p))) ``` [-sqrt(15)/5, 0, sqrt(15)/5] [-sqrt(15)/5, 0, sqrt(15)/5] [0] [-0.577350269189626, 0.577350269189626] [-0.774596669241483, 0, 0.774596669241483] [-0.861136311594053, -0.339981043584856, 0.339981043584856, 0.861136311594053] [-0.906179845938664, -0.538469310105683, 0, 0.538469310105683, 0.906179845938664] $$ w_i = \int_{-1}^{1} l_i(x) $$ ```python Lg = [1. for i in range(len(q))] print(Lg) #for i in range(n+1): for i in range(len(q)): for j in range(len(q)): if j != i: Lg[i] *= (t-q[j])/(q[i]-q[j]) print(Lg) x = np.linspace(-1,1,100) for poly in Lg: fs = sym.lambdify(t, poly, 'numpy') _ = pl.plot(x,fs(x)) ``` ```python for poly in Lg: print(sym.integrate(poly,(t,-1,1))) ``` 0.555555555555555 0.888888888888889 0.555555555555555 ### Hint Proiezione usando polinomi LEGENDRE (f,v_i) # Now let's get Numerical From now on I work on the $[0,1]$ interval, becouse i like it this way :) In the previus section we explored what sympbolically was happening, now we implement things on the computer. We saw how important are the legendre plynomials. Here a little documentation on that. I pont it out not because you need to read it all, but because I would like you get some aquitance with this criptic documentation pages [doc](https://docs.scipy.org/doc/numpy/reference/generated/numpy.polynomial.legendre.legroots.html#numpy.polynomial.legendre.legroots). The problem we aim at solving is finding the coefficents $p_j$ such that: $$ (v_j,v_i) p^j = (f,v_i),\quad \forall v_i\in V. $$ Remind in this section the einstein notation holds. We can expand the compact scalar product notation: $$ p^j \int_0^1 v_i\, v_j = \int_0^1 f\, v_i,\quad \forall v_i\in V. $$ We consider $V = \mathrm{span}\{l_i\}$. Our problem becomes: $$ p^j \int_0^1 l_i\, l_j = \int_0^1 f\, l_i,\quad \mathrm{for}\ i = 0,\ldots,\mathtt{deg} $$ Let's focus on mass matrix: $$ \int_0^1 l_i(x)\, l_j(x) = \sum_k l_i(x_k)\, w_k\, l_j(x_k) = $$ $$ = \left( \begin{array}{c c c c} l_0(x_0) & l_0(x_1) & \ldots & l_0(x_q) \\ l_1(x_0) & l_1(x_1) & \ldots & l_1(x_q) \\ & \ldots & \ldots & \\ l_n(x_0) & l_n(x_1) & \ldots & l_n(x_q) \\ \end{array} \right) \left( \begin{array}{c c c c} w_0 & 0 & \ldots & 0 \\ 0 & w_1 & \ldots & 0 \\ & \ldots & \ldots & \\ 0 & 0 & \ldots & w_q \\ \end{array} \right) \left( \begin{array}{c c c c} l_0(x_0) & l_1(x_0) & \ldots & l_n(x_0) \\ l_0(x_1) & l_1(x_1) & \ldots & l_n(x_1) \\ & \ldots & \ldots & \\ l_0(x_q) & l_1(x_q) & \ldots & l_n(x_q) \\ \end{array} \right) = B\, W\, B^T $$ A piece of curiosity, how the the two functions to find theros in two different ways ```python print sym.nroots(sym.poly(Pn[-1])) coeffs = np.zeros(6) coeffs[-1] = 1. print(leg.legroots(coeffs)) ``` [-0.906179845938664, -0.538469310105683, 0, 0.538469310105683, 0.906179845938664] [ -9.06179846e-01 -5.38469310e-01 -5.96500148e-17 5.38469310e-01 9.06179846e-01] ```python print gauss_points(3) print(np.sqrt(3./5.)*.5)+.5 ``` [ 0.11270167 0.5 0.88729833] 0.887298334621 ```python def define_lagrange_basis_set(q): n = q.shape[0] L = [n_poly.Polynomial.fromroots([xj for xj in q if xj != q[i]]) for i in range(n)] L = [L[i]/L[i](q[i]) for i in range(n)] return L ``` differenza fra le roots "simboliche" e non ```python deg = 4 Nq = deg+1 p,w = leg.leggauss(Nq) w = .5 * w p = .5*(p+1) #print p #print w W = np.diag(w) #print W ``` ```python int_p = np.linspace(0,1,deg+1) L = define_lagrange_basis_set(int_p) print(len(L)) x = np.linspace(0,1,1025) for f in L: _ = pl.plot(x, f(x)) _ = pl.plot(int_p, 0*int_p, 'ro') ``` ```python B = np.zeros((0,Nq)) for l in L: B = np.vstack([B,l(p)]) ``` Recall: $$ B\, W\, B^T p = B W f $$ $$ B\, W\, B^T = \left( \begin{array}{c c c c} l_0(x_0) & l_0(x_1) & \ldots & l_0(x_q) \\ l_1(x_0) & l_1(x_1) & \ldots & l_1(x_q) \\ & & \ddots & \\ l_n(x_0) & l_n(x_1) & \ldots & l_n(x_q) \\ \end{array} \right) \left( \begin{array}{c c c c} w_0 & 0 & \ldots & 0 \\ 0 & w_1 & \ldots & 0 \\ & & \ddots & \\ 0 & 0 & \ldots & w_q \\ \end{array} \right) \left( \begin{array}{c c c c} l_0(x_0) & l_1(x_0) & \ldots & l_n(x_0) \\ l_0(x_1) & l_1(x_1) & \ldots & l_n(x_1) \\ & & \ddots & \\ l_0(x_q) & l_1(x_q) & \ldots & l_n(x_q) \\ \end{array} \right) $$ ```python print(B.shape) _ = pl.plot(B.T) M = B.dot(W.dot(B.T)) print np.linalg.matrix_rank(M) print np.linalg.cond(M) ``` ```python def step_function(): def sf(x): index = where((x>.3) & (x<.7)) step = zeros(x.shape) step[index] = 1 return step return lambda x : sf(x) ``` $$ B\, W\, f = \left( \begin{array}{c c c c} l_0(x_0) & l_0(x_1) & \ldots & l_0(x_q) \\ l_1(x_0) & l_1(x_1) & \ldots & l_1(x_q) \\ & \ldots & \ldots & \\ l_n(x_0) & l_n(x_1) & \ldots & l_n(x_q) \\ \end{array} \right) \left( \begin{array}{c c c c} w_0 & 0 & \ldots & 0 \\ 0 & w_1 & \ldots & 0 \\ & \ldots & \ldots & \\ 0 & 0 & \ldots & w_q \\ \end{array} \right) \left( \begin{array}{c} f(x_0) \\ f(x_1) \\ \vdots\\ f(x_q) \\ \end{array} \right) $$ ```python g = lambda x: np.sin(2*np.pi*x) #g = step_function() p = p.reshape((p.shape[0],1)) G = g(p) print G.shape print B.shape print W.shape G = B.dot(W.dot(G)) ``` (5, 1) (5, 5) (5, 5) ```python u = np.linalg.solve(M, G) print u ``` [[ -1.92161045e-01] [ 9.79052672e-01] [ -1.35712301e-15] [ -9.79052672e-01] [ 1.92161045e-01]] ```python def get_interpolating_function(LL,ui): def func(LL,ui,x): acc = 0 for L,u in zip(LL,ui): #print(L,u) acc+=u*L(x) return acc return lambda x : func(LL,ui,x) ``` ```python I = get_interpolating_function(L,u) sampling = np.linspace(0,1,101) _= pl.plot(sampling, I(sampling)) #plot(xp, G,'ro') ``` ## Diference in between projection and interpolation runge example Proiezione usando polinomi LEGENDRE (f,v_i) con quadratura con 18 punti Interpolazione usando polinomi LAGRANGE (sui punti di quadratura che sono i punti di gauss della funzione sopra) ```python ```

556e173c830749844ac5bf5b9208c0adcc551aa1

ipynb

Jupyter Notebook

python-lectures/04_best_approximation.ipynb

denocris/Introduction-to-Numerical-Analysis

45b40a7743e11457b644fc6a7de17a0854ece4f0

2018-01-16T15:59:48.000Z

2022-03-31T09:29:31.000Z

python-lectures/04_best_approximation.ipynb

denocris/Introduction-to-Numerical-Analysis

45b40a7743e11457b644fc6a7de17a0854ece4f0

python-lectures/04_best_approximation.ipynb

denocris/Introduction-to-Numerical-Analysis

45b40a7743e11457b644fc6a7de17a0854ece4f0

2018-01-21T16:45:34.000Z

2021-06-25T15:56:27.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# Examples of image reconstruction using PCA Data classification in high dimensional spaces can be challenging and the results often lack robustness. This well-known problem has its own name; <i>the curse of dimensionality</i>. Principal Component Analysis is a popular method for dimensionality reduction. It can also be used as a visualisation tool to project data into lower dimensional spaces, which improves data exploration and comprehension. In this script, we will use PCA to study a few characteristics of the MNIST test dataset. It contains 10 K images of hand-written digits from 0 to 9. It is a good introduction to PCA in image analysis. ## The PCA transform This linear transform allows us to move from the natural/original space $\cal{X}$ into the component space $\cal{Z}$ and is defined as <blockquote> $\bf{z} = \bf{W}^{T}(\bf{x}-\bf{\mu})$</blockquote> with <blockquote> $\begin{align} \bf{x} &= [x_{1} x_{2} \cdots x_{N}]^\top \\ \bf{\mu} &= [\mu_{1} \mu_{2} \cdots \mu_{N}]^\top \\ \bf{z} &= [z_{1} z_{2} \cdots z_{N}]^\top \\ \end{align}$ </blockquote> where N is the dimension of space and $\bf{\mu}$ is the mean of the N-dimensional data X. The $W$ matrix if made of the N eigenvectors $\bf{w}_{i}$ of the covariance matrix $\Sigma$. They are stacked together along columns <blockquote> $\begin{align} \bf{W} &= \begin{pmatrix} \bf{w}_{1} & \bf{w}_{2} & \dotsb & \bf{w}_{N} \end{pmatrix} \\ &= \begin{pmatrix} w_{1,1} & w_{2,1} & \dotsb & w_{N,1} \\ w_{1,2} & w_{2,2} & \dotsb & w_{N,2} \\ \vdots & \vdots & \dotsb & \vdots \\ w_{1,N} & w_{2,N} & \dotsb & w_{N,N} \end{pmatrix} \end{align}$ </blockquote> As for the covariance matrix $\Sigma$, it is computed from the N-dimensional data distribution X <blockquote> $ \begin{align} \bf{\Sigma} &= E\{(\bf{x}-\bf{\mu})(\bf{x}-\bf{\mu})^{T} \} \\ &= \begin{pmatrix} \sigma_{1}^2 & \sigma_{1,2} & \cdots & \sigma_{1,N} \\ \sigma_{1,2} & \sigma_{2}^2 & \cdots & \sigma_{2,N} \\ \vdots & \vdots & \ddots & \vdots \\ \sigma_{1,N} & \sigma_{2,N} & \cdots & \sigma_{N}^2 \end{pmatrix} \end{align} $ </blockquote> The $\it{inverse}$ PCA transform allows us to move from the component space $\cal{Z}$ back to the natural/original space $\cal{X}$ and is defined as <blockquote> $\bf{x} = \bf{W}\bf{z} + \bf{\mu}$</blockquote> The principal components z are sorted in decreasing order of variance $var(z_{i})=\lambda_{i}$ where the $\lambda_{i}$ are the eigenvalues of the covariance matrix $\bf{\Sigma}$. N.B. The principal components usually come in one of the two popular notations: $z_{i}$ or $PCA_{i}$. ## PCA as a tool for dimensionality reduction The last equation shows that we can reconstruct the vector $\bf{x}$ exactly. We usually drop the least significant principal components (the last elements in z and the last columns in $\bf{W}$) because they only contain noise. This produces an approximate reconstruction of x <blockquote> $\bf{x} \approx \bf{\tilde{W}}\bf{\tilde{z}} + \bf{\mu}$</blockquote> with the modified arrays <blockquote> $\bf{\tilde{z}} = \begin{pmatrix} z_{1} \ z_{2} \ \dotsb \ z_{M} \end{pmatrix}^{T} $ </blockquote> and <blockquote> $ \begin{align} \bf{\tilde{W}} &= \begin{pmatrix} \bf{w}_{1} & \bf{w}_{2} & \dotsb & \bf{w}_{M} \end{pmatrix} \\ &= \begin{pmatrix} w_{1,1} & w_{2,1} & \dotsb & w_{M,1} \\ w_{1,2} & w_{2,2} & \dotsb & w_{M,2} \\ \vdots & \vdots & \ddots & \vdots \\ w_{1,N} & w_{2,N} & \dotsb & w_{M,N} \end{pmatrix} \end{align} $ </blockquote> The scree plot, which displays $\lambda$ $\it{versus}$ the component number, is a practical tool for finding the number of relevant components, i.e. those that contain information rather than noise. ## PCA as a tool for visualisation The MNIST dataset contains 10 K images. A PCA analysis will generate as many eigenvectors $\bf{w}_{i}$ that can be reshaped into images. Each original images is a linear combinations of the eigenvectors. As we will see below, the first principal components $z_{i}$ are the most important ones. If we keep only the first two, each image $\bf{x}$ can be approximated as <blockquote> $ \begin{align} \bf{x} &= \sum_{i=1}^N z_{i} \bf{w}_{i} + \bf{\mu} \\ & \approx z_{1} \bf{w}_{1} + z_{2} \bf{w}_{2} + \bf{\mu} \end{align} $ </blockquote> This means that each image can be 'summarized' by only two numbers $z_{1}$ and $z_{2}$. Thus, the 10 K images can be represented by as many points in the 2-D PCA space of coordinates ($z_{1}$, $z_{2}$) or equivalently ($PCA_{1}$, $PCA_{2}$). This representation makes image comparison easy as we will see below. ```python print(__doc__) # Author: Pierre Gravel <pierre.gravel@iid.ulaval.ca> # License: BSD %matplotlib inline import os import numpy as np import pandas as pd import matplotlib.pyplot as plt from matplotlib.offsetbox import OffsetImage, AnnotationBbox from sklearn.preprocessing import StandardScaler from sklearn.decomposition import PCA from sklearn.model_selection import train_test_split from sklearn.neighbors import KNeighborsClassifier from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay import seaborn as sns sns.set(color_codes=True) # Used for reproductibility of the results np.random.seed(43) ``` Automatically created module for IPython interactive environment # Data preprocessing ### Load the MNIST test dataset. The dataset contains 10 K images of size 28 x 28, each stored into a line of 784 elements. The X data is an array of shape 10K x 784; each line corresponds to an image (an observation) and each column corresponds to a feature. The y data is an array of 10 K elements that contains the image labels $[0,\cdots ,9]$ The test dataset can be downloaded from the Kaggle website: https://www.kaggle.com/oddrationale/mnist-in-csv In what follows, we assume that you downloaded the dataset into the current directory. ```python filename = 'mnist_test.csv' df = pd.read_csv(filename) # Extract from the Panda dataframe the features X and the labels y X = df.drop(['label'], axis=1).values y = df[['label']].values ``` Display one (inverted) image for each class. N.B. The original images are white on a black background. ```python fig, ax = plt.subplots(2,5, figsize=(10,6)) for i in range(10): idx = np.where(y==i) idx = idx[0][0] plt.subplot(2,5, i + 1) plt.imshow(255 - X[idx,:].reshape(28, 28), cmap='gray', interpolation='nearest') plt.xticks(()) plt.yticks(()) fig.tight_layout() plt.savefig('13.1.1_Examples_from_MNIST_dataset.png') plt.savefig('13.1.1_Examples_from_MNIST_dataset.pdf') ``` ### Normalise the data ```python sc = StandardScaler().fit(X) X_s = sc.transform(X) ``` # PCA analysis ### Compute the PCA transform using all the images ```python pca = PCA() pca.fit(X_s); ``` ### Display the PCA scree plot The scree plot shows the eigenvalues $\lambda$ in a decreasing order. The most relevant eigenvectors are on the left and the least relevant ones on the right. The second panel shows the fraction of the image variance already explained by the first n principal components. For instance, the first 50 principal components explain about 60% of the information in the dataset, whereas the first 200 account for 90% of it. ```python (n,m) = X_s.shape n_components = np.arange(1,m+1) fig, ax = plt.subplots(2,1, figsize=(10,6)) ax[0].plot(n_components, pca.singular_values_) ax[0].set_xlabel('Eigenvectors', fontsize=16) ax[0].set_ylabel('Eigenvalues', fontsize=16) ax[0].set_title('MNIST Scree plot', fontsize=16) ax[1].plot(n_components, 100*np.cumsum(pca.explained_variance_ratio_)) ax[1].set_xlabel('Eigenvectors', fontsize=16) ax[1].set_ylabel('Ratio (%)', fontsize=16) ax[1].set_title('Proportion of variance explained', fontsize=16) fig.tight_layout() plt.savefig('13.1.2_MNIST_scree_plot.png') plt.savefig('13.1.2_MNIST_scree_plot.pdf') ``` ### Show examples of eigenvectors (reshaped as images) The first eigenvectors (first row) are the most important ones as they contain coherent structures. The last eigenvectors (second row) usually contain only noise and are generally discarded. ```python indx = [1, 2, 3, 4, 300, 400, 500, 600] fig, ax = plt.subplots(2,4, figsize=(10,6)) for i in range(8): im = pca.components_[indx[i]-1,:].reshape(28, 28) plt.subplot(2,4, i + 1) plt.imshow(im, cmap='gray', interpolation='nearest') plt.title('$Eigenvector_{%d}$' % (indx[i]), fontsize=16) plt.xticks(()) plt.yticks(()) fig.tight_layout() plt.savefig('13.1.3_Examples_of_eigenvectors.png') plt.savefig('13.1.3_Examples_of_eigenvectors.pdf') ``` # Image similarities ### Project the image data into a 2-D space defined by the first two principal components. Compute the principal components of the image data and make a plot where each image is represented as a point in 2-D PCA space of coordinates ($PCA_{1}$, $PCA_{2}$) or equivalently ($z_{1}$, $z_{2}$). Superpose on it the labels for five images in each class. Notice how the classes are clustered; the '1' images are on the left, the '0' images are on the right, the '7' on the top, etc. This is one of the reasons why PCA is so much used in data analysis. The classes are not perfectly separated however since there is some visible overlap between them. ```python Z = pca.transform(X_s) ``` ```python sns.set_style('white') fig, ax = plt.subplots(figsize = (10, 10)) ax.scatter(Z[:,0],Z[:,1], c = 'c', s=1) ax.set_xlabel('$PCA_{1}$', fontsize=18) ax.set_ylabel('$PCA_{2}$', fontsize=18) ax.set_title('2-D PCA space for MNIST', fontsize=16) for i in range(10): idx = np.where(y==i) idx = idx[0][0:5] ax.scatter(Z[idx,0], Z[idx,1],c='k', marker=r"$ {} $".format(i), edgecolors='none', s=150 ) ax.grid(color='k', linestyle='--', linewidth=.2) sns.despine() plt.savefig('13.1.4_2D_PCA_space_for_MNIST.png') plt.savefig('13.1.4_2D_PCA_space_for_MNIST.pdf') ``` In the next figure, we replace the label markers with their corresponding images. Different labels overlap because their handwritten images share similarities. For instance, a curved '7' may look like a '9', a squashed '3' may looked like an '8', etc. ```python sns.set_style('white') image_shape = (28, 28) fig, ax = plt.subplots(figsize = (10, 10)) ax.scatter(Z[:,0],Z[:,1], c = 'b', s=1) ax.set_xlabel('$PCA_{1}$', fontsize=18) ax.set_ylabel('$PCA_{2}$', fontsize=18) ax.set_title('2-D PCA space for MNIST', fontsize=16) z = np.zeros((28, 28)) for i in range(10): idx = np.where(y==i) idx = idx[0] for j in range(5): J = 1.-X[idx[j],:].reshape(image_shape) I = (np.dstack((J,J,z)) * 255.999) .astype(np.uint8) imagebox = OffsetImage(I, zoom=.5); ab = AnnotationBbox(imagebox, (Z[idx[j],0], Z[idx[j],1]), frameon=True, pad=0); ax.add_artist(ab); ax.grid(color='k', linestyle='--', linewidth=.2) sns.despine() plt.savefig('13.1.5_2D_PCA_space_for_MNIST_with_images.png') plt.savefig('13.1.5_2D_PCA_space_for_MNIST_with_images.pdf') ``` # Find the most similar image classes If images from two different classes look alike, chances are, we will make classification errors when looking at them. The example of '1' and '7' images is well known. This is why we often put an horizontal bar in the middle of the '7' to make differences between them more visible. Do classifiers make the same errors? In what follows, we will split the dataset into a training and a test datasets. A K-Nearest-Neighbor classifier (KNN) will first be trained on the training dataset. Then, it will be used to make class predictions on the test dataset. The confusion matrix between the predicted and the true test labels will help to identify the most common errors. This will tell us what are the most lookalike image classes from the classifier standpoint. ### Split the dataset into a training and a test datasets ```python X_train, X_test, y_train, y_test = train_test_split(X_s, y, random_state=0,train_size=0.8) y_train = y_train.ravel() y_test = y_test.ravel() ``` Train a KNN classifier on the training dataset (using 5 neighbors) and use it to classify the test dataset. Warning: the next cell may take a few seconds to a minute to compute. In a few years from now, this warning will be pointless given the increasing speeds of hardware and software! ```python clf = KNeighborsClassifier(n_neighbors=5) clf.fit(X_train, y_train) y_pred = clf.predict(X_test) ``` Compute and display the confusion matrix between the true and the predicted labels for the test dataset. The confusion matrix tells us what are the most common classification mistakes. For instance, images of '8' were confused 13 times with images of '5'. The most common mistakes were found between (8,5) and (7,9) pairs. Surprisingly, the (1,7) pair was not the most prevalent source of confusion. ```python fig, ax = plt.subplots(figsize = (7, 7)) cm = confusion_matrix(y_test, y_pred) ConfusionMatrixDisplay(cm).plot(ax=ax) fig.savefig('13.1.6_confusion_matrix.png') fig.savefig('13.1.6_confusion_matrix.pdf') ``` # Examples of image reconstructions and comparisons The following section will explain several observations we made about the image class distributions in the 2-D PCA space. It is important to mention that the results could have been different if we had trained the KNN classifier with more neighbors (5) and more principal components per image (2). ### A few useful functions We define functions that will be used to <ul> <li>Show the reconstruction performances with increasing number of principal components </li> <li>Compare the images reconstructed from the first two components $PCA_{1}$ and $PCA_{2}$ </li> </ul> The first function computes PCA approximations of images of labels i and j using the first n principal components. ```python def PCA_approximations(n_comp, X_s, y, sc, image_shape, i, j): # Find one image with label i and one image with label j idx = np.where(y==i) idx = idx[0][0] image_i = X_s[idx,:].reshape(1, -1) idx = np.where(y==j) idx = idx[0][0] image_j = X_s[idx,:].reshape(1, -1) # Compute the PCA transform using only the first n principal components pca = PCA(n_components=n_comp) pca.fit(X_s) # Transform and reconstruct the image i using the first n principal components Z = pca.transform(image_i) x_i = pca.inverse_transform(Z) # Remove the normalisation transform x_i = sc.inverse_transform(x_i) x_i = x_i.reshape(image_shape) # Transform and reconstruct the image using the first n principal components Z = pca.transform(image_j) x_j = pca.inverse_transform(Z) # Remove the normalisation transform x_j = sc.inverse_transform(x_j) x_j = x_j.reshape(image_shape) # Remove the normalisation transform from the corresponding original images X_i = sc.inverse_transform(image_i) X_i = X_i.reshape(image_shape) X_j = sc.inverse_transform(image_j) X_j = X_j.reshape(image_shape) return (x_i, x_j, X_i, X_j) ``` The second function displays a mosaic of the original images with their PCA approximations with 1, 2, 20 and 200 principal components. ```python def display_PCA_reconstructions(X_s, y, sc, image_shape, i, j): # Number of principal components used for the reconstruction of each image ncomp = [1, 2, 20, 200] fig, ax = plt.subplots(2,len(ncomp)+1, figsize=(10,6)) for k in range(len(ncomp)): # Reconstruct both images with the same number of components (x_i, x_j, X_i, X_j) = PCA_approximations(ncomp[k], X_s, y, sc, image_shape, i, j) plt.subplot(2,5, k+2) plt.imshow(255-x_i, cmap='gray', interpolation='nearest') plt.title('M = %d' % ncomp[k], fontsize=16) plt.xticks(()) plt.yticks(()) plt.subplot(2,5, k + 7) plt.imshow(255-x_j, cmap='gray', interpolation='nearest') plt.xticks(()) plt.yticks(()) # Original images for reference plt.subplot(2,5, 1) plt.imshow(255-X_i, cmap='gray', interpolation='nearest') plt.title('Original', fontsize=16) plt.xticks(()) plt.yticks(()) plt.subplot(2,5, 6) plt.imshow(255-X_j, cmap='gray', interpolation='nearest') plt.xticks(()) plt.yticks(()) fig.tight_layout() ``` ## Example I: 7 versus 9 The figure below shows image reconstructions for an increasing number of principal components. Notice how the reconstructions of '7' and '9' images become easily recognizable when 200 principal components are used. This is not too surprising since, as mentionned before, the first 200 components account for 90% of the total image variance. Notice also how the first two reconstructions (M = 1,2) are very similar for both '7' and '9' images. Hence, they share similar values of $z_{1}$ and $z_{2}$. As a result, the '7' and '9' images should be neighbors in the 2-D PCA space ($z_{1}$, $z_{2}$) or equivalently ($PCA_{1}$, $PCA_{2}$). This is the case; their distributions overlap in the top of the 2-D PCA space (see corresponding figures above). ```python i = 7 j = 9 display_PCA_reconstructions(X_s, y, sc, image_shape, i, j) plt.savefig('13.1.7_Examples_image_reconstructions_7_and_9.png') plt.savefig('13.1.7_Examples_image_reconstructions_7_and_9.pdf') ``` ## Example II: 1 versus 7 This new example is counter intuitive. The reconstructions with M = 2 are now quite different; the '1' and '7' images do not share similar values of $z_{1}$ and $z_{2}$. As a result, the '1' and '7' images are not close neighbors in the 2-D PCA space. The '1' are found on the left of the 2-D PCA space whereas the '7' are found at the top. Their distributions barely overlap. ```python i = 1 j = 7 display_PCA_reconstructions(X_s, y, sc, image_shape, i, j) plt.savefig('13.1.8_Examples_image_reconstructions_1_and_7.png') plt.savefig('13.1.8_Examples_image_reconstructions_1_and_7.pdf') ``` ```python ```

7451263beba85f8bafd8c4413d4143be5e64d0f1

ipynb

Jupyter Notebook

13.1_Generate_image_reconstructions_using_PCA.ipynb

AstroPierre/Scripts-for-figures-courses-GIF-4101-GIF-7005

a38ad6f960cc6b8155fad00e4c4562f5e459f248

13.1_Generate_image_reconstructions_using_PCA.ipynb

AstroPierre/Scripts-for-figures-courses-GIF-4101-GIF-7005

a38ad6f960cc6b8155fad00e4c4562f5e459f248

13.1_Generate_image_reconstructions_using_PCA.ipynb

AstroPierre/Scripts-for-figures-courses-GIF-4101-GIF-7005

a38ad6f960cc6b8155fad00e4c4562f5e459f248

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

<a href="https://colab.research.google.com/github/neurologic/MotorSystems_BIOL358_SP22/blob/main/Tutorial_GeometricViewOfData.ipynb" target="_parent"></a> # Tutorial: Geometric view of data --- # Objectives In this notebook we'll explore how multivariate data can be represented in different orthonormal bases (dimensions). In other words, how to change the dimensions defining a set of data. As a start, the cartesian coordinates are an example of a two-dimensional orthogonal basis. This notebook will help you build intuition that will be helpful in understanding the use of PCA in research that you will be reading about. Overview: - Explore correlated multivariate data. - Define and visualize an arbitrary orthonormal basis. - Project data from one basis (cartesian) onto another basis (arbitrary). --- # Setup ```python # @title Imports, Settings, Functions # @markdown Execute this code cell to set up the notebook import numpy as np import matplotlib.pyplot as plt import ipywidgets as widgets # interactive display %config InlineBackend.figure_format = 'retina' plt.style.use("https://raw.githubusercontent.com/NeuromatchAcademy/course-content/master/nma.mplstyle") def plot_data(X): """ Plots bivariate data. Includes a plot of each random variable, and a scatter plot of their joint activity. The title indicates the sample correlation calculated from the data. Args: X (numpy array of floats) : Data matrix each column corresponds to a different random variable Returns: Nothing. """ fig = plt.figure(figsize=[10, 6]) gs = fig.add_gridspec(2, 2) ax1 = fig.add_subplot(gs[0, 0]) ax1.plot(X[:, 0], color='k') plt.ylabel('Neuron 1') plt.title('Sample var 1: {:.1f}'.format(np.var(X[:, 0]))) ax1.set_xticklabels([]) ax2 = fig.add_subplot(gs[1, 0]) ax2.plot(X[:, 1], color='k') plt.xlabel('Sample Number') plt.ylabel('Neuron 2') plt.title('Sample var 2: {:.1f}'.format(np.var(X[:, 1]))) ax3 = fig.add_subplot(gs[:, 1]) ax3.plot(X[:, 0], X[:, 1], '.', markerfacecolor=[.5, .5, .5], markeredgewidth=0) ax3.axis('equal') plt.xlabel('Neuron 1 activity') plt.ylabel('Neuron 2 activity') plt.title('Sample corr: {:.1f}'.format(np.corrcoef(X[:, 0], X[:, 1])[0, 1])) plt.show() def plot_basis_vectors(X, W): """ Plots bivariate data as well as new basis vectors. Args: X (numpy array of floats) : Data matrix each column corresponds to a different random variable W (numpy array of floats) : Square matrix representing new orthonormal basis each column represents a basis vector Returns: Nothing. """ plt.figure(figsize=[4, 4]) plt.plot(X[:, 0], X[:, 1], '.', color=[.5, .5, .5], label='Data') plt.axis('equal') plt.xlabel('Neuron 1 activity') plt.ylabel('Neuron 2 activity') plt.plot([0, W[0, 0]], [0, W[1, 0]], color='r', linewidth=3, label='Basis vector 1') plt.plot([0, W[0, 1]], [0, W[1, 1]], color='b', linewidth=3, label='Basis vector 2') plt.legend() plt.show() def plot_data_new_basis(Y): """ Plots bivariate data after transformation to new bases. Similar to plot_data but with colors corresponding to projections onto basis 1 (red) and basis 2 (blue). The title indicates the sample correlation calculated from the data. Note that samples are re-sorted in ascending order for the first random variable. Args: Y (numpy array of floats): Data matrix in new basis each column corresponds to a different random variable Returns: Nothing. """ fig = plt.figure(figsize=[8, 4]) gs = fig.add_gridspec(2, 2) ax1 = fig.add_subplot(gs[0, 0]) ax1.plot(Y[:, 0], 'r') plt.xlabel plt.ylabel('Projection \n basis vector 1') plt.title('Sample var 1: {:.1f}'.format(np.var(Y[:, 0]))) ax1.set_xticklabels([]) ax2 = fig.add_subplot(gs[1, 0]) ax2.plot(Y[:, 1], 'b') plt.xlabel('Sample number') plt.ylabel('Projection \n basis vector 2') plt.title('Sample var 2: {:.1f}'.format(np.var(Y[:, 1]))) ax3 = fig.add_subplot(gs[:, 1]) ax3.plot(Y[:, 0], Y[:, 1], '.', color=[.5, .5, .5]) ax3.axis('equal') plt.xlabel('Projection basis vector 1') plt.ylabel('Projection basis vector 2') plt.title('Sample corr: {:.1f}'.format(np.corrcoef(Y[:, 0], Y[:, 1])[0, 1])) plt.show() def get_data(cov_matrix): """ Returns a matrix of 1000 samples from a bivariate, zero-mean Gaussian. Note that samples are sorted in ascending order for the first random variable Args: cov_matrix (numpy array of floats): desired covariance matrix Returns: (numpy array of floats) : samples from the bivariate Gaussian, with each column corresponding to a different random variable """ mean = np.array([0, 0]) X = np.random.multivariate_normal(mean, cov_matrix, size=1000) indices_for_sorting = np.argsort(X[:, 0]) # X = X[indices_for_sorting, :] return X def calculate_cov_matrix(var_1, var_2, corr_coef): """ Calculates the covariance matrix based on the variances and correlation coefficient. Args: var_1 (scalar) : variance of the first random variable var_2 (scalar) : variance of the second random variable corr_coef (scalar) : correlation coefficient Returns: (numpy array of floats) : covariance matrix """ # Calculate the covariance from the variances and correlation cov = corr_coef * np.sqrt(var_1 * var_2) cov_matrix = np.array([[var_1, cov], [cov, var_2]]) return cov_matrix def define_orthonormal_basis(u): """ Calculates an orthonormal basis given an arbitrary vector u. Args: u (numpy array of floats) : arbitrary 2-dimensional vector used for new basis Returns: (numpy array of floats) : new orthonormal basis columns correspond to basis vectors """ # Normalize vector u u = u / np.sqrt(u[0] ** 2 + u[1] ** 2) # Calculate vector w that is orthogonal to w w = np.array([-u[1], u[0]]) # Put in matrix form W = np.column_stack([u, w]) return W def change_of_basis(X, W): """ Projects data onto new basis W. Args: X (numpy array of floats) : Data matrix each column corresponding to a different random variable W (numpy array of floats) : new orthonormal basis columns correspond to basis vectors Returns: (numpy array of floats) : Data matrix expressed in new basis """ # Project data onto new basis described by W Y = X @ W return Y ``` --- # Section 1: (Correlated) multivariate data This notebook provides code to draw random samples from a zero-mean bivariate normal distribution with a specified covariance matrix. Throughout this tutorial, we'll imagine these samples represent the activity (firing rates) of two recorded neurons on different trials. <details> <summary> <font color='blue'>Click here if you are interested in detials about the math behind multivariate normal distributions </font></summary> To gain intuition, we will first use a simple model to generate multivariate data. Specifically, we will draw random samples from a *bivariate normal distribution*. This is an extension of the one-dimensional normal distribution to two dimensions, in which each $x_i$ is marginally normal with mean $\mu_i$ and variance $\sigma_i^2$: \begin{align} x_i \sim \mathcal{N}(\mu_i,\sigma_i^2). \end{align} Additionally, the joint distribution for $x_1$ and $x_2$ has a specified correlation coefficient $\rho$. Recall that the correlation coefficient is a normalized version of the covariance, and ranges between -1 and +1: \begin{align} \rho = \frac{\text{cov}(x_1,x_2)}{\sqrt{\sigma_1^2 \sigma_2^2}}. \end{align} For simplicity, we will assume that the mean of each variable has already been subtracted, so that $\mu_i=0$ for both $i=1$ and $i=2$. The remaining parameters can be summarized in the covariance matrix, which for two dimensions has the following form: \begin{align} {\bf \Sigma} = \begin{pmatrix} \text{var}(x_1) & \text{cov}(x_1,x_2) \\ \text{cov}(x_1,x_2) &\text{var}(x_2) \end{pmatrix}. \end{align} In general, $\bf \Sigma$ is a symmetric matrix with the variances $\text{var}(x_i) = \sigma_i^2$ on the diagonal, and the covariances on the off-diagonal. Later, we will see that the covariance matrix plays a key role in PCA. The covariance can be found by rearranging the equation above: \begin{align} \text{cov}(x_1,x_2) = \rho \sqrt{\sigma_1^2 \sigma_2^2}. \end{align} </details> ## Interactive Demo 1: Effect of correlation on data in two dimensions Executing the code cell below will enable you to can change the correlation coefficient between data in two dimensions via an interactive slider. You should get a feel for how changing the correlation coefficient affects the geometry of the simulated data. 1. What effect do negative correlation coefficient values have? 2. What correlation coefficient results in a circular data cloud? ```python # @markdown Execute this cell to enable widget def _calculate_cov_matrix(var_1, var_2, corr_coef): # Calculate the covariance from the variances and correlation cov = corr_coef * np.sqrt(var_1 * var_2) cov_matrix = np.array([[var_1, cov], [cov, var_2]]) return cov_matrix @widgets.interact(corr_coef = widgets.FloatSlider(value=.2, min=-1, max=1, step=0.1)) def visualize_correlated_data(corr_coef=0): variance_1 = 1 variance_2 = 1 # Compute covariance matrix cov_matrix = _calculate_cov_matrix(variance_1, variance_2, corr_coef) # Generate data with this covariance matrix X = get_data(cov_matrix) # Visualize plot_data(X) ``` --- # Section 2: Define an orthonormal basis (a different set of dimensions) Data can be represented in many ways using different bases. We will be using "orthonormal" bases (orthogonal with length 1). <details> <summary> <font color='blue'>Click here if you are interested in some detail about the math </font></summary> We will define a new orthonormal basis of vectors ${\bf u} = [u_1,u_2]$ and ${\bf w} = [w_1,w_2]$. Two vectors are orthonormal if: 1. They are orthogonal (i.e., their dot product is zero): \begin{align} {\bf u\cdot w} = u_1 w_1 + u_2 w_2 = 0 \end{align} 2. They have unit length: \begin{align} ||{\bf u} || = ||{\bf w} || = 1 \end{align} In two dimensions, it is easy to make an arbitrary orthonormal basis. All we need is a random vector ${\bf u}$, which we have normalized. If we now define the second basis vector to be ${\bf w} = [-u_2,u_1]$, we can check that both conditions are satisfied: \begin{align} {\bf u\cdot w} = - u_1 u_2 + u_2 u_1 = 0 \end{align} and \begin{align} {|| {\bf w} ||} = \sqrt{(-u_2)^2 + u_1^2} = \sqrt{u_1^2 + u_2^2} = 1, \end{align} where we used the fact that ${\bf u}$ is normalized. So, with an arbitrary input vector, we can define an orthonormal basis, which we will write in matrix by stacking the basis vectors horizontally: \begin{align} {{\bf W} } = \begin{pmatrix} u_1 & w_1 \\ u_2 & w_2 \end{pmatrix}. \end{align} </details> ```python # @markdown Execute this cell to plot two orthonormal bases, # @markdown with the first dimension based on a vector defined by `[x,y]` # @widgets.interact(corr_coef = widgets.FloatSlider(value=.2, min=-1, max=1, step=0.1)) def visualize_orthonormal_bases(x=0,y=3): u = [x,y] # Get orthonomal basis W = define_orthonormal_basis(u) # Visualize with plt.xkcd(): fig,ax = plt.subplots(figsize=[6, 6]) # ax = plt.subplot(1) # plt.figure(figsize=[6, 6]) ax.axis('equal') ax.plot([0, u[0]], [0, u[1]], color='k', linewidth=6, label='Original vector') ax.plot([0, W[0, 0]], [0, W[1, 0]], color='r', linewidth=3, label='Basis vector 1') ax.plot([0, W[0, 1]], [0, W[1, 1]], color='b', linewidth=3, label='Basis vector 2') ax.legend() plt.show() _ = widgets.interact(visualize_orthonormal_bases, x=(-3,3,0.2), y=(-3,3,0.2)) ``` --- # Section 3: Project data onto new basis Finally, we will express bivariate (2-dimensional) data ($\bf X$) in a new 2-dimensional basis defined as in Section 2. We can project the data into our new basis using ***matrix multiplication*** : \begin{align} {\bf Y = X W}. \end{align} We will explore the geometry of the transformed data $\bf Y$ as we vary the choice of basis. ## Interactive Demo 3: Play with the basis vectors To see what happens to the correlation between dimensions as we change the basis vectors, run the cell below. The parameter corr_coeff controls the correlation between the two original dimensions. The parameter $\theta$ controls the angle of the first basis vector (red, $\bf u$) in degrees. The second basis vector will be orthogonal to the first. Use the slider to rotate the basis vectors (the new dimensions). 1. What happens to the projected data as you rotate the basis? 2. How does the correlation coefficient change? How does the variance of the projection onto each basis vector change? 3. Are you able to find a basis in which the projected data is **uncorrelated**? ```python # @markdown Execute this cell to enable the widget def refresh(corr_coef=0.5,theta=0): # corr_coef=0.5 variance_1 = 1 variance_2 = 1 # Compute covariance matrix cov_matrix = _calculate_cov_matrix(variance_1, variance_2, corr_coef) # Generate data with this covariance matrix X = get_data(cov_matrix) u = [1, np.tan(theta * np.pi / 180)] W = define_orthonormal_basis(u) Y = change_of_basis(X, W) # plot_basis_vectors(X, W) # plot_data_new_basis(Y) fig = plt.figure(figsize=[20, 10]) gs = fig.add_gridspec(4, 4) ax1 = fig.add_subplot(gs[0, 0]) ax1.plot(X[:, 0], color='k') plt.ylabel('Neuron 1') plt.title('Sample var 1: {:.1f}'.format(np.var(X[:, 0]))) ax1.set_xticklabels([]) ax2 = fig.add_subplot(gs[1, 0]) ax2.plot(X[:, 1], color='k') plt.xlabel('Sample Number') plt.ylabel('Neuron 2') plt.title('Sample var 2: {:.1f}'.format(np.var(X[:, 1]))) ax3 = fig.add_subplot(gs[0:2, 1]) ax3.plot(X[:, 0], X[:, 1], '.', markerfacecolor=[.5, .5, .5], markeredgewidth=0) ax3.plot([0, W[0, 0]], [0, W[1, 0]], color='r', linewidth=3, label='Basis vector 1') ax3.plot([0, W[0, 1]], [0, W[1, 1]], color='b', linewidth=3, label='Basis vector 2') ax3.axis('equal') plt.xlabel('Neuron 1 activity') plt.ylabel('Neuron 2 activity') plt.title('Sample corr: {:.1f}'.format(np.corrcoef(X[:, 0], X[:, 1])[0, 1])) ax4 = fig.add_subplot(gs[2, 0]) ax4.plot(Y[:, 0], 'r') plt.xlabel plt.ylabel('Projection \n basis vector 1') plt.title('Sample var 1: {:.1f}'.format(np.var(Y[:, 0]))) ax4.set_xticklabels([]) ax5 = fig.add_subplot(gs[3, 0]) ax5.plot(Y[:, 1], 'b') plt.xlabel('Sample number') plt.ylabel('Projection \n basis vector 2') plt.title('Sample var 2: {:.1f}'.format(np.var(Y[:, 1]))) ax6 = fig.add_subplot(gs[2:4, 1]) ax6.plot(Y[:, 0], Y[:, 1], '.', color=[.5, .5, .5]) ax6.axis('equal') plt.xlabel('Projection basis vector 1') plt.ylabel('Projection basis vector 2') plt.title('Sample corr: {:.1f}'.format(np.corrcoef(Y[:, 0], Y[:, 1])[0, 1])) plt.show() _ = widgets.interact(refresh, corr_coef=(-1,1,0.1), theta=(-90, 90, 5)) ``` --- # Summary - In this tutorial, we learned that multivariate data can be visualized as a cloud of points in a high-dimensional vector space. The geometry of this cloud is shaped by the *covariance matrix*. - Multivariate data can be represented in a new orthonormal basis using the dot product (matrix multiplication). These new basis vectors correspond to specific mixtures of the original variables - *for example, in neuroscience, they could represent different ratios of activation across a population of neurons*. - The projected data (after transforming into the new basis) will generally have a different geometry from the original data. In particular, taking basis vectors that are aligned with the spread of cloud of points decorrelates the data. * These concepts - covariance, projections, and orthonormal bases - are key for understanding PCA, which is a foundational computational tool in a wide variety of neuroscience research. --- # Notation \begin{align} x_i &\quad \text{data point for dimension } i\\ \mu_i &\quad \text{mean along dimension } i\\ \sigma_i^2 &\quad \text{variance along dimension } i \\ \bf u, \bf w &\quad \text{orthonormal basis vectors}\\ \rho &\quad \text{correlation coefficient}\\ \bf \Sigma &\quad \text{covariance matrix}\\ \bf X &\quad \text{original data matrix}\\ \bf W &\quad \text{projection matrix}\\ \bf Y &\quad \text{transformed data}\\ \end{align} --- This tutorial was written by Krista Perks for BIOL358 Motor Systems taught at Wesleyan University. Based on content from **Neuromatch Academy 2020: Week 1, Day 5: Dimensionality Reduction** by Alex Cayco Gajic, John Murray

8f62b2d84c4462256124646b707888ea7b132be9

ipynb

Jupyter Notebook

Tutorial_GeometricViewOfData.ipynb

neurologic/MotorSystems_BIOL358_SP22

ddec85c10e2bbc08a24cba0b6ff7b58466172b21

Tutorial_GeometricViewOfData.ipynb

neurologic/MotorSystems_BIOL358_SP22

ddec85c10e2bbc08a24cba0b6ff7b58466172b21

Tutorial_GeometricViewOfData.ipynb

neurologic/MotorSystems_BIOL358_SP22

ddec85c10e2bbc08a24cba0b6ff7b58466172b21

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

```python import numpy as np import scipy import sympy as sym import pandas as pd from scipy import linalg from scipy import optimize from scipy import interpolate import matplotlib.pyplot as plt from matplotlib import cm from mpl_toolkits.mplot3d import Axes3D sym.init_printing(use_unicode=True) ``` # 1. Human capital accumulation Consider a worker living in **two periods**, $t \in \{1,2\}$. In each period she decides whether to **work ($l_t = 1$) or not ($l_t = 0$)**. She can *not* borrow or save and thus **consumes all of her income** in each period. If she **works** her **consumption** becomes: $$c_t = w h_t l_t\,\,\text{if}\,\,l_t=1$$ where $w$ is **the wage rate** and $h_t$ is her **human capital**. If she does **not work** her consumption becomes: $$c_t = b\,\,\text{if}\,\,l_t=0$$ where $b$ is the **unemployment benefits**. Her **utility of consumption** is: $$ \frac{c_t^{1-\rho}}{1-\rho} $$ Her **disutility of working** is: $$ \gamma l_t $$ From period 1 to period 2, she **accumulates human capital** according to: $$ h_2 = h_1 + l_1 + \begin{cases} 0 & \text{with prob. }0.5 \\ \Delta & \text{with prob. }0.5 \end{cases} \\ $$ where $\Delta$ is a **stochastic experience gain**. In the **second period** the worker thus solves: $$ \begin{eqnarray*} v_{2}(h_{2}) & = &\max_{l_{2}} \frac{c_2^{1-\rho}}{1-\rho} - \gamma l_2 \\ & \text{s.t.} & \\ c_{2}& = & w h_2 l_2 \\ l_{2}& \in &\{0,1\} \end{eqnarray*} $$ In the **first period** the worker thus solves: $$ \begin{eqnarray*} v_{1}(h_{1}) &=& \max_{l_{1}} \frac{c_1^{1-\rho}}{1-\rho} - \gamma l_1 + \beta\mathbb{E}_{1}\left[v_2(h_2)\right] \\ & \text{s.t.} & \\ c_1 &=& w h_1 l_1 \\ h_2 &=& h_1 + l_1 + \begin{cases} 0 & \text{with prob. }0.5\\ \Delta & \text{with prob. }0.5 \end{cases}\\ l_{1} &\in& \{0,1\}\\ \end{eqnarray*} $$ where $\beta$ is the **discount factor** and $\mathbb{E}_{1}\left[v_2(h_2)\right]$ is the **expected value of living in period two**. The **parameters** of the model are: The **relevant levels of human capital** are: ```python h_vec = np.linspace(0.1,1.5,100) ``` **Question 1:** Solve the model in period 2 and illustrate the solution (including labor supply as a function of human capital). **Answer to Q1** We start by defining the consumption function, which will depend on whether or not she is working. If she is not working, then $l=0$ and she will consume $c=b$, if she is working she will consume $c=w*h$. Afterwards we define the utility function and bequest, the utility function is the first part of $v_2(h_2)$ defined in the text, and bequest is the second part in $v_2(h_2)$. ```python l = [0, 1] def consumption(w,h,b,l): if l == 0: c = b elif l == 1: c = w*h return c def utility(rho,h,w,b,l): return consumption(w,h,b,l)**(1-rho)/(1-rho) def bequest(l,gamma): return gamma*l def v2(l2,h2,w,b,rho,gamma): return utility(rho,h2,w,b,l2) - bequest(l2,gamma) ``` ```python rho = 2 beta = 0.96 gamma = 0.1 w = 2 b = 1 Delta = 0.1 ``` We are now ready to solve the model. We do that by maximizing the utility given a level of human capital. ```python def solve_period_2(w,b,rho,gamma): # h2_vec is the same as h_vec # we then define an array without any entries, we define 100 of those for both l2 and v2. h2_vec = np.linspace(0.1,1.5,100) l2_vec = np.empty(100) v2_vec = np.empty(100) # Solve for each h2 in grid for i,h2 in enumerate(h2_vec): # We calculate the utility when working, that is v2_Yes and when not working (v2_No). v2_No = v2(l[0],h2,w,b,rho,gamma) v2_Yes = v2(l[1],h2,w,b,rho,gamma) # We then find the utility maximizing level of labor. v2_vec[i] = max(v2_No,v2_Yes) #the vector is the maximum of the utility of either working or not working l2_vec[i] = v2_Yes>v2_No return h2_vec,v2_vec,l2_vec ``` ```python h2_vec,v2_vec,l2_vec = solve_period_2(w,b,rho,gamma); ``` ```python solution = np.where(l2_vec == 1)[0][0]; print(str(round(h2_vec[solution],3))) ``` 0.567 We have that solution $h_2^*=0.567$ and she chooses the work whenever $h_2$ is greater than or equal to $0.567$ ```python fig = plt.figure(figsize=(20,4)) ax = fig.add_subplot(1,3,3) ax.plot(h2_vec,l2_vec) ax.grid() ax.set_xlabel('$Human\ capital, period 2$') ax.set_ylabel('$Labor, period 2$') ax.set_xlim([0.0,1.2]) ax.plot(0.555567,0.5,marker='.') ``` **Question 2:** Solve the model in period 1 and illustrate the solution (including labor supply as a function of human capital). **Answer to Q2** To solve this, we start out by constructing an interpolator, since the values in period 1 will depend on the values from period 2. ```python v2_interp = interpolate.RegularGridInterpolator([h2_vec], v2_vec,bounds_error=False,fill_value=None) ``` We can now define the utility in period 1, which will depend on the value of v2 in period 2. ```python def v1(l1,h1,w,b,rho,gamma,beta,Delta,v2_interp): # The level of v2 when gain is 0 with probability 50% h2_zero = h1 + l1 v2_zero = v2_interp([h2_zero])[0] # The level of v2 when gain is Delta with probability 50% h2_delta = h1 + l1 + Delta v2_delta = v2_interp([h2_delta])[0] # We know calculate the expected value of v2 v2_expected = 0.5 * v2_zero + 0.5 * v2_delta # And at last we get the total utility return utility(rho,h1,w,b,l1) - bequest(l1,gamma) + beta*v2_expected ``` From here we do it the same way as we did in question 1. ```python def solve_period_1(w,b,rho,gamma,Delta,beta,v2_interp): # This is done in the same way as in question 1: h1_vec = np.linspace(0.1,1.5,100) l1_vec = np.empty(100) v1_vec = np.empty(100) for i,h1 in enumerate(h1_vec): v1_No = v1(l[0],h1,w,b,rho,gamma,beta,Delta,v2_interp) v1_Yes = v1(l[1],h1,w,b,rho,gamma,beta,Delta,v2_interp) v1_vec[i] = max(v1_No,v1_Yes) l1_vec[i] = v1_Yes > v1_No return h1_vec,v1_vec,l1_vec ``` ```python h1_vec,v1_vec,l1_vec = solve_period_1(w,b,rho,gamma,Delta,beta,v2_interp) ``` ```python solution = np.where(l1_vec == 1)[0][0]; print(str(round(h1_vec[solution],3))) ``` 0.355 We have that $h_1^*=0.355$ So she will decide to work in period 1 if her human capital is greater that or equal to $0.355$. We illustrate a figure below with the labor supply as a function of human capital. ```python fig = plt.figure(figsize=(20,4)) ax = fig.add_subplot(1,3,3) ax.plot(h1_vec,l1_vec) ax.grid() ax.set_xlabel('$Human\ capital, period 1$') ax.set_ylabel('$Labor, period 1$') ax.set_xlim([0.0,1.0]) ax.plot(0.3445,0.5,marker='.') ``` **Question 3:** Will the worker never work if her potential wage income is lower than the unemployment benefits she can get? Explain and illustrate why or why not. **Answer to Q3** The worker might work even though her potential wage income in period 1 is lower than the unemployment benefit. The reason is the stochastic experience gain we have defined. She accumulates human capital, if she doesn't work than $h_2=h_1+l_1$ while if she works then $h_2=h_1+l_1+\Delta$. The reason she might be working in period 1 even though her wage income is lower than the unemployment benefit, is because she might accumulate enough human capital such that in period 2 she will get an even higher wage, and thus be able to consume more. ```python def v1NO(l1,h1,w,b,rho,gamma,beta,v2_interp): # The level of v2 when gain is 0 with probability 50% h2_zero = h1 + l1 v2_zero = v2_interp([h2_zero])[0] # d. total value return utility(rho,h1,w,b,l1) - bequest(l1,gamma) + beta*v2_zero ``` ```python def solve_period_1NO(w,b,rho,gamma,Delta,beta,v2_interp): # a. grids h1NO_vec = np.linspace(0.1,1.5,100) l1NO_vec = np.empty(100) v1NO_vec = np.empty(100) # b. solve for each h1 in grid for i,h1 in enumerate(h1_vec): # We now calculate the utility when working (v1_1) and not working (v1_0) v1NO_0 = v1NO(l[0],h1,w,b,rho,gamma,beta,v2_interp) v1NO_1 = v1NO(l[1],h1,w,b,rho,gamma,beta,v2_interp) v1NO_vec[i] = max(v1NO_0,v1NO_1) l1NO_vec[i] = v1NO_1 > v1NO_0 return h1NO_vec,v1NO_vec,l1NO_vec ``` The idea here was to show the utility as defined in question two and a utility function where there are no stochastic gain (so only $h_1+l_1$ with probability 1), but it somehow messes up. The idea was to show how the utilities differ, and that might explain why sometimes she might choose to work even though she would consume less in the first period. # AS-AD model Consider the following **AS-AD model**. The **goods market equilibrium** is given by $$ y_{t} = -\alpha r_{t} + v_{t} $$ where $y_{t}$ is the **output gap**, $r_{t}$ is the **ex ante real interest** and $v_{t}$ is a **demand disturbance**. The central bank's **Taylor rule** is $$ i_{t} = \pi_{t+1}^{e} + h \pi_{t} + b y_{t}$$ where $i_{t}$ is the **nominal interest rate**, $\pi_{t}$ is the **inflation gap**, and $\pi_{t+1}^{e}$ is the **expected inflation gap**. The **ex ante real interest rate** is given by $$ r_{t} = i_{t} - \pi_{t+1}^{e} $$ Together, the above implies that the **AD-curve** is $$ \pi_{t} = \frac{1}{h\alpha}\left[v_{t} - (1+b\alpha)y_{t}\right]$$ Further, assume that the **short-run supply curve (SRAS)** is given by $$ \pi_{t} = \pi_{t}^{e} + \gamma y_{t} + s_{t}$$ where $s_t$ is a **supply disturbance**. **Inflation expectations are adaptive** and given by $$ \pi_{t}^{e} = \phi\pi_{t-1}^{e} + (1-\phi)\pi_{t-1}$$ Together, this implies that the **SRAS-curve** can also be written as $$ \pi_{t} = \pi_{t-1} + \gamma y_{t} - \phi\gamma y_{t-1} + s_{t} - \phi s_{t-1} $$ The **parameters** of the model are: ```python par = {} par['alpha'] = 5.76 par['h'] = 0.5 par['b'] = 0.5 par['phi'] = 0 par['gamma'] = 0.075 #Defining symbols pi_t = sym.symbols('pi_t') pi_t2 = sym.symbols('pi_t-1') y_t = sym.symbols('y_t') y_t2 = sym.symbols('y_t-1') v_t = sym.symbols('v_t') s_t = sym.symbols('s_t') s_t2 = sym.symbols('s_t-1') alpha = sym.symbols('alpha') gamma = sym.symbols('gamma') phi = sym.symbols('phi') h = sym.symbols('h') b = sym.symbols('b') ``` **Question 1:** Use the ``sympy`` module to solve for the equilibrium values of output, $y_t$, and inflation, $\pi_t$, (where AD = SRAS) given the parameters ($\alpha$, $h$, $b$, $\alpha$, $\gamma$) and $y_{t-1}$ , $\pi_{t-1}$, $v_t$, $s_t$, and $s_{t-1}$. **Answer for Q1** First, one start by defining the AD and SRAS functions, and then solving AD=SRAS with sympy solver for both $y_t$ and $\pi_t$. ```python #Defining AD-curve AD = sym.Eq(pi_t,(1/(h*alpha))*(v_t-(1+b*alpha)*y_t)) #Defining SRAS-curve SRAS = sym.Eq(pi_t,pi_t2+gamma*y_t-phi*gamma*y_t2+s_t-phi*s_t2) #Setting AD equal to SRAS and solving for equilibrium values of output, y*. eq_1= sym.solve([AD, SRAS], [y_t, pi_t]) eq_y=eq_1[y_t] print('The equilibrium for output y is:') eq_y ``` ```python eq_pi=eq_1[pi_t] print('The equilibrium for output pi is:') eq_pi ``` ```python #lambdifying for later use pi_func = sym.lambdify((pi_t2, y_t2, v_t, s_t, s_t2, alpha, h, b, phi, gamma), eq_pi) y_func = sym.lambdify((pi_t2, y_t2, v_t, s_t, s_t2, alpha, h, b, phi, gamma), eq_y) ``` Now, one an just set the paramter values to find the equilibrium given the paramter values through the same procedure as above. ```python #Setting parameter values alpha = par['alpha'] h = par['h'] b = par['b'] phi = par['phi'] gamma = par['gamma'] #Resolving for equilibrium AD_SRAS_val=sym.Eq((1/(h*alpha))*(v_t-(1+b*alpha)*y_t),pi_t2+gamma*y_t-phi*gamma*y_t2+s_t-phi*s_t2) eq_y_val = sym.solve(AD_SRAS_val,y_t) print('The equilibrium for output y given parameter values is:') eq_y_val ``` ```python eq_pi_val=1/(h*alpha)*(v_t-(1+b*alpha)*eq_y_val[0]) print('The equilibrium for output pi given parameter values is:') eq_pi_val ``` **Question 2:** Find and illustrate the equilibrium when $y_{t-1} = \pi_{t-1} = v_t = s_t = s_{t-1} = 0$. Illustrate how the equilibrium changes when instead $v_t = 0.1$. **Answer to Q2** To find the equilibrium when $y_{t-1} = \pi_{t-1} = v_t = s_t = s_{t-1} = 0$, one needs to set the new values for the variables, and here, just re-solve the same problem as earlier. ```python #Setting variable values - parameter is similar to previous questions pi_t2 = 0 y_t2 = 0 v_t = 0 s_t = 0 s_t2 = 0 #Solving for equilibrium given variable values AD_SRAS_param=sym.Eq((1/(h*alpha))*(v_t-(1+b*alpha)*y_t),pi_t2+gamma*y_t-phi*gamma*y_t2+s_t-phi*s_t2) eq_y_param = sym.solve(AD_SRAS_param,y_t) eq_pi_param=1/(h*alpha)*(v_t-(1+b*alpha)*eq_y_param[0]) print('The equilibrium for output y given parameter and variable values is: %8.3f' % eq_y_param[0]) print('The equilibrium for output pi given parameter and variable values is: %8.3f' % eq_pi_param) ``` The equilibrium for output y given parameter and variable values is: 0.000 The equilibrium for output pi given parameter and variable values is: 0.000 With the assumption $y_{t-1} = \pi_{t-1} = v_t = s_t = s_{t-1} = 0$, one can see that $\pi_t=y_t=0$ in equilibrium. Now, one can investigate how the equilibrium changes when $v_t=0.1$ ```python #Solving for equilibrium given v_t=0.1 v_t2 = 0.1 AD_SRAS_param2=sym.Eq((1/(h*alpha))*(v_t2-(1+b*alpha)*y_t),pi_t2+gamma*y_t-phi*gamma*y_t2+s_t-phi*s_t2) eq_y_param2 = sym.solve(AD_SRAS_param2,y_t) eq_pi_param2=1/(h*alpha)*(v_t2-(1+b*alpha)*eq_y_param2[0]) print('The equilibrium for output y given parameter and variable values is: %8.4f' % eq_y_param2[0]) print('The equilibrium for output pi given parameter and variable values is: %8.4f' % eq_pi_param2) ``` The equilibrium for output y given parameter and variable values is: 0.0244 The equilibrium for output pi given parameter and variable values is: 0.0018 In the case of $v_t=0.1$ both $\pi_t$ and $y_t$ becomes positive but $y_t^*>\pi_t^*$ Now, lets illustrate the equilibria. First, one creates a vector consisting of the equilibrium values for $y_t$ and $\pi_t$, respectively. Next step is to construct a illustration of the equilibrium values for given values of $v_t$. ```python #Creating vector with equilibrium values for y_t and pi_t for given values of v_t ## Vector with equilibrium values for y y_values=[] y_values.append(eq_y_param[0]) y_values.append(eq_y_param2[0]) ## Vector with equilibrium values for pi pi_values=[] pi_values.append(eq_pi_param) pi_values.append(eq_pi_param2) ``` ```python #Creating illustration of the equilibrium values fig = plt.figure() ax = fig.add_subplot(1, 1, 1) ax.scatter(pi_values[0], y_values[0], label='$v_t=0$') ax.scatter(pi_values[1], y_values[1], label='$v_t=0.1$') #Setting up illustration ax.grid() ax.legend() ax.set_ylabel('$y_t^*$') ax.set_xlabel('$\pi_t^*$') ax.set_title('Equilibrium values for given values of $v_t$') ``` **Persistent disturbances:** Now, additionaly, assume that both the demand and the supply disturbances are AR(1) processes $$ v_{t} = \delta v_{t-1} + x_{t} $$ $$ s_{t} = \omega s_{t-1} + c_{t} $$ where $x_{t}$ is a **demand shock**, and $c_t$ is a **supply shock**. The **autoregressive parameters** are: ```python par['delta'] = 0.80 par['omega'] = 0.15 delta = par['delta'] omega = par['omega'] ``` **Question 3:** Starting from $y_{-1} = \pi_{-1} = s_{-1} = 0$, how does the economy evolve for $x_0 = 0.1$, $x_t = 0, \forall t > 0$ and $c_t = 0, \forall t \geq 0$? **Answer to Q3** ```python par['delta'] = 0.80 par['omega'] = 0.15 delta = par['delta'] omega = par['omega'] ``` Firstly, one needs to define the demand and supply disturbances as functions, set the value for the shocks, the amount of periods for the simulation to investigate the evolvement of the economy given $x_0 = 0.1$, $x_t = 0, \forall t > 0$ and $c_t = 0, \forall t \geq 0$. Then, one can simulate the model. This will also be the order of solution. ```python #Defining demand and supply disturbances and vectors v_t2 = sym.symbols('v_t2') s_t2 = sym.symbols('s_t2') v = lambda v_t2,x: delta*v_t2 + x s = lambda s_t2,c: omega*s_t2 + c v_vector = [0] s_vector = [0] #Defining amount of periods for simulation, demand and supply shock vectors. T = 200 x = np.zeros(T) c = np.zeros(T) x[1] = 0.1 ``` Now, one can run a loop to simulate the model for T periods. ```python y_output = [0] pi_inflation = [0] #Running simulation of the model for t in range (1,T): v_vector.append(v(v_vector[t-1], x[t])) s_vector.append(s(s_vector[t-1], c[t])) ``` ```python for t in range(1,T): y_output.append(y_func(pi_inflation[t-1], y_output[t-1], v_vector[t], s_vector[t], s_vector[t-1], alpha, h, b, phi, gamma)) pi_inflation.append(pi_func(pi_inflation[t-1], y_output[t-1], v_vector[t], s_vector[t], s_vector[t-1], alpha, h, b, phi, gamma)) ``` ```python #Creating illustration of the equilibrium values fig = plt.figure(figsize= (10,5)) bx = fig.add_subplot(1,1,1) bx.plot(range(0,200,1), y_output, label = 'Output') bx.plot(range(0,200,1), pi_inflation, label = 'Inflation') #Setting up illustration bx.legend() bx.grid() bx.set_xlabel('t') # bx.set_ylabel('$y_t, \pi_t$') bx.set_title('Output and inflation gap for 200 periods') plt.xticks(range(0, 201, 50)) plt.show() ``` One can see that the output has a faster convergence than inflation given $v_t$. Additionally, the output reacts immediately to the shock, whereas the inflation gap reacts slower to the demand shock. **Stochastic shocks:** Now, additionally, assume that $x_t$ and $c_t$ are stochastic and normally distributed $$ x_{t}\sim\mathcal{N}(0,\sigma_{x}^{2}) $$ $$ c_{t}\sim\mathcal{N}(0,\sigma_{c}^{2}) $$ The **standard deviations of the shocks** are: ```python par['sigma_x'] = 3.492 par['sigma_c'] = 0.2 ``` **Question 4:** Simulate the AS-AD model for 1,000 periods. Calculate the following five statistics: 1. Variance of $y_t$, $var(y_t)$ 2. Variance of $\pi_t$, $var(\pi_t)$ 3. Correlation between $y_t$ and $\pi_t$, $corr(y_t,\pi_t)$ 4. Auto-correlation between $y_t$ and $y_{t-1}$, $corr(y_t,y_{t-1})$ 5. Auto-correlation between $\pi_t$ and $\pi_{t-1}$, $corr(\pi_t,\pi_{t-1})$ **Answer Q4** **Stochastic shocks:** Now, additionally, assume that $x_t$ and $c_t$ are stochastic and normally distributed $$ x_{t}\sim\mathcal{N}(0,\sigma_{x}^{2}) $$ $$ c_{t}\sim\mathcal{N}(0,\sigma_{c}^{2}) $$ The **standard deviations of the shocks** are: ```python par['sigma_x'] = 3.492 par['sigma_c'] = 0.2 sigma_x = par['sigma_x'] sigma_c = par['sigma_c'] ``` The following will be more or less equal to the simulation from **Q3**. Just with the modelling of stochastic shocks which are normally distributed. Firstly, one define the stochastic process and then run the simulation ```python #Defining stochastic shocks np.random.seed(127) T=1000 x = np.random.normal(loc = 0, scale=sigma_x, size =T) c = np.random.normal(loc = 0, scale=sigma_c, size =T) ``` Now, one can start simulating the model for which a function, simulate, is defined. ```python #Defining simulating function def simulate(T,phi_var): #Defining empty lists / Assuming y_{-1} = \pi_{-1} = s_{-1} = 0 v_vector2 = [0] s_vector2 = [0] pi_inflation2 = [0] y_output2 = [0] for t in range(1,T): v_vector2.append(v(v_vector2[t-1], x[t])) s_vector2.append(s(s_vector2[t-1], c[t])) #new output and inflation y_output2.append(y_func(pi_inflation2[t-1], y_output2[t-1], v_vector2[t], s_vector2[t], s_vector2[t-1], alpha, h, b, phi_var, gamma)) pi_inflation2.append(pi_func(pi_inflation2[t-1], y_output2[t-1], v_vector2[t], s_vector2[t], s_vector2[t-1], alpha, h, b, phi_var, gamma)) #Converting to numpy arrays y_output_sol=np.array(y_output2) pi_inflation_sol=np.array(pi_inflation2) return y_output_sol, pi_inflation_sol #Simulation of the model y_output_sol, pi_inflation_sol = simulate(T,phi) #Printing the results print('Variance of y is %8.3f' % y_output_sol.var()) print('Variance of pi is %8.3f' % pi_inflation_sol.var()) print('Correlation between y and $\pi$ is %8.3f' % np.corrcoef(y_output_sol, pi_inflation_sol)[1,0]) print('Auto-correlation between $y_t$ and $y_t-1$ is %8.3f' % np.corrcoef(y_output_sol[1:], y_output_sol[:-1])[1,0]) print('Auto-correlation between $pi_t$ and $\pi_t-1$ is %8.3f' % np.corrcoef(pi_inflation_sol[1:], pi_inflation_sol[:-1])[1,0]) ``` Variance of y is 1.993 Variance of pi is 1.039 Correlation between y and $\pi$ is -0.167 Auto-correlation between $y_t$ and $y_t-1$ is 0.775 Auto-correlation between $pi_t$ and $\pi_t-1$ is 0.980 As expected $y$ has larger variance than $\phi$ due to the demand shock. The negative correlation between $y$ and $\pi$ reflects, the inflation gap decreases as/if the output gap increases. **Question 5:** Plot how the correlation between $y_t$ and $\pi_t$ changes with $\phi$. Use a numerical optimizer or root finder to choose $\phi\in(0,1)$ such that the simulated correlation between $y_t$ and $\pi_t$ comes close to 0.31. ### Answer to Q5 To plot the correlation between inflation and output, one need to simulate output and inflation for different values of $\phi$. The simulation from **Q4** will be used, and then the saved to be plotted. ```python #Definning new phi and empty list for simulation / Assuming y_{-1} = \pi_{-1} = s_{-1} = 0 phi_new = np.linspace(0,1,10) y_sim = {} pi_sim = {} corr_ypi = [] ``` ```python #Simulation with changes in phi for i,p in enumerate(phi_new): pi_sim['pi_inflation3_%s' % i], y_sim['y_output3_%s' % i] = simulate(T, phi_new[i]) corr_ypi.append(np.corrcoef(y_sim['y_output3_%s' %i], pi_sim['pi_inflation3_%s' % i])[1,0]) ``` One can now illustrate the correlation for different values of $\phi$. This is perfomed below. ```python #Creating illustration of the equilibrium values fig = plt.figure(figsize= (10,5)) cx = fig.add_subplot(1, 1, 1) cx.plot(phi_new, corr_ypi, label = 'Correlation') #Setting up illustration cx.grid() cx.legend() cx.set_ylabel('Correlation between $y$ and $\pi$') cx.set_xlabel('$\phi$') cx.set_title('Correlation for different values of $\phi$') plt.show() ``` One can see from the illustration that when $corr(y_t,\pi_t)=0.31$, the value of $\phi$ is approaching a values close to 1. To investigate this one can use the optimize module from the sympy packages. Define an objective, s olving the objective to finally print the result. ```python #Objective obj = lambda phi: np.corrcoef(simulate(T, phi)[0], simulate(T, phi)[1])[1,0] - 0.31 #Optimizing phi_opt = optimize.root_scalar(obj, x0 = 0.8, bracket = [0,1], method = 'bisect') #Result sol = phi_opt.flag phi_opt = phi_opt.root print('Optimal values of phi to find corr(y_t,pi_t)=0.31: %8.3f' % phi_opt) print('Correlation for optimal phi: %8.3f' % np.corrcoef(simulate(T, phi_opt)[0], simulate(T, phi_opt)[1])[1,0]) ``` Optimal values of phi to find corr(y_t,pi_t)=0.31: 0.983 Correlation for optimal phi: 0.310 **Quesiton 6:** Use a numerical optimizer to choose $\sigma_x>0$, $\sigma_c>0$ and $\phi\in(0,1)$ to make the simulated statistics as close as possible to US business cycle data where: 1. $var(y_t) = 1.64$ 2. $var(\pi_t) = 0.21$ 3. $corr(y_t,\pi_t) = 0.31$ 4. $corr(y_t,y_{t-1}) = 0.84$ 5. $corr(\pi_t,\pi_{t-1}) = 0.48$ **Answer to Q6**: We have tried to come up with a solution but no luck. This is one of the attempts did not work. #Defining simulation smiliar to the one above def simulate3(x): #Assuming y_{-1} = \pi_{-1} = s_{-1} = 0 v_vector3 = [0] s_vector3 = [0] pi_inflation3 = [0] y_output3 = [0] corr_ypi3 = [] #Disturbances np.random.seed(3) sigma_x = par['sigma_x'] sigma_c = par['sigma_c'] x = np.random.normal(loc = 0, scale=sigma_x, size =T) c = np.random.normal(loc = 0, scale=sigma_c, size =T) #Simulation for i in range(1,10): v_vector3.append(v(v_vector3[t-1], x[t])) s_vector3.append(s(s_vector3[t-1], c[t])) #new output and inflation y_output3.append(y_func(pi_inflation3[t-1], y_output3[t-1], v_vector3[t], s_vector3[t], s_vector3[t-1], alpha, h, b, phi_var, gamma)) pi_inflation3.append(pi_func(pi_inflation3[t-1], y_output3[t-1], v_vector3[t], s_vector3[t], s_vector3[t-1], alpha, h, b, phi_var, gamma)) #Converting to numpy arrays y_output_sol3=np.array(y_output3) pi_inflation_sol3=np.array(pi_inflation3) #Statistics y_var=np.var(y_output3) pi_var=np.inflation = np.var(pi_inflation3) corr_ypi=np.corrcoef(y_output_sol3, pi_inflation_sol3)[1,0] pi_ac = np.corrcoef(y_output_sol[1:], y_output_sol[:-1])[1,0] y_ac = np.corrcoef(pi_inflation_sol[1:], pi_inflation_sol[:-1])[1,0] #Differences from the US businees cycle data / squarred to aviod negative y_diff = (y_var - 1.64)**2 pi_diff = (var_inflation - 0.21)**2 corr_ypi_diff = (corr_ypi - 0.31)**2 #squared difference pi_ac_doff = (pi_ac - 0.84)**2 y_ac_fiff = (y_ac - 0.48)**2 #Sum of differences sum_diff=sum([y_diff, pi_diff, corr_ypi_diff, pi_ac_diff, y_ac_diff]) return sum_diff #Defining objective, guess and bounds for optimizer obj = lambda sim: simulate3(sim) x0 = (phi_opt, sigma_x, sigma_c) bounds = [[0,1], [0,100], [0,100]] #Simulation and solving the problem with scipy minimizer sol = optimize.minimize(obj, x0=x0, method='L-BFGS-B', bounds=bounds) # 3. Exchange economy Consider an **exchange economy** with 1. 3 goods, $(x_1,x_2,x_3)$ 2. $N$ consumers indexed by \\( j \in \{1,2,\dots,N\} \\) 3. Preferences are Cobb-Douglas with log-normally distributed coefficients $$ \begin{eqnarray*} u^{j}(x_{1},x_{2},x_{3}) &=& \left(x_{1}^{\beta_{1}^{j}}x_{2}^{\beta_{2}^{j}}x_{3}^{\beta_{3}^{j}}\right)^{\gamma}\\ & & \,\,\,\beta_{i}^{j}=\frac{\alpha_{i}^{j}}{\alpha_{1}^{j}+\alpha_{2}^{j}+\alpha_{3}^{j}} \\ & & \,\,\,\boldsymbol{\alpha}^{j}=(\alpha_{1}^{j},\alpha_{2}^{j},\alpha_{3}^{j}) \\ & & \,\,\,\log(\boldsymbol{\alpha}^j) \sim \mathcal{N}(\mu,\Sigma) \\ \end{eqnarray*} $$ 4. Endowments are exponentially distributed, $$ \begin{eqnarray*} \boldsymbol{e}^{j} &=& (e_{1}^{j},e_{2}^{j},e_{3}^{j}) \\ & & e_i^j \sim f, f(z;\zeta) = 1/\zeta \exp(-z/\zeta) \end{eqnarray*} $$ Let $p_3 = 1$ be the **numeraire**. The implied **demand functions** are: $$ \begin{eqnarray*} x_{i}^{\star j}(p_{1},p_{2},\boldsymbol{e}^{j})&=&\beta^{j}_i\frac{I^j}{p_{i}} \\ \end{eqnarray*} $$ where consumer $j$'s income is $$I^j = p_1 e_1^j + p_2 e_2^j +p_3 e_3^j$$ The **parameters** and **random preferences and endowments** are given by: ```python # a. parameters N = 50000 mu = np.array([3,2,1]) Sigma = np.array([[0.25, 0, 0], [0, 0.25, 0], [0, 0, 0.25]]) gamma = 0.8 zeta = 1 # b. random draws seed = 1986 np.random.seed(seed) # preferences alphas = np.exp(np.random.multivariate_normal(mu, Sigma, size=N)) betas = alphas/np.reshape(np.sum(alphas,axis=1),(N,1)) # endowments e1 = np.random.exponential(zeta,size=N) e2 = np.random.exponential(zeta,size=N) e3 = np.random.exponential(zeta,size=N) ``` **Question 1:** Plot the histograms of the budget shares for each good across agents. Consider the **excess demand functions:** $$ z_i(p_1,p_2) = \sum_{j=1}^N x_{i}^{\star j}(p_{1},p_{2},\boldsymbol{e}^{j}) - e_i^j$$ **Answer to Q1** ```python # Plotting histogram of budget shares # Plotting histogram of each beta with 200 bins. fig = plt.figure(figsize=(12,5)) ax = fig.add_subplot(1,3,1) ax.hist(betas[:,0],bins=200,histtype='bar') ax.set_xlabel('$beta_1$') ax.set_ylabel('Consumers') ax.set_title('Good 1') ax.set_ylim([0, 1250]) ax = fig.add_subplot(1,3,2) ax.hist(betas[:,1],bins=200,histtype='bar') ax.set_xlabel('$beta_2$') ax.set_title('Good 2') ax.set_ylim([0, 1250]) ax = fig.add_subplot(1,3,3) ax.hist(betas[:,2],bins=200,histtype='bar') ax.set_xlabel('$beta_3$') ax.set_title('Good 3') ax.set_ylim([0, 1250]); ``` **Question 2:** Plot the excess demand functions. **Answer to Q2** ```python #We first define the demand functions, as we set p3=1 we have just excluded that term. def demand_good1(p1,p2,e1,e2,e3,betas): I = e1*p1+e2*p2+e3 return betas[:,0]*I/p1 def demand_good2(p1,p2,e1,e2,e3,betas): I = e1*p1+e2*p2+e3 return betas[:,1]*I/p2 def demand_good3(p1,p2,e1,e2,e3,betas): I = e1*p1+e2*p2+e3 return betas[:,2]*I #We then define the excess demand functions, and supply functions for good 1 and good 2. def excess1(p1,p2,e1,e2,e3,betas): demand = np.sum(demand_good1(p1,p2,e1,e2,e3,betas)) supply = np.sum(e1) excess1 = demand - supply return excess1 def excess2(p1,p2,e1,e2,e3,betas): demand = np.sum(demand_good2(p1,p2,e1,e2,e3,betas)) supply = np.sum(e2) excess2 = demand - supply return excess2 # We then define an array of prices p1_s = np.linspace(0.1,10,100) p2_s = np.linspace(0.1,10,100) # Creating grids for excess demand excess_grid1 = np.empty((100,100)) excess_grid2 = np.empty((100,100)) # And then we transform our price-vectors into grids using meshgrid p1_grid, p2_grid = np.meshgrid(p1_s,p2_s,indexing='ij') # We can then calculate excess demand for each combination of prices: for i,p1 in enumerate(p1_s): for j,p2 in enumerate(p2_s): excess_grid1[i,j] = excess1(p1,p2,e1,e2,e3,betas) excess_grid2[i,j] = excess2(p1,p2,e1,e2,e3,betas) ``` ```python # We can now plot our results fig = plt.figure(figsize=(10,4)) ax = fig.add_subplot(1,2,1, projection='3d') ax.plot_surface(p1_grid, p2_grid, excess_grid1) ax.invert_xaxis() ax.set_title('Excess demand, good 1') ax.set_xlabel('$p_1$') ax.set_ylabel('$p_2$') ax = fig.add_subplot(1,2,2, projection='3d') ax.plot_surface(p1_grid, p2_grid, excess_grid2) ax.invert_xaxis() ax.set_title('Excess demand, good 2') ax.set_xlabel('$p_1$') ax.set_ylabel('$p_2$'); ``` **Quesiton 3:** Find the Walras-equilibrium prices, $(p_1,p_2)$, where both excess demands are (approximately) zero, e.g. by using the following tâtonnement process: 1. Guess on $p_1 > 0$, $p_2 > 0$ and choose tolerance $\epsilon > 0$ and adjustment aggressivity parameter, $\kappa > 0$. 2. Calculate $z_1(p_1,p_2)$ and $z_2(p_1,p_2)$. 3. If $|z_1| < \epsilon$ and $|z_2| < \epsilon$ then stop. 4. Else set $p_1 = p_1 + \kappa \frac{z_1}{N}$ and $p_2 = p_2 + \kappa \frac{z_2}{N}$ and return to step 2. **Answer to Q3** ```python def tatonnement(p1,p2,e1,e2,e3,betas,tol=1e-7,kappa=0.2,prints=True): # Calculating initial excess demands z_1 = excess1(p1,p2,e1,e2,e3,betas) z_2 = excess2(p1,p2,e1,e2,e3,betas) # Setting iteration counter to 1 t = 1 # We start the loop here, we will have a maximum of 20.000 loops while t < 20000: # We calculate the initial excess demands z_1 = excess1(p1,p2,e1,e2,e3,betas) z_2 = excess2(p1,p2,e1,e2,e3,betas) # Set our tolerance level: if abs(z_1)<tol and abs(z_2)<tol: if prints: print(f'\nIn the Walras equilibrium we have: p1 = {p1:.2f} and p2 = {p2:.2f}') p1_eq = p1 p2_eq = p2 return p1_eq, p2_eq # If no convergence, we will multiply our excess demand by kappa and take the average: else: p1 += kappa*z_1/N p2 += kappa*z_2/N # We then print the iteration proces if prints: if t <= 10 or t%1000==0: print(f'Iter {t:6.0f}: Excess good 1 = {z_1:10.2f}, Excess good 2 = {z_2:10.2f} => p1 = {p1:10.2f}, p2 = {p2:10.2f}') t += 1 # Print statement if maximum numbers of iterations is exceeded if t == 20000: text = 'No convergence \n' print(text) return None, None ``` ```python # Finding Walras-equilibrium prices # Initial guess on prices p1 = 4 p2 = 1 # Calling function to find equilibrium prices p1_eq, p2_eq = tatonnement(p1,p2,e1,e2,e3,betas) ``` Iter 1: Excess good 1 = -1802.03, Excess good 2 = 27583.49 => p1 = 3.99, p2 = 1.11 Iter 2: Excess good 1 = -890.71, Excess good 2 = 21094.24 => p1 = 3.99, p2 = 1.19 Iter 3: Excess good 1 = -200.19, Excess good 2 = 16961.42 => p1 = 3.99, p2 = 1.26 Iter 4: Excess good 1 = 346.52, Excess good 2 = 14060.01 => p1 = 3.99, p2 = 1.32 Iter 5: Excess good 1 = 790.31, Excess good 2 = 11901.20 => p1 = 3.99, p2 = 1.37 Iter 6: Excess good 1 = 1156.25, Excess good 2 = 10231.46 => p1 = 4.00, p2 = 1.41 Iter 7: Excess good 1 = 1461.18, Excess good 2 = 8903.73 => p1 = 4.00, p2 = 1.44 Iter 8: Excess good 1 = 1717.07, Excess good 2 = 7825.81 => p1 = 4.01, p2 = 1.47 Iter 9: Excess good 1 = 1932.83, Excess good 2 = 6936.50 => p1 = 4.02, p2 = 1.50 Iter 10: Excess good 1 = 2115.29, Excess good 2 = 6193.32 => p1 = 4.03, p2 = 1.53 Iter 1000: Excess good 1 = 42.54, Excess good 2 = 15.87 => p1 = 6.44, p2 = 2.60 Iter 2000: Excess good 1 = 1.08, Excess good 2 = 0.40 => p1 = 6.49, p2 = 2.62 Iter 3000: Excess good 1 = 0.03, Excess good 2 = 0.01 => p1 = 6.49, p2 = 2.62 Iter 4000: Excess good 1 = 0.00, Excess good 2 = 0.00 => p1 = 6.49, p2 = 2.62 Iter 5000: Excess good 1 = 0.00, Excess good 2 = 0.00 => p1 = 6.49, p2 = 2.62 Iter 6000: Excess good 1 = 0.00, Excess good 2 = 0.00 => p1 = 6.49, p2 = 2.62 In the Walras equilibrium we have: p1 = 6.49 and p2 = 2.62 **Question 4:** Plot the distribution of utility in the Walras-equilibrium and calculate its mean and variance. **Answer to Q4** ```python def u(p1, p2, e1, e2, e3, betas, gamma): # Income is given by: I = p1*e1+p2*e2+e3 # Demand is given by: demand1 = betas[:,0]*(I/p1) demand2 = betas[:,1]*(I/p2) demand3 = betas[:,2]*I # Calculating utility u = (demand1**betas[:,0]+demand2**betas[:,1]+demand3**betas[:,2])**gamma return u ``` ```python # We make a function that creates a vector of utilities u_vec = u(p1_eq, p2_eq, e1, e2, e3, betas, gamma) # we can then find the mean and variance mean = np.mean(u_vec) var = np.var(u_vec) print(f'Mean: {mean:.2f}') print(f'Variance: {var:.2f}') ``` Mean: 2.38 Variance: 0.21 ```python # Plotting distribution of utilities, and printing mean and variance plt.hist(u_vec, bins=500) plt.title('Utility distribution') plt.xlabel('Utility') plt.ylabel('Consumers') ``` **Question 5:** Find the Walras-equilibrium prices if instead all endowments were distributed equally. Discuss the implied changes in the distribution of utility. Does the value of $\gamma$ play a role for your conclusions? **Answer to Q5** ```python e1_new = np.ones(N)*np.mean(e1) e2_new = np.ones(N)*np.mean(e2) e3_new = np.ones(N)*np.mean(e3) ``` ```python p1 = 4 p2 = 1 p1_new, p2_new = tatonnement(p1,p2,e1_new,e2_new,e3_new,betas) ``` Iter 1: Excess good 1 = -1811.29, Excess good 2 = 27618.68 => p1 = 3.99, p2 = 1.11 Iter 2: Excess good 1 = -898.66, Excess good 2 = 21117.58 => p1 = 3.99, p2 = 1.19 Iter 3: Excess good 1 = -207.23, Excess good 2 = 16978.68 => p1 = 3.99, p2 = 1.26 Iter 4: Excess good 1 = 340.19, Excess good 2 = 14073.55 => p1 = 3.99, p2 = 1.32 Iter 5: Excess good 1 = 784.53, Excess good 2 = 11912.24 => p1 = 3.99, p2 = 1.37 Iter 6: Excess good 1 = 1150.94, Excess good 2 = 10240.69 => p1 = 4.00, p2 = 1.41 Iter 7: Excess good 1 = 1456.26, Excess good 2 = 8911.60 => p1 = 4.00, p2 = 1.44 Iter 8: Excess good 1 = 1712.48, Excess good 2 = 7832.63 => p1 = 4.01, p2 = 1.47 Iter 9: Excess good 1 = 1928.53, Excess good 2 = 6942.48 => p1 = 4.02, p2 = 1.50 Iter 10: Excess good 1 = 2111.24, Excess good 2 = 6198.61 => p1 = 4.03, p2 = 1.53 Iter 1000: Excess good 1 = 42.32, Excess good 2 = 15.81 => p1 = 6.44, p2 = 2.60 Iter 2000: Excess good 1 = 1.07, Excess good 2 = 0.40 => p1 = 6.48, p2 = 2.62 Iter 3000: Excess good 1 = 0.03, Excess good 2 = 0.01 => p1 = 6.49, p2 = 2.62 Iter 4000: Excess good 1 = 0.00, Excess good 2 = 0.00 => p1 = 6.49, p2 = 2.62 Iter 5000: Excess good 1 = 0.00, Excess good 2 = 0.00 => p1 = 6.49, p2 = 2.62 Iter 6000: Excess good 1 = 0.00, Excess good 2 = 0.00 => p1 = 6.49, p2 = 2.62 In the Walras equilibrium we have: p1 = 6.49 and p2 = 2.62 We see that the changes in the distribution of endowments doesn't have a significant effect on the prices. In fact the prices are identical to the previous situation. ```python def u_new(p1, p2, e1, e2, e3, betas, gamma): # Income is given by: I = p1*e1+p2*e2+e3 # Demand is given by: demand1_new = betas[:,0]*(I/p1) demand2_new = betas[:,1]*(I/p2) demand3_new = betas[:,2]*I # Calculating utility u = (demand1_new**betas[:,0]+demand2_new**betas[:,1]+demand3_new**betas[:,2])**gamma return u_new ``` ```python # We make a function that creates a vector of utilities u_vec_new = u(p1_eq, p2_eq, e1, e2, e3, betas, 1.5) # we can then find the mean and variance mean = np.mean(u_vec_new) var = np.var(u_vec_new) print(f'Mean: {mean:.2f}') print(f'Variance: {var:.2f}') ``` Mean: 5.22 Variance: 3.71 Even though the prices are unchanged, gamma will have an impact on the mean and variance. By increasing gamma from $0.8$ to $1.5$ the mean have increased from $2.38$ to $5.22$ while the variance have increased from $0.21$ to $3.71$ ```python fig = plt.figure(figsize=(12,5)) plt.hist(u_vec, bins=200, label='$\gamma$ = 0.8') plt.hist(u_vec_new, bins=200, color='orange', label='$\gamma$ = 1.5') plt.legend() plt.title('Distribution of utility') plt.xlabel('Utility') plt.ylabel('Consumers'); ```

5d1c53b3c6fdf8a60221195ce4cd360fd5ad82f4

ipynb

Jupyter Notebook

examproject/examproject/examproject.ipynb

NumEconCopenhagen/projects-2019-wp

01c7730beba383f59efc73a70cebf1fd2b8be301

examproject/examproject/examproject.ipynb

NumEconCopenhagen/projects-2019-wp

01c7730beba383f59efc73a70cebf1fd2b8be301

2019-04-15T16:23:44.000Z

2019-05-21T07:35:17.000Z

examproject/examproject/examproject.ipynb

NumEconCopenhagen/projects-2019-wp

01c7730beba383f59efc73a70cebf1fd2b8be301

2019-05-12T14:44:57.000Z

2020-03-15T10:59:04.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

```python from sympy.abc import s, t from sympy.integrals.transforms import inverse_laplace_transform from cardioLPN import A_R, A_L, A_C from sympy import symbols from sympy import * import matplotlib.pyplot as plt import numpy as np ``` ```python R_p, R_d, R, L, C = symbols('R_p, R_d R L C', positive=True) U_2, I_2 = symbols('U_2 I_2', positive=True) U, I = symbols('U I', positive=True) t = symbols('t', positive=True, real = True) #s = symbols('s', positive=True) A_result = A_C(C) * A_L(L) * A_R(R) # defining a function for U_2 and I_2 U_2 = 1/(s*(1+s*5)) I_2 = 1/(s*(1+s*15)) # defining x_2 = Matrix([U_2, I_2]) x_1 = A_result * x_2 # U_1 = x_1[0] I_1 = x_1[1] u_1 = inverse_laplace_transform(x_1[0], s, t) ``` ```python A_result = A_C(2) * A_L(3) * A_R(2) # defining a function for U_2 and I_2 U_2 = 1/(s*(1+s*5)) I_2 = 1/(s*(1+s*15)) # defining x_2 = Matrix([U_2, I_2]) x_1 = A_result * x_2 # U_1 = x_1[0] I_1 = x_1[1] # inverse laplace transform # output u_1 = inverse_laplace_transform(x_1[0], s, t) # inputs u_2 = inverse_laplace_transform(U_2, s, t) i_2 = inverse_laplace_transform(I_2, s, t) ``` ```python x_1[0] #(3*s + 2)/(s*(15*s + 1)) + (2*s*(3*s + 2) + 1)/(s*(5*s + 1)) ``` (3*s + 2)/(s*(15*s + 1)) + 1/(s*(5*s + 1)) ```python u_1_func = lambdify(t, u_1) time = np.linspace(0.5, 100, 100) u_1_array = [u_1_func(t_) for t_ in time] #u_1_func(time) #u_1_array plt.plot(time, u_1_array) # Input u_2 u_2_func = lambdify(t, u_2) time = np.linspace(0.5, 100, 100) u_2_array = [u_2_func(t_) for t_ in time] plt.plot(time, u_2_array, 'r') plt.show() # Input i_2 i_2_func = lambdify(t, i_2) time = np.linspace(0.5, 100, 100) i_2_array = [i_2_func(t_) for t_ in time] plt.plot(time, i_2_array, 'r') plt.show() ``` ```python ## New configuration A_result_2 = A_L(3) * A_R(2) * A_C(2) x_1 = A_result_2 * x_2 U_1 = x_1[0] I_1 = x_1[1] ``` ```python # inverse laplace transform # output u_1_vary = inverse_laplace_transform(simplify(x_1[0]), s, t) ``` ```python x_1[0] ``` (3*s + 2)/(s*(15*s + 1)) + (2*s*(3*s + 2) + 1)/(s*(5*s + 1)) ```python u_1_vary_func = lambdify(t, u_1_vary) u_1_vary_array = [u_1_vary_func(t_) for t_ in time] #u_1_func(time) #u_1_array plt.plot(time, u_1_vary_array) plt.show() ``` ```python import mpmath as mp import numpy as np def f(s): return 1 / (s-1) x_1_func = lambdify(s, x_1[0]) def u_1(s): return x_1_func(s) t = np.linspace(0.01, 100,100) G = [] for i in t: G.append(mp.invertlaplace(test_function, i, method = 'dehoog', dps = 10, degree = 18)) plt.plot(t, G) plt.plot(time, u_1_array, 'r') plt.show() ```

4e06f24bb1265ad1ee4be52a7afef99b502539c3

ipynb

Jupyter Notebook

example_config.ipynb

xi2pi/cardioLPN

34759fea55f73312ccb8fb645ce2d04a0e2dddea

example_config.ipynb

xi2pi/cardioLPN

34759fea55f73312ccb8fb645ce2d04a0e2dddea

example_config.ipynb

xi2pi/cardioLPN

34759fea55f73312ccb8fb645ce2d04a0e2dddea

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# Diffusion Theory ```python # Our numerical workhorses import numpy as np import pandas as pd # Import matplotlib stuff for plotting import matplotlib.pyplot as plt import matplotlib.cm as cm # Seaborn, useful for graphics import seaborn as sns # favorite Seaborn settings for notebooks rc={'lines.linewidth': 2, 'axes.facecolor' : 'F4F3F6', 'axes.edgecolor' : '000000', 'axes.linewidth' : 1.2, 'grid.color' : 'a6a6a6', 'lines.linewidth': 2, 'axes.labelsize': 18, 'axes.titlesize': 20, 'xtick.major' : 13, 'xtick.labelsize': 'large', 'ytick.labelsize': 13, 'font.family': 'Lucida Sans Unicode', 'grid.linestyle': ':', 'grid.linewidth': 1.5, 'mathtext.fontset': 'stixsans', 'mathtext.sf': 'sans', 'legend.frameon': True, 'legend.fontsize': 13} plt.rc('text.latex', preamble=r'\usepackage{sfmath}') plt.rc('mathtext', fontset='stixsans', sf='sans') sns.set_style('darkgrid', rc=rc) sns.set_palette("colorblind", color_codes=True) sns.set_context('notebook', rc=rc) # Magic function to make matplotlib inline; other style specs must come AFTER %matplotlib inline # This enables SVG graphics inline (only use with static plots (non-Bokeh)) %config InlineBackend.figure_format = 'svg' ``` # Kolmogorov Forward Equation. ## Mutation and Selection. The steady state distribution for mutation and selection is of the form $$ P(f) \propto \left[ f(1-f) \right]^{2N\mu - 1}, \tag{1} $$ where $f$ is the allele frequency $\mu$ is the mutation rate, and $N$ is the population size (effective population size can be). Let's plot this for different values of $\mu$ ```python def mut_drift(f, N_mu): prob = (f * (1 - f))**(2 * N_mu - 1) idx = np.logical_and(prob >=0, prob!=np.inf) # to avoid indeterminations return f[idx], prob[idx] ``` ```python # Define parameters N_mu = [0.1, 1 / 2, 10, 100] freq = np.linspace(0, 1, 200) fig, ax = plt.subplots(1, 1) # Loop through mutation rates and plot the distribution for nm in N_mu: f, prob = mut_drift(freq, nm) plt.plot(f, prob / np.sum(prob), label=str(nm)) ax.legend(title='$N \mu$') ax.set_xlabel('allele frequency $f$') ax.set_ylabel('$\propto$ probability') ax.set_title('mutation-drift') ax.axes.get_yaxis().set_ticks([]) ax.margins(0.02) plt.tight_layout() plt.savefig('fig/mutation_drift.png') ``` /Users/razo/anaconda3/lib/python3.6/site-packages/ipykernel/__main__.py:2: RuntimeWarning: divide by zero encountered in power from ipykernel import kernelapp as app ## Selection and Drift #### Haploid organisms The steady state distribution of allele frequency for an allele $A$ with fitness $\omega_A = 1$ that is in a population with another allele $a$ with fitness $\omega_a = 1 - s$ is of the form $$ P(f) \propto \frac{e^{-2Ns(1-f)}}{f(1-f)} \tag{2} $$ Let's plot it for different values of $s$. ```python def sel_drift_hap(f, N_s): prob = np.exp(-2 * N_s * (1 - f)) / (f * (1 - f)) idx = np.logical_and(prob >=0, prob!=np.inf) # to avoid indeterminations return f[idx], prob[idx] ``` ```python # Define parameters N_s = [0, 0.1, 1, 10] freq = np.linspace(0, 1, 200) fig, ax = plt.subplots(1, 1) # Loop through mutation rates and plot the distribution for ns in N_s: f, prob = sel_drift_hap(freq, ns) plt.plot(f, prob, #/ np.sum(prob), label=str(ns)) ax.legend(loc='upper center', title='$N s$') ax.set_xlabel('allele frequency $f$') ax.set_ylabel('$\propto$ probability') ax.set_title('selection-drift (haploids)') ax.axes.get_yaxis().set_ticks([]) ax.margins(0.02) plt.tight_layout() plt.savefig('fig/sel_drift_haploid.png') ``` /Users/razo/anaconda3/lib/python3.6/site-packages/ipykernel/__main__.py:2: RuntimeWarning: divide by zero encountered in true_divide from ipykernel import kernelapp as app ### Diploid organisms #### Heterozygote advantage. For the case of a diploid organism where the genotypes have fitness values \begin{align} \omega_{AA} = 1,\\ \omega_{Aa} = 1 + s,\\ \omega_{aa} = 1, \end{align} we have that the steady state distribution of alleles is of the form $$ P(f) \propto \frac{e^{4Ns f(1 - f)}}{f(1 - f)} \tag{3} $$ Let's look at some distributions. ```python def sel_drift_dip_hetero_advantage(f, N_s): prob = np.exp(4 * N_s * f * (1 - f)) / (f * (1 - f)) idx = np.logical_and(prob >=0, prob!=np.inf) # to avoid indeterminations return f[idx], prob[idx] ``` ```python # Define parameters N_s = [1, 10, 50] freq = np.linspace(0, 1, 200) fig, ax = plt.subplots(1, 1) # Loop through mutation rates and plot the distribution for ns in N_s: f, prob = sel_drift_dip_hetero_advantage(freq, ns) plt.plot(f, prob / np.sum(prob), label=str(ns)) ax.legend(loc=0, title='$N s$') ax.set_xlabel('allele frequency $f$') ax.set_ylabel('$\propto$ probability') ax.set_title('selection-drift (diploids heterozygote advantage)', fontsize=14) ax.axes.get_yaxis().set_ticks([]) ax.margins(0.02) plt.tight_layout() plt.savefig('fig/sel_drift_diploid_hetero_advantage.png') ``` /Users/razo/anaconda3/lib/python3.6/site-packages/ipykernel/__main__.py:2: RuntimeWarning: divide by zero encountered in true_divide from ipykernel import kernelapp as app #### Heterozygote Intermediate. For the case of a diploid organism where the genotypes have fitness values \begin{align} \omega_{AA} = 1 + 2s,\\ \omega_{Aa} = 1 + s,\\ \omega_{aa} = 1, \end{align} we have that the steady state distribution of alleles is of the form $$ P(f) \propto \frac{e^{4Ns f}}{f(1 - f)} \tag{3} $$ Let's look at some distributions. ```python def sel_drift_dip_hetero_intermediate(f, N_s): prob = np.exp(4 * N_s * f ) / (f * (1 - f)) idx = np.logical_and(prob >=0, prob!=np.inf) # to avoid indeterminations return f[idx], prob[idx] ``` ```python # Define parameters N_s = [0.1, 1, 5] freq = np.linspace(0, 0.95, 200) fig, ax = plt.subplots(1, 1) # Loop through mutation rates and plot the distribution for ns in N_s: f, prob = sel_drift_dip_hetero_intermediate(freq, ns) plt.plot(f, prob / np.sum(prob), label=str(ns)) ax.legend(loc=0, title='$N s$') ax.set_xlabel('allele frequency $f$') ax.set_ylabel('$\propto$ probability') ax.set_title('selection-drift (diploids heterozygote intermediate)', fontsize=14) ax.axes.get_yaxis().set_ticks([]) ax.set_xlim([0, 1]) ax.margins(0.02) plt.tight_layout() plt.savefig('fig/sel_drift_diploid_hetero_intermediate.png') ``` /Users/razo/anaconda3/lib/python3.6/site-packages/ipykernel/__main__.py:2: RuntimeWarning: divide by zero encountered in true_divide from ipykernel import kernelapp as app ### Mutation-Selection-Drift. For the case of a diploid organism where the genotypes have fitness values \begin{align} \omega_{AA} = 1 - s,\\ \omega_{Aa} = 1,\\ \omega_{aa} = 1, \end{align} And the mutation rates are given by \begin{align} \mu_{A \rightarrow a} = 0\\ \mu_{a \rightarrow A} = \mu\\ \end{align} we have that the steady state distribution of alleles is of the form $$ P(f) \propto \frac{e^{-2Ns f^2} (1 - f)^{2N \mu}}{f(1 - f)} \tag{3} $$ Let's look at some distributions. ```python def mut_sel_drift(f, N, s, mu): prob = np.exp(- 2 * N * s * f**2) * (1 - f)**(2 * N * mu) / (f * (1 - f)) idx = np.logical_and(prob >=0, prob!=np.inf) # to avoid indeterminations return f[idx], prob[idx] ``` ```python # Define parameters N = [10**2, 10**4] s = 0.0001 mu = [10**-1, 10**-6] ``` ```python freq = np.linspace(0, 1, 200) fig, ax = plt.subplots(1, 1) # Loop through mutation rates and plot the distribution for n in N: for m in mu: f, prob = mut_sel_drift(freq, n, s, m) plt.plot(f, prob / np.sum(prob), label='$N = {0:d}, \mu = {1:f}$'.format(n, m)) ax.legend(loc=0) ax.set_xlabel('allele frequency $f$') ax.set_ylabel('$\propto$ probability') ax.set_title('selection-drift (diploids heterozygote intermediate)', fontsize=14) ax.axes.get_yaxis().set_ticks([]) ax.set_xlim([0, 1]) ax.margins(0.02) plt.tight_layout() # plt.savefig('fig/sel_drift_diploid_hetero_intermediate.png') ``` /Users/razo/anaconda3/lib/python3.6/site-packages/ipykernel/__main__.py:2: RuntimeWarning: divide by zero encountered in true_divide from ipykernel import kernelapp as app /Users/razo/anaconda3/lib/python3.6/site-packages/ipykernel/__main__.py:2: RuntimeWarning: invalid value encountered in true_divide from ipykernel import kernelapp as app /Users/razo/anaconda3/lib/python3.6/site-packages/ipykernel/__main__.py:3: RuntimeWarning: invalid value encountered in greater_equal app.launch_new_instance() ```python freq = np.linspace(1E-3, 0.02, 200) fig, ax = plt.subplots(1, 1) # Loop through mutation rates and plot the distribution for n in N: for m in mu: f, prob = mut_sel_drift(freq, n, s, m) plt.plot(f, prob / np.sum(prob), label='$N = {0:d}, \mu = {1:f}$'.format(n, m)) ax.legend(loc=0) ax.set_xlabel('allele frequency $f$') ax.set_ylabel('$\propto$ probability') ax.set_title('selection-drift (diploids heterozygote intermediate)', fontsize=14) ax.axes.get_yaxis().set_ticks([]) # ax.set_xlim([0, 1]) ax.margins(0.02) plt.tight_layout() # plt.savefig('fig/sel_drift_diploid_hetero_intermediate.png') ``` # Kolmogorov Backwards Equation. ## Probability of fixation (Haploid) Using the Kolmogorov backwards equation we derived that the probability of an allele being fixed is of the form $$ P(1, \infty \mid f_o) = \frac{1 - e^{-2N_e s f_o}}{1 - e^{-2N_e s}}, \tag{4} $$ where $f_o$ is the initial frequency of the allele, $N_e$ is the effective population size, and $s$ is the selection coefficient. Let's define a function to compute this quantity. ```python def fix_prob_haploid(N, s, fo): return (1 - np.exp(-2 * N * s * fo)) / (1 - np.exp(-2 * N * s)) ``` ```python N_array = 10**np.array([2, 3, 4]) s_array = np.linspace(-0.005, 0.005, 100) fig, ax = plt.subplots(1, 1) # Loop through mutation rates and plot the distribution for n in N_array: prob = fix_prob_haploid(n, s_array, 1 / n) plt.plot(s_array, prob, label='$N = {0:d}$'.format(n)) ax.legend(loc=0) ax.set_xlabel('selection coefficient $s$') ax.set_ylabel('fixation probability') ax.set_title('haploids', fontsize=14) ax.margins(0.02) plt.tight_layout() plt.savefig('fig/fix_prob_haploid.png') ``` ## Probability of fixation (diploids) For the diploid case we have a very similar equation for the probability of fixation of an allele $$ P(1, \infty \mid f_o) = \frac{1 - e^{-4N_e h s f_o}}{1 - e^{-2N_e h s}}, \tag{5} $$ where $f_o$ is the initial frequency of the allele, $N_e$ is the effective population size, $h$ is the dominance, and $s$ is the selection coefficient. Let's define a function to compute this quantity. ```python def fix_prob_diploid(N, h, s, fo): return (1 - np.exp(-4 * N * h * s * fo)) / (1 - np.exp(-4 * N * h * s)) ``` ```python h_array = [0.05, 0.5, 1] s_array = np.linspace(-0.005, 0.005, 100) N = 1E3 fig, ax = plt.subplots(1, 1) # Loop through mutation rates and plot the distribution for h in h_array: prob = fix_prob_diploid(N, h, s_array, 1 / N) plt.plot(s_array, prob, label='$h = {0:.1f}$'.format(h)) ax.legend(loc=0) ax.set_xlabel('selection coefficient $s$') ax.set_ylabel('fixation probability') ax.set_title('diploids', fontsize=14) ax.margins(0.02) plt.tight_layout() plt.savefig('fig/fix_prob_diploids.png') ``` ```python ```

43fbbcb149e49d6d265a46cae40718345907f890

ipynb

Jupyter Notebook

code/classic_diffusion/diffusion_theory.ipynb

mrazomej/stat_gen

abafd9ecc63ae8a804c8df5b9658e47cabf951fa

code/classic_diffusion/diffusion_theory.ipynb

mrazomej/stat_gen

abafd9ecc63ae8a804c8df5b9658e47cabf951fa

2019-03-05T00:17:26.000Z

2019-03-05T00:17:26.000Z

code/classic_diffusion/diffusion_theory.ipynb

mrazomej/pop_gen

abafd9ecc63ae8a804c8df5b9658e47cabf951fa

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# Lecture 30: Chi-Square, Student's t, Multivariate Normal ## Stat 110, Prof. Joe Blitzstein, Harvard University ---- ## $\chi^2$ Distribution The Chi-square Distribution is denoted as $\chi^2(n)$ or sometimes $\chi_{n}^2$, where $n$ indicates the _degrees of freedom_. It used everywhere (I think you used it before in feature analysis). It is related to Normal distribution. Let $V = Z_1^2 + Z_2^3 + \dots + Z_n^2$, where the $Z_j$ are i.i.d. $\mathcal{N}(0,1)$. Then by definition, $V \sim \chi^2(n)$. You will find that in a lot of things involving statistics, the sum of squares of $\mathcal{N}(0,1)$ often pops up. ```python import matplotlib import numpy as np import matplotlib.pyplot as plt from matplotlib.ticker import (MultipleLocator, FormatStrFormatter, AutoMinorLocator) from scipy.stats import chi2 %matplotlib inline plt.xkcd() dof_values = [1,2,3,4,5,6,7,8] x = np.linspace(0, 10, 1000) # plot the distributions _, ax = plt.subplots(figsize=(12,8)) for d in dof_values: ax.plot(x, chi2.pdf(x, d), lw=3.2, alpha=0.6, label='df={}'.format(d)) # legend styling legend = ax.legend() for label in legend.get_texts(): label.set_fontsize('large') for label in legend.get_lines(): label.set_linewidth(1.5) # y-axis ax.set_ylim([0.0, 0.5]) ax.set_ylabel(r'$f(x)$') # x-axis ax.set_xlim([0, 10.0]) ax.set_xlabel(r'$x$') # x-axis tick formatting majorLocator = MultipleLocator(2.0) majorFormatter = FormatStrFormatter('%0.1f') minorLocator = MultipleLocator(1.0) ax.xaxis.set_major_locator(majorLocator) ax.xaxis.set_major_formatter(majorFormatter) ax.xaxis.set_minor_locator(minorLocator) ax.grid(color='grey', linestyle='-', linewidth=0.3) plt.suptitle(r'Examples of $\chi^2_n$ with varying degrees of freedom') plt.show() ``` ### Fact: $\chi^2(1)$ is $\operatorname{Gamma}(\frac{1}{2}, \frac{1}{2})$ #### Proof Let $Y = Z^2$ where $Z \sim \mathcal{N}(0,1)$ and $y \gt 0$. \begin{align} P(Y \le y) &= P(Z^2 \le y) \\ &= P( -y^{\frac{1}{2}} \le y \le y^{\frac{1}{2}}) \\ &= \Phi(y^{\frac{1}{2}}) - \Phi(y^{-\frac{1}{2}}) \\ &= \Phi(y^{\frac{1}{2}}) - \left( 1 - \Phi(y^{\frac{1}{2}}) \right) \\ &= 2 \, \Phi(y^{\frac{1}{2}}) - 1 \\ \\ \Rightarrow f_{Y}(y) &= y^{-\frac{1}{2}} \, \phi(y^{\frac{1}{2}}) \\ &= \frac{1}{\sqrt{2\pi}} \, y^{-\frac{1}{2}} \, e^{-\frac{y}{2}} \\ \\ \operatorname{Gamma}\left(\frac{1}{2}, \frac{1}{2}\right) &= \frac{1}{\Gamma(\frac{1}{2})} \, \left(\frac{y}{2}\right)^{\frac{1}{2}} \, e^{-\frac{y}{2}} \, \frac{1}{y} \\ &= \frac{1}{\sqrt{\pi}} \, \sqrt{\frac{y}{2}} \, e^{-\frac{y}{2}} \, \frac{1}{y} \\ &= \frac{1}{\sqrt{2\pi}} \, y^{-\frac{1}{2}} \, e^{-\frac{y}{2}} &\blacksquare \\ \end{align} Here's a quick graph to illustrate. ```python from scipy.stats import gamma _, (ax1, ax2) = plt.subplots(1, 2, sharey=True, figsize=(14,6)) x = np.linspace(0, 20, 1000) ax1.plot(x, chi2.pdf(x, 1), lw=3.2, alpha=0.6, color='#33AAFF', label='df=1') ax1.set_title('$\chi^2_1$', y=1.02) ax1.set_xlim((0,20.0)) ax1.set_ylim((0,0.5)) ax1.legend() ax1.grid(color='grey', linestyle='-', linewidth=0.3) # gamma.pdf API: scale = 1 / beta l = 0.5 ax2.plot(x, gamma.pdf(x, 0.5, scale=1/l), lw=3.2, alpha=0.6, color='#FF9933', label=r'$\alpha$=1/2, $\lambda$=1/2') ax2.set_title(r'$Gamma(\frac{1}{2}, \frac{1}{2})$', y=1.02) ax2.set_xlim((0,20.0)) ax2.set_ylim((0,0.5)) ax2.legend() ax2.grid(color='grey', linestyle='-', linewidth=0.3) None ``` ### Fact: $\chi^2(n)$ is $\operatorname{Gamma}\left( \frac{n}{2}, \frac{1}{2} \right)$ It follows then that $\chi^2(n) = \operatorname{Gamma}\left( \frac{n}{2}, \frac{1}{2} \right)$ ```python _, (ax1, ax2) = plt.subplots(1, 2, sharey=True, figsize=(14,6)) x = np.linspace(0, 20, 1000) dof_values = [1, 2, 5, 10, 20] col_alph_values = [0.8, 0.6, 0.5, 0.4, 0.3] for df,c_alph in zip(dof_values, col_alph_values): ax1.plot(x, chi2.pdf(x, df), color='#33AAFF', lw=3.2, alpha=c_alph, label='df={}'.format(df)) ax1.set_title('$\chi^2_n$ for varying degrees of freedom', y=1.02) ax1.set_xlim((0,20.0)) ax1.set_ylim((0,0.5)) ax1.legend() ax1.grid(color='grey', linestyle='-', linewidth=0.3) # gamma.pdf API: scale = 1 / lambda l = 0.5 for alph,c_alph in zip(dof_values, col_alph_values): ax2.plot(x, gamma.pdf(x, alph/2, scale=1/l), lw=3.2, alpha=c_alph, color='#FF9933', label=r'$\alpha$={}/2, $\lambda$=1/2'.format(alph)) ax2.set_title(r'$Gamma(\frac{n}{2}, \frac{1}{2})$ for varying n', y=1.02) ax2.set_xlim((0,20.0)) ax2.set_ylim((0,0.5)) ax2.legend() ax2.grid(color='grey', linestyle='-', linewidth=0.3) None ``` ---- ## Student's $t$-Distribution The Student's $t$-distribution can be described in terms of the standard normal $Z \sim N(0,1)$ and $X^2$ $V(n)$ distributions, so that means it can be entirely described in terms of the standard normal distribution. Let $T = \frac{Z}{\sqrt{V/n}}$, with $Z \sim \mathcal{N}(0,1)$ and $V \sim \chi^2(n)$, where $Z, V$ are independent. Then we can write $T \sim t_n$, where $n$ is the degrees of freedom. $t_1$ does not have a $1^{st}$ moment; $t_2$ does not have a $2^{nd}$ moment; $t_3$ does not have a $3^{rd}$ moment; and so on. Odd moments, if they exist, are 0 ```python from scipy.stats import t dof_values = [1,2,5,10,30,1E10] col_alph_values = [0.2, 0.3, 0.4, 0.5, 0.6, 0.8] x = np.linspace(-5, 5, 1000) # plot the distributions fig, ax = plt.subplots(figsize=(8, 6)) for df,c_alph in zip(dof_values, col_alph_values): if df > 30: dl = r'$+\infty$' else: dl = df ax.plot(x, t.pdf(x, df), lw=3.2, color='#A93226', alpha=c_alph, label=r'df={}'.format(dl)) # legend styling legend = ax.legend() for label in legend.get_texts(): label.set_fontsize('large') for label in legend.get_lines(): label.set_linewidth(1.5) # y-axis ax.set_ylim([0, .43]) ax.set_ylabel(r'$P(x)$') # x-axis ax.set_xlim([-3.0, 3.0]) ax.set_xlabel(r'$x$') ax.grid(color='grey', linestyle='-', linewidth=0.3) plt.title(r'Examples of $t_n$ with varying degrees of freedom', y=1.02) plt.text(x=3.5, y=0.22, s=r'Fatter tails with fewer degrees of freedom') plt.text(x=3.5, y=0.19, s=r'Approaches $\mathbb{N}(0,1)$ as $df \rightarrow +\infty$') plt.show() ``` ### Properties 1. symmetric, i.e., $-T \sim t_n$ <p/> 1. $n=1 \, \Rightarrow $ Cauchy, so $t_1$ does not have a mean<p/> 1. $n \ge 2 \Rightarrow \mathbb{E}(T) = \mathbb{E}(Z)\,\mathbb{E}\left(\frac{1}{\sqrt{V/n}}\right) = 0$ <p/> 1. heavier-tailed than Normal <p/> 1. for $n$ large, $t_n$ looks very much like Normal <p/> ### Brief interlude: even moments of $Z$ and the Gamma distribution It was proved earlier that for $Z \sim \mathcal{N}(0,1)$, the *even* moments are such that \begin{align} \mathbb{E}(Z^2) &= 1 \\ \mathbb{E}(Z^4) &= 1 \times 3 = 3 \\ \mathbb{E}(Z^6) &= 1 \times 3 \times 5 = 15 &\quad \text{ skip factorial} \\ \end{align} Now, this was proven using moment-generating functions, but we can also relate this to the Gamma distribution. \begin{align} \mathbb{E}(Z^{2n}) &= \mathbb{E}\left( (Z^2)^n \right) \\ &= \mathbb{E}\left( \chi^2_1 )^n \right) &\text{ but by definition } Z^2 \text{ is } \chi^2_1 \\ &= \mathbb{E}\left( \operatorname{Gamma}(\frac{1}{2}, \frac{1}{2})^n \right) \end{align} ... and after this point, we can use our knowledge of the Gamma distribution and LOTUS. #### Finding $\mathbb{E}(Z^8)$ with $\operatorname{Gamma}(\frac{1}{2}, \frac{1}{2})$ \begin{align} \mathbb{E}(Z^8) &= \mathbb{E}\left( (Z^2)^4 \right) \\ &= \mathbb{E}\left( \operatorname{Gamma}(\frac{1}{2}, \frac{1}{2})^4 \right) \\ &= \frac{\Gamma(\alpha + 4)}{\Gamma(\alpha) \, \lambda^4} \\ &= \frac{(\alpha + 3) \, \Gamma(\alpha + 3)}{\Gamma(\alpha) \, \lambda^4} \\ &= \frac{(\alpha + 3) \, (\alpha + 2) \, \Gamma(\alpha + 2)}{\Gamma(\alpha) \, \lambda^4} \\ &= \frac{(\alpha + 3) \, (\alpha + 2) \, (\alpha + 1) \, \Gamma(\alpha + 1)}{\Gamma(\alpha) \, \lambda^4} \\ &= \frac{(\alpha + 3) \, (\alpha + 2) \, (\alpha + 1) \, \alpha \, \Gamma(\alpha)}{\Gamma(\alpha) \, \lambda^4} \\ &= \frac{\frac{7}{2} \, \frac{5}{2} \, \frac{3}{2} \, \frac{1}{2}}{\frac{1}{2^4}} \\ &= 1 \times 3 \times 5 \times 7 \\ &= 105 \end{align} You can [double-check this answer on WolframAlpha](http://www.wolframalpha.com/input/?i=expected+value+of+Z%5E8). ### Proof of property 5: Student's $t$ when $n$ get large Let's prove property 5 above, but use the Law of Large Numbers (c.f. Lesson 29). * Let $T_n = \frac{Z}{\sqrt{V/n}}$ with $Z_1, Z_2, \dots , Z_n$ i.i.d. $\mathcal{N}(0,1)$ * $V = Z_1^2 + Z_2^2 + \dots + Z_n^2$ * $Z$ is independent of the $Z_j^2$ Now we can choose any distribution for this case as long as it is $\mathcal{N}(0,1)$, and so there is nothing wrong in choosing the same distribution $Z$ for the numerator and all elements of the denominator as well. Then $\frac{V_n}{n} \rightarrow 1$ with probability 1 by the Law of Large Numbers, since the average $\frac{V_n}{n}$ will approach the true average $Z_1^2$ as $n$ gets large. We know that $Z_1^2 = 1$. Now, the Law of Large Numbers is with regards to point-wise estimates, so we can further state that $\sqrt{\frac{V_n}{n}} \rightarrow 1$ with probability 1. So $T_n \rightarrow Z$ with probability 1, since the denominator goes to 1 when you have a large number of degrees of freedom; only the $Z$ in the numerator will be of importance. \begin{align} \end{align} ---- ## Multivariate Normal ### Definition Random vector $(X_1, X_2, \cdots , X_k) = \vec{X}$ is Multivariate Normal if every linear combination $t_1 X_1 + t_2 X_2 + \cdots + t_k X_k$ is Normal. ### An example that is multivariate Normal Let $Z, W$ be i.i.d. $\mathcal{N}(0,1)$. Then $( Z + 2W, 3 \, Z + 5W)$ is multivariate Normal (MVN). Given constants $s,t$ \begin{align} s (Z + 2 \, W) + t (3 \, Z + 5 \, W) &= (s + 3t) Z + (2s + 5t) W \\ \end{align} But since this is $(s + 3t)$ and $(2s + 5t)$ are just scaling independent Normal random variables $Z$ and $W$ respectively; and since we know that the sum of Normal random variables is also Normal, we know that $(s + 3t) Z + (2s + 5t) W$ is also necessarily a Normal r.v. ### A non-example (NOT multivariate Normal) Let $Z \sim \mathcal{N}(0,1)$, and let $S$ be a random sign that is independent of $Z$. Then $Z,SZ$ are marginally $\mathcal{N}(0,1)$ (consider both individually on their own). But $(Z, SZ)$ is _not_ multivariate normal! Just test this by considering $(Z + SZ)$. $Z + SZ$ cannot be Normal, since: * half the time, the sum of $Z$ and $SZ$ will be zero when $S$ is negative * the other times, the sum will be $2Z$ * this is some mixture of discrete and continuous ## MGF of $\vec{X}$ Now with $X \sim \mathcal{N}(\mu, \sigma^2)$, the moment generating function $M(X)$ is \begin{align} M(X) &= \mathbb{E}(e^{tX}) \\ &= e^{t\mu + \frac{1}{2} \, t^2 \sigma^2} \\\\ \end{align} Extending this one-dimensional case to the multidimensional $\vec{X}$: \begin{align} M(\vec{X}) &= \mathbb{E}(e^{\vec{t} \, \vec{X}}) \\ &= \mathbb{E}(e^{t_1 \, X_1 + t_2 \, X_2 + \cdots + t_n \, X_n}) \\ &= \mathbb{E}(e^{t_1 \, \mu_1 + t_2 \, \mu_2 + \cdots + t_n \, \mu_n + \frac{1}{2} Var(t_1 \, X_1 + t_2 \, X_2 + \cdots + t_n \, X_n)} \end{align} ## Theorem: Within an MVN, uncorrelated implies independent Recall that in general, independence implies uncorrelation, but the vice versa is not always true. In the case of an MVN, however, it **is** true. In other words, consider vector \begin{align} \vec{X} &= \begin{bmatrix} \vec{X_1} \\ \vec{X_2} \\ \end{bmatrix} \end{align} If every component of $\vec{X_1}$ is uncorrelated with every component of $\vec{X_2}$, then $\vec{X_1}$ is independent of $\vec{X_2}$. ### Example Let $X,Y$ be i.i.d. $\mathcal{N}(0,1)$. Then $(X+Y, X-Y)$ is MVN (_bivariate Normal_ to be precise). It is easy enough to show that $X+Y$ and $X-Y$ are uncorrelated: \begin{align} \operatorname{Cov}(X+Y, X-Y) &= \operatorname{Var}(X) + \operatorname{Cov}(X,Y) - \operatorname{Cov}(X,Y) - \operatorname{Var}(Y) \\ &= \operatorname{Var}(X) - \operatorname{Var}(Y) \\ &= 1 - 1 \\ &= 0 \end{align} But can we show that $X+Y$ and $X-Y$ are _independent_? ### Proof Let's try for something a bit more abstract. We suppose that $X,Y$ are _independent_, zero-mean normal random variables with variances $\sigma_U, \sigma_V$. Let $U = aX + bY$, and $V = cX + dY$ so that $U,V$ are jointly normal; this is a more general represention of the above example, where $a = 1, b=1, c=1, d=-1$. Say we have some scalars $t_1, t_2$, and let $Z = t_{1}U + t_{2}V$. Then \begin{align} M_{U,V}(t_1, t_2) &= \mathbb{E}(e^{t_1 \, U + t_2 \, V}) \\ &= \mathbb{E}(e^{Z}) \\ &= \mathbb{E}(e^{t_1 \, \mu_U + t_2 \, \mu_V + \frac{1}{2} Var(t_1 \, U + t_2 \, V)} \\ &= \mathbb{E}(e^{\frac{1}{2} Var(t_1 \, U + t_2 \, V}) \\ &= \mathbb{E}(e^{\frac{t_U^2 \, \sigma_U^2 + t_V^2 \, \sigma_V^2}{2}}) \end{align} Now let $U\prime, V\prime$ be independent zero-mean normal random variables with the same variances $\sigma_U, \sigma_V$. Since $U\prime, V\prime$ are independent, they are also _uncorrelated_, and so the moment generating function of their bivariate normal distribution is given by $M_{U\prime,V\prime}(t_1, t_2) = \mathbb{E}(e^{\frac{t_U^2 \, \sigma_U^2 + t_V^2 \, \sigma_V^2}{2}}) $. Since both $U,V$ and $U\prime,V\prime$ have the same moment generating function, they are boht associated with the same bivariate Normal distribution (they share the same joint PDF). Thereforce, since $U\prime,V\prime$ are _independent_, we conclude that $U,V$ are also independent. QED. ---- View [Lecture 30: Chi-Square, Student-t, Multivariate Normal | Statistics 110](http://bit.ly/2Qfy1vJ) on YouTube.

3b3e7d45c8d7acb41253367cb003e48daf15c98c

ipynb

Jupyter Notebook

Lecture_30.ipynb

abhra-nilIITKgp/stats-110

258461cdfbdcf99de5b96bcf5b4af0dd98d48f85

2016-04-29T07:27:33.000Z

2022-02-27T18:32:47.000Z

Lecture_30.ipynb

snoop2head/stats-110

88d0cc56ede406a584f6ba46368e548010f2b14a

Lecture_30.ipynb

snoop2head/stats-110

88d0cc56ede406a584f6ba46368e548010f2b14a

2016-12-24T02:02:25.000Z

2022-02-13T13:20:02.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# CHEM 1000 - Spring 2022 Prof. Geoffrey Hutchison, University of Pittsburgh ## Graded Homework 3 For this homework, we'll focus on: - vector arithmetic - scalar dot product - vector cross product - simple operators --- As a reminder, you do not need to use Python to solve the problems. If you want, you can use other methods, just put your answers in the appropriate places. To turn in, either download as Notebook (.ipynb) or Print to PDF and upload to Gradescope. Make sure you fill in any place that says YOUR CODE HERE or "YOUR ANSWER HERE", as well as your name and collaborators (i.e., anyone you discussed this with) below: ```python NAME = "" COLLABORATORS = "" ``` ### Vector Arithmetic (4 points) We're going to use some vectors on a more complicated molecule, biphenyl: ```python import py3Dmol # 7095 is the PubChem Compound ID (CID) for biphenyl: # https://pubchem.ncbi.nlm.nih.gov/compound/Biphenyl view = py3Dmol.view(width=400,height=400,query='cid:7095') view.setStyle({'stick':{}}) view.addSurface(py3Dmol.VDW,{'opacity':0.7,'color':'white'}) view.zoomTo() view.show() ``` <div id="3dmolviewer_1599837352608927" style="position: relative; width: 400px; height: 400px"> <p id="3dmolwarning_1599837352608927" style="background-color:#ffcccc;color:black">You appear to be running in JupyterLab (or JavaScript failed to load for some other reason). You need to install the 3dmol extension: <br> <tt>jupyter labextension install jupyterlab_3dmol</tt></p> </div> ```python # here are the coordinates of the indicated atoms import numpy as np c1 = np.array([ 1.441, -1.132, 0.414]) c2 = np.array([ 0.742, 0.001, 0.004]) c3 = np.array([-0.742, 0.000, 0.002]) c4 = np.array([-1.443, 1.133, 0.412]) # find the vector for c1-c2 bond by subtraction c1c2 = c2c3 = c3c4 = # print the length of the c1c2 bond (i.e., the magnitude or 'norm' in numpy) print( round(np.linalg.norm(c1c2), 3) ) # print the length of the c2c3 bond print( round(np.linalg.norm(c2c3), 3) ) # print the length of the c3c4 bond print( round(np.linalg.norm(c3c4), 3) ) ``` <div class="alert alert-block alert-info"> **Concept**: Are the bonds all the same length or not? Why? YOUR ANSWER HERE </div> ## Center of Geometry Find the 'centroid' or center point for the atoms c1, c2, c3, c4. (This should obviously be the center of the molecule, and between atoms c3 and c4). ```python # YOUR CODE HERE centroid = # FIXME print(centroid) ``` <div class="alert alert-block alert-info"> **Concept**: Are the coordinates of this molecule exactly at the origin 0,0,0? YOUR ANSWER HERE </div> ## Scalar Dot Product Use the scalar dot product to find the angle between c1c2 and c2c3 (i.e., the c1-c2-c3 angle) As a reminder: $$ \cos (\theta)=\frac{\mathbf{u} \cdot \mathbf{v}}{|\mathbf{u}||\mathbf{v}|} $$ ```python # YOUR CODE HERE mag_c1c2 = np.linalg.norm(c1c2) mag_c2c3 = np.linalg.norm(c2c3) theta = np.arccos( # FIXME ) print( round(np.degrees(theta), 3) ) ``` <div class="alert alert-block alert-info"> **Concept:** Does your answer above match your expectation? What do you think the angle should be based on chemistry? YOUR ANSWER HERE </div> ### Vector Cross Product Let's say we want to know the angle between the two benzene rings in biphenyl. That's the *dihedral* or torsion angle around c1-c2-c3-c4. We know that c1-c2-c3 form a plane (i.e., three points determine a plane) and that the cross product will give us the vector perpendicular to that plane. So we'll need to take two cross products (and be careful to take them in the right order) ```python # YOUR CODE HERE # find the cross product between c1c2 and c2c3 bonds c1c2c3 = print(c1c2c3) # find the cross product between c2c3 and c3c4 bonds c2c3c4 = print(c2c3c4) # the following code should get the torsion angle for you mag_c1c2c3 = np.linalg.norm(c1c2c3) mag_c2c3c4 = np.linalg.norm(c2c3c4) torsion = np.arccos(np.dot(c1c2c3, c2c3c4) / (mag_c1c2c3 * mag_c2c3c4)) print( round(np.degrees(torsion), 3) ) ``` <div class="alert alert-block alert-info"> **Concept** What happens if you reverse the order of the bonds in the cross product? Will it change your answer for the angle? Explain: YOUR ANSWER HERE </div> ### Operators Unfortunately, what we've learned about operators is a bit abstract still. (We'll design some operators that tell us things about energies, forces, etc. on Monday.) If you find these hard, they can be. You can either do this with Sympy, or create a PDF of this notebook and add pages with your work. 5.3 Consider the linear momentum operator $$ \hat{p} \equiv-i \hbar \frac{d}{d x} $$ where $\hbar$ is a constant. For the function $\psi(x)=\mathrm{e}^{i k x},$ show that $\hat{p} \psi(x)=\hbar k \psi(x)$ 5.4 Consider the kinetic energy operator $$ \hat{H} \equiv-\frac{h^{2}}{8 \pi^{2} m} \frac{d^{2}}{d x^{2}} $$ For the function $\psi(x)=\sin \left(\frac{\pi x}{L}\right),$ show that $\hat{H} \psi(x)=\frac{h^{2}}{8 m L^{2}} \psi(x)$ ```python from sympy import init_session init_session() i, hbar = symbols('i hbar') h, m, L = symbols('h m L') ``` ```python # YOUR CODE HERE # if you have an error, make sure you run the cell above this psi = exp(i*k*x) p = print(p) ``` ```python # YOUR CODE HERE psi = sin(pi*x/L) H = print(H) ```

85e77515445faeadfc1dcd1232af1afe46b105b4

ipynb

Jupyter Notebook

homework/ps3/ps3.ipynb

ghutchis/chem1000

07a7eac20cc04ee9a1bdb98339fbd5653a02a38d

2020-06-23T18:44:37.000Z

2022-03-14T10:13:05.000Z

homework/ps3/ps3.ipynb

ghutchis/chem1000

07a7eac20cc04ee9a1bdb98339fbd5653a02a38d

homework/ps3/ps3.ipynb

ghutchis/chem1000

07a7eac20cc04ee9a1bdb98339fbd5653a02a38d

2021-07-29T10:45:23.000Z

2021-10-16T09:51:00.000Z

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

```python %matplotlib inline ``` ```python # Write your imports here import numpy as np import math import matplotlib.pyplot as plt ``` # Basic Algebra Exercise ## Functions, Polynomials, Complex Numbers. Applications of Abstract Algebra ### Problem 1. Polynomial Interpolation We know that if we have a set of $n$ data points with coordinates $(x_1; y_1), (x_2; y_2), \dots, (x_n; y_n)$, we can try to figure out what function may have generated these points. Please note that **our assumptions about the data** will lead us to choosing one function over another. This means that our results are as good as our data and assumptions. Therefore, it's extremely important that we write down our assumptions (which sometimes can be difficult as we sometimes don't realize we're making them). It will be better for our readers if they know what those assumptions and models are. In this case, we'll state two assumptions: 1. The points in our dataset are generated by a polynomial function 2. The points are very precise, there is absolutely no error in them. This means that the function should pass **through every point** This method is called *polynomial interpolation* (*"polynomial"* captures assumption 1 and *"interpolation"* captures assumption 2). It can be proved (look at [Wikipedia](https://en.wikipedia.org/wiki/Polynomial_interpolation) for example) that if we have $n$ data points, there is only one polynomial of degree $n-1$ which passes through them. In "math speak": "the vector spaces of $n$ points and polynomials of degree $n-1$ are isomorphic (there exists a bijection mapping one to the other)". There are a lot of ways to do interpolation. We can also write the function ourselves if we want but this requires quite a lot more knowledge than we already covered in this course. So we'll use a function which does this for us. `numpy.polyfit()` is one such function. It accepts three main parameters (there are others as well, but they are optional): a list of $x$ coordinates, a list of $y$ coordinates, and a polynomial degree. Let's say we have these points: ```python points = np.array([(0, 0), (1, 0.8), (2, 0.9), (3, 0.1), (4, -0.8), (5, -1.0)]) ``` First, we need to "extract" the coordinates: ```python x = points[:, 0] y = points[:, 1] ``` Then, we need to calculate the interpolating polynomial. For the degree, we'll set $n-1$: ```python coefficients = np.polyfit(x, y, len(points) - 1) poly = np.poly1d(coefficients) ``` After that, we need to plot the function. To do this, we'll create a range of $x$ values and evaluate the polynomial at each value: ```python plot_x = np.linspace(np.min(x), np.max(x), 1000) plot_y = poly(plot_x) ``` Finally, we need to plot the result. We'll plot both the fitting polynomial curve (using `plt.plot()`) and the points (using `plt.scatter`). It's also nice to have different colors to make the line stand out from the points. ```python plt.plot(plot_x, plot_y, c = "green") plt.scatter(x, y) plt.xlabel("x") plt.ylabel("y") plt.show() ``` Don't forget to label the axes! Your task now is to wrap the code in a function. It should accept a list of points, the polynomial degree, min and max value of $x$ used for plotting. We'll use this function to try some other cases. ```python import numpy as np import numpy.polynomial.polynomial as p def interpolate_polynomial(points, degree, min_x, max_x): """ Interpolates a polynomial of the specified degree through the given points and plots it points - a list of points (x, y) to plot degree - the polynomial degree min_x, max_x - range of x values used to plot the interpolating polynomial """ x = points[:, 0] y = points[:, 1] coefficients = np.polyfit(x, y, degree) poly = np.poly1d(coefficients) plot_x = np.linspace(np.min(min_x), np.max(max_x), 1000) plot_y = poly(plot_x) plt.plot(plot_x, plot_y, c = "green") plt.scatter(x, y) plt.xlabel("x") plt.ylabel("y") plt.show() ``` ```python points = np.array([(0, 0), (1, 0.8), (2, 0.9), (3, 0.1), (4, -0.8), (5, -1.0)]) interpolate_polynomial(points, len(points) - 1, np.min(points[:, 0]), np.max(points[:, 0])) ``` We see this is a very nice fit. This is expected, of course. Let's try to expand our view a little. Let's try to plot other values of $x$, further than the original ones. This is **extrapolation**. ```python interpolate_polynomial(points, len(points) - 1, -5, 10) ``` Hmmm... it seems our polynomial goes a little wild outside the original range. This is to show how **extrapolation can be quite dangerous**. Let's try a lower polynomial degree now. We used 4, how about 3, 2 and 1? **Note:** We can add titles to every plot so that we know what exactly we're doing. Te title may be passed as an additional parameter to our function. ```python interpolate_polynomial(points, 3, np.min(points[:, 0]), np.max(points[:, 0])) interpolate_polynomial(points, 2, np.min(points[:, 0]), np.max(points[:, 0])) interpolate_polynomial(points, 1, np.min(points[:, 0]), np.max(points[:, 0])) ``` We see the fitting curves (or line in the last case) struggle more and more and they don't pass through every point. This breaks our assumptions but it can be very useful. Okay, one more thing. How about increasing the degree? Let's try 5, 7 and 10. Python might complain a little, just ignore it, everything is fine... sort of :). ```python interpolate_polynomial(points, 5, np.min(points[:, 0]), np.max(points[:, 0])) interpolate_polynomial(points, 7, np.min(points[:, 0]), np.max(points[:, 0])) interpolate_polynomial(points, 10, np.min(points[:, 0]), np.max(points[:, 0])) ``` Those graphs look pretty much the same. But that's the point exactly. I'm being quite sneaky here. Let's try to expand our view once again and see what our results really look like. ```python interpolate_polynomial(points, 5, -10, 10) interpolate_polynomial(points, 7, -10, 10) interpolate_polynomial(points, 10, -10, 10) ``` Now we see there are very wild differences. Even though the first two plots look quite similar, look at the $y$ values - they're quite different. So, these are the dangers of interpolation. Use a too high degree, and you get "the polynomial wiggle". These are all meant to represent **the same** data points but they look insanely different. Here's one more comparison. ```python interpolate_polynomial(points, len(points) - 1, -2, 7) interpolate_polynomial(points, len(points) + 1, -2, 7) ``` Now we can see what big difference even a small change in degree can make. This is why we have to choose our interpolating functions very carefully. Generally, a lower degree means a simpler function, which is to be preferred. See [Occam's razor](https://en.wikipedia.org/wiki/Occam%27s_razor). And also, **we need to be very careful about our assumptions**. ```python points = np.array([(-5, 0.03846), (-4, 0.05882), (-3, 0.1), (-2, 0.2), (-1, 0.5), (0, 1), (1, 0.5), (2, 0.2), (3, 0.1), (4, 0.05882), (5, 0.03846)]) interpolate_polynomial(points, len(points) - 1, np.min(points[:, 0]), np.max(points[:, 0])) ``` This one definitely looks strange. Even stranger, if we remove the outermost points... ($x = \pm 5$), we get this ```python points = np.array([(-4, 0.05882), (-3, 0.1), (-2, 0.2), (-1, 0.5), (0, 1), (1, 0.5), (2, 0.2), (3, 0.1), (4, 0.05882)]) interpolate_polynomial(points, len(points - 1), np.min(points[:, 0]), np.max(points[:, 0])) ``` This is because the generating function is not a polynomial. It's actually: $$ y = \frac{1}{1 + x^2} $$ Plot the polynomial interpolation and the real generating function **on the same plot**. You may need to modify the original plotting function or just copy its contents. ```python def interpolate_polynomial2(points, degree, min_x, max_x): x=np.linspace(np.min(min_x), np.max(max_x), 1000) f_vectorized = np.vectorize(lambda x:1/(1+x**2)) y = f_vectorized(x) plt.plot(x, y) ax = plt.gca() ax.spines["bottom"].set_position("zero") ax.spines["left"].set_position("zero") ax.spines["top"].set_visible(False) ax.spines["right"].set_visible(False) xx = points[:, 0] yy = points[:, 1] coefficients = np.polyfit(xx, yy, degree) poly = np.poly1d(coefficients) plot_x = np.linspace(np.min(min_x), np.max(max_x), 1000) plot_y = poly(plot_x) plt.plot(plot_x, plot_y, c = "green") plt.scatter(xx, yy) plt.xlabel("x") plt.ylabel("y") plt.show() pass ``` ```python points = np.array([(-4, 0.05882), (-3, 0.1), (-2, 0.2), (-1, 0.5), (0, 1), (1, 0.5), (2, 0.2), (3, 0.1), (4, 0.05882)]) interpolate_polynomial2(points, len(points - 1), np.min(points[:, 0]), np.max(points[:, 0])) ``` ### Problem 2. Complex Numbers as Vectors We saw that a complex number $z = a + bi$ is equivalent to (and therefore can be represented as) the ordered tuple $(a; b)$, which can be plotted in a 2D space. So, complex numbers and 2D points are equivalent. What is more, we can draw a vector from the origin of the coordinate plane to our point. This is called a point's **radius-vector**. Let's try plotting complex numbers as radius vectors. Don't forget to label the real and imaginary axes. Also, move the axes to the origin. Hint: These are called "spines"; you'll need to move 2 of them to the origin and remove the other 2 completely. Hint 2: You already did this in the previous lab. We can use `plt.quiver()` to plot the vector. It can behave a bit strangely, so we'll need to set the scale of the vectors to be the same as the scale on the graph axes: ```python plt.quiver(0, 0, z.real, z.imag, angles = "xy", scale_units = "xy", scale = 1) ``` Other than that, the main parameters are: $x_{begin}$, $y_{begin}$, $x_{length}$, $y_{length}$ in that order. Now, set the aspect ratio of the axes to be equal. Also, add grid lines. Set the axis numbers (called ticks) to be something like `range(-3, 4)` for now. ```python plt.xticks(range(-3, 4)) plt.yticks(range(-3, 4)) ``` If you wish to, you can be a bit more clever with the tick marks. Find the minimal and maximal $x$ and $y$ values and set the ticks according to them. It's a good practice not to jam the plot too much, so leave a little bit of space. That is, if the actual x-range is $[-2; 2]$, set the plotting to be $[-2.5; 2.5]$ for example. Otherwise, the vector heads (arrows) will be "jammed" into a corner or side of the plot. ```python def plot_complex_number(z): """ Plots the complex number z as a radius vector in the 2D space """ plt.quiver(0, 0, z.real, z.imag, angles = "xy", scale_units = "xy", scale = 1) plt.xticks(range(-3, 5)) plt.yticks(range(-3, 5)) pass plot_complex_number(2 + 3j) ``` How about many numbers? We'll need to get a little bit more creative. First, we need to create a 2D array, each element of which will be a 4-element array: `[0, 0, z.real, z.imag]`. Next, `plt.quiver()` can accept a range of values. Look at [this StackOverflow post](https://stackoverflow.com/questions/12265234/how-to-plot-2d-math-vectors-with-matplotlib) for details and adapt your code. ```python def plot_complex_numbers(numbers, colors): """ Plots the given complex numbers as radius vectors in the 2D space """ list_numbers = np.array([numbers]) for z in list_numbers: # Plots the vector plt.quiver(0, 0, z.real, z.imag, angles = "xy", scale_units = "xy", scale = 1.5, color=colors) # Sets the aspect ratio of the axes to be equal plt.gca().set_aspect("equal") # Sets range of axis numbers plt.xticks(range(-3, 4)) plt.yticks(range(-3, 4)) pass ``` ```python plot_complex_numbers([2 + 3j, -2 - 1j, -3, 2j], ["green", "red", "blue", "orange"]) ``` Now let's see what the operations look like. Let's add two numbers and plot the result. ```python z1 = 2 + 3j z2 = 1 - 1j plot_complex_numbers([z1, z2, z1 + z2], ["red", "blue", "green"]) ``` We can see that adding the complex numbers is equivalent to adding vectors (remember the "parallelogram rule"). As special cases, let's try adding pure real and pure imaginary numbers: ```python z1 = 2 + 3j z2 = 2 + 0j plot_complex_numbers([z1, z2, z1 + z2], ["red", "blue", "green"]) ``` ```python z1 = 2 + 3j z2 = 0 + 2j plot_complex_numbers([z1, z2, z1 + z2], ["red", "blue", "green"]) ``` How about multiplication? First we know that multiplying by 1 gives us the same vector and mulpiplying by -1 gives us the reversed version of the same vector. How about multiplication by $\pm i$? ```python z = 2 + 3j plot_complex_numbers([z, z * 1], ["red", "blue"]) plot_complex_numbers([z, z * -1], ["red", "blue"]) plot_complex_numbers([z, z * 1j], ["red", "blue"]) plot_complex_numbers([z, z * -1j], ["red", "blue"]) ``` So, multiplication by $i$ is equivalent to 90-degree rotation. We can actually see the following equivalence relationships between multiplying numbers and rotation about the origin: | Real | Imaginary | Result rotation | |------|-----------|-----------------| | 1 | 0 | $0^\circ$ | | 0 | 1 | $90^\circ$ | | -1 | 0 | $180^\circ$ | | 0 | -1 | $270^\circ$ | Once again, we see the power of abstraction and algebra in practice. We know that complex numbers and 2D vectors are equivalent. Now we see something more: addition and multiplication are equivalent to translation (movement) and rotation! Let's test the multiplication some more. We can see the resulting vector is the sum of the original vectors, but *scaled and rotated*: ```python z1 = 2 + 3j z2 = 1 - 2j plot_complex_numbers([z1, z2, z1 * z2], ["red", "blue", "green"]) ``` ### Problem 3. Recursion and Fractals > "To understand recursion, you first need to understand recursion." There are three main parts to a recursive function: 1. Bottom - when the recursion should finish 2. Operation - some meaningful thing to do 3. Recursive call - calling the same function 4. Clean-up - returning all data to its previous state (this reverses the effect of the operation) Let's do one of the most famous recursion examples. And I'm not talking about Fibonacci here. Let's draw a tree using recursive functions. The figure we're going to draw is called a **fractal**. It's self-similar, which means that if you zoom in on a part of it, it will look the same. You can see fractals everywhere in nature, with broccoli being one of the prime examples. Have a look: First, we need to specify the recursive part. In order to draw a tree, we need to draw a line of a given length (which will be the current branch), and then draw two more lines to the left and right. By "left" and "right", we should mean "rotation by a specified angle". So, this is how to draw a branch: draw a line and prepare to draw two more branches to the left and right. This is going to be our recursive call. To make things prettier, more natural-looking (and have a natural end to our recursion), let's draw each "sub-branch" a little shorter. If the branch becomes too short, it won't have "child branches". This will be the bottom of our recursion. There's one more important part of recursion, and this is **"the clean-up"**. After we did something in the recursive calls, it's very important to return the state of everything as it was **before** we did anything. In this case, after we draw a branch, we go back to our starting position. Let's first import the most import-ant (no pun intended...) Python drawing library: `turtle`! In order to make things easier, we'll import all methods directly. ```python from turtle import * ``` You can look up the docs about turtle if you're more interested. The basic things we're going to use are going forward and backward by a specified number of pixels and turning left and right by a specified angle (in degrees). Let's now define our recursive function: ```python def draw_branch(branch_length, angle): if branch_length > 5: forward(branch_length) right(angle) draw_branch(branch_length - 15, angle) left(2 * angle) draw_branch(branch_length - 15, angle) right(angle) backward(branch_length) ``` And let's call it: ```python draw_branch(100, 20) ``` We need to start the tree not at the middle, but toward the bottom of the screen, so we need to make a few more adjustments. We can wrap the setup in another function and call it. Let's start one trunk length below the center (the trunk length is the length of the longest line). ```python def draw_tree(trunk_length, angle): speed("fastest") left(90) up() backward(trunk_length) down() draw_branch(trunk_length, angle) ``` Note that the graphics will show in a separate window. Also note that sometimes you might get bugs. If you do, go to Kernel > Restart. ```python from turtle import * def draw_branch(branch_length, angle): if branch_length > 5: forward(branch_length) right(angle) draw_branch(branch_length - 15, angle) left(2 * angle) draw_branch(branch_length - 15, angle) right(angle) backward(branch_length) ``` ```python def draw_tree(trunk_length, angle): speed("fastest") left(90) up() backward(trunk_length) down() draw_branch(trunk_length, angle) ``` ```python draw_tree(100, 20) ``` Experiment with different lengths and angles. Especially interesting angles are $30^\circ$, $45^\circ$, $60^\circ$ and $90^\circ$. ```python draw_tree(100, 30) ``` ```python draw_tree(100, 45) ``` ```python draw_tree(100, 90) ``` Now modify the original function a little. Draw the lines with different thickness. Provide the trunk thickness at the initial call. Similar to how branches go shorter, they should also go thinner. ```python def draw_branch2(branch_length, angle): if branch_length > 5: forward(branch_length) right(angle) draw_branch2(branch_length - 15, angle) left(2 * angle) draw_branch2(branch_length - 15, angle) right(angle) backward(branch_length) ``` ```python def draw_tree2(trunk_length, angle): width(width=10) speed("fastest") left(90) up() backward(trunk_length) down() draw_branch2(trunk_length, angle) ``` ```python draw_tree2(100, 90) ``` #### * Optional problem Try to draw another kind of fractal graphic using recursion and the `turtle` library. Two very popular examples are the "Koch snowflake" and the "Sierpinski triangle". You can also modify the original tree algorithm to create more natural-looking trees. You can, for example, play with angles, number of branches, lengths, and widths. The Internet has a lot of ideas about this :). Hint: Look up **"L-systems"**. ### Problem 4. Run-length Encoding One application of algebra and basic math can be **compression**. This is a way to save data in less space than it originally takes. The most basic form of compression is called [run-length encoding](https://en.wikipedia.org/wiki/Run-length_encoding). Write a function that encodes a given text. Write another one that decodes. We can see that RLE is not very useful in the general case. But it can be extremely useful if we have very few symbols. An example of this can be DNA and protein sequences. DNA code, for example, has only 4 characters. Test your encoding and decoding functions on a DNA sequence (you can look up some on the Internet). Measure how much your data is compressed relative to the original. ```python from re import sub def encode(text): """ Returns the run-length encoded version of the text (numbers after symbols, length = 1 is skipped) """ di=sub(r'(.)\1*', lambda m: m.group(1)+str(len(m.group(0))),text) di = di.replace("1", "") return di pass def decode(text): """ Decodes the text using run-length encoding """ return sub(r'(\D)(\d+)', lambda m: m.group(1) * int(m.group(2)),text) pass ``` ```python # Tests # Test that the functions work on their own assert encode("AABCCCDEEEE") == "A2BC3DE4" assert decode("A2BC3DE4") == "AABCCCDEEEE" # Test that the functions really invert each other assert decode(encode("AABCCCDEEEE")) == "AABCCCDEEEE" assert encode(decode("A2BC3DE4")) == "A2BC3DE4" ``` ### Problem 5. Function Invertibility and Cryptography As we already saw, some functions are able to be inverted. That is, if we know the output, we can see what input generated it directly. This is true if the function is **one-to-one correspondence** (bijection). However, not all functions are created the same. Some functions are easy to compute but their inverses are extremely difficult. A very important example is **number factorization**. It's relatively easy (computationally) to multiply numbers but factoring them is quite difficult. Let's run an experiment. We'll need a function to generate random n-bit numbers. One such number can be found in the `Crypto` package ```python from Crypto.Util import number random_integer = number.getRandomNBitInteger(n_bits) ``` We could, of course, write our factorization by hand but we'll use `sympy` ```python from sympy.ntheory import factorint factorint(1032969399047817906432668079951) # {3: 2, 79: 1, 36779: 1, 7776252885493: 1, 5079811103: 1} ``` This function returns a `dict` where the keys are the factors, and the values - how many times they should be multiplied. We'll also need a tool to accurately measure performance. Have a look at [this one](https://docs.python.org/3/library/time.html#time.time) for example. Specity a sequence of bit lengths, in increasing order. For example, you might choose something like `[10, 20, 25, 30, 32, 33, 35, 38, 40]`. Depending on your computer's abilities you can go as high as you want. For each bit length, generate a number. See how much time it takes to factor it. Then see how much time it takes to multiply the factors. Be careful how you measure these. You shouldn't include the number generation (or any other external functions) in your timing. In order to have better accuracy, don't do this once per bit length. Do it, for example, five times, and average the results. Plot all multiplication and factorization times as a function of the number of bits. You should see that factorization is much, much slower. If you don't see this, just try larger numbers :D. ```python # Write your code here from Crypto.Util import number random_integer = number.getRandomNBitInteger(40) from sympy.ntheory import factorint factorint(1032969399047817906432668079951) ``` {3: 2, 79: 1, 36779: 1, 5079811103: 1, 7776252885493: 1} ### * Problem 6. Diffie - Hellman Simulation As we already saw, there are functions which are very easy to compute in the "forward" direction but really difficult (computationally) to invert (that is, determine the input from the output). There is a special case: the function may have a hidden "trap door". If you know where that door is, you can invert the function easily. This statement is at the core of modern cryptography. Look up **Diffie - Hellman key exchange** (here's a [video](https://www.youtube.com/watch?v=cM4mNVUBtHk) on that but feel free to use anything else you might find useful). Simulate the algorithm you just saw. Generate large enough numbers so the difference is noticeable (say, factoring takes 10-15 seconds). Simulate both participants in the key exchange. Simulate an eavesdropper. First, make sure after both participants run the algotihm, they have *the same key* (they generate the same number). Second, see how long it takes for them to exchange keys. Third, see how long it takes the eavesdropper to arrive at the correct shared secret. You should be able to see **the power of cryptography**. In this case, it's not that the function is irreversible. It can be reversed, but it takes a really long time (and with more bits, we're talking billions of years). However, if you know something else (this is called a **trap door**), the function becomes relatively easy to invert. ```python # Write your code here ``` ### ** Problem 7. The Galois Field in Cryptography Research about the uses of the Galois field. What are its properties? How can it be used in cryptography? Write a simple cryptosystem based on the field. You can use the following questions to facilitate your research: * What is a field? * What is GF(2)? Why is it an algebraic field? * What is perfect secrecy? How does it relate to the participants in the conversation, and to the outside eavesdropper? * What is symmetrical encryption? * How to encrypt one-bit messages? * How to extend the one-bit encryption system to many buts? * Why is the system decryptable? How do the participants decrypt the encrypted messages? * Why isn't the eavesdropper able to decrypt? * What is a one-time pad? * How does the one-time pad achieve perfect secrecy? * What happens if we try to use a one-time pad many times? * Provide an example where you break the "many-time pad" security * What are some current enterprise-grade applications of encryption over GF(2)? * Implement a cryptosystem based on GF(2). Show correctness on various test cases ### ** Problem 8. Huffman Compression Algorithm Examine and implement the **Huffman algorithm** for compressing data. It's based on information theory and probiability theory. Document your findings and provide your implementation. This algorithm is used for **lossless compression**: compressing data without loss of quality. You can use the following checklist: * What is the difference betwenn lossless and lossy compression? * When can we get away with lossy compression? * What is entropy? * How are Huffman trees constructed? * Provide a few examples * How can we get back the uncompressed data from the Huffman tree? * How and where are Huffman trees stored? * Implement the algorithm. Add any other formulas / assumptions / etc. you might need. * Test the algorithm. A good meaure would be percentage compression: $$\frac{\text{compressed}}{\text{uncompressed}} * 100\%$$ * How well does Huffman's algorithm perform compared to other compression algorithms (e.g. LZ77)?

37361c9cb790d1b87657fcb38bb915a90930e6c6

ipynb

Jupyter Notebook

Basic_Algebra/.ipynb_checkpoints/Basic-Algebra-Exercise-checkpoint.ipynb

ivaylokanov/Math_Concepts_for_Developers

646d4d5de48535c22b9a8fcb624973b917661c5e

Basic_Algebra/.ipynb_checkpoints/Basic-Algebra-Exercise-checkpoint.ipynb

ivaylokanov/Math_Concepts_for_Developers

646d4d5de48535c22b9a8fcb624973b917661c5e

Basic_Algebra/.ipynb_checkpoints/Basic-Algebra-Exercise-checkpoint.ipynb

ivaylokanov/Math_Concepts_for_Developers

646d4d5de48535c22b9a8fcb624973b917661c5e

Qwen/Qwen-72B

1. YES 2. YES

__label__eng_Latn

# Animating a simple wave We'll plot at various times a wave $u(x,t)$ that starts as a triangular shape as in Taylor Example 16.1, and then animate it. We can imagine this as simulating a wave on a taut string. Here $u$ is the transverse displacement (i.e., $y$ in our two-dimensional plots). We are not solving the wave equation as a differential equation here, but starting with $u(x,0) \equiv u_0(x)$ and plotting the solution at time $t$: $\begin{align} u(x,t) = \frac12 u_0(x - ct) + \frac12 u_0(x + ct) \;, \end{align}$ which *is* the solution to the wave equation starting with $u_0(x)$ at time $t=0$. We have various choices for animation in a Jupyter notebook. We will consider two possibilities, which both use `FuncAnimation` from `matplotlib.animation`. 1. Make a javascript movie that is then displayed inline with a movie-playing widget using `HTML`. We use `%matplotlib inline` for this option and use `%%capture` to prevent the figure from displaying prematurely. 2. Update the figure in real time (so to speak) by using `%matplotlib notebook`, which creates active figures that we can modify after they are displayed. We'll do the first option here. We should define at least one class for the animation. v1: Created 25-Mar-2019. Last revised 27-Mar-2019 by Dick Furnstahl (furnstahl.1@osu.edu). ```python %matplotlib inline ``` To use option 2: uncomment `%matplotlib notebook` here and `fig.show()` just after we define `anim`. Comment out `%%capture` and `HTML(anim.to_jshtml())` below. ```python #%matplotlib notebook ``` ```python import numpy as np import matplotlib.pyplot as plt from matplotlib import animation, rc from IPython.display import HTML ``` First define functions for the $t=0$ wave function form (here a triangle) and for the subsequent shape at any time $t$ based on the wave speed `c_wave`. ```python def u_0_triangle(x_pts, height=1., width=1.): """Returns a triangular wave of amplitude height and width 2*width. """ y_pts = np.zeros(len(x_pts)) # set the y array to all zeros for i, x in enumerate(x_pts): if x < width and x >= 0.: y_pts[i] = -(height/width) * x + height elif x < 0 and x >= -width: y_pts[i] = (height/width) * x + height else: pass # do nothing (everything else is zero already) return y_pts ``` ```python def u_triangle(x_pts, t, c_wave = 1., height=1., width=1.): """Returns the wave at time t resulting from a triangular wave of amplitude height and width 2*width at time t=0. It is the superposition of two traveling waves moving to the left and the right. """ y_pts = -u_0_triangle(x_pts + c_wave * t) / 2. + \ u_0_triangle(x_pts - c_wave * t) / 2. return y_pts ``` ```python # Set up the array of x points (whatever looks good) x_min = -5. x_max = +5. delta_x = 0.01 x_pts = np.arange(x_min, x_max, delta_x) ``` First look at the initial ($t=0$) wave form. ```python # Define the initial (t=0) wave form and the wave speed. height = 1. width = 1. c_wave = 1. # Make a figure showing the initial wave. t_now = 0. fig = plt.figure(figsize=(6,2), num='Triangular wave') ax = fig.add_subplot(1,1,1) ax.set_xlim(x_min, x_max) gap = 0.1 ax.set_ylim(-height -gap, height + gap) ax.set_xlabel(r'$x$') ax.set_ylabel(r'$u_0(x)$') ax.set_title(rf'$t = {t_now:.1f}$') line, = ax.plot(x_pts, u_triangle(x_pts, t_now, c_wave, height, width), color='blue', lw=2) fig.tight_layout() ``` Next make some plots at an array of time points. ```python t_array = np.array([0., 1, 2., 3, 4., -2.]) fig_array = plt.figure(figsize=(12,6), num='Triangular wave') for i, t_now in enumerate(t_array): ax_array = fig_array.add_subplot(3, 2, i+1) ax_array.set_xlim(x_min, x_max) gap = 0.1 ax_array.set_ylim(-height -gap, height + gap) ax_array.set_xlabel(r'$x$') ax_array.set_ylabel(r'$u_0(x)$') ax_array.set_title(rf'$t = {t_now:.1f}$') ax_array.plot(x_pts, u_triangle(x_pts, t_now, c_wave, height, width), color='blue', lw=2) fig_array.tight_layout() fig_array.savefig('Taylor_Example_16p2_triangle_waves.png', bbox_inches='tight') ``` Now it is time to animate! ```python # Set up the t mesh for the animation. The maximum value of t shown in # the movie will be t_min + delta_t * frame_number t_min = 0. # You can make this negative to see what happens before t=0! t_max = 15. delta_t = 0.1 t_pts = np.arange(t_min, t_max, delta_t) ``` We use the cell "magic" `%%capture` to keep the figure from being shown here. If we didn't the animated version below would be blank. ```python %%capture fig_anim = plt.figure(figsize=(6,2), num='Triangular wave') ax_anim = fig_anim.add_subplot(1,1,1) ax_anim.set_xlim(x_min, x_max) gap = 0.1 ax_anim.set_ylim(-height -gap, height + gap) # By assigning the first return from plot to line_anim, we can later change # the values in the line. line_anim, = ax_anim.plot(x_pts, u_triangle(x_pts, t_min, c_wave, height, width), color='blue', lw=2) fig_anim.tight_layout() ``` ```python def animate_wave(i): """This is the function called by FuncAnimation to create each frame, numbered by i. So each i corresponds to a point in the t_pts array, with index i. """ t = t_pts[i] y_pts = u_triangle(x_pts, t, c_wave, height, width) line_anim.set_data(x_pts, y_pts) # overwrite line_anim with new points return (line_anim,) # this is needed for blit=True to work ``` ```python frame_interval = 40. # time between frames frame_number = 100 # number of frames to include (index of t_pts) anim = animation.FuncAnimation(fig_anim, animate_wave, init_func=None, frames=frame_number, interval=frame_interval, blit=True, repeat=False) #fig.show() ``` ```python HTML(anim.to_jshtml()) ``` <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/font-awesome/4.4.0/ css/font-awesome.min.css"> <div class="animation" align="center"> <br> <input id="_anim_slider769a861c9a6848a797049c48584581ca" type="range" style="width:350px" name="points" min="0" max="1" step="1" value="0" onchange="anim769a861c9a6848a797049c48584581ca.set_frame(parseInt(this.value));"></input> <br> <button onclick="anim769a861c9a6848a797049c48584581ca.slower()"><i class="fa fa-minus"></i></button> <button onclick="anim769a861c9a6848a797049c48584581ca.first_frame()"><i class="fa fa-fast-backward"> </i></button> <button onclick="anim769a861c9a6848a797049c48584581ca.previous_frame()"> <i class="fa fa-step-backward"></i></button> <button onclick="anim769a861c9a6848a797049c48584581ca.reverse_animation()"> <i class="fa fa-play fa-flip-horizontal"></i></button> <button onclick="anim769a861c9a6848a797049c48584581ca.pause_animation()"><i class="fa fa-pause"> </i></button> <button onclick="anim769a861c9a6848a797049c48584581ca.play_animation()"><i class="fa fa-play"></i> </button> <button onclick="anim769a861c9a6848a797049c48584581ca.next_frame()"><i class="fa fa-step-forward"> </i></button> <button onclick="anim769a861c9a6848a797049c48584581ca.last_frame()"><i class="fa fa-fast-forward"> </i></button> <button onclick="anim769a861c9a6848a797049c48584581ca.faster()"><i class="fa fa-plus"></i></button> <form action="#n" name="_anim_loop_select769a861c9a6848a797049c48584581ca" class="anim_control"> <input type="radio" name="state" value="once" checked> Once </input> <input type="radio" name="state" value="loop" > Loop </input> <input type="radio" name="state" value="reflect" > Reflect </input> </form> </div> ```python ```

c7c7f5e1fd9a5aa8c4872ece225ae95648b6fdb7

ipynb

Jupyter Notebook

2020_week_11/Problem_16.11.ipynb

CLima86/Physics_5300_CDL

d9e8ee0861d408a85b4be3adfc97e98afb4a1149

2020_week_11/Problem_16.11.ipynb